X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Ftype.h;h=916006c1f6120c24e3576ab00cab4314c7e92fa6;hb=d0d85962ef52c14950db90e5981a7bea36023ab3;hp=fc87b502d37ae3fd9d258d9dbbba0f80ddfc0094;hpb=feaa0dfbcff2612559f774caf49c91d67294ea70;p=libfirm diff --git a/ir/tr/type.h b/ir/tr/type.h index fc87b502d..916006c1f 100644 --- a/ir/tr/type.h +++ b/ir/tr/type.h @@ -5,7 +5,7 @@ * 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$ */ @@ -59,31 +59,33 @@ * * 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. * @@ -107,10 +109,10 @@ typedef struct ir_type ir_type; # 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. @@ -139,22 +141,22 @@ const char* get_type_name(const ir_type *tp); */ 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. * @@ -194,23 +196,24 @@ typedef enum { * 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. */ @@ -287,11 +290,15 @@ void set_type_alignment_bytes(ir_type *tp, int size); */ 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. */ @@ -323,7 +330,7 @@ void inc_master_type_visited(void); * @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. @@ -398,7 +405,7 @@ int equal_type(ir_type *typ1, ir_type *typ2); * @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 @@ -406,7 +413,7 @@ int smaller_type (ir_type *st, ir_type *lt); * If the type opcode is set to type_class the type represents class * types. A list of fields and methods is associated with a class. * Further a class can inherit from and bequest to other classes. - * @@@ value class??? + * * The following attributes are private to this type kind: * - member: All entities belonging to this class. This are method entities * which have type_method or fields that can have any of the @@ -435,7 +442,7 @@ int smaller_type (ir_type *st, ir_type *lt); * representing this type. This information is useful for lowering * of InstOf and TypeChk nodes. Default: NULL * - * - vtable_size: The size of this class vritual function table. + * - vtable_size: The size of this class virtual function table. * Default: 0 * * - final: A final class is always a leaf in the class hierarchy. Final @@ -443,6 +450,16 @@ int smaller_type (ir_type *st, ir_type *lt); * can only be computed in whole world compilations, we allow to * set this flag. It is used in optimizations if get_opt_closed_world() * is false. Default: false + * + * - interface: The class represents an interface. This flag can be set to distinguish + * between interfaces, abstract classes and other classes that all may + * have the peculiarity peculiarity_description. Depending on this flag + * the lowering might do different actions. Default: false + * + * - abstract : The class represents an abstract class. This flag can be set to distinguish + * between interfaces, abstract classes and other classes that all may + * have the peculiarity peculiarity_description. Depending on this flag + * the lowering might do different actions. Default: false */ /** Creates a new class type. */ @@ -454,37 +471,37 @@ ir_type *new_d_type_class (ident *name, dbg_info *db); /* --- 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. @@ -566,7 +583,7 @@ void remove_class_supertype(ir_type *clss, ir_type *supertype); #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!)*/ @@ -580,19 +597,21 @@ typedef enum peculiarity { peculiarity_existent /**< The entity/type (can) exist. @@@ eventually rename to 'real' i.e., 'echt' This serves better as opposition to description _and_ inherited.*/ -} peculiarity; -const char *get_peculiarity_string(peculiarity p); +} ir_peculiarity; + +/** Returns a human readable string for a peculiarity. */ +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); @@ -603,10 +622,22 @@ void set_class_vtable_size(ir_type *clss, unsigned size); /** Returns non-zero if a class is final. */ int is_class_final(const ir_type *clss); -/** Sets if a class is final. */ +/** Sets the class final flag. */ void set_class_final(ir_type *clss, int flag); -/* Set and get a class' dfn -- +/** Return non-zero if a class is an interface */ +int is_class_interface(const ir_type *clss); + +/** Sets the class interface flag. */ +void set_class_interface(ir_type *clss, int flag); + +/** Return non-zero if a class is an abstract class. */ +int is_class_abstract(const ir_type *clss); + +/** Sets the class abstract flag. */ +void set_class_abstract(ir_type *clss, int flag); + +/** Set and get a class' dfn -- @todo This is an undocumented field, subject to change! */ void set_class_dfn (ir_type *clss, int dfn); int get_class_dfn (const ir_type *clss); @@ -617,8 +648,9 @@ int is_Class_type(const ir_type *clss); /** * @page struct_type Representation of a struct type * - * Type_strct represents aggregate types that consist of a list + * A struct type represents aggregate types that consist of a list * of fields. + * * The following attributes are private to this type kind: * - member: All entities belonging to this class. This are the fields * that can have any of the following types: type_class, @@ -637,26 +669,26 @@ ir_type *new_d_type_struct (ident *name, dbg_info* db); /* --- 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 @@ -733,11 +765,20 @@ ir_type *get_method_param_type(ir_type *method, int pos); 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); @@ -749,7 +790,7 @@ ir_type *get_method_res_type(ir_type *method, int pos); 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. @@ -792,9 +833,9 @@ int get_method_first_variadic_param_index(const ir_type *method); void set_method_first_variadic_param_index(ir_type *method, int index); /** - * additional method type properties: - * Tell about special properties of a method type. Some - * of these may be discovered by analyses. + * Additional method type properties: + * Tell about special properties of a method type. Some + * of these may be discovered by analyses. */ typedef enum { mtp_no_property = 0x00000000, /**< no additional properties, default */ @@ -816,8 +857,9 @@ typedef enum { 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_inherited = (1<<31) /**< used only in irg's, means property is inherited - from type. */ + 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; /** Returns the mask of the additional graph properties. */ @@ -830,26 +872,28 @@ void set_method_additional_properties(ir_type *method, unsigned property_mask); void set_method_additional_property(ir_type *method, mtp_additional_property flag); /** - * calling conventions: lower 24 bits are the number of register parameters, - * upper 8 encode the calling conventions + * Calling conventions: lower 24 bits are the number of register parameters, + * upper 8 encode the calling conventions. */ typedef enum { cc_reg_param = 0x01000000, /**< Transmit parameters in registers, else the stack is used. This flag may be set as default on some architectures. */ cc_last_on_top = 0x02000000, /**< The last non-register parameter is transmitted on top of - the stack. This is equivalent to the stdcall or pascal - calling convention. If this flag is not set, the first - non-register parameter is used (cdecl calling convention) */ + the stack. This is equivalent to the pascal + calling convention. If this flag is not set, the first + non-register parameter is used (stdcall or cdecl + calling convention) */ cc_callee_clear_stk = 0x04000000, /**< The callee clears the stack. This forbids variadic function calls (stdcall). */ cc_this_call = 0x08000000, /**< The first parameter is a this pointer and is transmitted in a special way. */ - cc_bits = (0xFF << 24) /**< the calling convention bits */ } calling_convention; -/* some often used cases: made as defines for firmjni */ +/* some often used cases: made as defines because firmjni cannot handle two + equal enum values. */ + /** cdecl calling convention */ #define cc_cdecl_set (0) /** stdcall calling convention */ @@ -857,7 +901,7 @@ typedef enum { /** fastcall calling convention */ #define cc_fastcall_set (cc_reg_param|cc_callee_clear_stk) -/** return the default calling convention for method types */ +/** Returns the default calling convention for method types. */ unsigned get_default_cc_mask(void); /** @@ -876,17 +920,17 @@ unsigned get_default_cc_mask(void); #define IS_FASTCALL(cc_mask) (((cc_mask) & cc_bits) == cc_fastcall_set) /** - * set the CDECL convention bits + * Sets the CDECL convention bits. */ #define SET_CDECL(cc_mask) (((cc_mask) & ~cc_bits) | cc_cdecl_set) /** - * set the STDCALL convention bits + * Set. the STDCALL convention bits. */ #define SET_STDCALL(cc_mask) (((cc_mask) & ~cc_bits) | cc_stdcall_set) /** - * set the FASTCALL convention bits + * Sets the FASTCALL convention bits. */ #define SET_FASTCALL(cc_mask) (((cc_mask) & ~cc_bits) | cc_fastcall_set) @@ -908,7 +952,10 @@ int is_Method_type (const ir_type *method); /** * @page union_type Representation of a union (variant) type. * - * The union type represents union types. + * The union type represents union types. Note that this representation + * resembles the C union type. For tagged variant types like in Pascal or Modula + * a combination of a struct and a union type must be used. + * * - n_types: Number of unioned types. * - members: Entities for unioned types. Fixed length array. * This is a dynamic list that can be grown with an "add_" function, @@ -926,19 +973,19 @@ ir_type *new_d_type_union (ident *name, dbg_info* db); 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); @@ -989,7 +1036,7 @@ ir_type *new_d_type_array (ident *name, int n_dimensions, int get_array_n_dimensions (const ir_type *array); /** - * Allocates Const nodes of mode_I for one array dimension. + * Allocates Const nodes of mode_Is for one array dimension. * Upper bound in Firm is the element next to the last, i.e. [lower,upper[ */ void set_array_bounds_int (ir_type *array, int dimension, int lower_bound, @@ -1003,14 +1050,14 @@ void set_array_bounds (ir_type *array, int dimension, ir_node *lower_boun /** Sets the lower bound for one array dimension, i.e. [lower,upper[ */ void set_array_lower_bound (ir_type *array, int dimension, ir_node *lower_bound); -/** Allocates Const nodes of mode_I for the lower bound of an array +/** Allocates Const nodes of mode_Is for the lower bound of an array dimension, i.e. [lower,upper[ */ void set_array_lower_bound_int (ir_type *array, int dimension, int lower_bound); /** Sets the upper bound for one array dimension, i.e. [lower,upper[ */ void set_array_upper_bound (ir_type *array, int dimension, ir_node *upper_bound); -/** Allocates Const nodes of mode_I for the upper bound of an array +/** Allocates Const nodes of mode_Is for the upper bound of an array dimension, i.e. [lower,upper[. */ void set_array_upper_bound_int (ir_type *array, int dimension, int upper_bound); @@ -1033,7 +1080,7 @@ void set_array_order (ir_type *array, int dimension, int order); /** 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. */ @@ -1043,10 +1090,10 @@ void set_array_element_type (ir_type *array, ir_type* tp); 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); @@ -1057,40 +1104,55 @@ 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); + +/** Returns the enumeration constant at a given position. */ +ir_enum_const *get_enumeration_const(const ir_type *enumeration, int pos); -/** Sets the enumeration value at a given position. */ -void set_enumeration_enum (ir_type *enumeration, int pos, tarval *con); +/** Returns the enumeration type owner of an enumeration constant. */ +ir_type *get_enumeration_owner(const ir_enum_const *enum_cnst); -/** Returns the enumeration value at a given position. */ -tarval *get_enumeration_enum (const ir_type *enumeration, int pos); +/** Sets the enumeration constant value. */ +void set_enumeration_value(ir_enum_const *enum_cnst, tarval *con); -/** Assign an ident to an enumeration value at a given position. */ -void set_enumeration_nameid (ir_type *enumeration, int pos, ident *id); +/** Returns the enumeration constant value. */ +tarval *get_enumeration_value(const ir_enum_const *enum_cnst); -/** Returns the assigned ident of an enumeration value at a given position. */ -ident *get_enumeration_nameid (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 name of an enumeration value at a given position. */ -const char *get_enumeration_name(const ir_type *enumeration, int pos); +/** 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 @@ -1126,18 +1188,18 @@ ir_type *find_pointer_type_to_type (ir_type *tp); /** * @page primitive_type Representation of a primitive type * - * Primitive types are types that represent indivisible data values that - * map directly to modes. They don't have a private attribute. The + * Primitive types are types that represent atomic data values that + * map directly to modes. They don't have private attributes. The * 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); /** @@ -1159,7 +1221,8 @@ int is_Primitive_type (const ir_type *primitive); */ /** A variable that contains the only none type. */ extern ir_type *firm_none_type; -/** Returns the none type */ + +/** Returns the none type. */ ir_type *get_none_type(void); /** @@ -1181,7 +1244,8 @@ ir_type *get_none_type(void); */ /** A variable that contains the only unknown type. */ extern ir_type *firm_unknown_type; -/** Returns the unknown type */ + +/** Returns the unknown type. */ ir_type *get_unknown_type(void); @@ -1195,7 +1259,7 @@ int is_atomic_type(const ir_type *tp); /* --- Support for compound types --- */ /** - * Gets the number of elements in a firm compound type. + * Gets the number of elements in a Firm compound type. * * This is just a comfortability function, because structs and * classes can often be treated be the same code, but they have @@ -1208,7 +1272,7 @@ int is_atomic_type(const ir_type *tp); int get_compound_n_members(const ir_type *tp); /** - * Gets the member of a firm compound type at position pos. + * Gets the member of a Firm compound type at position pos. * * @param tp The type (must be struct, union or class). * @param pos The number of the member. @@ -1217,13 +1281,13 @@ int get_compound_n_members(const ir_type *tp); * * @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 compound. + * Checks whether a type is a compound type. * * @param tp - any type * @@ -1236,6 +1300,11 @@ int is_compound_type(const ir_type *tp); */ 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. */ @@ -1246,11 +1315,11 @@ int is_lowered_type(const ir_type *tp); * so all class access functions work. * Frame types are not in the global list of types. */ -ir_type *new_type_frame(ident *name); +ir_type *new_type_frame(ident *name); /** * Sets a lowered type for a type. This sets both associations - * and marks lowered type as a "lowered" one. + * and marks lowered_type as a "lowered" one. */ void set_lowered_type(ir_type *tp, ir_type *lowered_type); @@ -1263,7 +1332,7 @@ ir_type *get_associated_type(const ir_type *tp); /** * Allocate an area of size bytes aligned at alignment * at the start or the end of a frame type. - * The frame type must have already an fixed layout. + * The frame type must already have a fixed layout. * * @param frame_type a frame type * @param size the size of the entity @@ -1272,7 +1341,7 @@ ir_type *get_associated_type(const ir_type *tp); * * @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 **/