* tpop.h
*****
*/
+
+/* $Id$ */
+
# ifndef _TYPE_H_
# define _TYPE_H_
typedef struct entity entity;
#endif
+#ifndef _IR_NODE_TYPEDEF_
+#define _IR_NODE_TYPEDEF_
+typedef struct ir_node ir_node;
+#endif
+
/****s* type/type
*
* NAME
* occupy size bytes in memory. In several cases this is
* determined when fixing the layout of this type (class,
* struct, union, array, enumeration).
+ * state The state of the type. The state represents whether the
+ * layout of the type is undefined or fixed (values: layout_undefined
+ * or layout_fixed). Compound types can have an undefined
+ * layout. The layout of the basic types primitive and pointer
+ * is always layout_fixed. If the layout of
+ * compound types is fixed all entities must have an offset
+ * and the size of the type must be set.
+ * A fixed layout for enumeration types means that each enumeration
+ * is associated with an implementation value.
* visit A counter for walks of the type information.
+ * link A void* to associate some additional inforamtion with the type.
*
* These fields can only be accessed via access functions.
*
*/
typedef struct type type;
+void* get_type_link(type *tp);
+void set_type_link(type *tp, void *l);
tp_op* get_type_tpop(type *tp);
ident* get_type_tpop_nameid(type *tp);
const char* get_type_tpop_name(type *tp);
ir_mode* get_type_mode(type *tp);
void set_type_mode(type *tp, ir_mode* m);
-ident* get_type_nameid(type *tp);
-void set_type_nameid(type *tp, ident* id);
+ident* get_type_ident(type *tp);
+void set_type_ident(type *tp, ident* id);
const char* get_type_name(type *tp);
int get_type_size(type *tp);
+/* For primitives and pointer types the size is always fixed.
+ This call is legal but has no effect. */
void set_type_size(type *tp, int size);
+typedef enum {
+ layout_undefined, /* The layout of this type is not defined.
+ Address computation to access fields is not
+ possible, fields must be accessed by Sel nodes.
+ This is the default value except for pointer and
+ primitive types. */
+ layout_fixed /* The layout is fixed, all component/member entities
+ have an offset assigned. Size of the type is known.
+ Arrays can be accessed by explicit address
+ computation. Default for pointer and primitive types.
+ */
+} type_state;
+
+type_state get_type_state(type *tp);
+/* For primitives and pointer types the layout is always fixed.
+ This call is legal but has no effect. */
+void set_type_state(type *tp, type_state state);
+
unsigned long get_type_visited(type *tp);
void set_type_visited(type *tp, unsigned long num);
/* Sets visited field in type to type_visited. */
/* create a new class type */
type *new_type_class (ident *name);
-/* manipulate private fields of class type */
+/** manipulate private fields of class type **/
+/* Adds the entity as member of the class. */
void add_class_member (type *clss, entity *member);
+/* Returns the number of members of this class. */
int get_class_n_member (type *clss);
+/* Returns the member at position pos, 0 <= pos < n_member */
entity *get_class_member (type *clss, int pos);
+/* Overwrites the member at position pos, 0 <= pos < n_member with
+ the passed entity. */
void set_class_member (type *clss, entity *member, int pos);
+/* Finds member in the list of members and overwrites it with NULL
+ @@@ Doesn't work properly. */
+void remove_class_member(type *clss, entity *member);
+
+/* Adds subtype as subtype to clss.
+ Checks whether clss is a supertype of subtype. If not
+ adds also clss as supertype to subtype. */
void add_class_subtype (type *clss, type *subtype);
+/* Returns the number of subtypes */
int get_class_n_subtype (type *clss);
+/* Gets the subtype at position pos, 0 <= pos < n_subtype. */
type *get_class_subtype (type *clss, int pos);
+/* Sets the subtype at positioin pos, 0 <= pos < n_subtype. Does not
+ set the corresponding supertype relation for subtype: this might
+ be a different position! */
void set_class_subtype (type *clss, type *subtype, int pos);
+/* Finds subtype in the list of subtypes and overwrites it with NULL
+ @@@ Doesn't work properly. */
+void remove_class_subtype(type *clss, type *subtype);
+
+/* Adds supertype as supertype to class.
+ Checks whether clss is a subtype of supertype. If not
+ adds also clss as subtype to supertype. */
void add_class_supertype (type *clss, type *supertype);
+/* Returns the number of supertypes */
int get_class_n_supertype (type *clss);
+/* Gets the supertype at position pos, 0 <= pos < n_supertype. */
type *get_class_supertype (type *clss, int pos);
+/* Sets the supertype at postition pos, 0 <= pos < n_subtype. Does not
+ set the corresponding subtype relation for supertype: this might
+ be a different position! */
void set_class_supertype (type *clss, type *supertype, int pos);
+/* Finds supertype in the list of supertypes and overwrites it with NULL
+ @@@ Doesn't work properly. */
+void remove_class_supertype(type *clss, type *supertype);
/* typecheck */
bool is_class_type(type *clss);
* type_pointer, type_primitive.
* This is a dynamic list that can be grown with an "add_" function,
* but not shrinked.
+ * This is a dynamic list that can be grown with an "add_" function,
+ * but not shrinked.
* SOURCE
*/
/* create a new type struct */
int get_struct_n_member (type *strct);
entity *get_struct_member (type *strct, int pos);
void set_struct_member (type *strct, int pos, entity *member);
+/* Finds member in the list of memberss and overwrites it with NULL
+ @@@ Doesn't work properly. */
+void remove_struct_member (type *strct, entity *member);
/* typecheck */
bool is_struct_type(type *strct);
* The union type represents union types.
* ATTRIBUTES
* n_types Number of unioned types.
- * unioned_type A list of unioned types.
- * delim_names Idents for the names of the union delimiters.
+ * members Entities for unioned types. Fixed length array.
+ * This is a dynamic list that can be grown with an "add_" function,
+ * but not shrinked.
* SOURCE
*/
-/* create a new type union
- The arrays for the types and idents are not initialized by the
- constructor. */
-type *new_type_union (ident *name, int n_types);
+/* create a new type union */
+type *new_type_union (ident *name);
/* manipulate private fields of struct */
-int get_union_n_types (type *uni);
+int get_union_n_members (type *uni);
+void add_union_member (type *uni, entity *member);
+entity *get_union_member (type *uni, int pos);
+void set_union_member (type *uni, int pos, entity *member);
+/* Finds member in the list of members and overwrites it with NULL
+ @@@ Doesn't work properly. */
+void remove_union_member (type *uni, entity *member);
+/* typecheck */
+bool is_union_type (type *uni);
+/*****/
+
+#if 0
+/* We don't need these if the union has entities, which it now
+ does. The entities are necessary for the analysis algorithms. */
type *get_union_unioned_type (type *uni, int pos);
void set_union_unioned_type (type *uni, int pos, type *type);
ident *get_union_delim_nameid (type *uni, int pos);
const char *get_union_delim_name (type *uni, int pos);
void set_union_delim_nameid (type *uni, int pos, ident *id);
-
-/* typecheck */
-bool is_union_type (type *uni);
-/*****/
+#endif
/****** type/array
* NAME
* Representation of an array type.
* NOTE
* The array type represents rectangular multi dimensional arrays.
+ * The constants representing the bounds must be allocated to
+ * get_const_code_irg() by setting current_ir_graph accordingly.
* ATTRIBUTES
* n_dimensions Number of array dimensions.
* *lower_bound Lower bounds of dimensions. Usually all 0.
* *upper_bound Upper bounds or dimensions.
* *element_type The type of the array elements.
+ * *element_ent An entity for the array elements to be used for
+ * element selection with Sel.
+ * @@@ Do we need several entities? One might want
+ * to select a dimension and not a single element in
+ * case of multidim arrays.
* SOURCE
*/
-/* create a new type array -- set dimension sizes independently */
-type *new_type_array (ident *name, int n_dimensions);
+/* create a new type array --
+ Set dimension sizes after call to constructor with set_* routines.
+ Entity for array elements is built automatically. */
+type *new_type_array (ident *name, int n_dimensions,
+ type *element_type);
/* manipulate private fields of array type */
int get_array_n_dimensions (type *array);
-void set_array_bounds (type *array, int dimension, int lower_bound,
+/* Allocates Const nodes of mode_I for the array dimensions */
+void set_array_bounds_int (type *array, int dimension, int lower_bound,
int upper_bound);
-void set_array_lower_bound (type *array, int dimension, int lower_bound);
-void set_array_upper_bound (type *array, int dimension, int upper_bound);
-int get_array_lower_bound (type *array, int dimension);
-int get_array_upper_bound (type *array, int dimension);
+void set_array_bounds (type *array, int dimension, ir_node *lower_bound,
+ ir_node *upper_bound);
+void set_array_lower_bound (type *array, int dimension, ir_node *lower_bound);
+void set_array_upper_bound (type *array, int dimension, ir_node *upper_bound);
+ir_node * get_array_lower_bound (type *array, int dimension);
+ir_node * get_array_upper_bound (type *array, int dimension);
void set_array_element_type (type *array, type *type);
type *get_array_element_type (type *array);
+void set_array_element_entity (type *array, entity *ent);
+entity *get_array_element_entity (type *array);
+
/* typecheck */
bool is_array_type (type *array);
/*****/
bool is_primitive_type (type *primitive);
/*****/
+
+
+/****f* type/is_atomic_type
+ *
+ * NAME
+ * is_atomic_type - Checks whether a type is atomic.
+ * SYNOPSIS
+ * int is_atomic_type(type *tp);
+ * INPUTS
+ * tp - any type
+ * RESULT
+ * true if type is primitive, pointer or enumeration
+ ***
+ */
+int is_atomic_type(type *tp);
+
+/****f* type/is_compound_type
+ *
+ * NAME
+ * is_compound_type - Checks whether a type is compound.
+ * SYNOPSIS
+ * int is_compound_type(type *tp)
+ * INPUTS
+ * tp - any type
+ * RESULT
+ * true if the type is class, structure, union or array type.
+ ***
+ */
+int is_compound_type(type *tp);
+
# endif /* _TYPE_H_ */
projects / libfirm / blobdiff