*/
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);
void set_type_ident(type *tp, ident* id);
const char* get_type_name(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
*/
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, retuns -1 if the size is NOT
+ * a byte size, ie not dividable by 8. */
+int get_type_size_bytes(type *tp);
-/** Sets the size of a type.
+/** Returns the size of a type in bits. */
+int get_type_size_bits(type *tp);
+
+/** 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_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(type *tp, int size);
+void set_type_size_bits(type *tp, int size);
unsigned long get_type_visited(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(type *tp); */
+int type_not_visited(type *tp);
void* get_type_link(type *tp);
void set_type_link(type *tp, void *l);
int get_class_dfn (type *clss);
/** Returns true if a type is a class type. */
-bool is_class_type(type *clss);
+int is_class_type(type *clss);
/** Returns true if low is subclass of high. */
bool is_subclass_of(type *low, type *high);
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(type *strct);
/**
* @page method_type Representation of a method type
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
- for compounds passed by value. This information is constructed only on demand. */
+ for compounds passed by value. This information is constrnewucted only on demand. */
entity *get_method_value_param_ent(type *method, int pos);
/**
* Returns a type that represents the copied value arguments.
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 (type *method);
/**
* @page union_type Representation of a union type.
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 (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);
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 (type *array, int dimension);
+ir_node * get_array_lower_bound (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 (type *array, int dimension);
+/** returns true if lower bound != Unknown */
+int has_array_upper_bound (type *array, int dimension);
+ir_node * get_array_upper_bound (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 (type *array, int dimension);
void set_array_order (type *array, int dimension, int order);
int get_array_order (type *array, int dimension);
entity *get_array_element_entity (type *array);
/** Returns true if a type is an array type. */
-bool is_array_type (type *array);
+int is_array_type(type *array);
/**
* @page enumeration_type Representation of an enumeration type
const char *get_enumeration_name(type *enumeration, int pos);
/** Returns true if a type is a enumeration type. */
-bool is_enumeration_type (type *enumeration);
+int is_enumeration_type (type *enumeration);
/**
* @page pointer_type Representation of a pointer type
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 (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 (type *primitive);
/**
/*******************************************************************/
-/** 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_ */