* Author: Goetz Lindenmaier
* Modified by: Michael Beck
* Created:
- * Copyright: (c) 2001-2003 Universität Karlsruhe
+ * Copyright: (c) 2001-2006 Universität Karlsruhe
* Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
* CVS-ID: $Id$
*/
*
* The common fields are:
*
- * - firm_kind: A firm_kind tag containing k_type. This is useful
- * for dynamically checking whether a node is a type node.
- * - type_op: A tp_op specifying the kind of the type.
- * - mode: The mode to be used to represent the type on a machine.
- * - 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 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
- * 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 information with the type.
+ * - firm_kind: A firm_kind tag containing k_type. This is useful
+ * for dynamically checking whether a node is a type node.
+ * - type_op: A tp_op specifying the kind of the type.
+ * - name: An identifier specifying the name of the type. To be
+ * set by the frontend.
+ * - visibility: The visibility of this type.
+ * - size: The size of the type, i.e. an entity of this type will
+ * 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)
+ * - mode: The mode to be used to represent the type on a machine.
+ * - 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.
+ * - assoc_type: The associated lowered/upper type.
+ * - visit: A counter for walks of the type information.
+ * - link: A void* to associate some additional information with the type.
*
* These fields can only be accessed via access functions.
*
# include "type_or_entity.h"
-/** frees all entities associated with a type.
- Does not free array entity.
- Warning: make sure these entities are not referenced anywhere else.
-*/
+/** Frees all entities associated with a type.
+ * Does not free the array entity.
+ * Warning: ensure these entities are not referenced anywhere else.
+ */
void free_type_entities(ir_type *tp);
/** Frees the memory used by the type.
*/
typedef enum {
visibility_local, /**< The entity is only visible locally. This is the default for
- entities.
- The type is only visible locally. All instances are allocated
- locally, and no pointer to entities of this type are passed
- out of this compilation unit. */
+ entities.
+ The type is only visible locally. All instances are allocated
+ locally, and no pointer to entities of this type are passed
+ out of this compilation unit. */
visibility_external_visible, /**< The entity is visible to other external program parts, but
- it is defined here. It may not be optimized away. The entity must
- be static_allocated.
- For types: entities of this type can be accessed externally. No
- instances of this type are allocated externally. */
+ it is defined here. It may not be optimized away. The entity must
+ be static_allocated.
+ For types: entities of this type can be accessed externally. No
+ instances of this type are allocated externally. */
visibility_external_allocated /**< The entity is defined and allocated externally. This compilation
- must not allocate memory for this entity. The entity must
- be static_allocated. This can also be an external defined
- method.
- For types: entities of this type are allocated and accessed from
- external code. Default for types. */
-} visibility;
+ must not allocate memory for this entity. The entity must
+ be static_allocated. This can also be an external defined
+ method.
+ For types: entities of this type are allocated and accessed from
+ external code. Default for types. */
+} ir_visibility;
/** The visibility of a type.
*
* Entities of types are never visibility_external_allocated (right?).
* Else returns visibility_local.
*/
-visibility get_type_visibility (const ir_type *tp);
-void set_type_visibility (ir_type *tp, visibility v);
+ir_visibility get_type_visibility(const ir_type *tp);
+void set_type_visibility(ir_type *tp, ir_visibility v);
/** 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
- possible, fields must be accessed by Sel
- nodes. This is the default value except for
- pointer, primitive and method types. */
+ Address computation to access fields is not
+ possible, fields must be accessed by Sel
+ nodes. Enumeration constants might be undefined.
+ This is the default value except for
+ pointer, primitive and method 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, primitive and method
- types. */
+ have an offset assigned. Size of the type is known.
+ Arrays can be accessed by explicit address
+ computation. Enumeration constants must be defined.
+ Default for pointer, primitive and method types. */
} type_state;
/** Returns a human readable string for the enum entry. */
*/
void set_type_alignment_bits(ir_type *tp, int size);
+/** Returns the visited count of a type. */
unsigned long get_type_visited(const ir_type *tp);
+/** Sets the visited count of a type to num. */
void set_type_visited(ir_type *tp, unsigned long num);
-/* Sets visited field in type to type_visited. */
+/** Sets visited field in type to type_visited. */
void mark_type_visited(ir_type *tp);
+/** Returns non-zero if the type is already visited */
int type_visited(const ir_type *tp);
+/** Returns non-zero if the type is not yet visited */
int type_not_visited(const ir_type *tp);
/** Returns the associated link field of a type. */
* @return
* true if the thing is a type, else false
*/
-int is_type (const void *thing);
+int is_type(const void *thing);
/**
* Checks whether two types are structurally equal.
* @return smaller than the points_to type of lt.
*
*/
-int smaller_type (ir_type *st, ir_type *lt);
+int smaller_type(ir_type *st, ir_type *lt);
/**
* @page class_type Representation of a class type
/* --- manipulate private fields of class type --- */
/** Adds the entity as member of the class. */
-void add_class_member (ir_type *clss, entity *member);
+void add_class_member (ir_type *clss, ir_entity *member);
/** Returns the number of members of this class. */
-int get_class_n_members (const ir_type *clss);
+int get_class_n_members (const ir_type *clss);
/** Returns the member at position pos, 0 <= pos < n_member */
-entity *get_class_member (const ir_type *clss, int pos);
+ir_entity *get_class_member (const ir_type *clss, int pos);
/** Returns index of mem in clss, -1 if not contained. */
-int get_class_member_index(const ir_type *clss, entity *mem);
+int get_class_member_index(const ir_type *clss, ir_entity *mem);
/** Finds the member with name 'name'. If several members with the same
* name returns one of them. Returns NULL if no member found. */
-entity *get_class_member_by_name(ir_type *clss, ident *name);
+ir_entity *get_class_member_by_name(ir_type *clss, ident *name);
/** Overwrites the member at position pos, 0 <= pos < n_member with
* the passed entity. */
-void set_class_member (ir_type *clss, entity *member, int pos);
+void set_class_member (ir_type *clss, ir_entity *member, int pos);
/** Replaces complete member list in class type by the list passed.
*
* Copies the list passed. This function is necessary to reduce the number of members.
* members is an array of entities, num the size of this array. Sets all
* owners of the members passed to clss. */
-void set_class_members (ir_type *clss, entity *members[], int arity);
+void set_class_members (ir_type *clss, ir_entity *members[], int arity);
/** Finds member in the list of members and removes it.
*
* Shrinks the member list, so iterate from the end!!!
* Does not deallocate the entity. */
-void remove_class_member(ir_type *clss, entity *member);
+void remove_class_member(ir_type *clss, ir_entity *member);
/** Adds subtype as subtype to clss.
#define remove_class_base_type(clss, basetype) remove_class_supertype(clss, basetype)
/** This enumeration flags the peculiarity of entities and types. */
-typedef enum peculiarity {
+typedef enum {
peculiarity_description, /**< Represents only a description. The entity/type is never
allocated, no code/data exists for this entity/type.
@@@ eventually rename to descriptive (adjective as the others!)*/
peculiarity_existent /**< The entity/type (can) exist.
@@@ eventually rename to 'real' i.e., 'echt'
This serves better as opposition to description _and_ inherited.*/
-} peculiarity;
+} ir_peculiarity;
/** Returns a human readable string for a peculiarity. */
-const char *get_peculiarity_string(peculiarity p);
+const char *get_peculiarity_name(ir_peculiarity p);
/** Returns the peculiarity of the class. */
-peculiarity get_class_peculiarity (const ir_type *clss);
+ir_peculiarity get_class_peculiarity (const ir_type *clss);
/** Sets the peculiarity of the class. */
-void set_class_peculiarity (ir_type *clss, peculiarity pec);
+void set_class_peculiarity (ir_type *clss, ir_peculiarity pec);
/** Returns the type info entity of a class. */
-entity *get_class_type_info(const ir_type *clss);
+ir_entity *get_class_type_info(const ir_type *clss);
/** Set a type info entity for the class. */
-void set_class_type_info(ir_type *clss, entity *ent);
+void set_class_type_info(ir_type *clss, ir_entity *ent);
/** Returns the size of the virtual function table. */
unsigned get_class_vtable_size(const ir_type *clss);
/* --- manipulate private fields of struct --- */
/** Adds the entity as member of the struct. */
-void add_struct_member (ir_type *strct, entity *member);
+void add_struct_member (ir_type *strct, ir_entity *member);
/** Returns the number of members of this struct. */
-int get_struct_n_members (const ir_type *strct);
+int get_struct_n_members (const ir_type *strct);
/** Returns the member at position pos, 0 <= pos < n_member */
-entity *get_struct_member (const ir_type *strct, int pos);
+ir_entity *get_struct_member (const ir_type *strct, int pos);
/** Returns index of member in strct, -1 if not contained. */
-int get_struct_member_index(const ir_type *strct, entity *member);
+int get_struct_member_index(const ir_type *strct, ir_entity *member);
/** Overwrites the member at position pos, 0 <= pos < n_member with
the passed entity. */
-void set_struct_member (ir_type *strct, int pos, entity *member);
+void set_struct_member (ir_type *strct, int pos, ir_entity *member);
/** Finds member in the list of members and removes it. */
-void remove_struct_member (ir_type *strct, entity *member);
+void remove_struct_member (ir_type *strct, ir_entity *member);
/** Returns true if a type is a struct type. */
-int is_Struct_type(const ir_type *strct);
+int is_Struct_type(const ir_type *strct);
/**
* @page method_type Representation of a method type
void set_method_param_type(ir_type *method, int pos, ir_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. */
-entity *get_method_value_param_ent(ir_type *method, int pos);
+ir_entity *get_method_value_param_ent(ir_type *method, int pos);
/**
- * Returns a type that represents the copied value arguments.
+ * Returns a type that represents the copied value arguments if one
+ * was allocated, else NULL.
*/
ir_type *get_method_value_param_type(const ir_type *method);
+/** Returns an ident representing the parameters name. Returns NULL if not set.
+ For debug support only. */
+ident *get_method_param_ident(ir_type *method, int pos);
+/** Returns a string representing the parameters name. Returns NULL if not set.
+ For debug support only. */
+const char *get_method_param_name(ir_type *method, int pos);
+/** Sets an ident representing the parameters name. For debug support only. */
+void set_method_param_ident(ir_type *method, int pos, ident *id);
/** Returns the number of results of a method type. */
int get_method_n_ress (const ir_type *method);
void set_method_res_type(ir_type *method, int pos, ir_type *tp);
/** 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(ir_type *method, int pos);
+ir_entity *get_method_value_res_ent(ir_type *method, int pos);
/**
* Returns a type that represents the copied value results.
GCC: __attribute__((malloc)). */
mtp_property_intrinsic = 0x00000040, /**< This method is intrinsic. It is expected that
a lowering phase will remove all calls to it. */
+ mtp_property_runtime = 0x00000080, /**< This method represents a runtime routine. */
mtp_property_inherited = (1<<31) /**< Internal. Used only in irg's, means property is
inherited from type. */
} mtp_additional_property;
int get_union_n_members (const ir_type *uni);
/** Adds a new entity to a union type */
-void add_union_member (ir_type *uni, entity *member);
+void add_union_member (ir_type *uni, ir_entity *member);
/** Returns the entity at position pos of a union */
-entity *get_union_member (const ir_type *uni, int pos);
+ir_entity *get_union_member (const ir_type *uni, int pos);
/** Returns index of member in uni, -1 if not contained. */
-int get_union_member_index(const ir_type *uni, entity *member);
+int get_union_member_index(const ir_type *uni, ir_entity *member);
/** Overwrites a entity at position pos in a union type. */
-void set_union_member (ir_type *uni, int pos, entity *member);
+void set_union_member (ir_type *uni, int pos, ir_entity *member);
/** Finds member in the list of members and removes it. */
-void remove_union_member (ir_type *uni, entity *member);
+void remove_union_member (ir_type *uni, ir_entity *member);
/** Returns true if a type is a union type. */
int is_Union_type (const ir_type *uni);
/** Returns the order of an array dimension. */
int get_array_order (const ir_type *array, int dimension);
-/** Find the array dimension that is placed at order ord. */
+/** Find the array dimension that is placed at order order. */
int find_array_dimension(const ir_type *array, int order);
/** Sets the array element type. */
ir_type *get_array_element_type (ir_type *array);
/** Sets the array element entity. */
-void set_array_element_entity (ir_type *array, entity *ent);
+void set_array_element_entity (ir_type *array, ir_entity *ent);
/** Get the array element entity. */
-entity *get_array_element_entity (const ir_type *array);
+ir_entity *get_array_element_entity (const ir_type *array);
/** Returns true if a type is an array type. */
int is_Array_type(const ir_type *array);
* Enumeration types need not necessarily be represented explicitly
* by Firm types, as the frontend can lower them to integer constants as
* well. For debugging purposes or similar tasks this information is useful.
+ * The type state layout_fixed is set, if all enumeration constant have
+ * there tarvals assigned. Until then
*
- * - *enum: The target values representing the constants used to
+ * - *const: The target values representing the constants used to
* represent individual enumerations.
- * - *enum_nameid: Idents containing the source program name of the enumeration
- * constants
*/
+
+#ifndef _IR_ENUM_CONST_TYPEDEF_
+#define _IR_ENUM_CONST_TYPEDEF_
+typedef struct ir_enum_const ir_enum_const;
+#endif
+
/** Create a new type enumeration -- set the enumerators independently. */
-ir_type *new_type_enumeration (ident *name, int n_enums);
+ir_type *new_type_enumeration(ident *name, int n_enums);
/** Create a new type enumeration with debug information -- set the enumerators independently. */
-ir_type *new_d_type_enumeration (ident *name, int n_enums, dbg_info *db);
+ir_type *new_d_type_enumeration(ident *name, int n_enums, dbg_info *db);
/* --- manipulate fields of enumeration type. --- */
+/** Set an enumeration constant to a enumeration type at a given position. */
+void set_enumeration_const(ir_type *enumeration, int pos, ident *nameid, tarval *con);
+
/** Returns the number of enumeration values of this enumeration */
-int get_enumeration_n_enums (const ir_type *enumeration);
+int get_enumeration_n_enums(const ir_type *enumeration);
-/** Sets the enumeration value at a given position. */
-void set_enumeration_enum (ir_type *enumeration, int pos, tarval *con);
+/** Returns the enumeration constant at a given position. */
+ir_enum_const *get_enumeration_const(const ir_type *enumeration, int pos);
-/** Returns the enumeration value at a given position. */
-tarval *get_enumeration_enum (const ir_type *enumeration, int pos);
+/** Returns the enumeration type owner of an enumeration constant. */
+ir_type *get_enumeration_owner(const ir_enum_const *enum_cnst);
-/** Assign an ident to an enumeration value at a given position. */
-void set_enumeration_nameid (ir_type *enumeration, int pos, ident *id);
+/** Sets the enumeration constant value. */
+void set_enumeration_value(ir_enum_const *enum_cnst, tarval *con);
-/** Returns the assigned ident of an enumeration value at a given position. */
-ident *get_enumeration_nameid (const ir_type *enumeration, int pos);
+/** Returns the enumeration constant value. */
+tarval *get_enumeration_value(const ir_enum_const *enum_cnst);
-/** Returns the assigned name of an enumeration value at a given position. */
-const char *get_enumeration_name(const ir_type *enumeration, int pos);
+/** Assign an ident to an enumeration constant. */
+void set_enumeration_nameid(ir_enum_const *enum_cnst, ident *id);
+
+/** Returns the assigned ident of an enumeration constant. */
+ident *get_enumeration_nameid(const ir_enum_const *enum_cnst);
+
+/** Returns the assigned name of an enumeration constant. */
+const char *get_enumeration_name(const ir_enum_const *enum_cnst);
/** Returns true if a type is a enumeration type. */
-int is_Enumeration_type (const ir_type *enumeration);
+int is_Enumeration_type(const ir_type *enumeration);
/**
* @page pointer_type Representation of a pointer type
* important information they carry is held in the common mode field.
*/
/** Creates a new primitive type. */
-ir_type *new_type_primitive (ident *name, ir_mode *mode);
+ir_type *new_type_primitive(ident *name, ir_mode *mode);
/** Creates a new primitive type with debug information. */
-ir_type *new_d_type_primitive (ident *name, ir_mode *mode, dbg_info* db);
+ir_type *new_d_type_primitive(ident *name, ir_mode *mode, dbg_info* db);
/** Returns true if a type is a primitive type. */
-int is_Primitive_type (const ir_type *primitive);
+int is_Primitive_type(const ir_type *primitive);
/**
ir_type *get_none_type(void);
/**
- * @page unknown_type
+ * @page unknown_type The Unknown type
*
* This type is an auxiliary type dedicated to support type analyses.
*
*
* @see get_compound_n_members() for justification of existence.
*/
-entity *get_compound_member(const ir_type *tp, int pos);
+ir_entity *get_compound_member(const ir_type *tp, int pos);
/** Returns index of member in tp, -1 if not contained. */
-int get_compound_member_index(const ir_type *tp, entity *member);
+int get_compound_member_index(const ir_type *tp, ir_entity *member);
/**
* Checks whether a type is a compound type.
*/
int is_frame_type(const ir_type *tp);
+/**
+ * Checks, whether a type is a value parameter type.
+ */
+int is_value_param_type(const ir_type *tp);
+
/**
* Checks, whether a type is a lowered type.
*/
*
* @return the entity representing the area
*/
-entity *frame_alloc_area(type *frame_type, int size, int alignment, int at_start);
+ir_entity *frame_alloc_area(ir_type *frame_type, int size, int alignment, int at_start);
/*-----------------------------------------------------------------*/
/** Debug aides **/