X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Ftype.h;h=8d4f8f7c9e3205d7440656cba4d48621ed4b0c5b;hb=677f67f9b487e35b983148f48b933d54ee383db6;hp=98517c88cca6ea20c75a50c8cb4a01affb79a45f;hpb=b02303ed63a65997615318ee62f490b384421691;p=libfirm diff --git a/ir/tr/type.h b/ir/tr/type.h index 98517c88c..8d4f8f7c9 100644 --- a/ir/tr/type.h +++ b/ir/tr/type.h @@ -1,4 +1,4 @@ -/****h* libfirm/type +/****h* libfirm/type6 2002/03/19 13:08:33 * * NAME * file type.h - datastructure to hold type information. @@ -34,15 +34,16 @@ # define _TYPE_H_ # include "tpop.h" -# include "common.h" +# include "firm_common.h" # include "ident.h" # include "irmode.h" # include "bool.h" +# include "dbginfo.h" +/* to resolve recursion between entity.h and type.h */ #ifndef _ENTITY_TYPEDEF_ #define _ENTITY_TYPEDEF_ -/* to resolve recursion between entity.h and type.h */ typedef struct entity entity; #endif @@ -94,7 +95,7 @@ typedef struct ir_node ir_node; * A fixed layout for enumeration types means that each enumeration * is associated with an implementation value. * visit A counter for walks of the type information. - * link A void* to associate some additional inforamtion with the type. + * link A void* to associate some additional information with the type. * * These fields can only be accessed via access functions. * @@ -104,53 +105,61 @@ typedef struct ir_node ir_node; * class, struct, method, union, array, enumeration, pointer, primitive * SOURCE */ +#ifndef _TYPE_TYPEDEF_ +#define _TYPE_TYPEDEF_ typedef struct type type; +#endif # include "type_or_entity.h" -void* get_type_link(type *tp); -void set_type_link(type *tp, void *l); +/* Frees the memory used by the type. Does not free the entities + belonging to the type, except for the array element entity. */ +void free_type(type *tp); + tp_op* get_type_tpop(type *tp); ident* get_type_tpop_nameid(type *tp); const char* get_type_tpop_name(type *tp); tp_opcode get_type_tpop_code(type *tp); -/* Returns NULL for all non atomic types. */ -ir_mode* get_type_mode(type *tp); -/* Only has an effect on primitive and enumeration types */ -void set_type_mode(type *tp, ir_mode* m); - ident* get_type_ident(type *tp); void set_type_ident(type *tp, ident* id); const char* get_type_name(type *tp); -int get_type_size(type *tp); -/* For primitives, enumerationsm, pointer and method types the size - is always fixed. This call is legal but has no effect. */ -void set_type_size(type *tp, int size); - typedef enum { layout_undefined, /* The layout of this type is not defined. Address computation to access fields is not - possible, fields must be accessed by Sel nodes. - This is the default value except for pointer and - primitive types. */ + possible, fields must be accessed by Sel + nodes. This is the default value except for + pointer, primitive and method types. */ layout_fixed /* The layout is fixed, all component/member entities have an offset assigned. Size of the type is known. Arrays can be accessed by explicit address - computation. Default for pointer and primitive types. - */ + computation. Default for pointer, primitive ane method + types. */ } type_state; - type_state get_type_state(type *tp); /* For primitives, pointer and method types the layout is always fixed. This call is legal but has no effect. */ void set_type_state(type *tp, type_state state); +/* Returns NULL for all non atomic types. */ +ir_mode* get_type_mode(type *tp); +/* Only has an effect on primitive and enumeration types */ +void set_type_mode(type *tp, ir_mode* m); + +int get_type_size(type *tp); +/* For primitive, enumeration, pointer and method types the size + is always fixed. This call is legal but has no effect. */ +void set_type_size(type *tp, int size); + + unsigned long get_type_visited(type *tp); void set_type_visited(type *tp, unsigned long num); /* Sets visited field in type to type_visited. */ void mark_type_visited(type *tp); + +void* get_type_link(type *tp); +void set_type_link(type *tp, void *l); /*****/ /****v* type/visited @@ -168,6 +177,9 @@ void mark_type_visited(type *tp); * SOURCE */ extern unsigned long type_visited; +void set_master_type_visited(unsigned long val); +unsigned long get_master_type_visited(); +void inc_master_type_visited(); /*****/ /****f* type/is_type @@ -184,6 +196,86 @@ extern unsigned long type_visited; */ int is_type (void *thing); +/****f* type/equal_types + * + * NAME + * equal_type - Checks whether two types are structural equal. + * SYNOPSIS + * bool equal_types (type *typ1, type *typ2); + * INPUTS + * two pointer types + * RESULT + * true if the types are equal, else false. + * Types are equal if + * - they are the same type kind + * - they have the same name + * - they have the same mode (if applicable) + * - they have the same type_state and, ev., the same size + * - they are class types and have + * - the same members (see same_entity in entity.h) + * - the same supertypes -- the C-pointers are compared --> no recursive call. + * - the same number of subtypes. Subtypes are not compared, + * as this could cause a cyclic test. + * - the same peculiarity + * - they are structure types and have the same members + * - they are method types and have + * - the same parameter types + * - the same result types + * - they are union types and have the same members + * - they are array types and have + * - the same number of dimensions + * - the same dimension bounds + * - the same dimension order + * - 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. + * This is to avoid endless recursions; with pointer types circlic + * type graphs are possible.) + * + *** + */ +bool equal_type(type *tpy1, type *typ2); + +/****f* type/smaller_type + * + * NAME + * smaller_type - Checks whether two types are structural comparable. + * SYNOPSIS + * bool smaller_type (type *st, type *lt); + * INPUTS + * two pointer type + * RESULT + * true if type st is smaller than type lt, i.e. whenever + * lt is expected a st can be used. + * This is true if + * - they are the same type kind + * - mode(st) < mode (lt) (if applicable) + * - they are class types and st is (transitive) subtype of lt, + * - they are structure types and + * - the members of st have exactly one counterpart in lt with the same name, + * - the counterpart has a bigger type. + * - they are method types and have + * - the same number of parameter and result types, + * - the parameter types of st are smaller than those of lt, + * - the result types of st are smaller than those of lt + * - they are union types and have the members of st have exactly one + * counterpart in lt and the type is smaller + * - they are array types and have + * - the same number of dimensions + * - all bounds of lt are bound of st + * - the same dimension order + * - the same element type + * or + * - the element type of st is smaller than that of lt + * - the element types have the same size and fixed layout. + * - they are enumeration types and have the same enumerator names + * - they are pointer types and have the points_to type of st is + * smaller than the points_to type of lt. + *** + */ +bool smaller_type (type *st, type *lt); + /****** type/class * NAME * Representation of a class type. @@ -205,16 +297,27 @@ int is_type (void *thing); * * These are dynamic lists that can be grown with an "add_" function, * but not shrinked. + * + * peculiarity The peculiarity of this class. If the class is of peculiarity + * "description" it only is a description of requirememts to a class, + * as, e.g., a Java interface. The class will never be allocated. + * Peculiatity inherited is only possible for entities. An entity + * is of peculiarity inherited if the compiler generated the entity + * to explicitly resolve inheritance. An inherited method entity has + * no value for irg. + * Values: description, existent, inherited. Default: existent. + * * SOURCE */ /* create a new class type */ type *new_type_class (ident *name); +type *new_d_type_class (ident *name, dbg_info *db); /** manipulate private fields of class type **/ /* Adds the entity as member of the class. */ void add_class_member (type *clss, entity *member); /* Returns the number of members of this class. */ -int get_class_n_member (type *clss); +int get_class_n_members (type *clss); /* Returns the member at position pos, 0 <= pos < n_member */ entity *get_class_member (type *clss, int pos); /* Overwrites the member at position pos, 0 <= pos < n_member with @@ -225,8 +328,9 @@ void set_class_member (type *clss, entity *member, int pos); members is an array of entities, num the size of this array. Sets all owners of the members passed to clss. */ void set_class_members (type *clss, entity **members, int arity); -/* Finds member in the list of members and overwrites it with NULL - @@@ Doesn't work properly. */ +/* Finds member in the list of members and removes it. + Shrinks the member list, so iterate from the end!!! + Does not deallocate the entity. */ void remove_class_member(type *clss, entity *member); @@ -235,15 +339,14 @@ void remove_class_member(type *clss, entity *member); adds also clss as supertype to subtype. */ void add_class_subtype (type *clss, type *subtype); /* Returns the number of subtypes */ -int get_class_n_subtype (type *clss); +int get_class_n_subtypes (type *clss); /* Gets the subtype at position pos, 0 <= pos < n_subtype. */ type *get_class_subtype (type *clss, int pos); /* Sets the subtype at positioin pos, 0 <= pos < n_subtype. Does not set the corresponding supertype relation for subtype: this might be a different position! */ void set_class_subtype (type *clss, type *subtype, int pos); -/* Finds subtype in the list of subtypes and overwrites it with NULL - @@@ Doesn't work properly. */ +/* Finds subtype in the list of subtypes and removes it */ void remove_class_subtype(type *clss, type *subtype); @@ -252,19 +355,43 @@ void remove_class_subtype(type *clss, type *subtype); adds also clss as subtype to supertype. */ void add_class_supertype (type *clss, type *supertype); /* Returns the number of supertypes */ -int get_class_n_supertype (type *clss); +int get_class_n_supertypes (type *clss); /* Gets the supertype at position pos, 0 <= pos < n_supertype. */ type *get_class_supertype (type *clss, int pos); /* Sets the supertype at postition pos, 0 <= pos < n_subtype. Does not set the corresponding subtype relation for supertype: this might be a different position! */ void set_class_supertype (type *clss, type *supertype, int pos); -/* Finds supertype in the list of supertypes and overwrites it with NULL - @@@ Doesn't work properly. */ +/* Finds supertype in the list of supertypes and removes it */ void remove_class_supertype(type *clss, type *supertype); +/* This enumeration flags the peculiarity of entities and types. */ +typedef enum peculiarity { + description, /* Represents only a description. The entity/type is never + allocated, no code/data exists for this entity/type. */ + inherited, /* Describes explicitly that other entities are + inherited to the owner of this entity. + Overwrites must refer to at least one other + entity. If this is a method entity there exists + no irg for this entity, only for one of the + overwritten ones. */ + existent /* The entity/type (can) exist. */ +} peculiarity; + +/* The peculiarity of the class. The enumeration peculiarity is defined + in entity.h */ +INLINE peculiarity get_class_peculiarity (type *clss); +INLINE void set_class_peculiarity (type *clss, peculiarity pec); + +/* Set and get a class' dfn -- + @@@ This is an undocumented field, subject to change! */ +void set_class_dfn (type *clss, int dfn); +int get_class_dfn (type *clss); + /* typecheck */ -bool is_class_type(type *clss); +bool is_class_type(type *clss); +/* Returns true if low is subclass of high. */ +bool is_subclass_of(type *low, type *high); /*****/ /****** type/struct @@ -286,14 +413,14 @@ bool is_class_type(type *clss); */ /* create a new type struct */ type *new_type_struct (ident *name); +type *new_d_type_struct (ident *name, dbg_info* db); /* manipulate private fields of struct */ void add_struct_member (type *strct, entity *member); -int get_struct_n_member (type *strct); +int get_struct_n_members (type *strct); entity *get_struct_member (type *strct, int pos); void set_struct_member (type *strct, int pos, entity *member); -/* Finds member in the list of memberss and overwrites it with NULL - @@@ Doesn't work properly. */ +/* Finds member in the list of memberss and removees it */ void remove_struct_member (type *strct, entity *member); /* typecheck */ @@ -333,15 +460,16 @@ bool is_struct_type(type *strct); The arrays for the parameter and result types are not initialized by the constructor. */ type *new_type_method (ident *name, int n_param, int n_res); +type *new_d_type_method (ident *name, int n_param, int n_res, dbg_info* db); /* manipulate private fields of method. */ int get_method_n_params (type *method); type *get_method_param_type(type *method, int pos); -void set_method_param_type(type *method, int pos, type* type); +void set_method_param_type(type *method, int pos, type* tp); -int get_method_n_res (type *method); +int get_method_n_ress (type *method); type *get_method_res_type(type *method, int pos); -void set_method_res_type(type *method, int pos, type* type); +void set_method_res_type(type *method, int pos, type* tp); /* typecheck */ bool is_method_type (type *method); @@ -361,31 +489,20 @@ bool is_method_type (type *method); */ /* create a new type union */ type *new_type_union (ident *name); +type *new_d_type_union (ident *name, dbg_info* db); /* manipulate private fields of struct */ int get_union_n_members (type *uni); void add_union_member (type *uni, entity *member); entity *get_union_member (type *uni, int pos); void set_union_member (type *uni, int pos, entity *member); -/* Finds member in the list of members and overwrites it with NULL - @@@ Doesn't work properly. */ +/* Finds member in the list of members and removes it. */ void remove_union_member (type *uni, entity *member); /* typecheck */ bool is_union_type (type *uni); /*****/ -#if 0 -/* We don't need these if the union has entities, which it now - does. The entities are necessary for the analysis algorithms. */ -type *get_union_unioned_type (type *uni, int pos); -void set_union_unioned_type (type *uni, int pos, type *type); - -ident *get_union_delim_nameid (type *uni, int pos); -const char *get_union_delim_name (type *uni, int pos); -void set_union_delim_nameid (type *uni, int pos, ident *id); -#endif - /****** type/array * NAME * Representation of an array type. @@ -408,10 +525,12 @@ void set_union_delim_nameid (type *uni, int pos, ident *id); /* create a new type array -- Sets n_dimension to dimension and all dimension entries to NULL. Initializes order to the order of the dimensions. - Entity for array elements is built automatically. + The entity for array elements is built automatically. Set dimension sizes after call to constructor with set_* routines. */ type *new_type_array (ident *name, int n_dimensions, type *element_type); +type *new_d_type_array (ident *name, int n_dimensions, + type *element_type, dbg_info* db); /* manipulate private fields of array type */ int get_array_n_dimensions (type *array); @@ -423,13 +542,14 @@ void set_array_bounds (type *array, int dimension, ir_node *lower_bound, void set_array_lower_bound (type *array, int dimension, ir_node *lower_bound); void set_array_lower_bound_int (type *array, int dimension, int lower_bound); void set_array_upper_bound (type *array, int dimension, ir_node *upper_bound); +void set_array_upper_bound_int (type *array, int dimension, int lower_bound); ir_node * get_array_lower_bound (type *array, int dimension); ir_node * get_array_upper_bound (type *array, int dimension); void set_array_order (type *array, int dimension, int order); int get_array_order (type *array, int dimension); -void set_array_element_type (type *array, type *type); +void set_array_element_type (type *array, type *tp); type *get_array_element_type (type *array); void set_array_element_entity (type *array, entity *ent); @@ -456,6 +576,7 @@ bool is_array_type (type *array); */ /* create a new type enumeration -- set the enumerators independently */ type *new_type_enumeration (ident *name, int n_enums); +type *new_d_type_enumeration (ident *name, int n_enums, dbg_info* db); /* manipulate fields of enumeration type. */ int get_enumeration_n_enums (type *enumeration); @@ -482,9 +603,10 @@ bool is_enumeration_type (type *enumeration); */ /* Create a new type pointer */ type *new_type_pointer (ident *name, type *points_to); +type *new_d_type_pointer (ident *name, type *points_to, dbg_info* db); /* manipulate fields of type_pointer */ -void set_pointer_points_to_type (type *pointer, type *type); +void set_pointer_points_to_type (type *pointer, type *tp); type *get_pointer_points_to_type (type *pointer); /* typecheck */ @@ -502,6 +624,7 @@ bool is_pointer_type (type *pointer); */ /* create a new type primitive */ type *new_type_primitive (ident *name, ir_mode *mode); +type *new_d_type_primitive (ident *name, ir_mode *mode, dbg_info* db); /* typecheck */ bool is_primitive_type (type *primitive);