X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=include%2Flibfirm%2Ftyperep.h;h=9b081f8c255399b5a238049a9e99b33acec4f543;hb=e2e929ea04eb563b5fffadfd84bd61eb1f85735f;hp=fb34468548cc185fd7c0e9788cfbe402074cd6c7;hpb=12ad4306b9e51ff630e24a01f363fd141368c33c;p=libfirm diff --git a/include/libfirm/typerep.h b/include/libfirm/typerep.h index fb3446854..9b081f8c2 100644 --- a/include/libfirm/typerep.h +++ b/include/libfirm/typerep.h @@ -19,7 +19,7 @@ /** * @file - * Declarations for functions and datastructures to represent types + * @brief Declarations for functions and datastructures to represent types */ #ifndef FIRM_TYPEREP_H #define FIRM_TYPEREP_H @@ -497,73 +497,6 @@ void set_initializer_compound_value(ir_initializer_t *initializer, ir_initializer_t *get_initializer_compound_value( const ir_initializer_t *initializer, unsigned index); -/** Creates a new compound graph path of given length. */ -compound_graph_path *new_compound_graph_path(ir_type *tp, int length); - -/** Returns non-zero if an object is a compound graph path */ -int is_compound_graph_path(const void *thing); - -/** Frees a graph path object */ -void free_compound_graph_path(compound_graph_path *gr); - -/** Returns the length of a graph path */ -int get_compound_graph_path_length(const compound_graph_path *gr); - -/** Get the entity node of an compound graph path at position pos. */ -ir_entity *get_compound_graph_path_node(const compound_graph_path *gr, int pos); -/** Set the entity node of an compound graph path at position pos. */ -void set_compound_graph_path_node(compound_graph_path *gr, int pos, ir_entity *node); -/** Get the index of an compound graph path at position pos. */ -int get_compound_graph_path_array_index(const compound_graph_path *gr, int pos); -/** Set the index of an compound graph path at position pos. */ -void set_compound_graph_path_array_index(compound_graph_path *gr, int pos, int index); -/** Get the type of an compound graph path. */ -ir_type *get_compound_graph_path_type(const compound_graph_path *gr); - -/** 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); - -/* 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); - -/** 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); - -/** 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); - -/* 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. */ - -/** 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 last member in the path */ -ir_entity *get_compound_ent_value_member(ir_entity *ent, int pos); - -/** Sets the path at pos 0 */ -void set_compound_ent_value(ir_entity *ent, ir_node *val, ir_entity *member, int pos); - /** Sets the new style initializers of an entity. */ void set_entity_initializer(ir_entity *entity, ir_initializer_t *initializer); @@ -573,34 +506,6 @@ 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); -/** 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); - -/** - * 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); - -/** 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); - /* --- 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 @@ -647,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. @@ -730,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. */ @@ -758,8 +657,6 @@ typedef enum acc_bits { * 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 */ /** @@ -776,11 +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; /** @@ -789,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; @@ -810,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. * @@ -906,26 +794,6 @@ const tp_op *get_tpop_pointer(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. - */ -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) */ @@ -1074,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); @@ -1126,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 */ /* ----------------------------------------------------------------------- */ @@ -1215,32 +1081,6 @@ int tr_vrfy(void); #define TR_VRFY() tr_vrfy() #endif -/** 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 * @@ -1260,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. @@ -1488,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.) */ @@ -2260,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); @@ -2551,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; - */ -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. */ -}; - -/** - * 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 */