X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=include%2Flibfirm%2Ftyperep.h;h=4a0b4c9412e69b06c13c6c5fc8fd945eef8deb58;hb=2232b14b4acf810ae96a69d1d2a33cf150b695d9;hp=782c95f4fdabd4fef7a0b5b8becdb1be646f7c8b;hpb=0064ee54b41c007b5d33b557d053e602ac3be2cc;p=libfirm diff --git a/include/libfirm/typerep.h b/include/libfirm/typerep.h index 782c95f4f..4a0b4c941 100644 --- a/include/libfirm/typerep.h +++ b/include/libfirm/typerep.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -110,7 +110,7 @@ typedef enum { /** * linkage specifies how the linker treats symbols */ -typedef enum { +typedef enum ir_linkage { IR_LINKAGE_DEFAULT = 0, /** * A symbol whose definition won't change in a program. @@ -149,6 +149,7 @@ typedef enum { */ IR_LINKAGE_HIDDEN_USER = 1 << 4 } ir_linkage; +ENUM_BITSET(ir_linkage) /** * Return the visibility class of an entity @@ -199,6 +200,19 @@ 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); + /** * Copies the entity if the new_owner is different from the * owner of the old entity, else returns the old entity. @@ -250,11 +264,17 @@ FIRM_API void set_entity_ld_ident(ir_entity *ent, ident *ld_ident); /** Returns the mangled name of the entity as a string. */ FIRM_API const char *get_entity_ld_name(const ir_entity *ent); +/** returns 1 if the entity has an ld_ident set explicitely */ +FIRM_API int entity_has_ld_ident(const ir_entity *entity); + /** Returns the owner of the entity. */ FIRM_API ir_type *get_entity_owner(const ir_entity *ent); -/** Sets the owner field in entity to owner. Don't forget to add - ent to owner!! */ +/** + * Sets the owner field in entity to owner. + * Automatically removes entity from old owner type and adds it to the new + * one. + */ FIRM_API void set_entity_owner(ir_entity *ent, ir_type *owner); /** Returns the type of an entity. */ @@ -271,18 +291,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); -/** Returns 1 if the value of a global symbol never changes in a program */ -FIRM_API int is_entity_constant(const ir_entity *ent); - -/** - * 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 @@ -309,22 +317,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); @@ -357,6 +356,9 @@ FIRM_API void set_entity_link(ir_entity *ent, void *l); FIRM_API ir_graph *get_entity_irg(const ir_entity *ent); FIRM_API void set_entity_irg(ir_entity *ent, ir_graph *irg); +/** A reserved value for "not yet set". */ +#define IR_VTABLE_NUM_NOT_SET ((unsigned)(-1)) + /** Gets the entity vtable number. */ FIRM_API unsigned get_entity_vtable_number(const ir_entity *ent); @@ -411,6 +413,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); +#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); + /* -- Representation of constant values of entities -- */ /** * Returns true if the the node is representable as code on @@ -423,15 +443,13 @@ FIRM_API int is_irn_const_expression(ir_node *n); /** * Copies a Firm subgraph that complies to the restrictions for - * constant expressions to current_block in current_ir_graph. + * constant expressions to block. * - * @param dbg debug info for all newly created nodes - * @param n the node - * - * Set current_ir_graph to get_const_code_irg() to generate a constant - * expression. + * @param dbg debug info for all newly created nodes + * @param n the node + * @param to_block block to copy to */ -FIRM_API ir_node *copy_const_value(dbg_info *dbg, 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); @@ -467,28 +485,28 @@ FIRM_API ir_initializer_t *get_initializer_null(void); FIRM_API ir_initializer_t *create_initializer_const(ir_node *value); /** creates an initializer containing a single tarval value */ -FIRM_API ir_initializer_t *create_initializer_tarval(tarval *tv); +FIRM_API ir_initializer_t *create_initializer_tarval(ir_tarval *tv); /** return value contained in a const initializer */ FIRM_API ir_node *get_initializer_const_value(const ir_initializer_t *initializer); /** return value contained in a tarval initializer */ -FIRM_API tarval *get_initializer_tarval_value(const ir_initializer_t *initialzier); +FIRM_API ir_tarval *get_initializer_tarval_value(const ir_initializer_t *initialzier); /** creates a compound initializer which holds @p n_entries entries */ -FIRM_API ir_initializer_t *create_initializer_compound(unsigned n_entries); +FIRM_API ir_initializer_t *create_initializer_compound(size_t n_entries); /** returns the number of entries in a compound initializer */ -FIRM_API unsigned get_initializer_compound_n_entries(const ir_initializer_t *initializer); +FIRM_API size_t get_initializer_compound_n_entries(const ir_initializer_t *initializer); /** sets entry with index @p index to the initializer @p value */ FIRM_API void set_initializer_compound_value(ir_initializer_t *initializer, - unsigned index, + size_t index, ir_initializer_t *value); /** returns the value with index @p index of a compound initializer */ FIRM_API ir_initializer_t *get_initializer_compound_value( - const ir_initializer_t *initializer, unsigned index); + 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); @@ -510,16 +528,16 @@ FIRM_API ir_initializer_t *get_entity_initializer(const ir_entity *entity); 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 int get_entity_n_overwrites(const ir_entity *ent); -FIRM_API int get_entity_overwrites_index(const ir_entity *ent, ir_entity *overwritten); -FIRM_API ir_entity *get_entity_overwrites(const ir_entity *ent, int pos); -FIRM_API void set_entity_overwrites(ir_entity *ent, int pos, 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); +FIRM_API ir_entity *get_entity_overwrites(const ir_entity *ent, size_t pos); +FIRM_API void set_entity_overwrites(ir_entity *ent, size_t pos, ir_entity *overwritten); FIRM_API void remove_entity_overwrites(ir_entity *ent, ir_entity *overwritten); -FIRM_API int get_entity_n_overwrittenby(const ir_entity *ent); -FIRM_API int get_entity_overwrittenby_index(const ir_entity *ent, ir_entity *overwrites); -FIRM_API ir_entity *get_entity_overwrittenby(const ir_entity *ent, int pos); -FIRM_API void set_entity_overwrittenby(ir_entity *ent, int pos, ir_entity *overwrites); +FIRM_API size_t get_entity_n_overwrittenby(const ir_entity *ent); +FIRM_API size_t get_entity_overwrittenby_index(const ir_entity *ent, ir_entity *overwrites); +FIRM_API ir_entity *get_entity_overwrittenby(const ir_entity *ent, size_t pos); +FIRM_API void set_entity_overwrittenby(ir_entity *ent, size_t pos, ir_entity *overwrites); FIRM_API void remove_entity_overwrittenby(ir_entity *ent, ir_entity *overwrites); /** @@ -572,15 +590,15 @@ FIRM_API int entity_not_visited(const ir_entity *ent); * set_entity_additional_properties() or * set_entity_additional_property(). */ -FIRM_API unsigned get_entity_additional_properties(const ir_entity *ent); +FIRM_API mtp_additional_properties get_entity_additional_properties(const ir_entity *ent); /** Sets the mask of the additional graph properties. */ FIRM_API void set_entity_additional_properties(ir_entity *ent, - unsigned property_mask); + mtp_additional_properties prop); -/** Sets one additional graph property. */ -FIRM_API void set_entity_additional_property(ir_entity *ent, - mtp_additional_property flag); +/** Sets additional graph properties. */ +FIRM_API void add_entity_additional_properties(ir_entity *ent, + mtp_additional_properties flag); /** Returns the class type that this type info entity represents or NULL if ent is no type info entity. */ @@ -626,7 +644,7 @@ FIRM_API ir_entity *unknown_entity; FIRM_API ir_entity *get_unknown_entity(void); /** Encodes how a pointer parameter is accessed. */ -typedef enum acc_bits { +typedef enum ptr_access_kind { ptr_access_none = 0, /**< no access */ ptr_access_read = 1, /**< read access */ ptr_access_write = 2, /**< write access */ @@ -634,6 +652,7 @@ typedef enum acc_bits { ptr_access_store = 4, /**< the pointer is stored */ ptr_access_all = ptr_access_rw|ptr_access_store /**< all possible access */ } ptr_access_kind; +ENUM_BITSET(ptr_access_kind) #define IS_READ(a) ((a) & ptr_access_read) #define IS_WRITTEN(a) ((a) & ptr_access_write) @@ -684,7 +703,7 @@ typedef struct tp_op tp_op; * Returns the string for the type opcode. * * @param op The type opcode to get the string from. - * @return a string. (@todo Null terminated?) + * @return a string. */ FIRM_API const char *get_tpop_name(const tp_op *op); @@ -914,10 +933,9 @@ FIRM_API void resolve_inheritance(mangle_inherited_name_func *mfunc); /* Do the sets contain the node itself? I assume NOT! */ /* ----------------------------------------------------------------------- */ -/** The state of the transitive closure. - * - * @todo: we could manage the state for each relation separately. Invalidating - * the entity relations does not mean invalidating the class relation. */ +/** + * The state of the transitive closure. + */ typedef enum { inh_transitive_closure_none, /**< Closure is not computed, can not be accessed. */ inh_transitive_closure_valid, /**< Closure computed and valid. */ @@ -1017,9 +1035,9 @@ FIRM_API ir_class_cast_state get_irp_class_cast_state(void); FIRM_API void verify_irg_class_cast_state(ir_graph *irg); /** - * possible trvrfy() error codes + * possible trverify() error codes */ -enum trvrfy_error_codes { +enum trverify_error_codes { no_error = 0, /**< no error */ error_ent_not_cont, /**< overwritten entity not in superclass */ error_null_mem, /**< compound contains NULL member */ @@ -1046,7 +1064,7 @@ FIRM_API int check_type(ir_type *tp); * * @return * 0 if no error encountered - * != 0 a trvrfy_error_codes code + * != 0 a trverify_error_codes code */ FIRM_API int check_entity(ir_entity *ent); @@ -1062,7 +1080,7 @@ FIRM_API int check_entity(ir_entity *ent); * 0 if graph is correct * else error code. */ -FIRM_API int tr_vrfy(void); +FIRM_API int tr_verify(void); /** * @page type representation of types @@ -1375,30 +1393,20 @@ FIRM_API ident *get_class_ident(const ir_type *clss); FIRM_API const char *get_class_name(const ir_type *clss); /** Returns the number of members of this class. */ -FIRM_API int get_class_n_members(const ir_type *clss); +FIRM_API size_t get_class_n_members(const ir_type *clss); /** Returns the member at position pos, 0 <= pos < n_member */ -FIRM_API ir_entity *get_class_member(const ir_type *clss, int pos); +FIRM_API ir_entity *get_class_member(const ir_type *clss, size_t pos); -/** Returns index of mem in clss, -1 if not contained. */ -FIRM_API int get_class_member_index(const ir_type *clss, ir_entity *mem); +#define INVALID_MEMBER_INDEX ((size_t)-1) + +/** Returns index of mem in clss, INVALID_MEMBER_INDEX if not contained. */ +FIRM_API size_t 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. */ FIRM_API 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. */ -FIRM_API 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. */ -FIRM_API void set_class_members(ir_type *clss, ir_entity *members[], int arity); - - /** Adds subtype as subtype to clss. * * Checks whether clss is a supertype of subtype. If not @@ -1406,22 +1414,22 @@ FIRM_API void set_class_members(ir_type *clss, ir_entity *members[], int arity); FIRM_API void add_class_subtype(ir_type *clss, ir_type *subtype); /** Returns the number of subtypes */ -FIRM_API int get_class_n_subtypes(const ir_type *clss); +FIRM_API size_t get_class_n_subtypes(const ir_type *clss); /** Gets the subtype at position pos, 0 <= pos < n_subtype. */ -FIRM_API ir_type *get_class_subtype(ir_type *clss, int pos); +FIRM_API ir_type *get_class_subtype(ir_type *clss, size_t pos); /** Returns the index to access subclass as subtype of class. * * If subclass is no direct subtype of class returns -1. */ -FIRM_API int get_class_subtype_index(ir_type *clss, const ir_type *subclass); +FIRM_API size_t get_class_subtype_index(ir_type *clss, const ir_type *subclass); /** Sets the subtype at position pos, 0 <= pos < n_subtype. * * Does not set the corresponding supertype relation for subtype: this might * be a different position! */ -FIRM_API void set_class_subtype(ir_type *clss, ir_type *subtype, int pos); +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); @@ -1441,22 +1449,22 @@ FIRM_API void remove_class_subtype(ir_type *clss, ir_type *subtype); FIRM_API void add_class_supertype(ir_type *clss, ir_type *supertype); /** Returns the number of supertypes */ -FIRM_API int get_class_n_supertypes(const ir_type *clss); +FIRM_API size_t get_class_n_supertypes(const ir_type *clss); /** Returns the index to access superclass as supertype of class. * * If superclass is no direct supertype of class returns -1. */ -FIRM_API int get_class_supertype_index(ir_type *clss, ir_type *super_clss); +FIRM_API size_t get_class_supertype_index(ir_type *clss, ir_type *super_clss); /** Gets the supertype at position pos, 0 <= pos < n_supertype. */ -FIRM_API ir_type *get_class_supertype(ir_type *clss, int pos); +FIRM_API ir_type *get_class_supertype(ir_type *clss, size_t pos); /** Sets the supertype at position pos, 0 <= pos < n_supertype. * * Does not set the corresponding subtype relation for supertype: this might * be at a different position! */ -FIRM_API void set_class_supertype(ir_type *clss, ir_type *supertype, int pos); +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); @@ -1499,11 +1507,6 @@ FIRM_API int is_class_abstract(const ir_type *clss); /** Sets the class abstract flag. */ FIRM_API void set_class_abstract(ir_type *clss, int flag); -/** Set and get a class' dfn -- - @todo This is an undocumented field, subject to change! */ -FIRM_API void set_class_dfn(ir_type *clss, int dfn); -FIRM_API int get_class_dfn(const ir_type *clss); - /** Returns true if a type is a class type. */ FIRM_API int is_Class_type(const ir_type *clss); @@ -1537,17 +1540,13 @@ FIRM_API ident *get_struct_ident(const ir_type *strct); FIRM_API const char *get_struct_name(const ir_type *strct); /** Returns the number of members of this struct. */ -FIRM_API int get_struct_n_members(const ir_type *strct); +FIRM_API size_t get_struct_n_members(const ir_type *strct); -/** Returns the member at position pos, 0 <= pos < n_member */ -FIRM_API ir_entity *get_struct_member(const ir_type *strct, int pos); +/** Returns the member at position pos, pos < n_member */ +FIRM_API ir_entity *get_struct_member(const ir_type *strct, size_t pos); /** Returns index of member in strct, -1 if not contained. */ -FIRM_API 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. */ -FIRM_API void set_struct_member(ir_type *strct, int pos, ir_entity *member); +FIRM_API size_t get_struct_member_index(const ir_type *strct, ir_entity *member); /** Returns true if a type is a struct type. */ FIRM_API int is_Struct_type(const ir_type *strct); @@ -1580,10 +1579,6 @@ 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 @@ -1599,7 +1594,7 @@ FIRM_API int is_Struct_type(const ir_type *strct); * The arrays for the parameter and result types are not initialized by * the constructor. */ -FIRM_API ir_type *new_type_method(int n_param, int n_res); +FIRM_API ir_type *new_type_method(size_t n_param, size_t n_res); /** Create a new method type with debug information. * @@ -1610,56 +1605,28 @@ FIRM_API ir_type *new_type_method(int n_param, int n_res); * The arrays for the parameter and result types are not initialized by * the constructor. */ -FIRM_API ir_type *new_d_type_method(int n_param, int n_res, type_dbg_info *db); +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 int get_method_n_params(const ir_type *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, int 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, 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. */ -FIRM_API ir_entity *get_method_value_param_ent(ir_type *method, int 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. - */ -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, int 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, int pos); -/** Sets an ident representing the parameters name. For debug support only. */ -FIRM_API void set_method_param_ident(ir_type *method, int 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 int get_method_n_ress(const ir_type *method); +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, int pos); +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. 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_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. */ -FIRM_API ir_entity *get_method_value_res_ent(ir_type *method, int pos); - -/** - * Returns a type that represents the copied value results. - */ -FIRM_API ir_type *get_method_value_res_type(const ir_type *method); +FIRM_API void set_method_res_type(ir_type *method, size_t pos, ir_type *tp); /** * This enum flags the variadicity of methods (methods with a @@ -1680,32 +1647,16 @@ 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 int 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, int index); - /** Returns the mask of the additional graph properties. */ -FIRM_API unsigned get_method_additional_properties(const ir_type *method); +FIRM_API mtp_additional_properties get_method_additional_properties(const ir_type *method); /** Sets the mask of the additional graph properties. */ FIRM_API void set_method_additional_properties(ir_type *method, - unsigned property_mask); + mtp_additional_properties property_mask); /** Sets one additional graph property. */ -FIRM_API void set_method_additional_property(ir_type *method, - mtp_additional_property flag); +FIRM_API void add_method_additional_properties(ir_type *method, + mtp_additional_properties flag); /** * Calling conventions: lower 24 bits are the number of register parameters, @@ -1812,16 +1763,13 @@ FIRM_API ident *get_union_ident(const ir_type *uni); FIRM_API const char *get_union_name(const ir_type *uni); /** Returns the number of unioned types of this union */ -FIRM_API int get_union_n_members(const ir_type *uni); +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, int pos); +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 int get_union_member_index(const ir_type *uni, ir_entity *member); - -/** Overwrites a entity at position pos in a union type. */ -FIRM_API void set_union_member(ir_type *uni, int pos, ir_entity *member); +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); @@ -1839,10 +1787,6 @@ 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. - * @todo - * Do we need several entities? One might want - * to select a dimension and not a single element in case of multi - * dimensional arrays. */ /** Create a new type array. @@ -1852,7 +1796,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. * @@ -1862,68 +1806,68 @@ 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 int get_array_n_dimensions(const ir_type *array); +FIRM_API size_t get_array_n_dimensions(const ir_type *array); /** * 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[ */ -FIRM_API void set_array_bounds_int(ir_type *array, int dimension, +FIRM_API void set_array_bounds_int(ir_type *array, size_t dimension, int lower_bound, int upper_bound); /** * Sets the bounds for one array dimension. * Upper bound in Firm is the element next to the last, i.e. [lower,upper[ */ -FIRM_API void set_array_bounds(ir_type *array, int dimension, +FIRM_API void set_array_bounds(ir_type *array, size_t dimension, ir_node *lower_bound, ir_node *upper_bound); /** Sets the lower bound for one array dimension, i.e. [lower,upper[ */ -FIRM_API void set_array_lower_bound(ir_type *array, int dimension, +FIRM_API void set_array_lower_bound(ir_type *array, size_t dimension, ir_node *lower_bound); /** Allocates Const nodes of mode_Is for the lower bound of an array dimension, i.e. [lower,upper[ */ -FIRM_API void set_array_lower_bound_int(ir_type *array, int dimension, +FIRM_API void set_array_lower_bound_int(ir_type *array, size_t dimension, int lower_bound); /** Sets the upper bound for one array dimension, i.e. [lower,upper[ */ -FIRM_API void set_array_upper_bound(ir_type *array, int dimension, +FIRM_API void set_array_upper_bound(ir_type *array, size_t dimension, ir_node *upper_bound); /** Allocates Const nodes of mode_Is for the upper bound of an array dimension, i.e. [lower,upper[. */ -FIRM_API void set_array_upper_bound_int(ir_type *array, int dimension, +FIRM_API void set_array_upper_bound_int(ir_type *array, size_t dimension, int upper_bound); /** Returns true if lower bound != Unknown. */ -FIRM_API int has_array_lower_bound(const ir_type *array, int dimension); +FIRM_API int has_array_lower_bound(const ir_type *array, size_t dimension); /** Returns the lower bound of an array. */ -FIRM_API ir_node *get_array_lower_bound(const ir_type *array, int dimension); +FIRM_API ir_node *get_array_lower_bound(const ir_type *array, size_t dimension); /** Works only if bound is Const node with tarval that can be converted to long. */ -FIRM_API long get_array_lower_bound_int(const ir_type *array, int dimension); +FIRM_API long get_array_lower_bound_int(const ir_type *array, size_t dimension); /** returns true if lower bound != Unknown */ -FIRM_API int has_array_upper_bound(const ir_type *array, int dimension); +FIRM_API int has_array_upper_bound(const ir_type *array, size_t dimension); /** Returns the upper bound of an array. */ -FIRM_API ir_node *get_array_upper_bound(const ir_type *array, int dimension); +FIRM_API ir_node *get_array_upper_bound(const ir_type *array, size_t dimension); /** Works only if bound is Const node with tarval that can be converted to long. */ -FIRM_API long get_array_upper_bound_int(const ir_type *array, int 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, int 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, int 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 int 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); @@ -1951,10 +1895,10 @@ FIRM_API int is_Array_type(const ir_type *array); */ /** Create a new type enumeration -- set the enumerators independently. */ -FIRM_API ir_type *new_type_enumeration(ident *name, int n_enums); +FIRM_API ir_type *new_type_enumeration(ident *name, size_t n_enums); /** Create a new type enumeration with debug information -- set the enumerators independently. */ -FIRM_API ir_type *new_d_type_enumeration(ident *name, int 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. --- */ @@ -1966,24 +1910,24 @@ FIRM_API ident *get_enumeration_ident(const ir_type *enumeration); FIRM_API const char *get_enumeration_name(const ir_type *enumeration); /** Set an enumeration constant to a enumeration type at a given position. */ -FIRM_API void set_enumeration_const(ir_type *enumeration, int pos, - ident *nameid, tarval *con); +FIRM_API void set_enumeration_const(ir_type *enumeration, size_t pos, + ident *nameid, ir_tarval *con); /** Returns the number of enumeration values of this enumeration */ -FIRM_API int get_enumeration_n_enums(const ir_type *enumeration); +FIRM_API size_t get_enumeration_n_enums(const ir_type *enumeration); /** Returns the enumeration constant at a given position. */ FIRM_API ir_enum_const *get_enumeration_const(const ir_type *enumeration, - int pos); + size_t pos); /** Returns the enumeration type owner of an enumeration constant. */ FIRM_API ir_type *get_enumeration_owner(const ir_enum_const *enum_cnst); /** Sets the enumeration constant value. */ -FIRM_API void set_enumeration_value(ir_enum_const *enum_cnst, tarval *con); +FIRM_API void set_enumeration_value(ir_enum_const *enum_cnst, ir_tarval *con); /** Returns the enumeration constant value. */ -FIRM_API tarval *get_enumeration_value(const ir_enum_const *enum_cnst); +FIRM_API ir_tarval *get_enumeration_value(const ir_enum_const *enum_cnst); /** Assign an ident to an enumeration constant. */ FIRM_API void set_enumeration_nameid(ir_enum_const *enum_cnst, ident *id); @@ -2128,7 +2072,7 @@ FIRM_API const char *get_compound_name(const ir_type *tp); * * @return Number of members in the compound type. */ -FIRM_API int get_compound_n_members(const ir_type *tp); +FIRM_API size_t get_compound_n_members(const ir_type *tp); /** * Gets the member of a Firm compound type at position pos. @@ -2138,10 +2082,13 @@ FIRM_API int get_compound_n_members(const ir_type *tp); * * @return The member entity at position pos. */ -FIRM_API ir_entity *get_compound_member(const ir_type *tp, int pos); +FIRM_API ir_entity *get_compound_member(const ir_type *tp, size_t pos); /** Returns index of member in tp, -1 if not contained. */ -FIRM_API int get_compound_member_index(const ir_type *tp, ir_entity *member); +FIRM_API size_t get_compound_member_index(const ir_type *tp, ir_entity *member); + +/** Remove a member from a compound type. */ +FIRM_API void remove_compound_member(ir_type *compound, ir_entity *entity); /** * layout members of a struct/union or class type in a default way. @@ -2158,7 +2105,7 @@ 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. + * Checks whether a type is a code type. */ FIRM_API int is_code_type(const ir_type *tp); @@ -2167,23 +2114,6 @@ FIRM_API int is_code_type(const ir_type *tp); */ FIRM_API int is_frame_type(const ir_type *tp); -/** - * Checks, whether a type is a value parameter type. - */ -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, * so all class access functions work. @@ -2198,18 +2128,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. @@ -2245,80 +2163,8 @@ FIRM_API long get_type_nr(const ir_type *tp); */ typedef int (compare_types_func_t)(const void *tp1, const void *tp2); -/** Compares two types by their name. - * - * Compares the opcode and the name of the types. If these are - * equal returns 0, else non-zero. - */ -FIRM_API int compare_names(const void *tp1, const void *tp2); - -/** Compares two types strict. - * - * returns 0 if tp1 == tp2, else non-zero - */ -FIRM_API int compare_strict(const void *tp1, const void *tp2); - -/* ------------------------------------------------------------------------ */ - -/** Computes a hash value by the type name. - * - * Uses the name of the type and the type opcode to compute the hash. - */ -FIRM_API int firm_hash_name(ir_type *tp); - /* ------------------------------------------------------------------------ */ -/** Finalize type construction. - * - * Indicate that a type is so far completed that it can be - * distinguished from other types. Mature_type hashes the type into a - * table. It uses the function in compare_types_func to compare the - * types. - * - * If it finds a type identical to tp it returns this type. It turns - * tp into the Id type. All places formerly pointing to tp will now - * point to the found type. All entities of tp now refer to the found - * type as their owner, but they are not a member of this type. This - * is invalid firm -- the entities must be replaced by entities of the - * found type. The Id type will be removed from the representation - * automatically, but within an unknown time span. It occupies memory - * for this time. - * - * @param tp The type to mature. - */ -FIRM_API ir_type *mature_type(ir_type *tp); - -/** Finalize type construction. - * - * Indicate that a type is so far completed that it can be - * distinguished from other types. mature_type() hashes the type into a - * table. It uses the function in compare_types_func to compare the - * types. - * - * If it finds a type identical to tp it returns this type. It frees - * type tp and all its entities. - * - * @param tp The type to mature. - */ -FIRM_API ir_type *mature_type_free(ir_type *tp); - -/** Finalize type construction. - * - * Indicate that a type is so far completed that it can be - * distinguished from other types. Mature_type hashes the type into a - * table. It uses the function in compare_types_func to compare the - * types. - * - * If it find a type identical to tp it returns this type. It frees - * the entities and turns the type into an Id type. All places - * formerly pointing to tp will now point to the found type. The Id - * type will be removed from the representation automatically, but - * within an unknown time span. It occupies memory for this time. - * - * @param tp The type to mature. - */ -FIRM_API ir_type *mature_type_free_entities(ir_type *tp); - /** A data type to treat types and entities as the same. */ typedef union { ir_type *typ; /**< points to a type */ @@ -2359,16 +2205,14 @@ FIRM_API void type_walk_irg(ir_graph *irg, type_walk_func *pre, type_walk_func *post, void *env); /** - Touches every class in specified order: - - first the super class - - second the class itself - - third the sub classes. If new classes are created - during the traversal these will be visited, too. - - @todo should be named class-walk - - @deprecated will be removed? -*/ + * Touches every class in specified order: + * - first the super class + * - second the class itself + * - third the sub classes. If new classes are created + * during the traversal these will be visited, too. + * + * @deprecated will be removed? + */ FIRM_API void type_walk_super2sub(type_walk_func *pre, type_walk_func *post, void *env);