* - name: An identifier specifying the name of the type. To be
* set by the frontend.
* - size: The size of the type, i.e. an entity of this type will
- * occupy size bytes in memory. In several cases this is
+ * occupy size bits in memory. In several cases this is
* determined when fixing the layout of this type (class,
* struct, union, array, enumeration).
+ * - alignment The alignment of the type, i.e. an entity of this type will
+ * be allocated an an address in memory with this alignment.
+ * In several cases this is determined when fixing the layout
+ * of this type (class, struct, union, array)
* - 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
*/
void free_type_entities(type *tp);
-/** Frees the memory used by the type. Does not free the entities
- belonging to the type, except for the array element entity.
- Does not free if tp is "none" or "unknown".
- Frees entities in value param subtypes of method types!!! Make sure these
- are not referenced any more. */
+/** Frees the memory used by the type.
+ *
+ * Removes the type from the type list. Does not free the entities
+ * belonging to the type, except for the array element entity. Does
+ * not free if tp is "none" or "unknown". Frees entities in value
+ * param subtypes of method types!!! Make sure these are not
+ * referenced any more. Further make sure there is no pointer type
+ * that refers to this type. */
void free_type(type *tp);
-tp_op* get_type_tpop(type *tp);
-ident* get_type_tpop_nameid(type *tp);
-const char* get_type_tpop_name(type *tp);
-tp_opcode get_type_tpop_code(type *tp);
+tp_op* get_type_tpop(const type *tp);
+ident* get_type_tpop_nameid(const type *tp);
+const char* get_type_tpop_name(const type *tp);
+tp_opcode get_type_tpop_code(const type *tp);
-ident* get_type_ident(type *tp);
+ident* get_type_ident(const type *tp);
void set_type_ident(type *tp, ident* id);
-const char* get_type_name(type *tp);
+const char* get_type_name(const type *tp);
-/** The state of a type layout. */
+/** The state of the type layout. */
typedef enum {
layout_undefined, /**< The layout of this type is not defined.
Address computation to access fields is not
} type_state;
/** Returns the type layout state of a type. */
-type_state get_type_state(type *tp);
+type_state get_type_state(const type *tp);
/** Sets the type layout state of a type.
*
*
* Returns NULL for all non atomic types.
*/
-ir_mode* get_type_mode(type *tp);
+ir_mode* get_type_mode(const type *tp);
/** Sets the mode of a type.
*
*/
void set_type_mode(type *tp, ir_mode* m);
-/** Returns the size of a type. */
-int get_type_size(type *tp);
+/** Returns the size of a type in bytes, returns -1 if the size is NOT
+ * a byte size, ie not dividable by 8. */
+int get_type_size_bytes(const type *tp);
+
+/** Returns the size of a type in bits. */
+int get_type_size_bits(const type *tp);
-/** Sets the size of a type.
+/** Sets the size of a type in bytes.
*
* For primitive, enumeration, pointer and method types the size
* is always fixed. This call is legal but has no effect.
*/
-void set_type_size(type *tp, int size);
+void set_type_size_bytes(type *tp, int size);
+/** Sets the size of a type in bits.
+ *
+ * For primitive, enumeration, pointer and method types the size
+ * is always fixed. This call is legal but has no effect.
+ */
+void set_type_size_bits(type *tp, int size);
+
+/** Returns the alignment of a type in bytes, returns -1 if the alignment is NOT
+ * a byte size, ie not dividable by 8. Calls get_type_alignment_bits(). */
+int get_type_alignment_bytes(type *tp);
+
+/** Returns the alignment of a type in bits. If the alignment of a type is
+ * not set, it is calculated here according to the following rules:
+ * 1.) if a type has a mode, the aligment is the mode size.
+ * 2.) compound types have the alignment of it's biggest member.
+ * 3.) array types have the alignment of its element type.
+ * 4.) method types return 0 here.
+ * 5.) all other types return 8 here (i.e. aligned at byte).
+ */
+int get_type_alignment_bits(type *tp);
-unsigned long get_type_visited(type *tp);
+/** Sets the alignment of a type in bytes. */
+void set_type_alignment_bytes(type *tp, int size);
+
+/** Sets the alignment of a type in bits.
+ *
+ * For method types the alignment is always fixed.
+ * This call is legal but has no effect.
+ */
+void set_type_alignment_bits(type *tp, int size);
+
+unsigned long get_type_visited(const type *tp);
void set_type_visited(type *tp, unsigned long num);
/* Sets visited field in type to type_visited. */
void mark_type_visited(type *tp);
-/* @@@ name clash!! bool type_visited(type *tp); */
-bool type_not_visited(type *tp);
+/* @@@ name clash!! int type_visited(const type *tp); */
+int type_not_visited(const type *tp);
-void* get_type_link(type *tp);
+void* get_type_link(const type *tp);
void set_type_link(type *tp, void *l);
/**
* @return
* true if the thing is a type, else false
*/
-int is_type (void *thing);
+int is_type (const void *thing);
/**
* Checks whether two types are structural equal.
void add_class_member (type *clss, entity *member);
/** Returns the number of members of this class. */
-int get_class_n_members (type *clss);
+int get_class_n_members (const type *clss);
/** Returns the member at position pos, 0 <= pos < n_member */
-entity *get_class_member (type *clss, int pos);
+entity *get_class_member (const type *clss, int pos);
/** Returns index of mem in clss, -1 if not contained. */
int get_class_member_index(type *clss, entity *mem);
void add_class_subtype (type *clss, type *subtype);
/** Returns the number of subtypes */
-int get_class_n_subtypes (type *clss);
+int get_class_n_subtypes (const type *clss);
/** Gets the subtype at position pos, 0 <= pos < n_subtype. */
type *get_class_subtype (type *clss, int pos);
void add_class_supertype (type *clss, type *supertype);
/** Returns the number of supertypes */
-int get_class_n_supertypes (type *clss);
+int get_class_n_supertypes (const type *clss);
/** Returns the index of an supertype in a type. */
int get_class_supertype_index(type *clss, type *super_clss);
/** This enumeration flags the peculiarity of entities and types. */
typedef enum peculiarity {
peculiarity_description, /**< Represents only a description. The entity/type is never
- allocated, no code/data exists for this entity/type. */
+ allocated, no code/data exists for this entity/type.
+ @@@ eventually rename to descriptive (adjectiv as the others!)*/
peculiarity_inherited, /**< Describes explicitly that other entities are
inherited to the owner of this entity.
Overwrites must refer to at least one other
no irg for this entity, only for one of the
overwritten ones.
Only for entity. */
- peculiarity_existent /**< The entity/type (can) exist. */
+ peculiarity_existent /**< The entity/type (can) exist.
+ @@@ eventually rename to 'real' i.e., 'echt'
+ This serves better as opposition to description _and_ inherited.*/
} peculiarity;
-char *get_peculiarity_string(peculiarity p);
+const char *get_peculiarity_string(peculiarity p);
/* The peculiarity of the class. The enumeration peculiarity is defined
in entity.h */
-peculiarity get_class_peculiarity (type *clss);
+peculiarity get_class_peculiarity (const type *clss);
void set_class_peculiarity (type *clss, peculiarity pec);
/* Set and get a class' dfn --
@todo This is an undocumented field, subject to change! */
void set_class_dfn (type *clss, int dfn);
-int get_class_dfn (type *clss);
+int get_class_dfn (const type *clss);
/** Returns true if a type is a class type. */
-bool is_class_type(type *clss);
+int is_class_type(const type *clss);
/** Returns true if low is subclass of high. */
bool is_subclass_of(type *low, type *high);
/** Creates a new type struct with debug information. */
type *new_d_type_struct (ident *name, dbg_info* db);
-/* manipulate private fields of struct */
+/* --- manipulate private fields of struct --- */
+
+/** Adds the entity as member of the struct. */
void add_struct_member (type *strct, entity *member);
-int get_struct_n_members (type *strct);
-entity *get_struct_member (type *strct, int pos);
+
+/** Returns the number of members of this struct. */
+int get_struct_n_members (const type *strct);
+
+/** Returns the member at position pos, 0 <= pos < n_member */
+entity *get_struct_member (const type *strct, int pos);
+
+/** Returns index of member in strct, -1 if not contained. */
+int get_struct_member_index(type *strct, entity *member);
+
+/** Overwrites the member at position pos, 0 <= pos < n_member with
+ the passed entity. */
void set_struct_member (type *strct, int pos, entity *member);
/** Finds member in the list of members and removes it. */
void remove_struct_member (type *strct, entity *member);
/** Returns true if a type is a struct type. */
-bool is_struct_type(type *strct);
+int is_struct_type(const type *strct);
/**
* @page method_type Representation of a method type
/* -- manipulate private fields of method. -- */
/** Returns the number of parameters of this method. */
-int get_method_n_params (type *method);
+int get_method_n_params (const type *method);
/** Returns the type of the parameter at position pos of a method. */
type *get_method_param_type(type *method, int pos);
Also changes the type in the pass-by-value representation by just
changing the type of the corresponding entity if the representation is constructed. */
void set_method_param_type(type *method, int pos, type* tp);
-/* Returns an entity that represents the copied value argument. Only necessary
+/** Returns an entity that represents the copied value argument. Only necessary
for compounds passed by value. This information is constructed only on demand. */
entity *get_method_value_param_ent(type *method, int pos);
+/**
+ * Returns a type that represents the copied value arguments.
+ */
+type *get_method_value_param_type(const type *method);
-int get_method_n_ress (type *method);
+int get_method_n_ress (const type *method);
type *get_method_res_type(type *method, int pos);
/** Sets the type of the result at position pos of a method.
Also changes the type in the pass-by-value representation by just
changing the type of the corresponding entity if the representation is constructed. */
void set_method_res_type(type *method, int pos, type* tp);
-/* Returns an entity that represents the copied value result. Only necessary
+/** Returns an entity that represents the copied value result. Only necessary
for compounds passed by value. This information is constructed only on demand. */
entity *get_method_value_res_ent(type *method, int pos);
-/*
+
+/**
+ * Returns a type that represents the copied value results.
*/
-type *get_method_value_res_type(type *method);
+type *get_method_value_res_type(const type *method);
/**
* this enum flags the variadicity of methods (methods with a
const char *get_variadicity_name(variadicity vari);
/** Returns the variadicity of a method. */
-variadicity get_method_variadicity(type *method);
+variadicity get_method_variadicity(const type *method);
/** Sets the variadicity of a method. */
void set_method_variadicity(type *method, variadicity vari);
+/**
+ * Returns the first variadic parameter index of a type.
+ * If this index was NOT set, the index of the last parameter
+ * of the method type plus one is returned for variadic functions.
+ * Non-variadic function types always return -1 here.
+ */
+int get_method_first_variadic_param_index(const type *method);
+
+/**
+ * Sets the first variadic parameter index. This allows to specify
+ * a complete call type (containing the type of all parameters)
+ * but still have the knowledge, which parameter must be passed as
+ * variadic one.
+ */
+void set_method_first_variadic_param_index(type *method, int index);
+
/** Returns true if a type is a method type. */
-bool is_method_type (type *method);
+int is_method_type (const type *method);
/**
* @page union_type Representation of a union type.
/* --- manipulate private fields of struct --- */
/** Returns the number of unioned types of this union */
-int get_union_n_members (type *uni);
+int get_union_n_members (const type *uni);
/** Adds a new entity to a union type */
void add_union_member (type *uni, entity *member);
/** Returns the entity at position pos of a union */
-entity *get_union_member (type *uni, int pos);
+entity *get_union_member (const type *uni, int pos);
/** Overwrites a entity at position pos in a union type. */
void set_union_member (type *uni, int pos, entity *member);
void remove_union_member (type *uni, entity *member);
/** Returns true if a type is a union type. */
-bool is_union_type (type *uni);
+int is_union_type (const type *uni);
/**
* @page array_type Representation of an array type
* Initializes order to the order of the dimensions.
* The entity for array elements is built automatically.
* Set dimension sizes after call to constructor with set_* routines.
+ * A legal array type must have at least one dimension set.
*/
type *new_d_type_array (ident *name, int n_dimensions,
type *element_type, dbg_info* db);
/* --- manipulate private fields of array type --- */
/** Returns the number of array dimensions of this type. */
-int get_array_n_dimensions (type *array);
+int get_array_n_dimensions (const type *array);
/** Allocates Const nodes of mode_I for the array dimensions */
void set_array_bounds_int (type *array, int dimension, int lower_bound,
void set_array_lower_bound_int (type *array, int dimension, int lower_bound);
void set_array_upper_bound (type *array, int dimension, ir_node *upper_bound);
void set_array_upper_bound_int (type *array, int dimension, int lower_bound);
-/* returns true if lower bound != Unknown */
-int has_array_lower_bound (type *array, int dimension);
-ir_node * get_array_lower_bound (type *array, int dimension);
-int has_array_upper_bound (type *array, int dimension);
-ir_node * get_array_upper_bound (type *array, int dimension);
+/** returns true if lower bound != Unknown */
+int has_array_lower_bound (const type *array, int dimension);
+ir_node * get_array_lower_bound (const type *array, int dimension);
+/** Works only if bound is Const node with tarval that can be converted to long. */
+long get_array_lower_bound_int (const type *array, int dimension);
+/** returns true if lower bound != Unknown */
+int has_array_upper_bound (const type *array, int dimension);
+ir_node * get_array_upper_bound (const type *array, int dimension);
+/** Works only if bound is Const node with tarval that can be converted to long. */
+long get_array_upper_bound_int (const type *array, int dimension);
void set_array_order (type *array, int dimension, int order);
-int get_array_order (type *array, int dimension);
+int get_array_order (const type *array, int dimension);
void set_array_element_type (type *array, type *tp);
type *get_array_element_type (type *array);
void set_array_element_entity (type *array, entity *ent);
-entity *get_array_element_entity (type *array);
+entity *get_array_element_entity (const type *array);
/** Returns true if a type is an array type. */
-bool is_array_type (type *array);
+int is_array_type(const type *array);
/**
* @page enumeration_type Representation of an enumeration type
/* --- manipulate fields of enumeration type. --- */
/** Returns the number of enumeration values of this enumeration */
-int get_enumeration_n_enums (type *enumeration);
+int get_enumeration_n_enums (const type *enumeration);
/** Sets the enumeration value at a given position. */
void set_enumeration_enum (type *enumeration, int pos, tarval *con);
/** Returns the enumeration value at a given position. */
-tarval *get_enumeration_enum (type *enumeration, int pos);
+tarval *get_enumeration_enum (const type *enumeration, int pos);
/** Assign an ident to an enumeration value at a given position. */
void set_enumeration_nameid (type *enumeration, int pos, ident *id);
/** Returns the assigned ident of an enumeration value at a given position. */
-ident *get_enumeration_nameid (type *enumeration, int pos);
+ident *get_enumeration_nameid (const type *enumeration, int pos);
/** Returns the assigned name of an enumeration value at a given position. */
-const char *get_enumeration_name(type *enumeration, int pos);
+const char *get_enumeration_name(const type *enumeration, int pos);
/** Returns true if a type is a enumeration type. */
-bool is_enumeration_type (type *enumeration);
+int is_enumeration_type (const type *enumeration);
/**
* @page pointer_type Representation of a pointer type
*/
/** Creates a new type pointer with mode mode_p. */
-#define new_type_pointer(N, P) new_type_pointer_mode(N, P, mode_P)
-/* type *new_type_pointer (ident *name, type *points_to); */
+#define new_type_pointer(N, P) new_type_pointer_mode(N, P, mode_P_mach)
/** Creates a new type pointer with given pointer mode. */
type *new_type_pointer_mode (ident *name, type *points_to, ir_mode *ptr_mode);
type *get_pointer_points_to_type (type *pointer);
/** Returns true if a type is a pointer type. */
-bool is_pointer_type (type *pointer);
+int is_pointer_type (const type *pointer);
/** Returns the first pointer type that has as points_to tp.
* Not efficient: O(#types).
type *new_d_type_primitive (ident *name, ir_mode *mode, dbg_info* db);
/** Returns true if a type is a primitive type. */
-bool is_primitive_type (type *primitive);
+int is_primitive_type (const type *primitive);
/**
*/
/* A variable that contains the only unknown type. */
extern type *unknown_type;
-/* Returns the none type */
+/* Returns the unknown type */
type *get_unknown_type(void);
* @param tp - any type
* @return true if type is primitive, pointer or enumeration
*/
-int is_atomic_type(type *tp);
+int is_atomic_type(const type *tp);
/* --- Support for compound types --- */
*
* @return Number of members in the compound type.
*/
-int get_compound_n_members(type *tp);
+int get_compound_n_members(const type *tp);
/**
* Gets the member of a firm compound type at position pos.
*
* @see get_compound_n_members() for justifaction of existence.
*/
-entity *get_compound_member(type *tp, int pos);
+entity *get_compound_member(const type *tp, int pos);
/**
* Checks whether a type is compound.
*
* @return true if the type is class, structure, union or array type.
*/
-int is_compound_type(type *tp);
+int is_compound_type(const type *tp);
/**
* debugging, (configure with --enable-debug) else returns the address
* of the type cast to long.
*/
-long get_type_nr(type *tp);
+long get_type_nr(const type *tp);
/*******************************************************************/
/** Debug aides **/
/*******************************************************************/
-/** Write the type and all its attributes to stdout.
- *
- * Writes the type and all its attributes to stdout if DEBUG_libfirm
- * is set. Else does nothing. */
-void dump_type (type *tp);
# endif /* _TYPE_H_ */
projects / libfirm / blobdiff