X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=include%2Flibfirm%2Ftyperep.h;h=2984591c39f29e750f0e9251ea79a1d65d4252b4;hb=42ca1a98752df3defe526e0662939742fd88092b;hp=a56834c09abe4232b6d7b96e3a6a036becfb63e2;hpb=dd76896ea572a7712222cf8e4da0f3477e7af8b0;p=libfirm diff --git a/include/libfirm/typerep.h b/include/libfirm/typerep.h index a56834c09..2984591c3 100644 --- a/include/libfirm/typerep.h +++ b/include/libfirm/typerep.h @@ -46,7 +46,9 @@ * * - owner: A compound type this entity is a part of. * - type: The type of this entity. - * - name: The string that represents this entity in the source program. * - allocation: A flag saying whether the entity is dynamically or statically * allocated (values: dynamic_allocated, static_allocated, + * - name: The string that represents this entity in the source program. + * - allocation: A flag saying whether the entity is dynamically or statically + * allocated (values: dynamic_allocated, static_allocated, * automatic_allocated). * - visibility: A flag indicating the visibility of this entity (values: local, * external_visible, external_allocated) @@ -120,40 +122,6 @@ typedef enum { This serves better as opposition to description _and_ inherited.*/ } ir_peculiarity; -/** - * Additional method type properties: - * Tell about special properties of a method type. Some - * of these may be discovered by analyses. - */ -typedef enum { - mtp_no_property = 0x00000000, /**< no additional properties, default */ - mtp_property_const = 0x00000001, /**< This method did not access memory and calculates - its return values solely from its parameters. - GCC: __attribute__((const)). */ - mtp_property_pure = 0x00000002, /**< This method did NOT write to memory and calculates - its return values solely from its parameters and - the memory they points to (or global vars). - GCC: __attribute__((pure)). */ - mtp_property_noreturn = 0x00000004, /**< This method did not return due to an aborting system - call. - GCC: __attribute__((noreturn)). */ - mtp_property_nothrow = 0x00000008, /**< This method cannot throw an exception. - GCC: __attribute__((nothrow)). */ - mtp_property_naked = 0x00000010, /**< This method is naked. - GCC: __attribute__((naked)). */ - mtp_property_malloc = 0x00000020, /**< This method returns newly allocate memory. - GCC: __attribute__((malloc)). */ - mtp_property_weak = 0x00000040, /**< This method is weak. It is expected that - GCC: __attribute__((weak)). */ - mtp_property_intrinsic = 0x00000080, /**< This method is intrinsic. It is expected that - a lowering phase will remove all calls to it. */ - mtp_property_runtime = 0x00000100, /**< This method represents a runtime routine. */ - mtp_property_private = 0x00000200, /**< All method invocations are known, the backend is free to - optimize the call in any possible way. */ - mtp_property_inherited = (1<<31) /**< Internal. Used only in irg's, means property is - inherited from type. */ -} mtp_additional_property; - /** * Creates a new entity. * @@ -265,7 +233,7 @@ ir_allocation get_entity_allocation(const ir_entity *ent); void set_entity_allocation(ir_entity *ent, ir_allocation al); /** Return the name of the allocation type. */ -const char *get_allocation_name(ir_allocation vis); +const char *get_allocation_name(ir_allocation al); /** Returns the visibility of an entity. */ ir_visibility get_entity_visibility(const ir_entity *ent); @@ -311,17 +279,23 @@ void set_entity_volatility(ir_entity *ent, ir_volatility vol); /** Return the name of the volatility. */ const char *get_volatility_name(ir_volatility var); +/** Returns alignment of entity in bytes */ +unsigned get_entity_alignment(const ir_entity *entity); + +/** Sets alignment for entity in bytes */ +void set_entity_alignment(ir_entity *entity, unsigned alignment); + /** This enumeration flags the align of Loads/Stores. */ typedef enum { align_non_aligned, /**< The entity is not aligned. */ align_is_aligned /**< The entity is aligned. Default */ } ir_align; -/** Returns the alignment of an entity. */ -ir_align get_entity_align(const ir_entity *ent); +/** Returns indication wether entity is aligned in memory. */ +ir_align get_entity_aligned(const ir_entity *ent); -/** Sets the alignment of an entity. */ -void set_entity_align(ir_entity *ent, ir_align a); +/** Sets indication wether entity is aligned in memory */ +void set_entity_aligned(ir_entity *ent, ir_align a); /** Return the name of the alignment. */ const char *get_align_name(ir_align a); @@ -386,6 +360,11 @@ int is_entity_final(const ir_entity *ent); /** Sets/resets the final flag of an entity. */ void set_entity_final(ir_entity *ent, int final); +/** Set label number of an entity with code type */ +void set_entity_label(ir_entity *ent, ir_label_t label); +/** Return label number of an entity with code type */ +ir_label_t get_entity_label(const ir_entity *ent); + /** Checks if an entity is compiler generated. */ int is_entity_compiler_generated(const ir_entity *ent); @@ -402,10 +381,13 @@ void set_entity_backend_marked(ir_entity *ent, int flag); * Bitfield type indicating the way an entity is used. */ typedef enum { - ir_usage_address_taken = 1 << 0, - ir_usage_write = 1 << 1, - ir_usage_read = 1 << 2, - ir_usage_reinterpret_cast = 1 << 3, + ir_usage_none = 0, /**< This entity is unused. */ + ir_usage_address_taken = 1 << 0, /**< The address of this entity was taken. */ + ir_usage_write = 1 << 1, /**< The entity was written to. */ + ir_usage_read = 1 << 2, /**< The entity was read. */ + ir_usage_reinterpret_cast = 1 << 3, /**< The entity was read but with a wrong mode + (an implicit reinterpret cast) */ + /** Unknown access */ ir_usage_unknown = ir_usage_address_taken | ir_usage_write | ir_usage_read | ir_usage_reinterpret_cast @@ -473,6 +455,9 @@ typedef enum ir_initializer_kind_t { /** returns kind of an initializer */ ir_initializer_kind_t get_initializer_kind(const ir_initializer_t *initializer); +/** Return the name of the initializer kind. */ +const char *get_initializer_kind_name(ir_initializer_kind_t ini); + /** * returns the null initializer (there's only one instance of it in a program ) */ @@ -577,6 +562,9 @@ void set_compound_ent_value(ir_entity *ent, ir_node *val, ir_entity *member, int /** Sets the new style initializers of an entity. */ void set_entity_initializer(ir_entity *entity, ir_initializer_t *initializer); +/** Returns true, if an entity has new style initializers. */ +int has_entity_initializer(const ir_entity *entity); + /** Return the new style initializers of an entity. */ ir_initializer_t *get_entity_initializer(const ir_entity *entity); @@ -784,6 +772,7 @@ typedef enum { tpo_pointer, /**< A pointer type. */ tpo_primitive, /**< A primitive type. */ tpo_id, /**< Special Id tag used for type replacement. */ + tpo_code, /**< a piece of code (a basic block) */ tpo_none, /**< Special type for the None type. */ tpo_unknown, /**< Special code for the Unknown type. */ tpo_max /* not a type opcode */ @@ -833,8 +822,8 @@ ident *get_tpop_ident(const tp_op *op); * This struct is dynamically allocated but constant for the lifetime * of the library. */ -extern tp_op *type_class; -tp_op *get_tpop_class(void); +extern const tp_op *type_class; +const tp_op *get_tpop_class(void); /** * This type opcode marks that the corresponding type is a compound type @@ -845,8 +834,8 @@ tp_op *get_tpop_class(void); * This struct is dynamically allocated but constant for the lifetime * of the library. */ -extern tp_op *type_struct; -tp_op *get_tpop_struct(void); +extern const tp_op *type_struct; +const tp_op *get_tpop_struct(void); /** * This type opcode marks that the corresponding type is a method type. @@ -855,8 +844,8 @@ tp_op *get_tpop_struct(void); * This struct is dynamically allocated but constant for the lifetime * of the library. */ -extern tp_op *type_method; -tp_op *get_tpop_method(void); +extern const tp_op *type_method; +const tp_op *get_tpop_method(void); /** * This type opcode marks that the corresponding type is a union type. @@ -865,8 +854,8 @@ tp_op *get_tpop_method(void); * This struct is dynamically allocated but constant for the lifetime * of the library. */ -extern tp_op *type_union; -tp_op *get_tpop_union(void); +extern const tp_op *type_union; +const tp_op *get_tpop_union(void); /** * This type opcode marks that the corresponding type is an array type. @@ -876,8 +865,8 @@ tp_op *get_tpop_union(void); * This struct is dynamically allocated but constant for the lifetime * of the library. */ -extern tp_op *type_array; -tp_op *get_tpop_array(void); +extern const tp_op *type_array; +const tp_op *get_tpop_array(void); /** * This type opcode marks that the corresponding type is an enumeration type. @@ -888,8 +877,8 @@ tp_op *get_tpop_array(void); * This struct is dynamically allocated but constant for the lifetime * of the library. */ -extern tp_op *type_enumeration; -tp_op *get_tpop_enumeration(void); +extern const tp_op *type_enumeration; +const tp_op *get_tpop_enumeration(void); /** * This type opcode marks that the corresponding type is a pointer type. @@ -898,8 +887,8 @@ tp_op *get_tpop_enumeration(void); * This struct is dynamically allocated but constant for the lifetime * of the library. */ -extern tp_op *type_pointer; -tp_op *get_tpop_pointer(void); +extern const tp_op *type_pointer; +const tp_op *get_tpop_pointer(void); /** * This type opcode marks that the corresponding type is a primitive type. @@ -909,8 +898,8 @@ tp_op *get_tpop_pointer(void); * This struct is dynamically allocated but constant for the lifetime * of the library. */ -extern tp_op *type_primitive; -tp_op *get_tpop_primitive(void); +extern const tp_op *type_primitive; +const tp_op *get_tpop_primitive(void); /** * This type opcode is an auxiliary opcode dedicated to support transformations @@ -929,8 +918,14 @@ tp_op *get_tpop_primitive(void); * This struct is dynamically allocated but constant for the lifetime * of the library. */ -extern tp_op *type_id; -tp_op *get_tpop_id(void); +extern const tp_op *type_id; +const tp_op *get_tpop_id(void); + +/** + * The code type is used to mark pieces of code (basic blocks) + */ +extern const tp_op *tpop_code; +const tp_op *get_tpop_code_type(void); /** * This type opcode is an auxiliary opcode dedicated to support type analyses. @@ -940,8 +935,8 @@ tp_op *get_tpop_id(void); * contain a type or that are initialized for an analysis. There exists exactly * one type with this opcode. */ -extern tp_op *tpop_none; -tp_op *get_tpop_none(void); +extern const tp_op *tpop_none; +const tp_op *get_tpop_none(void); /** * This type opcode is an auxiliary opcode dedicated to support type analyses. @@ -951,8 +946,8 @@ tp_op *get_tpop_none(void); * yet) or to represent the top of a lattice (could not be determined). There exists * exactly one type with this opcode. */ -extern tp_op *tpop_unknown; -tp_op *get_tpop_unknown(void); +extern const tp_op *tpop_unknown; +const tp_op *get_tpop_unknown(void); /* ----------------------------------------------------------------------- */ /* Classify pairs of types/entities in the inheritance relations. */ @@ -1010,7 +1005,7 @@ ir_entity *resolve_ent_polymorphy(ir_type *dynamic_class, ir_entity* static_ent) * * Returns an ident that consists of the name of type followed by an * underscore and the name (not ld_name) of the entity. */ -ident *default_mangle_inherited_name(ir_entity *ent, ir_type *clss); +ident *default_mangle_inherited_name(const ir_entity *ent, const ir_type *clss); /** Type of argument functions for inheritance resolver. * @@ -1019,7 +1014,7 @@ ident *default_mangle_inherited_name(ir_entity *ent, ir_type *clss); * used. * @param clss The class type in which the new entity will be placed. */ -typedef ident *mangle_inherited_name_func(ir_entity *ent, ir_type *clss); +typedef ident *mangle_inherited_name_func(const ir_entity *ent, const ir_type *clss); /** Resolve implicit inheritance. * @@ -1144,16 +1139,16 @@ typedef enum { ir_class_casts_normalized = 2, /**< Class casts conform to inheritance edges. */ ir_class_casts_state_max } ir_class_cast_state; -char *get_class_cast_state_string(ir_class_cast_state s); +const char *get_class_cast_state_string(ir_class_cast_state s); void set_irg_class_cast_state(ir_graph *irg, ir_class_cast_state s); -ir_class_cast_state get_irg_class_cast_state(ir_graph *irg); +ir_class_cast_state get_irg_class_cast_state(const ir_graph *irg); void set_irp_class_cast_state(ir_class_cast_state s); ir_class_cast_state get_irp_class_cast_state(void); /** Verify the class cast state of an irg. * - * Asserts if state is to high, outputs warning if state is to low + * Asserts if state is to high, outputs debug warning if state is to low * and firm verbosity is set. */ void verify_irg_class_cast_state(ir_graph *irg); @@ -1704,14 +1699,6 @@ void remove_class_supertype(ir_type *clss, ir_type *supertype); #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) -/** 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 a human readable string for a peculiarity. */ const char *get_peculiarity_name(ir_peculiarity p); @@ -1889,6 +1876,10 @@ 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. */ ir_entity *get_method_value_param_ent(ir_type *method, int pos); +/** + * Sets the type that represents the copied value arguments. + */ +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. @@ -1925,19 +1916,19 @@ ir_type *get_method_value_res_type(const ir_type *method); * variable amount of arguments (e.g. C's printf). Default is * non_variadic. */ -typedef enum variadicity { - variadicity_non_variadic, /**< non variadic */ - variadicity_variadic /**< variadic */ -} variadicity; +typedef enum ir_variadicity { + variadicity_non_variadic, /**< non variadic */ + variadicity_variadic /**< variadic */ +} ir_variadicity; /** Returns the null-terminated name of this variadicity. */ -const char *get_variadicity_name(variadicity vari); +const char *get_variadicity_name(ir_variadicity vari); /** Returns the variadicity of a method. */ -variadicity get_method_variadicity(const ir_type *method); +ir_variadicity get_method_variadicity(const ir_type *method); /** Sets the variadicity of a method. */ -void set_method_variadicity(ir_type *method, variadicity vari); +void set_method_variadicity(ir_type *method, ir_variadicity vari); /** * Returns the first variadic parameter index of a type. @@ -2316,8 +2307,13 @@ void set_primitive_base_type(ir_type *tp, ir_type *base_tp); /** A variable that contains the only none type. */ extern ir_type *firm_none_type; +/** A variable that contains the only code type. */ +extern ir_type *firm_code_type; + /** Returns the none type. */ ir_type *get_none_type(void); +/** Returns the code type. */ +ir_type *get_code_type(void); /** * @page unknown_type The Unknown type @@ -2389,6 +2385,11 @@ int get_compound_member_index(const ir_type *tp, ir_entity *member); */ int is_compound_type(const ir_type *tp); +/** + * Checks wether a type is a code type. + */ +int is_code_type(const ir_type *tp); + /** * Checks, whether a type is a frame type. */ @@ -2404,6 +2405,13 @@ int is_value_param_type(const ir_type *tp); */ 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. + */ +ir_type *new_type_value(ident *name); + /** * Makes a new frame type. Frame types are class types, * so all class access functions work. @@ -2547,12 +2555,12 @@ ir_type *mature_type_free_entities(ir_type *tp); /** * The interface type for the type identify module; */ -typedef struct _type_identify_if_t { +struct type_identify_if_t { compare_types_func_t *cmp; /**< The function that should be used to compare two types. If NULL, compare_strict() will be used. */ hash_types_func_t *hash; /**< The function that should be used to calculate a hash value of a type. If NULL, hash_name() will be used. */ -} type_identify_if_t; +}; /** * Initialise the type identifier module. @@ -2590,6 +2598,10 @@ typedef void class_walk_func(ir_type *clss, void *env); * Does not touch frame types or types for value params ... */ 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). */ +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 @@ -2630,8 +2642,6 @@ void type_walk_super(type_walk_func *pre, type_walk_func *post, void *env); Then iterates to subclasses. Executes post after return from subclass. Does not visit global type, frame types. - - @bug ?? something is wrong with this. */ void class_walk_super2sub(class_walk_func *pre, class_walk_func *post, void *env);