/*
- * 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.
*
/**
* 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.
*/
IR_LINKAGE_HIDDEN_USER = 1 << 4
} ir_linkage;
+ENUM_BITSET(ir_linkage)
/**
* Return the visibility class of an entity
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.
/** 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. */
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
/**
- * 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);
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);
*/
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
/**
* 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);
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);
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);
/**
* 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. */
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 */
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)
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 */
*
* @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);
* 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
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);
+
+#define INVALID_MEMBER_INDEX ((size_t)-1)
-/** Returns index of mem in clss, -1 if not contained. */
-FIRM_API int get_class_member_index(const ir_type *clss, ir_entity *mem);
+/** 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
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);
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);
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);
* - 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
* 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.
*
* 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
/** 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,
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);
* 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.
*
* 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);
*/
/** 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. --- */
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);
*
* @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.
*
* @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.
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);
*/
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.
*/
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.
*/
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 */
projects / libfirm / blobdiff