#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
*
* 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.
+ *
+ * @{
*/
/**
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.
/** 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);
*/
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.
*/
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 */
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);
/** 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);
/** 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 */
} 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.
+ *
+ * @{
*/
/**
*/
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.
*
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
/** 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.
*
* 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.
*/
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.
*
*/
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.
* 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);
*/
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.
*
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.
* 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. */
/** 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);
/** 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)
/** 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);
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.
* 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);
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
* - 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
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.
+ * Note: does not change the corresponding parameter entities (if there are any)
*/
-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, 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
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 */
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);
-
-/** 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);
+FIRM_API const tp_op *type_method;
+FIRM_API const tp_op *get_tpop_method(void);
-/** 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
* - *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.
* 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 size_t get_array_n_dimensions(const ir_type *array);
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);
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
*
* - *const: The target values representing the constants used to
* represent individual enumerations.
+ * @{
*/
/** Create a new type enumeration -- set the enumerators independently. */
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);
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. */
/** 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);
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);
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.
*
* - 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.
*
* - 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.
*/
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
*/
FIRM_API int is_compound_type(const ir_type *tp);
-/**
- * Checks whether 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.
- */
-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.
+/** @defgroup frame_type Frame
+ * @{
*/
-FIRM_API ir_type *new_type_value(void);
/**
* Makes a new frame type. Frame types are class types,
*/
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
*/
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.
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.
*
*/
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 */
* 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
/** @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"
projects / libfirm / blobdiff