X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=include%2Flibfirm%2Ftyperep.h;h=9b081f8c255399b5a238049a9e99b33acec4f543;hb=e2e929ea04eb563b5fffadfd84bd61eb1f85735f;hp=457ce3fe41d37d157316b9aed49bcd9e4ccfa899;hpb=4ebc4b6497324aa5d2380a897c75d3c391760ba0;p=libfirm diff --git a/include/libfirm/typerep.h b/include/libfirm/typerep.h index 457ce3fe4..9b081f8c2 100644 --- a/include/libfirm/typerep.h +++ b/include/libfirm/typerep.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -16,6 +16,11 @@ * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE. */ + +/** + * @file + * @brief Declarations for functions and datastructures to represent types + */ #ifndef FIRM_TYPEREP_H #define FIRM_TYPEREP_H @@ -46,7 +51,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,38 +127,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_intrinsic = 0x00000040, /**< This method is intrinsic. It is expected that - a lowering phase will remove all calls to it. */ - mtp_property_runtime = 0x00000080, /**< This method represents a runtime routine. */ - mtp_property_private = 0x00000100, /**< 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. * @@ -263,7 +238,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); @@ -309,28 +284,35 @@ 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); /** This enumeration flags the stickyness of an entity. */ typedef enum { - stickyness_unsticky, /**< The entity can be removed from - the program, unless contraindicated - by other attributes. Default. */ - stickyness_sticky /**< The entity must remain in the - program in any case. */ + stickyness_unsticky, /**< The entity can be removed from + the program, unless contraindicated + by other attributes. Default. */ + stickyness_sticky /**< The entity must remain in the + program in any case. There might be external + callers. */ } ir_stickyness; /** Get the entity's stickyness. */ @@ -383,6 +365,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); @@ -396,22 +383,26 @@ int is_entity_backend_marked(const ir_entity *ent); void set_entity_backend_marked(ir_entity *ent, int flag); /** - * The state of the address_taken flag. + * Bitfield type indicating the way an entity is used. */ typedef enum { - ir_address_not_taken = 0, /**< The address is NOT taken. */ - ir_address_taken_unknown = 1, /**< The state of the address taken flag is unknown. */ - ir_address_taken = 2 /**< The address IS taken. */ -} ir_address_taken_state; - -/** Return the state of the address taken flag of an entity. */ -ir_address_taken_state get_entity_address_taken(const ir_entity *ent); + 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 +} ir_entity_usage; + +/** Return the entity usage */ +ir_entity_usage get_entity_usage(const ir_entity *ent); /** Sets/resets the state of the address taken flag of an entity. */ -void set_entity_address_taken(ir_entity *ent, ir_address_taken_state flag); - -/** Return the name of the address_taken state. */ -const char *get_address_taken_state_name(ir_address_taken_state state); +void set_entity_usage(ir_entity *ent, ir_entity_usage flag); /** * Returns the debug information of an entity. @@ -454,94 +445,66 @@ ir_node *copy_const_value(dbg_info *dbg, ir_node *n); ir_node *get_atomic_ent_value(ir_entity *ent); void set_atomic_ent_value(ir_entity *ent, ir_node *val); -/** Creates a new compound graph path of given length. */ -compound_graph_path *new_compound_graph_path(ir_type *tp, int length); +/** the kind (type) of an initializer */ +typedef enum ir_initializer_kind_t { + /** initializer containing an ir_node from the const-code irg */ + IR_INITIALIZER_CONST, + /** initializer containing a tarval */ + IR_INITIALIZER_TARVAL, + /** initializes type with default values (usually 0) */ + IR_INITIALIZER_NULL, + /** list of initializers used to initializer a compound or array type */ + IR_INITIALIZER_COMPOUND +} ir_initializer_kind_t; -/** Returns non-zero if an object is a compound graph path */ -int is_compound_graph_path(const void *thing); +/** returns kind of an initializer */ +ir_initializer_kind_t get_initializer_kind(const ir_initializer_t *initializer); -/** Frees a graph path object */ -void free_compound_graph_path(compound_graph_path *gr); +/** Return the name of the initializer kind. */ +const char *get_initializer_kind_name(ir_initializer_kind_t ini); -/** Returns the length of a graph path */ -int get_compound_graph_path_length(const compound_graph_path *gr); - -ir_entity *get_compound_graph_path_node(const compound_graph_path *gr, int pos); -void set_compound_graph_path_node(compound_graph_path *gr, int pos, ir_entity *node); -int get_compound_graph_path_array_index(const compound_graph_path *gr, int pos); -void set_compound_graph_path_array_index(compound_graph_path *gr, int pos, int index); +/** + * returns the null initializer (there's only one instance of it in a program ) + */ +ir_initializer_t *get_initializer_null(void); -/** Checks whether the path up to pos is correct. If the path contains a NULL, - * assumes the path is not complete and returns non-zero. */ -int is_proper_compound_graph_path(compound_graph_path *gr, int pos); +/** + * creates an initializer containing a reference to a node on the const-code + * irg. + */ +ir_initializer_t *create_initializer_const(ir_node *value); -/* A value of a compound entity is a pair of a value and the description of the - corresponding access path to the member of the compound. */ -void add_compound_ent_value_w_path(ir_entity *ent, ir_node *val, compound_graph_path *path); -void set_compound_ent_value_w_path(ir_entity *ent, ir_node *val, compound_graph_path *path, int pos); +/** creates an initializer containing a single tarval value */ +ir_initializer_t *create_initializer_tarval(tarval *tv); -/** Returns the number of constant values needed to initialize the entity. - * - * Asserts if the entity has variability_uninitialized. - * */ -int get_compound_ent_n_values(ir_entity *ent); -/** Returns a constant value given the position. */ -ir_node *get_compound_ent_value(ir_entity *ent, int pos); -/** Returns the access path for value at position pos. */ -compound_graph_path *get_compound_ent_value_path(ir_entity *ent, int pos); -/** Returns a constant value given the access path. - * The path must contain array indices for all array element entities. */ -ir_node *get_compound_ent_value_by_path(ir_entity *ent, compound_graph_path *path); +/** return value contained in a const initializer */ +ir_node *get_initializer_const_value(const ir_initializer_t *initializer); -/** Removes all constant entries where the path ends at value_ent. Does not - free the memory of the paths. (The same path might be used for several - constant entities. */ -void remove_compound_ent_value(ir_entity *ent, ir_entity *value_ent); +/** return value contained in a tarval initializer */ +tarval *get_initializer_tarval_value(const ir_initializer_t *initialzier); -/* Some languages support only trivial access paths, i.e., the member is a - direct, atomic member of the constant entities type. In this case the - corresponding entity can be accessed directly. The following functions - allow direct access. */ +/** creates a compound initializer which holds @p n_entries entries */ +ir_initializer_t *create_initializer_compound(unsigned n_entries); -/** Generates a Path with length 1. - Beware: Has a bad runtime for array elements (O(|array|) and should be - avoided there. Use add_compound_ent_value_w_path() instead and create - the path manually. */ -void add_compound_ent_value(ir_entity *ent, ir_node *val, ir_entity *member); +/** returns the number of entries in a compound initializer */ +unsigned get_initializer_compound_n_entries(const ir_initializer_t *initializer); -/** Returns the last member in the path */ -ir_entity *get_compound_ent_value_member(ir_entity *ent, int pos); +/** sets entry with index @p index to the initializer @p value */ +void set_initializer_compound_value(ir_initializer_t *initializer, + unsigned index, ir_initializer_t *value); -/** Sets the path at pos 0 */ -void set_compound_ent_value(ir_entity *ent, ir_node *val, ir_entity *member, int pos); +/** returns the value with index @p index of a compound initializer */ +ir_initializer_t *get_initializer_compound_value( + const ir_initializer_t *initializer, unsigned index); -/** Initializes the entity ent which must be of a one dimensional - array type with the values given in the values array. - The array must have a lower and an upper bound. Keeps the - order of values. Does not test whether the number of values - fits into the given array size. Does not test whether the - values have the proper mode for the array. */ -void set_array_entity_values(ir_entity *ent, tarval **values, int num_vals); +/** Sets the new style initializers of an entity. */ +void set_entity_initializer(ir_entity *entity, ir_initializer_t *initializer); -/** - * Return the offset in bits from the last byte address. - * - * This requires that the layout of all concerned types is fixed. - * - * @param ent Any entity of compound type with at least pos initialization values. - * @param pos The position of the value for which the offset is requested. - */ -unsigned get_compound_ent_value_offset_bit_remainder(ir_entity *ent, int pos); +/** Returns true, if an entity has new style initializers. */ +int has_entity_initializer(const ir_entity *entity); -/** Return the overall offset of value at position pos in bytes. - * - * This requires that the layout of all concerned types is fixed. - * Asserts if bit offset is not byte aligned. - * - * @param ent Any entity of compound type with at least pos initialization values. - * @param pos The position of the value for which the offset is requested. - */ -unsigned get_compound_ent_value_offset_bytes(ir_entity *ent, int pos); +/** Return the new style initializers of an entity. */ +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 @@ -580,7 +543,7 @@ int is_entity(const void *thing); /** Returns true if the type of the entity is a primitive, pointer * enumeration or method type. * - * @Note This is a different classification than from is_primitive_type(). + * @note This is a different classification than from is_primitive_type(). */ int is_atomic_entity(ir_entity *ent); /** Returns true if the type of the entity is a class, structure, @@ -589,13 +552,6 @@ int is_compound_entity(ir_entity *ent); /** Returns true if the type of the entity is a Method type. */ int is_method_entity(ir_entity *ent); -/** Returns non-zero if ent1 and ent2 have are equal except for their owner. - Two entities are equal if - - they have the same type (the same C-struct) - - ...? -*/ -int equal_entity(ir_entity *ent1, ir_entity *ent2); - /** Outputs a unique number for this entity if libfirm is compiled for * debugging, (configure with --enable-debug) else returns the address * of the type cast to long. @@ -603,10 +559,10 @@ int equal_entity(ir_entity *ent1, ir_entity *ent2); long get_entity_nr(const ir_entity *ent); /** Returns the entities visited count. */ -unsigned long get_entity_visited(ir_entity *ent); +ir_visited_t get_entity_visited(ir_entity *ent); /** Sets the entities visited count. */ -void set_entity_visited(ir_entity *ent, unsigned long num); +void set_entity_visited(ir_entity *ent, ir_visited_t num); /** Sets visited field in entity to entity_visited. */ void mark_entity_visited(ir_entity *ent); @@ -672,7 +628,8 @@ ir_type *get_entity_repr_class(const ir_entity *ent); * - irg = NULL * - link = NULL */ -/* A variable that contains the only unknown entity. */ + +/** A variable that contains the only unknown entity. */ extern ir_entity *unknown_entity; /** Returns the @link unknown_entity unknown entity @endlink. */ @@ -692,22 +649,6 @@ typedef enum acc_bits { #define IS_WRITTEN(a) ((a) & ptr_access_write) #define IS_STORED(a) ((a) & ptr_access_store) -/** - * Supported image sections. - * Currently only methods can be placed in different sections. - */ -typedef enum { - section_text, /**< The code segment. This is the default for methods. */ - section_constructors /**< The constructor section. */ -} ir_img_section; - -/** Returns the section of a method. */ -ir_img_section get_method_img_section(const ir_entity *method); - -/** Sets the section of a method. */ -void set_method_img_section(ir_entity *method, ir_img_section section); - - /** * @page tyop type operations * This module specifies the kinds of types available in firm. @@ -716,8 +657,6 @@ void set_method_img_section(ir_entity *method, ir_img_section section); * 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. - * - * @see type.h */ /** @@ -734,10 +673,10 @@ typedef enum { tpo_enumeration, /**< An enumeration type. */ 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 */ + tpo_last = tpo_unknown /* not a type opcode */ } tp_opcode; /** @@ -746,7 +685,7 @@ typedef enum { * this is only the kind name, an enum for case-switching and some * internal values. * - * @see get_tpop_name(), get_tpop_code(), get_tpop_ident() + * @see get_tpop_name(), get_tpop_code() */ typedef struct tp_op tp_op; @@ -767,14 +706,6 @@ const char *get_tpop_name(const tp_op *op); */ tp_opcode get_tpop_code(const tp_op *op); -/** - * Returns the ident for the type opcode. - * - * @param op The type opcode to get the ident from. - * @return The ident. - */ -ident *get_tpop_ident(const tp_op *op); - /** * This type opcode marks that the corresponding type is a class type. * @@ -784,8 +715,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 @@ -796,8 +727,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. @@ -806,8 +737,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. @@ -816,8 +747,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. @@ -827,8 +758,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. @@ -839,8 +770,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. @@ -849,8 +780,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. @@ -860,28 +791,14 @@ 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 - * of the type structure. - * - * If a type is changed to another type with another - * opcode the new type will be allocated with new memory. All nodes refering - * to the old type need to be changed to refer to the new one. This is simplified - * by turning the old type into an id type that merely forwards to the new type - * that now replaces the old one. - * type_ids should never be visible out of the type module. All access routines - * should automatically check for type_id and eventually follow the forward in - * type_id. Two types are exchanged by a call to exchange_types. - * If a type_id is visible externally report this as bug. If it is assured that - * this never happens this extern variable can be moved to tpop_t.h. - * This struct is dynamically allocated but constant for the lifetime - * of the library. + * The code type is used to mark pieces of code (basic blocks) */ -extern tp_op *type_id; -tp_op *get_tpop_id(void); +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. @@ -891,8 +808,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. @@ -902,8 +819,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. */ @@ -961,7 +878,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. * @@ -970,7 +887,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. * @@ -1025,7 +942,7 @@ inh_transitive_closure_state get_irp_inh_transitive_closure_state(void); /** Compute transitive closure of the subclass/superclass and * overwrites/overwrittenby relation. * - * This function walks over the ir (O(#types+#entities)) to compute the + * This function walks over the ir (O(\#types+\#entities)) to compute the * transitive closure. */ void compute_inh_transitive_closure(void); @@ -1077,8 +994,6 @@ ir_entity *get_entity_trans_overwrites_next(const ir_entity *ent); * relation. Example: (A)(new C()). * any: Cast operations do not conform with the transitive inheritance * relation. Example: (B2)(new B1()) - * - * @see: tropt.h */ /* ----------------------------------------------------------------------- */ @@ -1095,16 +1010,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); @@ -1166,38 +1081,6 @@ int tr_vrfy(void); #define TR_VRFY() tr_vrfy() #endif -/** - * - * @file typegmod.h - * This module supplies routines that support changing the type graph. - */ - -/** Replaces one type by the other. - * - * Old type is replaced by new_type. All references to old_type - * now point to new_type. The memory for the old type is destroyed, - * but still used. Therefore it is not freed. - * All referenced to this memory will be lost after a certain while. - * An exception is the list of types in irp (irprog.h). - * In the future there might be a routine to recover the memory, but - * this will be at considerable runtime cost. - * - * @param old_type - The old type that shall be replaced by the new type. - * @param new_type - The new type that will replace old_type. - * - */ -void exchange_types(ir_type *old_type, ir_type *new_type); - -/** Skip id types until a useful type is reached. - * - * @param tp - A type of arbitrary kind. - * - * @return - * tp if it is not an id type. - * If tp is an id type returns the real type it stands for. - */ -ir_type *skip_tid(ir_type *tp); - /** * @page type representation of types * @@ -1217,12 +1100,8 @@ ir_type *skip_tid(ir_type *tp); * 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. - * - * @see tpop.h */ -#include "typerep.h" - /** Frees all entities associated with a type. * Does not free the array entity. * Warning: ensure these entities are not referenced anywhere else. @@ -1341,10 +1220,7 @@ unsigned get_type_size_bytes(const ir_type *tp); */ void set_type_size_bytes(ir_type *tp, unsigned size); -/** Returns the alignment of a type in bytes. - * - * Returns -1 if the alignment is NOT - * a byte size, i.e. not dividable by 8. Calls get_type_alignment_bits(). */ +/** Returns the alignment of a type in bytes. */ unsigned get_type_alignment_bytes(ir_type *tp); /** Returns the alignment of a type in bits. @@ -1360,9 +1236,9 @@ unsigned get_type_alignment_bytes(ir_type *tp); void set_type_alignment_bytes(ir_type *tp, unsigned align); /** Returns the visited count of a type. */ -unsigned long get_type_visited(const ir_type *tp); +ir_visited_t get_type_visited(const ir_type *tp); /** Sets the visited count of a type to num. */ -void set_type_visited(ir_type *tp, unsigned long num); +void set_type_visited(ir_type *tp, ir_visited_t num); /** Sets visited field in type to type_visited. */ void mark_type_visited(ir_type *tp); /** Returns non-zero if the type is already visited */ @@ -1387,9 +1263,9 @@ void set_type_link(ir_type *tp, void *l); * * @see typewalk */ -void set_master_type_visited(unsigned long val); -unsigned long get_master_type_visited(void); -void inc_master_type_visited(void); +void set_master_type_visited(ir_visited_t val); +ir_visited_t get_master_type_visited(void); +void inc_master_type_visited(void); /** * Sets the debug information of a type. @@ -1448,7 +1324,7 @@ int is_type(const void *thing); * - the same element type * - they are enumeration types and have the same enumerator names * - they are pointer types and have the identical points_to type - * (i.e., the same C-struct to represent the type, type_id is skipped. + * (i.e., the same C-struct to represent the type. * This is to avoid endless recursions; with pointer types cyclic * type graphs are possible.) */ @@ -1658,14 +1534,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); @@ -1817,7 +1685,17 @@ ir_type *new_type_method(ident *name, int n_param, int n_res); * The arrays for the parameter and result types are not initialized by * the constructor. */ -ir_type *new_d_type_method(ident *name, int n_param, int n_res, dbg_info* db); +ir_type *new_d_type_method(ident *name, int n_param, int n_res, dbg_info *db); + +/** Clone an existing method type. + * + * @param tp the method type to clone. + * @param prefix if non-null, will be the prefix for the name of + * the cloned type + * + * @return the cloned method type. + */ +ir_type *clone_type_method(ir_type *tp, ident *prefix); /* -- manipulate private fields of method. -- */ @@ -1833,6 +1711,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. @@ -1869,19 +1751,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. @@ -1913,21 +1795,22 @@ void set_method_additional_property(ir_type *method, mtp_additional_property fla * upper 8 encode the calling conventions. */ typedef enum { - cc_reg_param = 0x01000000, /**< Transmit parameters in registers, else the stack is used. - This flag may be set as default on some architectures. */ - cc_last_on_top = 0x02000000, /**< The last non-register parameter is transmitted on top of - the stack. This is equivalent to the pascal - calling convention. If this flag is not set, the first - non-register parameter is used (stdcall or cdecl - calling convention) */ - cc_callee_clear_stk = 0x04000000, /**< The callee clears the stack. This forbids variadic - function calls (stdcall). */ - cc_this_call = 0x08000000, /**< The first parameter is a this pointer and is transmitted - in a special way. */ - cc_compound_ret = 0x10000000, /**< the method returns a compound - type */ - - cc_bits = (0xFF << 24) /**< the calling convention bits */ + cc_reg_param = 0x01000000, /**< Transmit parameters in registers, else the stack is used. + This flag may be set as default on some architectures. */ + cc_last_on_top = 0x02000000, /**< The last non-register parameter is transmitted on top of + the stack. This is equivalent to the pascal + calling convention. If this flag is not set, the first + non-register parameter is used (stdcall or cdecl + calling convention) */ + cc_callee_clear_stk = 0x04000000, /**< The callee clears the stack. This forbids variadic + function calls (stdcall). */ + cc_this_call = 0x08000000, /**< The first parameter is a this pointer and is transmitted + in a special way. */ + cc_compound_ret = 0x10000000, /**< The method returns a compound type. */ + cc_frame_on_caller_stk = 0x20000000, /**< The method did not allocate an own stack frame, instead the + caller must reserve size on its own stack. */ + cc_fpreg_param = 0x40000000, /**< Transmit floating point parameters in registers, else the stack is used. */ + cc_bits = (0xFF << 24)/**< The calling convention bits. */ } calling_convention; /* some often used cases: made as defines because firmjni cannot handle two @@ -2213,7 +2096,7 @@ ir_type *get_pointer_points_to_type(ir_type *pointer); int is_Pointer_type(const ir_type *pointer); /** Returns the first pointer type that has as points_to tp. - * Not efficient: O(#types). + * Not efficient: O(\#types). * If not found returns firm_unknown_type. */ ir_type *find_pointer_type_to_type(ir_type *tp); @@ -2259,8 +2142,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 @@ -2332,6 +2220,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. */ @@ -2347,6 +2240,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. @@ -2354,6 +2254,13 @@ int is_lowered_type(const ir_type *tp); */ ir_type *new_type_frame(ident *name); +/** + * Makes a clone of a frame type. + * Sets entity links from old frame entities to new onces and + * vice versa. + */ +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. @@ -2480,26 +2387,6 @@ ir_type *mature_type_free(ir_type *tp); */ ir_type *mature_type_free_entities(ir_type *tp); -/** - * The interface type for the type identify module; - */ -typedef 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. - * - * @param ti_if The interface functions for this module. - * - * If the parameter ti_if is NULL, the default functions compare_strict() and - * firm_hash_name() will be used. - */ -void init_type_identify(type_identify_if_t *ti_if); - /** A data type to treat types and entities as the same. */ typedef union { ir_type *typ; /**< points to a type */ @@ -2511,7 +2398,7 @@ typedef union { * @param tore points to the visited type or entity * @param env free environment pointer */ -typedef void type_walk_func(type_or_ent *tore, void *env); +typedef void type_walk_func(type_or_ent tore, void *env); /** The class walk function * @@ -2526,6 +2413,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 @@ -2566,8 +2457,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);