X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=include%2Flibfirm%2Ftyperep.h;h=fdc888006521cbe6ea2b1b662ce30b2187c1257f;hb=f7a0dee11313faad6f2ff54edc8eaadabd03e433;hp=930228db5b35be82e9c4662281000453fdede89d;hpb=78c9f9767f18b1b7a1b2a4d3856bafed029e46e5;p=libfirm diff --git a/include/libfirm/typerep.h b/include/libfirm/typerep.h index 930228db5..fdc888006 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. * @@ -143,11 +143,14 @@ typedef enum { 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 + mtp_property_weak = 0x00000040, /**< This method is weak. It is expected that + GCC: __attribute__((weak)). */ + mtp_property_intrinsic = 0x00000080, /**< 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 + mtp_property_runtime = 0x00000100, /**< This method represents a runtime routine. */ + mtp_property_private = 0x00000200, /**< All method invocations are known, the backend is free to optimize the call in any possible way. */ + mtp_property_has_loop = 0x00000400, /**< Set, if this method contains one possible endless loop. */ mtp_property_inherited = (1<<31) /**< Internal. Used only in irg's, means property is inherited from type. */ } mtp_additional_property; @@ -326,11 +329,12 @@ 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. */ @@ -396,22 +400,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,6 +462,55 @@ 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); +/** 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 kind of an initializer */ +ir_initializer_kind_t get_initializer_kind(const ir_initializer_t *initializer); + +/** + * returns the null initializer (there's only one instance of it in a program ) + */ +ir_initializer_t *get_initializer_null(void); + +/** + * creates an initializer containing a reference to a node on the const-code + * irg. + */ +ir_initializer_t *create_initializer_const(ir_node *value); + +/** creates an initializer containing a single tarval value */ +ir_initializer_t *create_initializer_tarval(tarval *tv); + +/** return value contained in a const initializer */ +ir_node *get_initializer_const_value(const ir_initializer_t *initializer); + +/** return value contained in a tarval initializer */ +tarval *get_initializer_tarval_value(const ir_initializer_t *initialzier); + +/** creates a compound initializer which holds @p n_entries entries */ +ir_initializer_t *create_initializer_compound(unsigned n_entries); + +/** returns the number of entries in a compound initializer */ +unsigned get_initializer_compound_n_entries(const ir_initializer_t *initializer); + +/** 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); + +/** 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); + /** Creates a new compound graph path of given length. */ compound_graph_path *new_compound_graph_path(ir_type *tp, int length); @@ -466,10 +523,16 @@ 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); -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); +/** 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. */ @@ -515,6 +578,12 @@ 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); + +/** 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 @@ -531,7 +600,7 @@ void set_array_entity_values(ir_entity *ent, tarval **values, int num_vals); * @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. */ -int get_compound_ent_value_offset_bit_remainder(ir_entity *ent, int pos); +unsigned get_compound_ent_value_offset_bit_remainder(ir_entity *ent, int pos); /** Return the overall offset of value at position pos in bytes. * @@ -541,7 +610,7 @@ int get_compound_ent_value_offset_bit_remainder(ir_entity *ent, int pos); * @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. */ -int get_compound_ent_value_offset_bytes(ir_entity *ent, int pos); +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 @@ -603,10 +672,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); @@ -692,22 +761,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. @@ -1331,32 +1384,18 @@ ir_mode *get_type_mode(const ir_type *tp); */ void set_type_mode(ir_type *tp, ir_mode* m); -/** Returns the size of a type in bytes, returns -1 if the size is NOT - * a byte size, i.e. not dividable by 8. */ -int get_type_size_bytes(const ir_type *tp); - -/** Returns the size of a type in bits. */ -int get_type_size_bits(const ir_type *tp); +/** Returns the size of a type in bytes. */ +unsigned get_type_size_bytes(const ir_type *tp); /** Sets the size of a type in bytes. * * For primitive, enumeration, pointer and method types the size * is always fixed. This call is legal but has no effect. */ -void set_type_size_bytes(ir_type *tp, int size); - -/** Sets the size of a type in bits. - * - * For primitive, enumeration, pointer and method types the size - * is always fixed. This call is legal but has no effect. - */ -void set_type_size_bits(ir_type *tp, int size); +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(). */ -int get_type_alignment_bytes(ir_type *tp); +/** Returns the alignment of a type in bytes. */ +unsigned get_type_alignment_bytes(ir_type *tp); /** Returns the alignment of a type in bits. * @@ -1366,24 +1405,14 @@ int get_type_alignment_bytes(ir_type *tp); * -#.) 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). + * -#.) all other types return 1 here (i.e. aligned at byte). */ -int get_type_alignment_bits(ir_type *tp); - -/** Sets the alignment of a type in bytes. */ -void set_type_alignment_bytes(ir_type *tp, int size); - -/** Sets the alignment of a type in bits. - * - * For method types the alignment is always fixed. - * This call is legal but has no effect. - */ -void set_type_alignment_bits(ir_type *tp, int size); +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 */ @@ -1408,9 +1437,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. @@ -1838,7 +1867,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. -- */ @@ -1934,21 +1973,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 @@ -2375,6 +2415,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. @@ -2399,7 +2446,7 @@ ir_type *get_associated_type(const ir_type *tp); * * @return the entity representing the area */ -ir_entity *frame_alloc_area(ir_type *frame_type, int size, int alignment, int at_start); +ir_entity *frame_alloc_area(ir_type *frame_type, int size, unsigned alignment, int at_start); /*-----------------------------------------------------------------*/ /** Debug aides **/ @@ -2532,7 +2579,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 *