X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=include%2Flibfirm%2Ftyperep.h;h=5b3903add8ffe265df6e3f02093190d785ac424b;hb=027ca22d1a07f01bafc1e393f09daa9bd0d3ea7b;hp=d2e8956a8be22b5b4999e7ce7bf9237c0bd5de1d;hpb=da0db014608257f77c6ed0518c685c8dc1b465c6;p=libfirm diff --git a/include/libfirm/typerep.h b/include/libfirm/typerep.h index d2e8956a8..5b3903add 100644 --- a/include/libfirm/typerep.h +++ b/include/libfirm/typerep.h @@ -30,7 +30,7 @@ #include "begin.h" /** - * @page entity Entity representation + * @defgroup ir_entity Entities * * An entity is the representation of program known objects in Firm. * The primary concept of entities is to represent members of complex @@ -73,7 +73,17 @@ * * These fields can only be accessed via access functions. * - * @see ir_type, ir_entity + * Overwrites is a field that specifies that an access to the overwritten + * entity in the supertype must use this entity. It's a list as with + * multiple inheritance several entities can be overwritten. This field + * is mostly useful for method entities. + * If a Sel node selects an entity that is overwritten by other entities it + * must return a pointer to the entity of the dynamic type of the pointer + * that is passed to it. Lowering of the Sel node must assure this. + * Overwrittenby is the inverse of overwrites. Both add routines add + * both relations, they only differ in the order of arguments. + * + * @{ */ /** @@ -200,6 +210,29 @@ FIRM_API ir_entity *new_entity(ir_type *owner, ident *name, ir_type *tp); FIRM_API ir_entity *new_d_entity(ir_type *owner, ident *name, ir_type *tp, dbg_info *db); +/** + * Creates a new entity corresponding to a function parameter. + * This must be created on an irgs frame_type + */ +FIRM_API ir_entity *new_parameter_entity(ir_type *owner, size_t pos, + ir_type *type); + +/** + * Like new_parameter_entity() but with debug information. + */ +FIRM_API ir_entity *new_d_parameter_entity(ir_type *owner, size_t pos, + ir_type *type, dbg_info *dbgi); + +/** + * Check an entity. Currently, we check only if initialized constants + * are build on the const irg graph. + * + * @return + * 0 if no error encountered + * != 0 a trverify_error_codes code + */ +FIRM_API int check_entity(ir_entity *ent); + /** * Copies the entity if the new_owner is different from the * owner of the old entity, else returns the old entity. @@ -278,15 +311,6 @@ FIRM_API void set_entity_linkage(ir_entity *entity, ir_linkage linkage); FIRM_API void add_entity_linkage(ir_entity *entity, ir_linkage linkage); FIRM_API void remove_entity_linkage(ir_entity *entity, ir_linkage linkage); -/** - * This enumeration flags the volatility of entities and Loads/Stores. - * @deprecated - */ -typedef enum { - volatility_non_volatile, /**< The entity is not volatile. Default. */ - volatility_is_volatile /**< The entity is volatile. */ -} ir_volatility; - /** * Returns the volatility of an entity. * @deprecated @@ -313,22 +337,13 @@ FIRM_API void set_entity_alignment(ir_entity *entity, unsigned alignment); /** - * This enumeration flags the align of Loads/Stores. - * @deprecated - */ -typedef enum { - align_non_aligned, /**< The entity is not aligned. */ - align_is_aligned /**< The entity is aligned. Default */ -} ir_align; - -/** - * Returns indication wether entity is aligned in memory. + * Returns indication whether entity is aligned in memory. * @deprecated */ FIRM_API ir_align get_entity_aligned(const ir_entity *ent); /** - * Sets indication wether entity is aligned in memory + * Sets indication whether entity is aligned in memory * @deprecated */ FIRM_API void set_entity_aligned(ir_entity *ent, ir_align a); @@ -355,9 +370,10 @@ FIRM_API void *get_entity_link(const ir_entity *ent); /** Stores new intermediate information. */ FIRM_API void set_entity_link(ir_entity *ent, void *l); -/* -- Fields of method entities -- */ -/** The entity knows the corresponding irg if the entity is a method. - This allows to get from a Call to the called irg. */ +/** + * The entity knows the corresponding irg if the entity is a method. + * This allows to get from a Call to the called irg. + */ FIRM_API ir_graph *get_entity_irg(const ir_entity *ent); FIRM_API void set_entity_irg(ir_entity *ent, ir_graph *irg); @@ -418,7 +434,24 @@ FIRM_API dbg_info *get_entity_dbg_info(const ir_entity *ent); */ FIRM_API void set_entity_dbg_info(ir_entity *ent, dbg_info *db); -/* -- Representation of constant values of entities -- */ +#define IR_VA_START_PARAMETER_NUMBER ((size_t)-1) + +/** + * returns true if a given entity is a parameter_entity representing the + * address of a function parameter + */ +FIRM_API int is_parameter_entity(const ir_entity *entity); + +/** + * returns number of parameter a parameter entitiy represents + */ +FIRM_API size_t get_entity_parameter_number(const ir_entity *entity); + +/** + * set number of parameter an entity represents + */ +FIRM_API void set_entity_parameter_number(ir_entity *entity, size_t n); + /** * Returns true if the the node is representable as code on * const_code_irg. @@ -438,10 +471,13 @@ FIRM_API int is_irn_const_expression(ir_node *n); */ FIRM_API ir_node *copy_const_value(dbg_info *dbg, ir_node *n, ir_node *to_block); -/* Set has no effect for existent entities of type method. */ FIRM_API ir_node *get_atomic_ent_value(ir_entity *ent); FIRM_API void set_atomic_ent_value(ir_entity *ent, ir_node *val); +/** @defgroup ir_initializer Entity Initializers + * @{ + */ + /** the kind (type) of an initializer */ typedef enum ir_initializer_kind_t { /** initializer containing an ir_node from the const-code irg */ @@ -495,6 +531,8 @@ FIRM_API void set_initializer_compound_value(ir_initializer_t *initializer, FIRM_API ir_initializer_t *get_initializer_compound_value( const ir_initializer_t *initializer, size_t index); +/** @} */ + /** Sets the new style initializers of an entity. */ FIRM_API void set_entity_initializer(ir_entity *entity, ir_initializer_t *initializer); @@ -504,16 +542,6 @@ FIRM_API int has_entity_initializer(const ir_entity *entity); /** Return the new style initializers of an entity. */ FIRM_API ir_initializer_t *get_entity_initializer(const ir_entity *entity); -/* --- Fields of entities with a class type as owner --- */ -/* Overwrites is a field that specifies that an access to the overwritten - entity in the supertype must use this entity. It's a list as with - multiple inheritance several entities can be overwritten. This field - is mostly useful for method entities. - If a Sel node selects an entity that is overwritten by other entities it - must return a pointer to the entity of the dynamic type of the pointer - that is passed to it. Lowering of the Sel node must assure this. - Overwrittenby is the inverse of overwrites. Both add routines add - both relations, they only differ in the order of arguments. */ FIRM_API void add_entity_overwrites(ir_entity *ent, ir_entity *overwritten); FIRM_API size_t get_entity_n_overwrites(const ir_entity *ent); FIRM_API size_t get_entity_overwrites_index(const ir_entity *ent, ir_entity *overwritten); @@ -630,6 +658,41 @@ FIRM_API ir_entity *unknown_entity; /** Returns the @link unknown_entity unknown entity @endlink. */ FIRM_API ir_entity *get_unknown_entity(void); +/** @deprecated */ +typedef enum { + allocation_automatic, + allocation_parameter, + allocation_dynamic, + allocation_static +} ir_allocation; +/** @deprecated */ +FIRM_API ir_allocation get_entity_allocation(const ir_entity *ent); +/** @deprecated */ +FIRM_API void set_entity_allocation(ir_entity *ent, ir_allocation al); + +/** @deprecated */ +typedef enum { + peculiarity_existent, + peculiarity_description, + peculiarity_inherited +} ir_peculiarity; +/** @deprecated */ +FIRM_API ir_peculiarity get_entity_peculiarity(const ir_entity *ent); +/** @deprecated */ +FIRM_API void set_entity_peculiarity(ir_entity *ent, ir_peculiarity pec); + +/** @deprecated */ +FIRM_API int is_entity_final(const ir_entity *ent); +/** @deprecated */ +FIRM_API void set_entity_final(ir_entity *ent, int final); + +/** @deprecated */ +FIRM_API ir_peculiarity get_class_peculiarity(const ir_type *clss); +/** @deprecated */ +FIRM_API void set_class_peculiarity(ir_type *clss, ir_peculiarity pec); + +/** @} */ + /** Encodes how a pointer parameter is accessed. */ typedef enum ptr_access_kind { ptr_access_none = 0, /**< no access */ @@ -641,18 +704,39 @@ typedef enum ptr_access_kind { } ptr_access_kind; ENUM_BITSET(ptr_access_kind) -#define IS_READ(a) ((a) & ptr_access_read) -#define IS_WRITTEN(a) ((a) & ptr_access_write) -#define IS_STORED(a) ((a) & ptr_access_store) +/** + * @defgroup ir_type Type System + * + * Datastructure to hold type information. + * + * This module supplies a datastructure to represent all types + * known in the compiled program. This includes types specified + * in the program as well as types defined by the language. In the + * view of the intermediate representation there is no difference + * between these types. Finally it specifies some auxiliary types. + * + * There exist several kinds of types, arranged by the structure of + * the type. A type is described by a set of attributes. Some of + * these attributes are common to all types, others depend on the + * kind of the type. + * + * Types are different from the modes defined in irmode: Types are + * on the level of the programming language, modes at the level of + * the target processor. + * + * @{ + */ /** - * @page tyop type operations + * @defgroup tp_op Type Opcodes * This module specifies the kinds of types available in firm. * * They are called type opcodes. These include classes, structs, methods, unions, * arrays, enumerations, pointers and primitive types. * Special types with own opcodes are the id type, a type representing an unknown * type and a type used to specify that something has no type. + * + * @{ */ /** @@ -702,125 +786,7 @@ FIRM_API const char *get_tpop_name(const tp_op *op); */ FIRM_API tp_opcode get_tpop_code(const tp_op *op); -/** - * This type opcode marks that the corresponding type is a class type. - * - * Consequently the type refers to supertypes, subtypes and entities. - * Entities can be any fields, but also methods. - * @@@ value class or not??? - * This struct is dynamically allocated but constant for the lifetime - * of the library. - */ -FIRM_API const tp_op *type_class; -FIRM_API const tp_op *get_tpop_class(void); - -/** - * This type opcode marks that the corresponding type is a compound type - * as a struct in C. - * - * Consequently the type refers to a list of entities - * which may not be methods (but pointers to methods). - * This struct is dynamically allocated but constant for the lifetime - * of the library. - */ -FIRM_API const tp_op *type_struct; -FIRM_API const tp_op *get_tpop_struct(void); - -/** - * This type opcode marks that the corresponding type is a method type. - * - * Consequently it refers to a list of arguments and results. - * This struct is dynamically allocated but constant for the lifetime - * of the library. - */ -FIRM_API const tp_op *type_method; -FIRM_API const tp_op *get_tpop_method(void); - -/** - * This type opcode marks that the corresponding type is a union type. - * - * Consequently it refers to a list of unioned types. - * This struct is dynamically allocated but constant for the lifetime - * of the library. - */ -FIRM_API const tp_op *type_union; -FIRM_API const tp_op *get_tpop_union(void); - -/** - * This type opcode marks that the corresponding type is an array type. - * - * Consequently it contains a list of dimensions (lower and upper bounds) - * and an element type. - * This struct is dynamically allocated but constant for the lifetime - * of the library. - */ -FIRM_API const tp_op *type_array; -FIRM_API const tp_op *get_tpop_array(void); - -/** - * This type opcode marks that the corresponding type is an enumeration type. - * - * Consequently it contains a list of idents for the enumeration identifiers - * and a list of target values that are the constants used to implement - * the enumerators. - * This struct is dynamically allocated but constant for the lifetime - * of the library. - */ -FIRM_API const tp_op *type_enumeration; -FIRM_API const tp_op *get_tpop_enumeration(void); - -/** - * This type opcode marks that the corresponding type is a pointer type. - * - * It contains a reference to the type the pointer points to. - * This struct is dynamically allocated but constant for the lifetime - * of the library. - */ -FIRM_API const tp_op *type_pointer; -FIRM_API const tp_op *get_tpop_pointer(void); - -/** - * This type opcode marks that the corresponding type is a primitive type. - * - * Primitive types are types that are directly mapped to target machine - * modes. - * This struct is dynamically allocated but constant for the lifetime - * of the library. - */ -FIRM_API const tp_op *type_primitive; -FIRM_API const tp_op *get_tpop_primitive(void); - -/** - * The code type is used to mark pieces of code (basic blocks) - */ -FIRM_API const tp_op *tpop_code; -FIRM_API const tp_op *get_tpop_code_type(void); - -/** - * This type opcode is an auxiliary opcode dedicated to support type analyses. - * - * Types with this opcode represents that there is no type. - * The type can be used to initialize fields of the type* that actually can not - * contain a type or that are initialized for an analysis. There exists exactly - * one type with this opcode. - */ -FIRM_API const tp_op *tpop_none; -FIRM_API const tp_op *get_tpop_none(void); - -/** - * This type opcode is an auxiliary opcode dedicated to support type analyses. - * - * Types with this opcode represents that there could be a type, but it is not - * known. This type can be used to initialize fields before an analysis (not known - * yet) or to represent the top of a lattice (could not be determined). There exists - * exactly one type with this opcode. - */ -FIRM_API const tp_op *tpop_unknown; -FIRM_API const tp_op *get_tpop_unknown(void); - -/* ----------------------------------------------------------------------- */ -/* Classify pairs of types/entities in the inheritance relations. */ -/* ----------------------------------------------------------------------- */ +/** @} */ /** Returns true if low is subclass of high. * @@ -867,10 +833,6 @@ FIRM_API int is_overwritten_by(ir_entity *high, ir_entity *low); FIRM_API ir_entity *resolve_ent_polymorphy(ir_type *dynamic_class, ir_entity* static_ent); -/* ----------------------------------------------------------------------- */ -/* Resolve implicit inheritance. */ -/* ----------------------------------------------------------------------- */ - /** Default name mangling for inherited entities. * * Returns an ident that consists of the name of type followed by an @@ -945,34 +907,24 @@ FIRM_API void compute_inh_transitive_closure(void); /** Free memory occupied by the transitive closure information. */ FIRM_API void free_inh_transitive_closure(void); - -/* - subtype ------------------------------------------------------------- */ - /** Iterate over all transitive subtypes. */ FIRM_API ir_type *get_class_trans_subtype_first(const ir_type *tp); FIRM_API ir_type *get_class_trans_subtype_next(const ir_type *tp); FIRM_API int is_class_trans_subtype(const ir_type *tp, const ir_type *subtp); -/* - supertype ----------------------------------------------------------- */ - /** Iterate over all transitive supertypes. */ FIRM_API ir_type *get_class_trans_supertype_first(const ir_type *tp); FIRM_API ir_type *get_class_trans_supertype_next(const ir_type *tp); -/* - overwrittenby ------------------------------------------------------- */ - /** Iterate over all entities that transitive overwrite this entities. */ FIRM_API ir_entity *get_entity_trans_overwrittenby_first(const ir_entity *ent); FIRM_API ir_entity *get_entity_trans_overwrittenby_next(const ir_entity *ent); -/* - overwrites ---------------------------------------------------------- */ - /** Iterate over all transitive overwritten entities. */ FIRM_API ir_entity *get_entity_trans_overwrites_first(const ir_entity *ent); FIRM_API ir_entity *get_entity_trans_overwrites_next(const ir_entity *ent); -/* ----------------------------------------------------------------------- */ /** The state of Cast operations that cast class types or pointers to class * types. * @@ -990,10 +942,8 @@ FIRM_API ir_entity *get_entity_trans_overwrites_next(const ir_entity *ent); * relation. Example: (A)(new C()). * any: Cast operations do not conform with the transitive inheritance * relation. Example: (B2)(new B1()) - */ -/* ----------------------------------------------------------------------- */ - -/** Flags for class cast state. + * + * Flags for class cast state. * * The state in irp is always smaller or equal to the state of any * irg. @@ -1045,16 +995,6 @@ enum trverify_error_codes { */ FIRM_API int check_type(ir_type *tp); -/** - * Check an entity. Currently, we check only if initialized constants - * are build on the const irg graph. - * - * @return - * 0 if no error encountered - * != 0 a trverify_error_codes code - */ -FIRM_API int check_entity(ir_entity *ent); - /** * Walks the type information and performs a set of sanity checks. * @@ -1069,41 +1009,21 @@ FIRM_API int check_entity(ir_entity *ent); */ FIRM_API int tr_verify(void); -/** - * @page type representation of types - * - * Datastructure to hold type information. - * - * This module supplies a datastructure to represent all types - * known in the compiled program. This includes types specified - * in the program as well as types defined by the language. In the - * view of the intermediate representation there is no difference - * between these types. Finally it specifies some auxiliary types. - * - * There exist several kinds of types, arranged by the structure of - * the type. A type is described by a set of attributes. Some of - * these attributes are common to all types, others depend on the - * kind of the type. - * - * Types are different from the modes defined in irmode: Types are - * on the level of the programming language, modes at the level of - * the target processor. - */ - -/** Frees all entities associated with a type. - * Does not free the array entity. - * Warning: ensure these entities are not referenced anywhere else. - */ -FIRM_API void free_type_entities(ir_type *tp); - -/** Frees the memory used by the type. +/** Frees all entities associated with a type. + * Does not free the array entity. + * Warning: ensure these entities are not referenced anywhere else. + */ +FIRM_API void free_type_entities(ir_type *tp); + +/** 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. */ + * that refers to this type. + */ FIRM_API void free_type(ir_type *tp); FIRM_API const tp_op *get_type_tpop(const ir_type *tp); @@ -1245,6 +1165,13 @@ FIRM_API type_dbg_info *get_type_dbg_info(const ir_type *tp); */ FIRM_API int is_type(const void *thing); +/** + * Outputs a unique number for this type if libfirm is compiled for + * debugging, (configure with --enable-debug) else returns the address + * of the type cast to long. + */ +FIRM_API long get_type_nr(const ir_type *tp); + /** * Checks whether two types are structurally equal. * @@ -1320,7 +1247,8 @@ FIRM_API int equal_type(ir_type *typ1, ir_type *typ2); FIRM_API int smaller_type(ir_type *st, ir_type *lt); /** - * @page class_type Representation of a class type + * @ingroup compound_type + * @defgroup class_type Class * * 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. @@ -1363,6 +1291,7 @@ FIRM_API int smaller_type(ir_type *st, ir_type *lt); * 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. */ @@ -1371,8 +1300,6 @@ FIRM_API ir_type *new_type_class(ident *name); /** Creates a new class type with debug information. */ FIRM_API ir_type *new_d_type_class(ident *name, type_dbg_info *db); -/* --- manipulate private fields of class type --- */ - /** return identifier of the class type */ FIRM_API ident *get_class_ident(const ir_type *clss); @@ -1421,7 +1348,6 @@ FIRM_API void set_class_subtype(ir_type *clss, ir_type *subtype, size_t pos); /** Finds subtype in the list of subtypes and removes it */ FIRM_API void remove_class_subtype(ir_type *clss, ir_type *subtype); -/* Convenience macros */ #define add_class_derived_type(clss, drvtype) add_class_subtype(clss, drvtype) #define get_class_n_derived_types(clss) get_class_n_subtypes(clss) #define get_class_derived_type(clss, pos) get_class_subtype(clss, pos) @@ -1456,14 +1382,6 @@ FIRM_API void set_class_supertype(ir_type *clss, ir_type *supertype, size_t pos) /** Finds supertype in the list of supertypes and removes it */ FIRM_API void remove_class_supertype(ir_type *clss, ir_type *supertype); -/** Convenience macro */ -#define add_class_base_type(clss, basetype) add_class_supertype(clss, basetype) -#define get_class_n_base_types(clss) get_class_n_supertypes(clss) -#define get_class_base_type_index(clss, base_clss) get_class_supertype_index(clss, base_clss) -#define get_class_base_type(clss, pos) get_class_supertype(clss, pos) -#define set_class_base_type(clss, basetype, pos) set_class_supertype(clss, basetype, pos) -#define remove_class_base_type(clss, basetype) remove_class_supertype(clss, basetype) - /** Returns the type info entity of a class. */ FIRM_API ir_entity *get_class_type_info(const ir_type *clss); @@ -1498,7 +1416,20 @@ FIRM_API void set_class_abstract(ir_type *clss, int flag); FIRM_API int is_Class_type(const ir_type *clss); /** - * @page struct_type Representation of a struct type + * This type opcode marks that the corresponding type is a class type. + * + * Consequently the type refers to supertypes, subtypes and entities. + * Entities can be any fields, but also methods. + * This struct is dynamically allocated but constant for the lifetime + * of the library. + */ +FIRM_API const tp_op *type_class; +FIRM_API const tp_op *get_tpop_class(void); + +/** @} */ + +/** @ingroup compound_type + * @defgroup struct_type Struct * * A struct type represents aggregate types that consist of a list * of fields. @@ -1512,14 +1443,14 @@ FIRM_API int is_Class_type(const ir_type *clss); * but not shrinked. * This is a dynamic list that can be grown with an "add_" function, * but not shrinked. + * @{ */ + /** Creates a new type struct */ FIRM_API ir_type *new_type_struct(ident *name); /** Creates a new type struct with debug information. */ FIRM_API ir_type *new_d_type_struct(ident *name, type_dbg_info* db); -/* --- manipulate private fields of struct --- */ - /** return struct identifier */ FIRM_API ident *get_struct_ident(const ir_type *strct); @@ -1539,7 +1470,72 @@ FIRM_API size_t get_struct_member_index(const ir_type *strct, ir_entity *member) FIRM_API int is_Struct_type(const ir_type *strct); /** - * @page method_type Representation of a method type + * This type opcode marks that the corresponding type is a compound type + * as a struct in C. + * + * Consequently the type refers to a list of entities + * which may not be methods (but pointers to methods). + * This struct is dynamically allocated but constant for the lifetime + * of the library. + */ +FIRM_API const tp_op *type_struct; +FIRM_API const tp_op *get_tpop_struct(void); + +/** @} */ + +/** + * @ingroup compound_type + * @defgroup union_type Union + * + * 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, but not shrinked. + * @{ + */ +/** Creates a new type union. */ +FIRM_API ir_type *new_type_union(ident *name); + +/** Creates a new type union with debug information. */ +FIRM_API ir_type *new_d_type_union(ident *name, type_dbg_info* db); + + +/** return union identifier */ +FIRM_API ident *get_union_ident(const ir_type *uni); + +/** return union identifier as c-string */ +FIRM_API const char *get_union_name(const ir_type *uni); + +/** Returns the number of unioned types of this union */ +FIRM_API size_t get_union_n_members(const ir_type *uni); + +/** Returns the entity at position pos of a union */ +FIRM_API ir_entity *get_union_member(const ir_type *uni, size_t pos); + +/** Returns index of member in uni, -1 if not contained. */ +FIRM_API size_t get_union_member_index(const ir_type *uni, ir_entity *member); + +/** Returns true if a type is a union type. */ +FIRM_API int is_Union_type(const ir_type *uni); + +/** + * This type opcode marks that the corresponding type is a union type. + * + * Consequently it refers to a list of unioned types. + * This struct is dynamically allocated but constant for the lifetime + * of the library. + */ +FIRM_API const tp_op *type_union; +FIRM_API const tp_op *get_tpop_union(void); + +/** @} */ + +/** + * @defgroup method_type Method * * A method type represents a method, function or procedure type. * It contains a list of the parameter and result types, as these @@ -1566,17 +1562,9 @@ FIRM_API int is_Struct_type(const ir_type *strct); * - res_type: A list with the types of parameters. This list is ordered. * The nth type in this list corresponds to the nth input to * Return nodes. (See ircons.h for more information.) - * - * - value_res_ents - * A list of entities (whose owner is a struct private to the - * method type) that represent results passed by value. + * @{ */ -/* These macros define the suffixes for the types and entities used - to represent value parameters / results. */ -#define VALUE_PARAMS_SUFFIX "val_param" -#define VALUE_RESS_SUFFIX "val_res" - /** Create a new method type. * * @param n_param the number of parameters @@ -1599,54 +1587,21 @@ FIRM_API ir_type *new_type_method(size_t n_param, size_t n_res); FIRM_API ir_type *new_d_type_method(size_t n_param, size_t n_res, type_dbg_info *db); -/* -- manipulate private fields of method. -- */ - /** Returns the number of parameters of this method. */ FIRM_API size_t get_method_n_params(const ir_type *method); /** Returns the type of the parameter at position pos of a method. */ -FIRM_API ir_type *get_method_param_type(ir_type *method, size_t pos); +FIRM_API ir_type *get_method_param_type(const ir_type *method, size_t pos); /** Sets the type of the parameter 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. */ -FIRM_API void set_method_param_type(ir_type *method, size_t 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. */ -FIRM_API ir_entity *get_method_value_param_ent(ir_type *method, size_t pos); -/** - * Sets the type that represents the copied value arguments. - */ -FIRM_API void set_method_value_param_type(ir_type *method, ir_type *tp); -/** - * Returns a type that represents the copied value arguments if one - * was allocated, else NULL. + * Note: does not change the corresponding parameter entities (if there are any) */ -FIRM_API 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. */ -FIRM_API ident *get_method_param_ident(ir_type *method, size_t pos); -/** Returns a string representing the parameters name. Returns NULL if not set. - For debug support only. */ -FIRM_API const char *get_method_param_name(ir_type *method, size_t pos); -/** Sets an ident representing the parameters name. For debug support only. */ -FIRM_API void set_method_param_ident(ir_type *method, size_t pos, ident *id); - +FIRM_API void set_method_param_type(ir_type *method, size_t pos, ir_type *tp); /** Returns the number of results of a method type. */ FIRM_API size_t get_method_n_ress(const ir_type *method); /** Returns the return type of a method type at position pos. */ -FIRM_API ir_type *get_method_res_type(ir_type *method, size_t 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. */ +FIRM_API ir_type *get_method_res_type(const ir_type *method, size_t pos); +/** Sets the type of the result at position pos of a method. */ FIRM_API void set_method_res_type(ir_type *method, size_t 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. */ -FIRM_API ir_entity *get_method_value_res_ent(ir_type *method, size_t pos); - -/** - * Returns a type that represents the copied value results. - */ -FIRM_API ir_type *get_method_value_res_type(const ir_type *method); /** * This enum flags the variadicity of methods (methods with a @@ -1667,23 +1622,6 @@ FIRM_API ir_variadicity get_method_variadicity(const ir_type *method); /** Sets the variadicity of a method. */ FIRM_API void set_method_variadicity(ir_type *method, ir_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. - */ -FIRM_API size_t get_method_first_variadic_param_index(const ir_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. - */ -FIRM_API void set_method_first_variadic_param_index(ir_type *method, - size_t index); - /** Returns the mask of the additional graph properties. */ FIRM_API mtp_additional_properties get_method_additional_properties(const ir_type *method); @@ -1718,9 +1656,6 @@ typedef enum { cc_bits = (0xFF << 24)/**< The calling convention bits. */ } calling_convention; -/* 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 */ @@ -1774,45 +1709,19 @@ FIRM_API void set_method_n_regparams(ir_type *method, unsigned n_regs); FIRM_API int is_Method_type(const ir_type *method); /** - * @page union_type Representation of a union (variant) type. - * - * 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. + * This type opcode marks that the corresponding type is a method type. * - * - 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, - * but not shrinked. + * Consequently it refers to a list of arguments and results. + * This struct is dynamically allocated but constant for the lifetime + * of the library. */ -/** Creates a new type union. */ -FIRM_API ir_type *new_type_union(ident *name); - -/** Creates a new type union with debug information. */ -FIRM_API ir_type *new_d_type_union(ident *name, type_dbg_info* db); - -/* --- manipulate private fields of struct --- */ - -/** return union identifier */ -FIRM_API ident *get_union_ident(const ir_type *uni); - -/** return union identifier as c-string */ -FIRM_API const char *get_union_name(const ir_type *uni); - -/** Returns the number of unioned types of this union */ -FIRM_API size_t get_union_n_members(const ir_type *uni); - -/** Returns the entity at position pos of a union */ -FIRM_API ir_entity *get_union_member(const ir_type *uni, size_t pos); +FIRM_API const tp_op *type_method; +FIRM_API const tp_op *get_tpop_method(void); -/** Returns index of member in uni, -1 if not contained. */ -FIRM_API size_t get_union_member_index(const ir_type *uni, ir_entity *member); - -/** Returns true if a type is a union type. */ -FIRM_API int is_Union_type(const ir_type *uni); +/** @} */ /** - * @page array_type Representation of an array type + * @defgroup array_type Array * * The array type represents rectangular multi dimensional arrays. * The constants representing the bounds must be allocated to @@ -1824,6 +1733,7 @@ FIRM_API int is_Union_type(const ir_type *uni); * - *element_type: The type of the array elements. * - *element_ent: An entity for the array elements to be used for * element selection with Sel. + * @{ */ /** Create a new type array. @@ -1833,7 +1743,7 @@ FIRM_API int is_Union_type(const ir_type *uni); * The entity for array elements is built automatically. * Set dimension sizes after call to constructor with set_* routines. */ -FIRM_API ir_type *new_type_array(int n_dims, ir_type *element_type); +FIRM_API ir_type *new_type_array(size_t n_dims, ir_type *element_type); /** Create a new type array with debug information. * @@ -1843,10 +1753,9 @@ FIRM_API ir_type *new_type_array(int n_dims, ir_type *element_type); * Set dimension sizes after call to constructor with set_* routines. * A legal array type must have at least one dimension set. */ -FIRM_API ir_type *new_d_type_array(int n_dims, ir_type *element_type, +FIRM_API ir_type *new_d_type_array(size_t n_dims, ir_type *element_type, type_dbg_info* db); -/* --- manipulate private fields of array type --- */ /** Returns the number of array dimensions of this type. */ FIRM_API size_t get_array_n_dimensions(const ir_type *array); @@ -1895,16 +1804,16 @@ FIRM_API ir_node *get_array_upper_bound(const ir_type *array, size_t dimension); FIRM_API long get_array_upper_bound_int(const ir_type *array, size_t dimension); /** Sets an array dimension to a specific order. */ -FIRM_API void set_array_order(ir_type *array, size_t dimension, int order); +FIRM_API void set_array_order(ir_type *array, size_t dimension, size_t order); /** Returns the order of an array dimension. */ -FIRM_API int get_array_order(const ir_type *array, size_t dimension); +FIRM_API size_t get_array_order(const ir_type *array, size_t dimension); /** Find the array dimension that is placed at order order. */ -FIRM_API size_t find_array_dimension(const ir_type *array, int order); +FIRM_API size_t find_array_dimension(const ir_type *array, size_t order); /** Sets the array element type. */ -FIRM_API void set_array_element_type(ir_type *array, ir_type* tp); +FIRM_API void set_array_element_type(ir_type *array, ir_type *tp); /** Gets the array element type. */ FIRM_API ir_type *get_array_element_type(const ir_type *array); @@ -1919,7 +1828,20 @@ FIRM_API ir_entity *get_array_element_entity(const ir_type *array); FIRM_API int is_Array_type(const ir_type *array); /** - * @page enumeration_type Representation of an enumeration type + * This type opcode marks that the corresponding type is an array type. + * + * Consequently it contains a list of dimensions (lower and upper bounds) + * and an element type. + * This struct is dynamically allocated but constant for the lifetime + * of the library. + */ +FIRM_API const tp_op *type_array; +FIRM_API const tp_op *get_tpop_array(void); + +/** @} */ + +/** + * @defgroup enumeration_type Enumeration * * Enumeration types need not necessarily be represented explicitly * by Firm types, as the frontend can lower them to integer constants as @@ -1929,6 +1851,7 @@ FIRM_API int is_Array_type(const ir_type *array); * * - *const: The target values representing the constants used to * represent individual enumerations. + * @{ */ /** Create a new type enumeration -- set the enumerators independently. */ @@ -1938,7 +1861,6 @@ FIRM_API ir_type *new_type_enumeration(ident *name, size_t n_enums); FIRM_API ir_type *new_d_type_enumeration(ident *name, size_t n_enums, type_dbg_info *db); -/* --- manipulate fields of enumeration type. --- */ /** return enumeration identifier */ FIRM_API ident *get_enumeration_ident(const ir_type *enumeration); @@ -1979,10 +1901,25 @@ FIRM_API const char *get_enumeration_const_name(const ir_enum_const *enum_cnst); FIRM_API int is_Enumeration_type(const ir_type *enumeration); /** - * @page pointer_type Representation of a pointer type + * This type opcode marks that the corresponding type is an enumeration type. + * + * Consequently it contains a list of idents for the enumeration identifiers + * and a list of target values that are the constants used to implement + * the enumerators. + * This struct is dynamically allocated but constant for the lifetime + * of the library. + */ +FIRM_API const tp_op *type_enumeration; +FIRM_API const tp_op *get_tpop_enumeration(void); + +/** @} */ + +/** + * @defgroup pointer_type Pointer * * Pointer types: - * - points_to: The type of the entity this pointer points to. + * - points_to: The type this pointer points to. + * @{ */ /** Creates a new type pointer. */ @@ -1991,7 +1928,6 @@ FIRM_API ir_type *new_type_pointer(ir_type *points_to); /** Creates a new type pointer with debug information. */ FIRM_API ir_type *new_d_type_pointer(ir_type *points_to, type_dbg_info* db); -/* --- manipulate fields of type_pointer --- */ /** Sets the type to which a pointer points to. */ FIRM_API void set_pointer_points_to_type(ir_type *pointer, ir_type *tp); @@ -2008,11 +1944,24 @@ FIRM_API int is_Pointer_type(const ir_type *pointer); FIRM_API ir_type *find_pointer_type_to_type(ir_type *tp); /** - * @page primitive_type Representation of a primitive type + * This type opcode marks that the corresponding type is a pointer type. + * + * It contains a reference to the type the pointer points to. + * This struct is dynamically allocated but constant for the lifetime + * of the library. + */ +FIRM_API const tp_op *type_pointer; +FIRM_API const tp_op *get_tpop_pointer(void); + +/** @} */ + +/** + * @defgroup primitive_type Primitive * * 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. */ FIRM_API ir_type *new_type_primitive(ir_mode *mode); @@ -2030,7 +1979,20 @@ FIRM_API ir_type *get_primitive_base_type(const ir_type *tp); FIRM_API void set_primitive_base_type(ir_type *tp, ir_type *base_tp); /** - * @page none_type The None type + * This type opcode marks that the corresponding type is a primitive type. + * + * Primitive types are types that are directly mapped to target machine + * modes. + * This struct is dynamically allocated but constant for the lifetime + * of the library. + */ +FIRM_API const tp_op *type_primitive; +FIRM_API const tp_op *get_tpop_primitive(void); + +/** @} */ + +/** + * @defgroup none_type None * * This type is an auxiliary type dedicated to support type analyses. * @@ -2045,20 +2007,44 @@ FIRM_API void set_primitive_base_type(ir_type *tp, ir_type *base_tp); * - name: "type_none" * - state: layout_fixed * - size: 0 + * @{ */ /** A variable that contains the only none type. */ FIRM_API ir_type *firm_none_type; +/** Returns the none type. */ +FIRM_API ir_type *get_none_type(void); +/** + * This type opcode is an auxiliary opcode dedicated to support type analyses. + * + * Types with this opcode represents that there is no type. + * The type can be used to initialize fields of the type* that actually can not + * contain a type or that are initialized for an analysis. There exists exactly + * one type with this opcode. + */ +FIRM_API const tp_op *tpop_none; +FIRM_API const tp_op *get_tpop_none(void); +/** @} */ +/** @defgroup code_type Code + * @{ + */ /** A variable that contains the only code type. */ FIRM_API ir_type *firm_code_type; - -/** Returns the none type. */ -FIRM_API ir_type *get_none_type(void); /** Returns the code type. */ FIRM_API ir_type *get_code_type(void); +/** + * Checks whether a type is a code type. + */ +FIRM_API int is_code_type(const ir_type *tp); +/** + * The code type is used to mark pieces of code (basic blocks) + */ +FIRM_API const tp_op *tpop_code; +FIRM_API const tp_op *get_tpop_code_type(void); +/** @} */ /** - * @page unknown_type The Unknown type + * @defgroup unknown_type Unknown * * This type is an auxiliary type dedicated to support type analyses. * @@ -2073,13 +2059,23 @@ FIRM_API ir_type *get_code_type(void); * - name: "type_unknown" * - state: layout_fixed * - size: 0 + * @{ */ /** A variable that contains the only unknown type. */ FIRM_API ir_type *firm_unknown_type; - /** Returns the unknown type. */ FIRM_API ir_type *get_unknown_type(void); - +/** + * This type opcode is an auxiliary opcode dedicated to support type analyses. + * + * Types with this opcode represents that there could be a type, but it is not + * known. This type can be used to initialize fields before an analysis (not known + * yet) or to represent the top of a lattice (could not be determined). There exists + * exactly one type with this opcode. + */ +FIRM_API const tp_op *tpop_unknown; +FIRM_API const tp_op *get_tpop_unknown(void); +/** @} */ /** * Checks whether a type is atomic. @@ -2088,7 +2084,11 @@ FIRM_API ir_type *get_unknown_type(void); */ FIRM_API int is_atomic_type(const ir_type *tp); -/* --- Support for compound types --- */ +/** + * @defgroup compound_type Compound + * + * @{ + */ /** * Gets the identifier of a compound type @@ -2141,32 +2141,11 @@ FIRM_API void default_layout_compound_type(ir_type *tp); */ FIRM_API int is_compound_type(const ir_type *tp); -/** - * Checks wether a type is a code type. - */ -FIRM_API int is_code_type(const ir_type *tp); +/** @} */ -/** - * Checks, whether a type is a frame type. - */ -FIRM_API int is_frame_type(const ir_type *tp); - -/** - * Checks, whether a type is a value parameter type. +/** @defgroup frame_type Frame + * @{ */ -FIRM_API int is_value_param_type(const ir_type *tp); - -/** - * Checks, whether a type is a lowered type. - */ -FIRM_API int is_lowered_type(const ir_type *tp); - -/** - * Makes a new value type. Value types are struct types, - * so all struct access functions work. - * Value types are not in the global list of types. - */ -FIRM_API ir_type *new_type_value(void); /** * Makes a new frame type. Frame types are class types, @@ -2175,6 +2154,11 @@ FIRM_API ir_type *new_type_value(void); */ FIRM_API ir_type *new_type_frame(void); +/** + * Checks, whether a type is a frame type. + */ +FIRM_API int is_frame_type(const ir_type *tp); + /** * Makes a clone of a frame type. * Sets entity links from old frame entities to new onces and @@ -2182,18 +2166,6 @@ FIRM_API ir_type *new_type_frame(void); */ FIRM_API ir_type *clone_frame_type(ir_type *type); -/** - * Sets a lowered type for a type. This sets both associations - * and marks lowered_type as a "lowered" one. - */ -FIRM_API void set_lowered_type(ir_type *tp, ir_type *lowered_type); - -/** - * Gets the lowered/unlowered type of a type or NULL if this type - * has no lowered/unlowered one. - */ -FIRM_API 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. @@ -2209,18 +2181,12 @@ FIRM_API ir_type *get_associated_type(const ir_type *tp); FIRM_API ir_entity *frame_alloc_area(ir_type *frame_type, int size, unsigned alignment, int at_start); -/*-----------------------------------------------------------------*/ -/** Debug aides **/ -/*-----------------------------------------------------------------*/ +/** @} */ /** - * Outputs a unique number for this type if libfirm is compiled for - * debugging, (configure with --enable-debug) else returns the address - * of the type cast to long. + * @defgroup trwalk Traversing + * @{ */ -FIRM_API long get_type_nr(const ir_type *tp); - -/* ------------------------------------------------------------------------ */ /** Type for a function that compares two types. * @@ -2229,8 +2195,6 @@ FIRM_API long get_type_nr(const ir_type *tp); */ typedef int (compare_types_func_t)(const void *tp1, const void *tp2); -/* ------------------------------------------------------------------------ */ - /** A data type to treat types and entities as the same. */ typedef union { ir_type *typ; /**< points to a type */ @@ -2257,11 +2221,6 @@ typedef void class_walk_func(ir_type *clss, void *env); * Does not touch frame types or types for value params ... */ FIRM_API void type_walk(type_walk_func *pre, type_walk_func *post, void *env); -/** Touches every type, entity, frame type, and value param type in - * unspecified order (also all segment types). */ -FIRM_API void type_walk_prog(type_walk_func *pre, type_walk_func *post, - void *env); - /** Walks over all type information reachable from an ir graph. * * Walks over all type information reachable from irg, i.e., starts a @@ -2337,38 +2296,9 @@ FIRM_API ir_visibility get_type_visibility(const ir_type *tp); /** @deprecated */ FIRM_API void set_type_visibility(ir_type *tp, ir_visibility v); -/** @deprecated */ -typedef enum { - allocation_automatic, - allocation_parameter, - allocation_dynamic, - allocation_static -} ir_allocation; -/** @deprecated */ -FIRM_API ir_allocation get_entity_allocation(const ir_entity *ent); -/** @deprecated */ -FIRM_API void set_entity_allocation(ir_entity *ent, ir_allocation al); +/** @} */ -/** @deprecated */ -typedef enum { - peculiarity_existent, - peculiarity_description, - peculiarity_inherited -} ir_peculiarity; -/** @deprecated */ -FIRM_API ir_peculiarity get_entity_peculiarity(const ir_entity *ent); -/** @deprecated */ -FIRM_API void set_entity_peculiarity(ir_entity *ent, ir_peculiarity pec); - -/** @deprecated */ -FIRM_API int is_entity_final(const ir_entity *ent); -/** @deprecated */ -FIRM_API void set_entity_final(ir_entity *ent, int final); - -/** @deprecated */ -FIRM_API ir_peculiarity get_class_peculiarity(const ir_type *clss); -/** @deprecated */ -FIRM_API void set_class_peculiarity(ir_type *clss, ir_peculiarity pec); +/** @} */ #include "end.h"