X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Ftype.h;h=e3360fea55ba58537ad72e7c60827cd334d0d724;hb=15714f5466df151f1e7552789c328f7e7beff04b;hp=49f200e93b79f092841a0ede635eccb81937d4bd;hpb=f915a8dfdc03533a92d8ab75cfb39b84c846f2c5;p=libfirm diff --git a/ir/tr/type.h b/ir/tr/type.h index 49f200e93..e3360fea5 100644 --- a/ir/tr/type.h +++ b/ir/tr/type.h @@ -35,25 +35,12 @@ # ifndef _TYPE_H_ # define _TYPE_H_ -#include - +# include "firm_types.h" # include "tpop.h" # include "firm_common.h" # include "ident.h" # include "irmode.h" # include "dbginfo.h" - -/* to resolve recursion between entity.h and type.h */ -#ifndef _ENTITY_TYPEDEF_ -#define _ENTITY_TYPEDEF_ -typedef struct entity entity; -#endif - -#ifndef _IR_NODE_TYPEDEF_ -#define _IR_NODE_TYPEDEF_ -typedef struct ir_node ir_node; -#endif - # include "tr_inheritance.h" /** @@ -307,7 +294,7 @@ unsigned long get_type_visited(const 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); -/* @@@ name clash!! int type_visited(const type *tp); */ +int type_visited(const type *tp); int type_not_visited(const type *tp); /** Returns the associated link field of a type. */ @@ -318,15 +305,15 @@ void set_type_link(type *tp, void *l); /** * Visited flag to traverse the type information. * - * Increase this flag by one before traversing the type information. - * Mark type nodes as visited by set_type_visited(type, type_visited). - * Check whether node was already visited by comparing get_type_visited(type) - * and type_visited. + * Increase this flag by one before traversing the type information + * using inc_master_type_visited(). + * Mark type nodes as visited by mark_type_visited(type). + * Check whether node was already visited by type_visited(type) + * and type_not_visited(type). * Or use the function to walk all types. * * @see typewalk */ -extern unsigned long type_visited; void set_master_type_visited(unsigned long val); unsigned long get_master_type_visited(void); void inc_master_type_visited(void); @@ -344,12 +331,13 @@ int is_type (const void *thing); /** * Checks whether two types are structurally equal. * - * @param st pointer type - * @param lt pointer type + * @param typ1 the first type + * @param typ2 the second type * * @return * true if the types are equal, else false. - * Types are equal if : + * + * Types are equal if : * - they are the same type kind * - they have the same name * - they have the same mode (if applicable) @@ -376,7 +364,7 @@ int is_type (const void *thing); * This is to avoid endless recursions; with pointer types cyclic * type graphs are possible.) */ -int equal_type(type *tpy1, type *typ2); +int equal_type(type *typ1, type *typ2); /** * Checks whether two types are structural comparable. @@ -550,6 +538,14 @@ 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) + /** 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) @@ -766,11 +762,89 @@ int get_method_first_variadic_param_index(const type *method); */ void set_method_first_variadic_param_index(type *method, int index); +/** + * 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 form 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_inherited = 0x40000000 /**< used only in irg's, means property is inherited + from type. */ +} mtp_additional_property; + +/** Returns the mask of the additional graph properties. */ +unsigned get_method_additional_properties(const type *method); + +/** Sets the mask of the additional graph properties. */ +void set_method_additional_properties(type *method, unsigned property_mask); + +/** Sets one additional graph property. */ +void set_method_additional_property(type *method, mtp_additional_property flag); + +/** + * calling conventions + */ +typedef enum { + cc_reg_param = 0x00000001, /**< Transmit parameters in registers, else the stack is used. + This flag may be set as default on some architectures. */ + cc_last_on_top = 0x00000002, /**< The last non-register parameter is transmitted on top of + the stack. This is equivalent to the stdcall or pascal + calling convention. If this flag is not set, the first + non-register parameter is used (cdecl calling convention) */ + cc_callee_clear_stk = 0x00000004, /**< The callee clears the stack. This forbids variadic + function calls (stdcall). */ + cc_this_call = 0x00000008 /**< The first parameter is a this pointer and is transmitted + in a special way. */ +} calling_convention; + +/** + * check for the CDECL calling convention + */ +#define IS_CDECL(cc_mask) (((cc_mask) & (cc_callee_clear_stk|cc_last_on_top)) == 0) + +/** + * check for the STDCALL calling convention + */ +#define IS_STDCALL(cc_mask) (((cc_mask) & (cc_callee_clear_stk|cc_last_on_top)) == cc_callee_clear_stk) + +/** + * add the CDECL convention bits + */ +#define SET_CDECL(cc_mask) ((cc_mask) & ~(cc_callee_clear_stk|cc_last_on_top)) + +/** + * add the STDCALL convention bits + */ +#define SET_STDCALL(cc_mask) (((cc_mask) & ~cc_last_on_top) | cc_callee_clear_stk) + +/** Returns the calling convention of an entities graph. */ +unsigned get_method_calling_convention(const type *method); + +/** Sets the calling convention of an entities graph. */ +void set_method_calling_convention(type *method, unsigned cc_mask); + /** Returns true if a type is a method type. */ int is_Method_type (const type *method); /** - * @page union_type Representation of a union type. + * @page union_type Representation of a union (variant) type. * * The union type represents union types. * - n_types: Number of unioned types. @@ -956,19 +1030,16 @@ int is_Enumeration_type (const type *enumeration); /** * @page pointer_type Representation of a pointer type * - * The mode of the pointer type must be a mode_reference. + * The mode of the pointer type must be a reference mode. * * Pointer types: * - points_to: The type of the entity this pointer points to. */ -/** Creates a new type pointer with mode mode_p. */ -#define new_type_pointer(N, P) new_type_pointer_mode(N, P, mode_P_mach) +/** Creates a new type pointer. */ +type *new_type_pointer (ident *name, type *points_to, ir_mode *ptr_mode); -/** Creates a new type pointer with given pointer mode. */ -type *new_type_pointer_mode (ident *name, type *points_to, ir_mode *ptr_mode); - -/** Creates a new type pointer given pointer mode and with debug information. */ +/** Creates a new type pointer with debug information. */ type *new_d_type_pointer (ident *name, type *points_to, ir_mode *ptr_mode, dbg_info* db); /* --- manipulate fields of type_pointer --- */ @@ -1084,14 +1155,26 @@ int get_compound_n_members(const type *tp); entity *get_compound_member(const type *tp, int pos); /** - * Checks whether a type is compound. + * Checks whether a type is compound. * - * @param tp - any type + * @param tp - any type * - * @return true if the type is class, structure, union or array type. + * @return true if the type is class, structure, union or array type. */ int is_compound_type(const type *tp); +/** + * Checks, whether a type is a frame type + */ +int is_frame_type(const type *tp); + +/** + * Makes a new frame type. Frame types are class types, + * so all class access functions work. + * Frame types are not in the global list of types. + */ +type *new_type_frame(ident *name); + /*-----------------------------------------------------------------*/ /** Debug aides **/ /*-----------------------------------------------------------------*/