X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Ftype.h;h=49f200e93b79f092841a0ede635eccb81937d4bd;hb=98ca7e71bc79bb2a3b2ccb039df78000fc48e70a;hp=4e2c9c00a318b2192cec344b05f9ecbfb7511a98;hpb=69c97994131c7e579ba3223610fc5d86b394c0f0;p=libfirm diff --git a/ir/tr/type.h b/ir/tr/type.h index 4e2c9c00a..49f200e93 100644 --- a/ir/tr/type.h +++ b/ir/tr/type.h @@ -1,5 +1,4 @@ /** - * * @file type.h * * Project: libFIRM
@@ -44,7 +43,6 @@ # include "irmode.h" # include "dbginfo.h" - /* to resolve recursion between entity.h and type.h */ #ifndef _ENTITY_TYPEDEF_ #define _ENTITY_TYPEDEF_ @@ -56,6 +54,8 @@ typedef struct entity entity; typedef struct ir_node ir_node; #endif +# include "tr_inheritance.h" + /** * An abstract data type to represent types. * @@ -148,6 +148,73 @@ ident* get_type_ident(const type *tp); void set_type_ident(type *tp, ident* id); const char* get_type_name(const type *tp); +/** This enumeration flags the visibility of entities and types. + * + * This is necessary for partial compilation. + * We rely on the ordering of the flags. + */ +typedef enum { + visibility_local, /**< The entity is only visible locally. This is the default for + entities. + The type is only visible locally. All instances are allocated + locally, and no pointer to entities of this type are passed + out of this compilation unit. */ + visibility_external_visible, /**< The entity is visible to other external program parts, but + it is defined here. It may not be optimized away. The entity must + be static_allocated. + For types: entities of this type can be accessed externally. No + instances of this type are allocated externally. */ + visibility_external_allocated /**< The entity is defined and allocated externally. This compilation + must not allocate memory for this entity. The entity must + be static_allocated. This can also be an external defined + method. + For types: entities of this type are allocated and accessed from + external code. Default for types. */ +} visibility; + +/** The visibility of a type. + * + * The visibility of a type indicates, whether entities of this type + * are accessed or allocated in external code. + * + * An entity of a type is allocated in external code, if the external + * code declares a variable of this type, or dynamically allocates + * an entity of this type. If the external code declares a (compound) + * type, that contains entities of this type, the visibility also + * must be external_allocated. + * + * The visibility must be higher than that of all entities, if the + * type is a compound. Here it is questionable, what happens with + * static entities. If these are accessed external by direct reference, + * (a static call to a method, that is also in the dispatch table) + * it should not affect the visibility of the type. + * + * + * @@@ Do we need a visibility for types? + * I change the layout of types radically when doing type splitting. + * I need to know, which fields of classes are accessed in the RTS, + * e.g., [_length. I may not move [_length to the split part. + * The layout though, is a property of the type. + * + * One could also think of changing the mode of a type ... + * + * But, we could also output macros to access the fields, e.g., + * ACCESS_[_length (X) X->length // conventional + * ACCESS_[_length (X) X->_split_ref->length // with type splitting + * + * For now I implement this function, that returns the visibility + * based on the visibility of the entities of a compound ... + * + * This function returns visibility_external_visible if one or more + * entities of a compound type have visibility_external_visible. + * Entities of types are never visibility_external_allocated (right?). + * Else returns visibility_local. + */ +visibility get_type_visibility (const type *tp); +void set_type_visibility (type *tp, visibility v); + + + /** The state of the type layout. */ typedef enum { layout_undefined, /**< The layout of this type is not defined. @@ -162,6 +229,9 @@ typedef enum { types. */ } type_state; +/** Returns a human readable string for the enum entry. */ +const char *get_type_state_name(type_state s); + /** Returns the type layout state of a type. */ type_state get_type_state(const type *tp); @@ -185,7 +255,7 @@ ir_mode* get_type_mode(const type *tp); void set_type_mode(type *tp, ir_mode* m); /** Returns the size of a type in bytes, returns -1 if the size is NOT - * a byte size, ie not dividable by 8. */ + * a byte size, i.e. not dividable by 8. */ int get_type_size_bytes(const type *tp); /** Returns the size of a type in bits. */ @@ -205,17 +275,21 @@ void set_type_size_bytes(type *tp, int size); */ void set_type_size_bits(type *tp, int size); -/** Returns the alignment of a type in bytes, returns -1 if the alignment is NOT - * a byte size, ie not dividable by 8. Calls get_type_alignment_bits(). */ +/** 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(). */ int get_type_alignment_bytes(type *tp); -/** Returns the alignment of a type in bits. If the alignment of a type is - * not set, it is calculated here according to the following rules: - * 1.) if a type has a mode, the alignment is the mode size. - * 2.) compound types have the alignment of it's biggest member. - * 3.) array types have the alignment of its element type. - * 4.) method types return 0 here. - * 5.) all other types return 8 here (i.e. aligned at byte). +/** Returns the alignment of a type in bits. + * + * If the alignment of a type is + * not set, it is calculated here according to the following rules: + * -#.) if a type has a mode, the alignment is the mode size. + * -#.) compound types have the alignment of there biggest member. + * -#.) array types have the alignment of there element type. + * -#.) method types return 0 here. + * -#.) all other types return 8 here (i.e. aligned at byte). */ int get_type_alignment_bits(type *tp); @@ -236,7 +310,9 @@ void mark_type_visited(type *tp); /* @@@ name clash!! int type_visited(const type *tp); */ int type_not_visited(const type *tp); +/** Returns the associated link field of a type. */ void* get_type_link(const type *tp); +/** Sets the associated link field of a type. */ void set_type_link(type *tp, void *l); /** @@ -278,7 +354,7 @@ int is_type (const void *thing); * - 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 + * - 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, @@ -297,7 +373,7 @@ int is_type (const void *thing); * - 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 + * This is to avoid endless recursions; with pointer types cyclic * type graphs are possible.) */ int equal_type(type *tpy1, type *typ2); @@ -347,7 +423,7 @@ int smaller_type (type *st, type *lt); * Further a class can inherit from and bequest to other classes. * @@@ value class??? * The following attributes are private to this type kind: - * - member: All entities belonging to this class. This are methode entities + * - member: All entities belonging to this class. This are method entities * which have type_method or fields that can have any of the * following type kinds: type_class, type_struct, type_union, * type_array, type_enumeration, type_pointer, type_primitive. @@ -391,28 +467,31 @@ entity *get_class_member (const type *clss, int pos); int get_class_member_index(type *clss, entity *mem); /** Finds the member with name 'name'. If several members with the same - name returns one of them. Returns NULL if no member found. */ + * name returns one of them. Returns NULL if no member found. */ entity *get_class_member_by_name(type *clss, ident *name); /** Overwrites the member at position pos, 0 <= pos < n_member with - the passed entity. */ + * the passed entity. */ void set_class_member (type *clss, entity *member, int pos); /** Replaces complete member list in class type by the list passed. - Copies the list passed. This function is necessary to reduce the number of members. - members is an array of entities, num the size of this array. Sets all - owners of the members passed to clss. */ + * + * Copies the list passed. This function is necessary to reduce the number of members. + * 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 removes it. - Shrinks the member list, so iterate from the end!!! - Does not deallocate the entity. */ + * + * Shrinks the member list, so iterate from the end!!! + * Does not deallocate the entity. */ void remove_class_member(type *clss, entity *member); /** Adds subtype as subtype to clss. - Checks whether clss is a supertype of subtype. If not - adds also clss as supertype to subtype. */ + * + * Checks whether clss is a supertype of subtype. If not + * adds also clss as supertype to subtype. */ void add_class_subtype (type *clss, type *subtype); /** Returns the number of subtypes */ @@ -421,37 +500,64 @@ int get_class_n_subtypes (const type *clss); /** Gets the subtype at position pos, 0 <= pos < n_subtype. */ type *get_class_subtype (type *clss, int pos); +/** Returns the index to access subclass as subtype of class. + * + * If subclass is no direct subtype of class returns -1. + */ +int get_class_subtype_index(type *clss, const type *subclass); + /** Sets the subtype at position pos, 0 <= pos < n_subtype. - Does not set the corresponding supertype relation for subtype: this might - be a different position! */ + * + * 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 removes it */ void remove_class_subtype(type *clss, 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) +#define get_class_derived_type_index(clss, drvtype) get_class_subtype_index(clss, drvtype) +#define set_class_derived_type(clss, drvtype, pos) set_class_subtype(clss, drvtype, pos) +#define remove_class_derived_type(clss, drvtype) remove_class_subtype(clss, drvtype) /** Adds supertype as supertype to class. - Checks whether clss is a subtype of supertype. If not - adds also clss as subtype to supertype. */ + * + * Checks whether clss is a subtype of supertype. If not + * adds also clss as subtype to supertype. */ void add_class_supertype (type *clss, type *supertype); /** Returns the number of supertypes */ int get_class_n_supertypes (const type *clss); -/** Returns the index of an supertype in a type. */ +/** Returns the index to access superclass as supertype of class. + * + * If superclass is no direct supertype of class returns -1. + */ int get_class_supertype_index(type *clss, type *super_clss); /** Gets the supertype at position pos, 0 <= pos < n_supertype. */ type *get_class_supertype (type *clss, int pos); -/** Sets the supertype at position pos, 0 <= pos < n_subtype. - Does not set the corresponding subtype relation for supertype: this might - be a different position! */ +/** Sets the supertype at position pos, 0 <= pos < n_supertype. + * + * Does not set the corresponding subtype relation for supertype: this might + * be at a different position! */ void set_class_supertype (type *clss, type *supertype, int pos); /** Finds supertype in the list of supertypes and removes it */ void remove_class_supertype(type *clss, 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) + /** This enumeration flags the peculiarity of entities and types. */ typedef enum peculiarity { peculiarity_description, /**< Represents only a description. The entity/type is never @@ -470,9 +576,9 @@ typedef enum peculiarity { } peculiarity; const char *get_peculiarity_string(peculiarity p); -/* The peculiarity of the class. The enumeration peculiarity is defined - in entity.h */ +/** Returns the peculiarity of the class. */ peculiarity get_class_peculiarity (const type *clss); +/** Sets the peculiarity of the class. */ void set_class_peculiarity (type *clss, peculiarity pec); /* Set and get a class' dfn -- @@ -483,9 +589,6 @@ int get_class_dfn (const type *clss); /** Returns true if a type is a class type. */ int is_Class_type(const type *clss); -/** Returns true if low is subclass of high. */ -int is_subclass_of(type *low, type *high); - /** * @page struct_type Representation of a struct type * @@ -611,7 +714,9 @@ entity *get_method_value_param_ent(type *method, int pos); */ type *get_method_value_param_type(const type *method); +/** Returns the number of results of a method type. */ int get_method_n_ress (const type *method); +/** Returns the return type of a method type at position pos. */ type *get_method_res_type(type *method, int 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 @@ -627,7 +732,7 @@ entity *get_method_value_res_ent(type *method, int pos); type *get_method_value_res_type(const type *method); /** - * this enum flags the variadicity of methods (methods with a + * This enum flags the variadicity of methods (methods with a * variable amount of arguments (e.g. C's printf). Default is * non_variadic. */ @@ -746,48 +851,62 @@ int get_array_n_dimensions (const type *array); /** * Allocates Const nodes of mode_I for one array dimension. - * Upper bound in Firm is the element next to the last, ie [lower,upper[ + * Upper bound in Firm is the element next to the last, i.e. [lower,upper[ */ void set_array_bounds_int (type *array, int dimension, int lower_bound, int upper_bound); /** * Sets the bounds for one array dimension. - * Upper bound in Firm is the element next to the last, ie [lower,upper[ + * Upper bound in Firm is the element next to the last, i.e. [lower,upper[ */ void set_array_bounds (type *array, int dimension, ir_node *lower_bound, ir_node *upper_bound); -/** Sets the lower bound for one array dimension, ie [lower,upper[ */ +/** Sets the lower bound for one array dimension, i.e. [lower,upper[ */ void set_array_lower_bound (type *array, int dimension, ir_node *lower_bound); /** Allocates Const nodes of mode_I for the lower bound of an array - dimension, ie [lower,upper[ */ + dimension, i.e. [lower,upper[ */ void set_array_lower_bound_int (type *array, int dimension, int lower_bound); -/** Sets the upper bound for one array dimension, ie [lower,upper[ */ +/** Sets the upper bound for one array dimension, i.e. [lower,upper[ */ void set_array_upper_bound (type *array, int dimension, ir_node *upper_bound); /** Allocates Const nodes of mode_I for the upper bound of an array - dimension, ie [lower,upper[ */ + dimension, i.e. [lower,upper[. */ void set_array_upper_bound_int (type *array, int dimension, int upper_bound); -/** returns true if lower bound != Unknown */ +/** Returns true if lower bound != Unknown. */ int has_array_lower_bound (const type *array, int dimension); +/** Returns the lower bound of an array. */ ir_node * get_array_lower_bound (const type *array, int dimension); /** Works only if bound is Const node with tarval that can be converted to long. */ long get_array_lower_bound_int (const type *array, int dimension); /** returns true if lower bound != Unknown */ int has_array_upper_bound (const type *array, int dimension); +/** Returns the upper bound of an array. */ ir_node * get_array_upper_bound (const type *array, int dimension); /** Works only if bound is Const node with tarval that can be converted to long. */ long get_array_upper_bound_int (const type *array, int dimension); +/** Sets an array dimension to a specific order. */ void set_array_order (type *array, int dimension, int order); + +/** Returns the order of an array dimension. */ int get_array_order (const type *array, int dimension); +/** Find the array dimension that is placed at order ord. */ +int find_array_dimension(const type *array, int order); + +/** Sets the array element type. */ void set_array_element_type (type *array, type *tp); + +/** Gets the array element type. */ type *get_array_element_type (type *array); +/** Sets the array element entity. */ void set_array_element_entity (type *array, entity *ent); + +/** Get the array element entity. */ entity *get_array_element_entity (const type *array); /** Returns true if a type is an array type. */ @@ -897,14 +1016,14 @@ int is_Primitive_type (const type *primitive); * allocated when initializing the type module. * * The following values are set: - * mode: mode_BAD - * name: "type_none" - * state: layout_fixed - * size: 0 + * - mode: mode_BAD + * - name: "type_none" + * - state: layout_fixed + * - size: 0 */ -/* A variable that contains the only none type. */ +/** A variable that contains the only none type. */ extern type *firm_none_type; -/* Returns the none type */ +/** Returns the none type */ type *get_none_type(void); /** @@ -919,20 +1038,20 @@ type *get_none_type(void); * allocated when initializing the type module. * * The following values are set: - * mode: mode_ANY - * name: "type_unknown" - * state: layout_fixed - * size: 0 + * - mode: mode_ANY + * - name: "type_unknown" + * - state: layout_fixed + * - size: 0 */ -/* A variable that contains the only unknown type. */ +/** A variable that contains the only unknown type. */ extern type *firm_unknown_type; -/* Returns the unknown type */ +/** Returns the unknown type */ type *get_unknown_type(void); /** * Checks whether a type is atomic. - * @param tp - any type + * @param tp any type * @return true if type is primitive, pointer or enumeration */ int is_atomic_type(const type *tp); @@ -960,7 +1079,7 @@ int get_compound_n_members(const type *tp); * * @return The member entity at position pos. * - * @see get_compound_n_members() for justifaction of existence. + * @see get_compound_n_members() for justification of existence. */ entity *get_compound_member(const type *tp, int pos); @@ -973,6 +1092,9 @@ entity *get_compound_member(const type *tp, int pos); */ int is_compound_type(const type *tp); +/*-----------------------------------------------------------------*/ +/** Debug aides **/ +/*-----------------------------------------------------------------*/ /** * Outputs a unique number for this type if libfirm is compiled for @@ -981,11 +1103,5 @@ int is_compound_type(const type *tp); */ long get_type_nr(const type *tp); -/*******************************************************************/ -/** Debug aides **/ -/*******************************************************************/ - - - # endif /* _TYPE_H_ */