X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=include%2Flibfirm%2Ftyperep.h;h=adabf1b30200d559037d2f065abd9edea52568ca;hb=a158f864beaee2de7ba4e0610a3a9960a0be5ed4;hp=e4012f3673b20385c018ef6b6e91f3e1a4e99918;hpb=db30faa048d1f60904d003f7bedf0f3358ff8903;p=libfirm diff --git a/include/libfirm/typerep.h b/include/libfirm/typerep.h index e4012f367..adabf1b30 100644 --- a/include/libfirm/typerep.h +++ b/include/libfirm/typerep.h @@ -1,20 +1,6 @@ /* - * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved. - * * This file is part of libFirm. - * - * This file may be distributed and/or modified under the terms of the - * GNU General Public License version 2 as published by the Free Software - * Foundation and appearing in the file LICENSE.GPL included in the - * packaging of this file. - * - * Licensees holding valid libFirm Professional Edition licenses may use - * this file in accordance with the libFirm Commercial License. - * Agreement provided with the Software. - * - * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE - * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE. + * Copyright (C) 2012 University of Karlsruhe. */ /** @@ -91,10 +77,13 @@ */ typedef enum { /** - * The entity is visible outside the compilation unit, but it is defined - * here. + * The entity is visible across compilation units. It might have an + * initializer/graph. + * Note that entities with visibility_external without initializer are + * assumed to be defined in another compilation unit (not like C variables + * which are considered 'uninitialized' in this case). */ - ir_visibility_default, + ir_visibility_external, /** * The entity is local to the compilation unit. * A local entity is not visible in other compilation units. @@ -103,18 +92,13 @@ typedef enum { */ ir_visibility_local, /** - * The entity is defined outside the compilation unit but potentially used - * here. - */ - ir_visibility_external, - /** - * This has the same semantic as visibility_local. Additionally the symbol is - * completely hidden from the linker (it only appears in the assembly). + * This has the same semantic as visibility_local. Additionally the symbol + * is completely hidden from the linker (it only appears in the assembly). * While visibility_local is probably still visible to debuggers, * visibility_private symbols aren't and probably won't appear in the object * files */ - ir_visibility_private + ir_visibility_private, } ir_visibility; /** @@ -157,22 +141,30 @@ typedef enum ir_linkage { * read/write behaviour to global variables or changing calling conventions * from cdecl to fastcall. */ - IR_LINKAGE_HIDDEN_USER = 1 << 4 + IR_LINKAGE_HIDDEN_USER = 1 << 4, + /** + * Do not generate code even if the entity has a graph attached. The graph + * is only used for inlining. Otherwise the entity is regarded as a + * declaration of an externally defined entity. + * This linkage flag can be used to implement C99 "inline" or GNU89 + * "extern inline". + */ + IR_LINKAGE_NO_CODEGEN = 1 << 5, } ir_linkage; ENUM_BITSET(ir_linkage) /** - * Return the visibility class of an entity + * Returns the visibility class of an entity */ FIRM_API ir_visibility get_entity_visibility(const ir_entity *entity); /** - * Set visibility class of an entity + * Sets visibility class of an entity */ FIRM_API void set_entity_visibility(ir_entity *entity, ir_visibility visibility); /** - * Return 1 if the entity is visible outside the current compilation unit + * Returns 1 if the entity is visible outside the current compilation unit * or to unknown callers (like asm statements). * (The entity might still be accessible indirectly through pointers) * This is a convenience function and does the same as @@ -182,8 +174,9 @@ FIRM_API void set_entity_visibility(ir_entity *entity, ir_visibility visibility) FIRM_API int entity_is_externally_visible(const ir_entity *entity); /** - * Return 1 if the entity has a definition (initializer) in the current - * compilation unit + * Returns 1 if the entity has a definition (initializer) in the current + * compilation unit. Note that this function returns false if + * IR_LINKAGE_NO_CODEGEN is set even if a graph is present. */ FIRM_API int entity_has_definition(const ir_entity *entity); @@ -227,11 +220,9 @@ FIRM_API ir_entity *new_d_parameter_entity(ir_type *owner, size_t pos, * Check an entity. Currently, we check only if initialized constants * are build on the const irg graph. * - * @return - * 0 if no error encountered - * != 0 a trverify_error_codes code + * @return non-zero if no errors were found */ -FIRM_API int check_entity(ir_entity *ent); +FIRM_API int check_entity(const ir_entity *ent); /** * Copies the entity if the new_owner is different from the @@ -306,9 +297,11 @@ FIRM_API void set_entity_type(ir_entity *ent, ir_type *tp); /** Returns the linkage of an entity. */ FIRM_API ir_linkage get_entity_linkage(const ir_entity *entity); -/** Sets the linkage of an entity. */ +/** Sets the linkage flags of entity @p entity to @p linkage. */ FIRM_API void set_entity_linkage(ir_entity *entity, ir_linkage linkage); +/** Adds linkage flags @p linkage to entity @p entity. */ FIRM_API void add_entity_linkage(ir_entity *entity, ir_linkage linkage); +/** Remove linkage flags @p linkage from entity @p entity. */ FIRM_API void remove_entity_linkage(ir_entity *entity, ir_linkage linkage); /** @@ -323,7 +316,7 @@ FIRM_API ir_volatility get_entity_volatility(const ir_entity *ent); */ FIRM_API void set_entity_volatility(ir_entity *ent, ir_volatility vol); -/** Return the name of the volatility. */ +/** Returns the name of the volatility. */ FIRM_API const char *get_volatility_name(ir_volatility var); /** Returns alignment of entity in bytes */ @@ -335,7 +328,6 @@ FIRM_API unsigned get_entity_alignment(const ir_entity *entity); */ FIRM_API void set_entity_alignment(ir_entity *entity, unsigned alignment); - /** * Returns indication whether entity is aligned in memory. * @deprecated @@ -348,16 +340,18 @@ FIRM_API ir_align get_entity_aligned(const ir_entity *ent); */ FIRM_API void set_entity_aligned(ir_entity *ent, ir_align a); -/** Return the name of the alignment. */ +/** Returns the name of the alignment. */ FIRM_API const char *get_align_name(ir_align a); -/** Returns the offset of an entity (in a compound) in bytes. Only set if layout = fixed. */ +/** Returns the offset of an entity (in a compound) in bytes. Only set if + * layout = fixed. */ FIRM_API int get_entity_offset(const ir_entity *ent); /** Sets the offset of an entity (in a compound) in bytes. */ FIRM_API void set_entity_offset(ir_entity *ent, int offset); -/** Returns the offset bit remainder of a bitfield entity (in a compound) in bits. Only set if layout = fixed. */ +/** Returns the offset bit remainder of a bitfield entity (in a compound) in + * bits. Only set if layout = fixed. */ FIRM_API unsigned char get_entity_offset_bits_remainder(const ir_entity *ent); /** Sets the offset bit remainder of a bitfield entity (in a compound) in bits. */ @@ -379,15 +373,15 @@ FIRM_API ir_graph *get_entity_irg(const ir_entity *ent); /** A reserved value for "not yet set". */ #define IR_VTABLE_NUM_NOT_SET ((unsigned)(-1)) -/** Gets the entity vtable number. */ +/** Returns the entity vtable number. */ FIRM_API unsigned get_entity_vtable_number(const ir_entity *ent); /** Sets the entity vtable number. */ FIRM_API void set_entity_vtable_number(ir_entity *ent, unsigned vtable_number); -/** Set label number of an entity with code type */ +/** Sets label number of an entity with code type */ FIRM_API void set_entity_label(ir_entity *ent, ir_label_t label); -/** Return label number of an entity with code type */ +/** Returns label number of an entity with code type */ FIRM_API ir_label_t get_entity_label(const ir_entity *ent); /** Checks if an entity is compiler generated. */ @@ -412,7 +406,7 @@ typedef enum { | ir_usage_reinterpret_cast } ir_entity_usage; -/** Return the entity usage */ +/** Returns the entity usage */ FIRM_API ir_entity_usage get_entity_usage(const ir_entity *ent); /** Sets/resets the state of the address taken flag of an entity. */ @@ -433,6 +427,14 @@ FIRM_API dbg_info *get_entity_dbg_info(const ir_entity *ent); */ FIRM_API void set_entity_dbg_info(ir_entity *ent, dbg_info *db); +/** + * Sepcial parameter number which can be used for parameter entities to + * indicate the first non-declared parameter in a procedure with variable + * arguments. + * We assumes that all additional parameters for variable parameters are on the + * stack. Starting from this address you can walk the stack to find all other + * parameters. + */ #define IR_VA_START_PARAMETER_NUMBER ((size_t)-1) /** @@ -470,7 +472,10 @@ FIRM_API int is_irn_const_expression(ir_node *n); */ FIRM_API ir_node *copy_const_value(dbg_info *dbg, ir_node *n, ir_node *to_block); -FIRM_API ir_node *get_atomic_ent_value(ir_entity *ent); +/** Returns initial value of entity with atomic type @p ent. */ +FIRM_API ir_node *get_atomic_ent_value(const ir_entity *ent); +/** Sets initial value of entity with atomic type @p ent to node @p val. + * @note @p val must be a node in the const_code graph */ FIRM_API void set_atomic_ent_value(ir_entity *ent, ir_node *val); /** @defgroup ir_initializer Entity Initializers @@ -489,44 +494,44 @@ typedef enum ir_initializer_kind_t { IR_INITIALIZER_COMPOUND } ir_initializer_kind_t; -/** returns kind of an initializer */ +/** Returns kind of an initializer */ FIRM_API ir_initializer_kind_t get_initializer_kind(const ir_initializer_t *initializer); -/** Return the name of the initializer kind. */ +/** Returns the name of the initializer kind. */ FIRM_API const char *get_initializer_kind_name(ir_initializer_kind_t ini); /** - * returns the null initializer (there's only one instance of it in a program ) + * Returns the null initializer (there's only one instance of it in a program ) */ FIRM_API ir_initializer_t *get_initializer_null(void); /** - * creates an initializer containing a reference to a node on the const-code + * Creates an initializer containing a reference to a node on the const-code * irg. */ FIRM_API ir_initializer_t *create_initializer_const(ir_node *value); -/** creates an initializer containing a single tarval value */ +/** Creates an initializer containing a single tarval value */ FIRM_API ir_initializer_t *create_initializer_tarval(ir_tarval *tv); -/** return value contained in a const initializer */ +/** Returns value contained in a const initializer */ FIRM_API ir_node *get_initializer_const_value(const ir_initializer_t *initializer); -/** return value contained in a tarval initializer */ +/** Returns value contained in a tarval initializer */ FIRM_API ir_tarval *get_initializer_tarval_value(const ir_initializer_t *initialzier); -/** creates a compound initializer which holds @p n_entries entries */ +/** Creates a compound initializer which holds @p n_entries entries */ FIRM_API ir_initializer_t *create_initializer_compound(size_t n_entries); -/** returns the number of entries in a compound initializer */ +/** Returns the number of entries in a compound initializer */ FIRM_API size_t get_initializer_compound_n_entries(const ir_initializer_t *initializer); -/** sets entry with index @p index to the initializer @p value */ +/** Sets entry with index @p index to the initializer @p value */ FIRM_API void set_initializer_compound_value(ir_initializer_t *initializer, size_t index, ir_initializer_t *value); -/** returns the value with index @p index of a compound initializer */ +/** Returns the value with index @p index of a compound initializer */ FIRM_API ir_initializer_t *get_initializer_compound_value( const ir_initializer_t *initializer, size_t index); @@ -538,21 +543,40 @@ FIRM_API void set_entity_initializer(ir_entity *entity, ir_initializer_t *initia /** Returns true, if an entity has new style initializers. */ FIRM_API int has_entity_initializer(const ir_entity *entity); -/** Return the new style initializers of an entity. */ +/** Returns the new style initializers of an entity. */ FIRM_API ir_initializer_t *get_entity_initializer(const ir_entity *entity); +/** Adds entity @p ent to the list of entities that overwrite @p overwritten. */ FIRM_API void add_entity_overwrites(ir_entity *ent, ir_entity *overwritten); +/** Returns the number of entities in the list of entities that overwrite + * entity @p ent. */ FIRM_API size_t get_entity_n_overwrites(const ir_entity *ent); -FIRM_API size_t get_entity_overwrites_index(const ir_entity *ent, ir_entity *overwritten); +/** Returns index of @p overwritten in list of entities overwriting entity + * @p ent. */ +FIRM_API size_t get_entity_overwrites_index(const ir_entity *ent, + ir_entity *overwritten); +/** Returns entry @p pos in list of entities overwriting entity @p ent. */ FIRM_API ir_entity *get_entity_overwrites(const ir_entity *ent, size_t pos); -FIRM_API void set_entity_overwrites(ir_entity *ent, size_t pos, ir_entity *overwritten); +/** Sets entry @p pos in list of entities overwriting entity @p ent. */ +FIRM_API void set_entity_overwrites(ir_entity *ent, size_t pos, + ir_entity *overwritten); +/** Remove @p overwritten from list of entities overwriting entity @p ent. */ FIRM_API void remove_entity_overwrites(ir_entity *ent, ir_entity *overwritten); +/** Returns number of entities overwritten by @p ent. */ FIRM_API size_t get_entity_n_overwrittenby(const ir_entity *ent); -FIRM_API size_t get_entity_overwrittenby_index(const ir_entity *ent, ir_entity *overwrites); +/** Returns index of @p overwrites in list of entities overwritten by entity + * @p ent. */ +FIRM_API size_t get_entity_overwrittenby_index(const ir_entity *ent, + ir_entity *overwrites); +/** Return entry @p pos in list of entities overwritten by entity @p ent. */ FIRM_API ir_entity *get_entity_overwrittenby(const ir_entity *ent, size_t pos); -FIRM_API void set_entity_overwrittenby(ir_entity *ent, size_t pos, ir_entity *overwrites); -FIRM_API void remove_entity_overwrittenby(ir_entity *ent, ir_entity *overwrites); +/** Sets entry @p pos in list of entities overwritten by entity @p ent. */ +FIRM_API void set_entity_overwrittenby(ir_entity *ent, size_t pos, + ir_entity *overwrites); +/** Removes entry @p overwrites in list of entities overwritten by @p ent. */ +FIRM_API void remove_entity_overwrittenby(ir_entity *ent, + ir_entity *overwrites); /** * Checks whether a pointer points to an entity. @@ -582,19 +606,24 @@ FIRM_API int is_method_entity(const ir_entity *ent); */ FIRM_API long get_entity_nr(const ir_entity *ent); -/** Returns the entities visited count. */ +/** Returns the entities visited counter. + * @see @ref visited_counters */ FIRM_API ir_visited_t get_entity_visited(const ir_entity *ent); -/** Sets the entities visited count. */ +/** Sets the entities visited counter. + * @see @ref visited_counters */ FIRM_API void set_entity_visited(ir_entity *ent, ir_visited_t num); -/** Sets visited field in entity to entity_visited. */ +/** Marks entity as visited. + * @see @ref visited_counters */ FIRM_API void mark_entity_visited(ir_entity *ent); -/** Returns true if this entity was visited. */ +/** Returns true if this entity was visited. + * @see @ref visited_counters */ FIRM_API int entity_visited(const ir_entity *ent); -/** Returns true if this entity was not visited. */ +/** Returns true if this entity was not visited. + * @see @ref visited_counters */ FIRM_API int entity_not_visited(const ir_entity *ent); /** @@ -614,10 +643,6 @@ FIRM_API void set_entity_additional_properties(ir_entity *ent, FIRM_API void add_entity_additional_properties(ir_entity *ent, mtp_additional_properties flag); -/** Returns the class type that this type info entity represents or NULL - if ent is no type info entity. */ -FIRM_API ir_type *get_entity_repr_class(const ir_entity *ent); - /** * @page unknown_entity The Unknown entity * @@ -651,12 +676,13 @@ FIRM_API ir_type *get_entity_repr_class(const ir_entity *ent); * - link = NULL */ -/** A variable that contains the only unknown entity. */ -FIRM_API ir_entity *unknown_entity; - /** Returns the @link unknown_entity unknown entity @endlink. */ FIRM_API ir_entity *get_unknown_entity(void); +/** Tests whether entity @p entity is (the) unknown entity. + * @returns 1 if it is the unknown entity, 0 otherwise */ +FIRM_API int is_unknown_entity(const ir_entity *entity); + /** @deprecated */ typedef enum { allocation_automatic, @@ -742,7 +768,7 @@ ENUM_BITSET(ptr_access_kind) * An enum for the type kinds. * For each type kind exists a typecode to identify it. */ -typedef enum { +typedef enum tp_opcode { tpo_uninitialized = 0, /* not a type opcode */ tpo_class, /**< A class type. */ tpo_struct, /**< A struct type. */ @@ -891,11 +917,16 @@ typedef enum { inh_transitive_closure_max /**< Invalid value. */ } inh_transitive_closure_state; +/** Sets the transitive closure of sub/superclass state for the + * whole program. */ FIRM_API void set_irp_inh_transitive_closure_state(inh_transitive_closure_state s); +/** Sets the transitive closure of sub/superclass state for the + * whole program to #inh_transitive_closure_invalid */ FIRM_API void invalidate_irp_inh_transitive_closure_state(void); +/** Returns the transitive closure of sub/superclass state for the + * whole program. */ FIRM_API inh_transitive_closure_state get_irp_inh_transitive_closure_state(void); - /** Compute transitive closure of the subclass/superclass and * overwrites/overwrittenby relation. * @@ -906,93 +937,52 @@ FIRM_API void compute_inh_transitive_closure(void); /** Free memory occupied by the transitive closure information. */ FIRM_API void free_inh_transitive_closure(void); -/** Iterate over all transitive subtypes. */ +/** Start iteration over all transitive subtypes of @p tp */ FIRM_API ir_type *get_class_trans_subtype_first(const ir_type *tp); +/** + * Returns next type in a subtype iteration started by + * get_class_trans_subtype_first() + */ FIRM_API ir_type *get_class_trans_subtype_next(const ir_type *tp); +/** + * Check if @p subtp is a subtype of @p tp. This function checks the full + * transitive closure of the subtype relation and not just direct subtyping. + * @return 1 if it is a subtype, 0 otherwise + */ FIRM_API int is_class_trans_subtype(const ir_type *tp, const ir_type *subtp); -/** Iterate over all transitive supertypes. */ +/** Start iteration over all transitive supertypes of @p tp */ FIRM_API ir_type *get_class_trans_supertype_first(const ir_type *tp); +/** + * Returns next type in a supertype iteration started by + * get_class_trans_supertype_first() + */ FIRM_API ir_type *get_class_trans_supertype_next(const ir_type *tp); -/** Iterate over all entities that transitive overwrite this entities. */ +/** Start iteration over all entities that transitive overwrite entity @p ent.*/ FIRM_API ir_entity *get_entity_trans_overwrittenby_first(const ir_entity *ent); +/** + * Returns next entity in a overwrittenby iteration started by + * get_entity_trans_overwrittenby_first() + */ FIRM_API ir_entity *get_entity_trans_overwrittenby_next(const ir_entity *ent); -/** Iterate over all transitive overwritten entities. */ +/** Start iteration over all transitive overwritten entities, overwritten by + * entity @p ent */ FIRM_API ir_entity *get_entity_trans_overwrites_first(const ir_entity *ent); -FIRM_API ir_entity *get_entity_trans_overwrites_next(const ir_entity *ent); - - -/** The state of Cast operations that cast class types or pointers to class - * types. - * - * The state expresses, how far Cast operations conform with the class - * hierarchy. - * - * class A {} - * class B1 extends A {} - * class B2 extends A {} - * class C extends B1 {} - * normalized: Cast operations conform with the inheritance relation. - * I.e., the type of the operand of a Cast is either a super= or a sub- - * type of the type casted to. Example: (A)((B2) (new C())). - * transitive: Cast operations conform with the transitive inheritance - * relation. Example: (A)(new C()). - * any: Cast operations do not conform with the transitive inheritance - * relation. Example: (B2)(new B1()) - * - * Flags for class cast state. - * - * The state in irp is always smaller or equal to the state of any - * irg. - * - * We rely on the ordering of the enum. */ -typedef enum { - ir_class_casts_any = 0, /**< There are class casts that do not cast in conformance with - the class hierarchy. @@@ So far this does not happen in Firm. */ - ir_class_casts_transitive = 1, /**< Class casts conform to transitive inheritance edges. Default. */ - ir_class_casts_normalized = 2, /**< Class casts conform to inheritance edges. */ - ir_class_casts_state_max -} ir_class_cast_state; -FIRM_API const char *get_class_cast_state_string(ir_class_cast_state s); - -FIRM_API void set_irg_class_cast_state(ir_graph *irg, - ir_class_cast_state s); -FIRM_API ir_class_cast_state get_irg_class_cast_state(const ir_graph *irg); -FIRM_API void set_irp_class_cast_state(ir_class_cast_state s); -FIRM_API ir_class_cast_state get_irp_class_cast_state(void); - -/** Verify the class cast state of an irg. - * - * Asserts if state is to high, outputs debug warning if state is to low - * and firm verbosity is set. - */ -FIRM_API void verify_irg_class_cast_state(ir_graph *irg); - /** - * possible trverify() error codes + * Returns next entity in a overwrites iteration started by + * get_entity_trans_overwrites_first() */ -enum trverify_error_codes { - no_error = 0, /**< no error */ - error_ent_not_cont, /**< overwritten entity not in superclass */ - error_null_mem, /**< compound contains NULL member */ - error_const_on_wrong_irg, /**< constant placed on wrong IRG */ - error_existent_entity_without_irg, /**< Method entities with pecularity_exist must have an irg */ - error_wrong_ent_overwrites, /**< number of entity overwrites exceeds number of class overwrites */ - error_inherited_ent_without_const, /**< inherited method entity not pointing to existent entity */ - error_glob_ent_allocation, /**< wrong allocation of a global entity */ - error_ent_const_mode, /**< Mode of constant in entity did not match entities type. */ - error_ent_wrong_owner /**< Mode of constant in entity did not match entities type. */ -}; +FIRM_API ir_entity *get_entity_trans_overwrites_next(const ir_entity *ent); + /** * Checks a type. * - * @return - * 0 if no error encountered + * @return non-zero if no errors were found */ -FIRM_API int check_type(ir_type *tp); +FIRM_API int check_type(const ir_type *tp); /** * Walks the type information and performs a set of sanity checks. @@ -1002,32 +992,25 @@ FIRM_API int check_type(ir_type *tp); * - class types: doesn't have NULL members * - class types: all overwrites are existent in the super type * - * @return - * 0 if graph is correct - * else error code. + * @return 0 if no error encountered */ FIRM_API int tr_verify(void); -/** Frees all entities associated with a type. - * Does not free the array entity. - * Warning: ensure these entities are not referenced anywhere else. - */ -FIRM_API void free_type_entities(ir_type *tp); - -/** Frees the memory used by the type. +/** + * Frees the memory used by the type. * - * Removes the type from the type list. Does not free the entities - * belonging to the type, except for the array element entity. Does - * not free if tp is "none" or "unknown". Frees entities in value - * param subtypes of method types!!! Make sure these are not - * referenced any more. Further make sure there is no pointer type - * that refers to this type. + * Removes the type from the type list and frees all entities + * belonging to the type. */ FIRM_API void free_type(ir_type *tp); +/** Returns type opcode of type @p tp */ FIRM_API const tp_op *get_type_tpop(const ir_type *tp); +/** Returns name identifier of type opcode of type @p tp */ FIRM_API ident *get_type_tpop_nameid(const ir_type *tp); +/** Returns name of type opcode of type @p tp */ FIRM_API const char *get_type_tpop_name(const ir_type *tp); +/** Returns opcode of type opcode of type @p tp */ FIRM_API tp_opcode get_type_tpop_code(const ir_type *tp); /** @@ -1095,27 +1078,32 @@ FIRM_API void set_type_size_bytes(ir_type *tp, unsigned size); /** Returns the alignment of a type in bytes. */ FIRM_API unsigned get_type_alignment_bytes(ir_type *tp); -/** Returns the alignment of a type in bits. +/** Sets the alignment of a type in bytes. * * 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. + * -#.) compound types have the alignment of their biggest member. + * -#.) array types have the alignment of their element type. * -#.) method types return 0 here. * -#.) all other types return 1 here (i.e. aligned at byte). */ FIRM_API void set_type_alignment_bytes(ir_type *tp, unsigned align); -/** Returns the visited count of a type. */ +/** Returns the visited counter of a type. + * @see @ref visited_counters */ FIRM_API ir_visited_t get_type_visited(const ir_type *tp); -/** Sets the visited count of a type to num. */ +/** Sets the visited counter of a type to num. + * @see @ref visited_counters */ FIRM_API void set_type_visited(ir_type *tp, ir_visited_t num); -/** Sets visited field in type to type_visited. */ +/** Sets visited field in type to type_visited. + * @see @ref visited_counters */ FIRM_API void mark_type_visited(ir_type *tp); -/** Returns non-zero if the type is already visited */ +/** Returns non-zero if the type is already visited + * @see @ref visited_counters */ FIRM_API int type_visited(const ir_type *tp); -/** Returns non-zero if the type is not yet visited */ +/** Returns non-zero if the type is not yet visited + * @see @ref visited_counters */ FIRM_API int type_not_visited(const ir_type *tp); /** Returns the associated link field of a type. */ @@ -1123,21 +1111,15 @@ FIRM_API void *get_type_link(const ir_type *tp); /** Sets the associated link field of a type. */ FIRM_API void set_type_link(ir_type *tp, void *l); -/** - * Visited flag to traverse the type information. - * - * Increase this flag by one before traversing the type information - * using inc_master_type_visited(). - * Mark type nodes as visited by mark_type_visited(ir_type). - * Check whether node was already visited by type_visited(ir_type) - * and type_not_visited(ir_type). - * Or use the function to walk all types. - * - * @see typewalk - */ +/** Increments type visited reference counter by one. + * @see @ref visited_counters, mark_type_visited(), type_visited() */ +FIRM_API void inc_master_type_visited(void); +/** Sets type visited reference counter. + * @see @ref visited_counters */ FIRM_API void set_master_type_visited(ir_visited_t val); +/** Returns type visited reference counter. + * @see @ref visited_counters */ FIRM_API ir_visited_t get_master_type_visited(void); -FIRM_API void inc_master_type_visited(void); /** * Sets the debug information of a type. @@ -1266,12 +1248,6 @@ FIRM_API int smaller_type(ir_type *st, ir_type *lt); * * - supertypes: A list of direct superclasses. * - * - type_info: An entity representing the type information of this class. - * This entity can be of arbitrari type, Firm did not use it yet. - * It allows to express the coupling of a type with an entity - * representing this type. This information is useful for lowering - * of InstOf and TypeChk nodes. Default: NULL - * * - vtable_size: The size of this class virtual function table. * Default: 0 * @@ -1299,10 +1275,10 @@ FIRM_API ir_type *new_type_class(ident *name); /** Creates a new class type with debug information. */ FIRM_API ir_type *new_d_type_class(ident *name, type_dbg_info *db); -/** return identifier of the class type */ +/** Returns identifier of the class type */ FIRM_API ident *get_class_ident(const ir_type *clss); -/** return identifier of the class type */ +/** Returns identifier of the class type */ FIRM_API const char *get_class_name(const ir_type *clss); /** Returns the number of members of this class. */ @@ -1311,6 +1287,10 @@ FIRM_API size_t get_class_n_members(const ir_type *clss); /** Returns the member at position pos, 0 <= pos < n_member */ FIRM_API ir_entity *get_class_member(const ir_type *clss, size_t pos); +/** + * Special index returned when get_class_member_index() cannot find a member. + * This index is never used for actual members. + */ #define INVALID_MEMBER_INDEX ((size_t)-1) /** Returns index of mem in clss, INVALID_MEMBER_INDEX if not contained. */ @@ -1329,7 +1309,7 @@ FIRM_API void add_class_subtype(ir_type *clss, ir_type *subtype); /** Returns the number of subtypes */ FIRM_API size_t get_class_n_subtypes(const ir_type *clss); -/** Gets the subtype at position pos, 0 <= pos < n_subtype. */ +/** Returns the subtype at position pos, 0 <= pos < n_subtype. */ FIRM_API ir_type *get_class_subtype(ir_type *clss, size_t pos); /** Returns the index to access subclass as subtype of class. @@ -1362,7 +1342,7 @@ FIRM_API size_t get_class_n_supertypes(const ir_type *clss); */ FIRM_API size_t get_class_supertype_index(ir_type *clss, ir_type *super_clss); -/** Gets the supertype at position pos, 0 <= pos < n_supertype. */ +/** Returns the supertype at position pos, 0 <= pos < n_supertype. */ FIRM_API ir_type *get_class_supertype(ir_type *clss, size_t pos); /** Sets the supertype at position pos, 0 <= pos < n_supertype. @@ -1374,12 +1354,6 @@ FIRM_API void set_class_supertype(ir_type *clss, ir_type *supertype, size_t pos) /** Finds supertype in the list of supertypes and removes it */ FIRM_API void remove_class_supertype(ir_type *clss, ir_type *supertype); -/** Returns the type info entity of a class. */ -FIRM_API ir_entity *get_class_type_info(const ir_type *clss); - -/** Set a type info entity for the class. */ -FIRM_API void set_class_type_info(ir_type *clss, ir_entity *ent); - /** Returns the size of the virtual function table. */ FIRM_API unsigned get_class_vtable_size(const ir_type *clss); @@ -1392,13 +1366,13 @@ FIRM_API int is_class_final(const ir_type *clss); /** Sets the class final flag. */ FIRM_API void set_class_final(ir_type *clss, int flag); -/** Return non-zero if a class is an interface */ +/** Returns non-zero if a class is an interface */ FIRM_API int is_class_interface(const ir_type *clss); /** Sets the class interface flag. */ FIRM_API void set_class_interface(ir_type *clss, int flag); -/** Return non-zero if a class is an abstract class. */ +/** Returns non-zero if a class is an abstract class. */ FIRM_API int is_class_abstract(const ir_type *clss); /** Sets the class abstract flag. */ @@ -1416,6 +1390,7 @@ FIRM_API int is_Class_type(const ir_type *clss); * of the library. */ FIRM_API const tp_op *type_class; +/** Returns type opcode for class type. @see type_class */ FIRM_API const tp_op *get_tpop_class(void); /** @} */ @@ -1443,10 +1418,10 @@ FIRM_API ir_type *new_type_struct(ident *name); /** Creates a new type struct with debug information. */ FIRM_API ir_type *new_d_type_struct(ident *name, type_dbg_info* db); -/** return struct identifier */ +/** Returns struct identifier */ FIRM_API ident *get_struct_ident(const ir_type *strct); -/** return struct identifier as c-string*/ +/** Returns struct identifier as c-string*/ FIRM_API const char *get_struct_name(const ir_type *strct); /** Returns the number of members of this struct. */ @@ -1471,6 +1446,7 @@ FIRM_API int is_Struct_type(const ir_type *strct); * of the library. */ FIRM_API const tp_op *type_struct; +/** Returns type opcode for struct type. @see type_struct */ FIRM_API const tp_op *get_tpop_struct(void); /** @} */ @@ -1496,10 +1472,10 @@ FIRM_API ir_type *new_type_union(ident *name); FIRM_API ir_type *new_d_type_union(ident *name, type_dbg_info* db); -/** return union identifier */ +/** Returns union identifier */ FIRM_API ident *get_union_ident(const ir_type *uni); -/** return union identifier as c-string */ +/** Returns union identifier as c-string */ FIRM_API const char *get_union_name(const ir_type *uni); /** Returns the number of unioned types of this union */ @@ -1522,6 +1498,7 @@ FIRM_API int is_Union_type(const ir_type *uni); * of the library. */ FIRM_API const tp_op *type_union; +/** Returns type opcode for union type. @see type_union */ FIRM_API const tp_op *get_tpop_union(void); /** @} */ @@ -1676,7 +1653,7 @@ typedef enum { #define SET_CDECL(cc_mask) (((cc_mask) & ~cc_bits) | cc_cdecl_set) /** - * Set. the STDCALL convention bits. + * Sets the STDCALL convention bits. */ #define SET_STDCALL(cc_mask) (((cc_mask) & ~cc_bits) | cc_stdcall_set) @@ -1708,6 +1685,7 @@ FIRM_API int is_Method_type(const ir_type *method); * of the library. */ FIRM_API const tp_op *type_method; +/** Returns type opcode for method type @see type_method */ FIRM_API const tp_op *get_tpop_method(void); /** @} */ @@ -1717,7 +1695,7 @@ FIRM_API const tp_op *get_tpop_method(void); * * The array type represents rectangular multi dimensional arrays. * The constants representing the bounds must be allocated to - * get_const_code_irg() by setting current_ir_graph accordingly. + * get_const_code_irg(). * * - n_dimensions: Number of array dimensions. * - *lower_bound: Lower bounds of dimensions. Usually all 0. @@ -1733,7 +1711,7 @@ FIRM_API const tp_op *get_tpop_method(void); * Sets n_dimension to dimension and all dimension entries to NULL. * Initializes order to the order of the dimensions. * The entity for array elements is built automatically. - * Set dimension sizes after call to constructor with set_* routines. + * Sets dimension sizes after call to constructor with set_* routines. */ FIRM_API ir_type *new_type_array(size_t n_dims, ir_type *element_type); @@ -1742,7 +1720,7 @@ FIRM_API ir_type *new_type_array(size_t n_dims, ir_type *element_type); * Sets n_dimension to dimension and all dimension entries to NULL. * Initializes order to the order of the dimensions. * The entity for array elements is built automatically. - * Set dimension sizes after call to constructor with set_* routines. + * Sets dimension sizes after call to constructor with set_* routines. * A legal array type must have at least one dimension set. */ FIRM_API ir_type *new_d_type_array(size_t n_dims, ir_type *element_type, @@ -1807,15 +1785,28 @@ FIRM_API size_t find_array_dimension(const ir_type *array, size_t order); /** Sets the array element type. */ FIRM_API void set_array_element_type(ir_type *array, ir_type *tp); -/** Gets the array element type. */ +/** Returns the array element type. */ FIRM_API ir_type *get_array_element_type(const ir_type *array); /** Sets the array element entity. */ FIRM_API void set_array_element_entity(ir_type *array, ir_entity *ent); -/** Get the array element entity. */ +/** Returns the array element entity. */ FIRM_API ir_entity *get_array_element_entity(const ir_type *array); +/** + * Sets the array variable size flag. + * If this flag is set then no upper/lower bounds need to be set and + * get_type_size_bytes() returns -1 + */ +FIRM_API void set_array_variable_size(ir_type *array, int variable_size_flag); + +/** + * Returns the array variable size flag. + * @see set_array_variable_size() + */ +FIRM_API int is_array_variable_size(const ir_type *array); + /** Returns true if a type is an array type. */ FIRM_API int is_Array_type(const ir_type *array); @@ -1828,6 +1819,7 @@ FIRM_API int is_Array_type(const ir_type *array); * of the library. */ FIRM_API const tp_op *type_array; +/** Returns type opcode for array type. @see type_array */ FIRM_API const tp_op *get_tpop_array(void); /** @} */ @@ -1838,8 +1830,8 @@ FIRM_API const tp_op *get_tpop_array(void); * Enumeration types need not necessarily be represented explicitly * by Firm types, as the frontend can lower them to integer constants as * well. For debugging purposes or similar tasks this information is useful. - * The type state layout_fixed is set, if all enumeration constant have - * there tarvals assigned. Until then + * The type state layout_fixed is set, if all enumeration constants have + * their tarvals assigned. Until then * * - *const: The target values representing the constants used to * represent individual enumerations. @@ -1854,13 +1846,13 @@ FIRM_API ir_type *new_d_type_enumeration(ident *name, size_t n_enums, type_dbg_info *db); -/** return enumeration identifier */ +/** Returns enumeration identifier */ FIRM_API ident *get_enumeration_ident(const ir_type *enumeration); -/** return enumeration identifier as c-string */ +/** Returns enumeration identifier as c-string */ FIRM_API const char *get_enumeration_name(const ir_type *enumeration); -/** Set an enumeration constant to a enumeration type at a given position. */ +/** Sets an enumeration constant to a enumeration type at a given position. */ FIRM_API void set_enumeration_const(ir_type *enumeration, size_t pos, ident *nameid, ir_tarval *con); @@ -1902,6 +1894,7 @@ FIRM_API int is_Enumeration_type(const ir_type *enumeration); * of the library. */ FIRM_API const tp_op *type_enumeration; +/** Returns type opcode for enumeration type. @see type_enumeration */ FIRM_API const tp_op *get_tpop_enumeration(void); /** @} */ @@ -1943,6 +1936,7 @@ FIRM_API ir_type *find_pointer_type_to_type(ir_type *tp); * of the library. */ FIRM_API const tp_op *type_pointer; +/** Returns type opcode for pointer type. @see type_pointer */ FIRM_API const tp_op *get_tpop_pointer(void); /** @} */ @@ -1964,7 +1958,7 @@ FIRM_API ir_type *new_d_type_primitive(ir_mode *mode, type_dbg_info* db); /** Returns true if a type is a primitive type. */ FIRM_API int is_Primitive_type(const ir_type *primitive); -/** Return the base type of a primitive (bitfield) type or NULL if none. */ +/** Returns the base type of a primitive (bitfield) type or NULL if none. */ FIRM_API ir_type *get_primitive_base_type(const ir_type *tp); /** Sets the base type of a primitive (bitfield) type. */ @@ -1979,6 +1973,7 @@ FIRM_API void set_primitive_base_type(ir_type *tp, ir_type *base_tp); * of the library. */ FIRM_API const tp_op *type_primitive; +/** Returns type opcode for primitive type. @see type_primitive */ FIRM_API const tp_op *get_tpop_primitive(void); /** @} */ @@ -2001,10 +1996,10 @@ FIRM_API const tp_op *get_tpop_primitive(void); * - size: 0 * @{ */ -/** A variable that contains the only none type. */ -FIRM_API ir_type *firm_none_type; /** Returns the none type. */ FIRM_API ir_type *get_none_type(void); +/** Checks whether type @p type is the none type. */ +FIRM_API int is_none_type(const ir_type *type); /** * This type opcode is an auxiliary opcode dedicated to support type analyses. * @@ -2014,14 +2009,13 @@ FIRM_API ir_type *get_none_type(void); * one type with this opcode. */ FIRM_API const tp_op *tpop_none; +/** Returns type opcode for none type. @see tpop_none */ FIRM_API const tp_op *get_tpop_none(void); /** @} */ /** @defgroup code_type Code * @{ */ -/** A variable that contains the only code type. */ -FIRM_API ir_type *firm_code_type; /** Returns the code type. */ FIRM_API ir_type *get_code_type(void); /** @@ -2032,6 +2026,7 @@ FIRM_API int is_code_type(const ir_type *tp); * The code type is used to mark pieces of code (basic blocks) */ FIRM_API const tp_op *tpop_code; +/** Returns type opcode for code type. @see tpop_code */ FIRM_API const tp_op *get_tpop_code_type(void); /** @} */ @@ -2053,10 +2048,10 @@ FIRM_API const tp_op *get_tpop_code_type(void); * - size: 0 * @{ */ -/** A variable that contains the only unknown type. */ -FIRM_API ir_type *firm_unknown_type; /** Returns the unknown type. */ FIRM_API ir_type *get_unknown_type(void); +/** Checks whether type @p type is the unknown type */ +FIRM_API int is_unknown_type(const ir_type *type); /** * This type opcode is an auxiliary opcode dedicated to support type analyses. * @@ -2066,6 +2061,7 @@ FIRM_API ir_type *get_unknown_type(void); * exactly one type with this opcode. */ FIRM_API const tp_op *tpop_unknown; +/** Returns type opcode for unknown type. @see tpop_unknown */ FIRM_API const tp_op *get_tpop_unknown(void); /** @} */ @@ -2083,15 +2079,15 @@ FIRM_API int is_atomic_type(const ir_type *tp); */ /** - * Gets the identifier of a compound type + * Returns the identifier of a compound type */ FIRM_API ident *get_compound_ident(const ir_type *tp); -/** return compound identifier as c-string */ +/** Returns compound identifier as c-string */ FIRM_API const char *get_compound_name(const ir_type *tp); /** - * Gets the number of elements in a Firm compound type. + * Returns the number of elements in a Firm compound type. * * This is just a comfortability function, because structs and * classes can often be treated be the same code, but they have @@ -2104,7 +2100,7 @@ FIRM_API const char *get_compound_name(const ir_type *tp); FIRM_API size_t get_compound_n_members(const ir_type *tp); /** - * Gets the member of a Firm compound type at position pos. + * Returns the member of a Firm compound type at position pos. * * @param tp The type (must be struct, union or class). * @param pos The number of the member. @@ -2119,6 +2115,20 @@ FIRM_API size_t get_compound_member_index(const ir_type *tp, ir_entity *member); /** Remove a member from a compound type. */ FIRM_API void remove_compound_member(ir_type *compound, ir_entity *entity); +/** + * Sets the variable size flag of a compound type. + * The last member of a variable size compound type may be an array type + * without explicit size. So the get_type_size_bytes() of a variable size + * compound type only returns a minimum size for the type (the size if the + * last members size is 0) + */ +FIRM_API void set_compound_variable_size(ir_type *compound, int variable_size); + +/** + * Returns the variable size flag. @see set_compound_variable_size() + */ +FIRM_API int is_compound_variable_size(const ir_type *compound); + /** * layout members of a struct/union or class type in a default way. */ @@ -2286,7 +2296,7 @@ FIRM_API void types_calc_finalization(void); /** @deprecated */ FIRM_API ir_visibility get_type_visibility(const ir_type *tp); /** @deprecated */ -FIRM_API void set_type_visibility(ir_type *tp, ir_visibility v); +FIRM_API void set_type_visibility(ir_type *tp, ir_visibility v); /** @} */