* WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE.
*/
+
+/**
+ * @file
+ * @brief Declarations for functions and datastructures to represent types
+ */
#ifndef FIRM_TYPEREP_H
#define FIRM_TYPEREP_H
#include "firm_types.h"
+#include <stdlib.h>
/**
* @page entity Entity representation
*
* - owner: A compound type this entity is a part of.
* - type: The type of this entity.
- * - name: The string that represents this entity in the source program.
- * - allocation: A flag saying whether the entity is dynamically or statically
- * allocated (values: dynamic_allocated, static_allocated,
- * automatic_allocated).
- * - visibility: A flag indicating the visibility of this entity (values: local,
- * external_visible, external_allocated)
- * - variability: A flag indicating the variability of this entity (values:
- * uninitialized, initialized, part_constant, constant)
- * - volatility: @@@
+ * - name: The string that represents this entity in the source program
+ * - linkage: A flag indicating how the linker treats a symbol
* - offset: The offset of the entity within the compound object in bytes. Only set
* if the owner in the state "layout_fixed".
* - offset_bits_remainder: The offset bit remainder of a bitfield entity (in a compound)
* - link: A void* to associate some additional information with the entity.
* - irg: If the entity is a method this is the ir graph that represents the
* code of the method.
- * - peculiarity: The peculiarity of the entity. If the entity is a method this
- * indicates whether the entity represents
- * a real method or whether it only exists to describe an interface.
- * In that case there nowhere exists code for this entity and this entity
- * is never dynamically used in the code.
- * Values: description, existent. Default: existent.
* - visited: visited flag. Master flag is type_visited.
*
* These fields can only be accessed via access functions.
* @see ir_type, ir_entity
*/
-/** This enumeration flags the visibility of entities and types.
- *
- * This is necessary for partial compilation.
- * We rely on the ordering of the flags.
+/**
+ * Visibility classed for entities.
*/
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. */
+ /**
+ * The entity is visible outside the compilation unit, but it is defined
+ * here.
+ */
+ ir_visibility_default,
+ /**
+ * The entity is local to the compilation unit.
+ * A local entity is not visible in other compilation units.
+ * Note that the entity might still be accessed indirectly from other units
+ * through pointers.
+ */
+ 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).
+ * 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;
-/** 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.
- @@@ eventually rename to descriptive (adjective as the others!)*/
- peculiarity_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.
- Only for entity. */
- peculiarity_existent /**< The entity/type (can) exist.
- @@@ eventually rename to 'real' i.e., 'echt'
- This serves better as opposition to description _and_ inherited.*/
-} ir_peculiarity;
-
/**
- * Additional method type properties:
- * Tell about special properties of a method type. Some
- * of these may be discovered by analyses.
+ * linkage specifies how the linker treats symbols
*/
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 from 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_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 = 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;
+ IR_LINKAGE_DEFAULT = 0,
+ /**
+ * A symbol whose definition won't change in a program.
+ * Optimisation might replace loads from this entity with constants.
+ * Also most linkers put such data in a constant segment which is shared
+ * between multiple running instances of the same application.
+ */
+ IR_LINKAGE_CONSTANT = 1 << 0,
+ /**
+ * The entity is a weak symbol.
+ * A weak symbol is overridden by a non-weak symbol if one exists.
+ * Most linkers only support the IR_LINKAGE_WEAK in combination with
+ * IR_LINKAGE_MERGE.
+ */
+ IR_LINKAGE_WEAK = 1 << 1,
+ /**
+ * The entity may be removed when it isn't referenced anywhere in the
+ * compilation unit even if it is exported (non-local).
+ * Typically used for C++ instantiated template code (,,COMDAT'' section).
+ */
+ IR_LINKAGE_GARBAGE_COLLECT = 1 << 2,
+ /**
+ * The linker will try to merge entities with same name from different
+ * compilation units. This is the usual behaviour for global variables
+ * without explicit initialisation in C (``COMMON'' symbols). It's also
+ * typically used in C++ for instantiated template code (,,COMDAT'' section)
+ */
+ IR_LINKAGE_MERGE = 1 << 3,
+ /**
+ * Some entity uses are potentially hidden from the compiler.
+ * (For example because they happen in an asm("") statement. This flag
+ * should be set for __attribute__((used)) in C code).
+ * Setting this flag prohibits that the compiler making assumptions about
+ * read/write behaviour to global variables or changing calling conventions
+ * from cdecl to fastcall.
+ */
+ IR_LINKAGE_HIDDEN_USER = 1 << 4
+} ir_linkage;
+
+/**
+ * Return the visibility class of an entity
+ */
+ir_visibility get_entity_visibility(const ir_entity *entity);
+
+/**
+ * Set visibility class of an entity
+ */
+void set_entity_visibility(ir_entity *entity, ir_visibility visibility);
+
+/**
+ * Return 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
+ * get_entity_visibility(entity) != ir_visibility_local ||
+ * (get_entity_linkage(entity) & IR_LINKAGE_HIDDEN_USER)
+ */
+int entity_is_externally_visible(const ir_entity *entity);
+
+/**
+ * Return 1 if the entity has a definition (initializer) in the current
+ * compilation unit
+ */
+int entity_has_definition(const ir_entity *entity);
/**
* Creates a new entity.
* Automatically inserts the new entity as a member of owner.
* Resets the overwrites/overwritten_by fields.
* Keeps the old atomic value.
- * @@@ Maybe we should change this. If peculiarity of a method
- * is existent, we should add a new SymConst that points to
- * itself and not to the origin. Right now we have to change
- * the peculiarity and then set a new atomic value by hand.
*/
ir_entity *copy_entity_own(ir_entity *old, ir_type *new_owner);
* Else it generates a name with mangle_entity()
* and remembers this new name internally.
*/
-ident *get_entity_ld_ident(ir_entity *ent);
+ident *get_entity_ld_ident(const ir_entity *ent);
/** Sets the mangled name of the entity. */
void set_entity_ld_ident(ir_entity *ent, ident *ld_ident);
/** Returns the mangled name of the entity as a string. */
-const char *get_entity_ld_name(ir_entity *ent);
+const char *get_entity_ld_name(const ir_entity *ent);
/** Returns the owner of the entity. */
-ir_type *get_entity_owner(ir_entity *ent);
+ir_type *get_entity_owner(const ir_entity *ent);
/** Sets the owner field in entity to owner. Don't forget to add
ent to owner!! */
void set_entity_owner(ir_entity *ent, ir_type *owner);
/** Returns the type of an entity. */
-ir_type *get_entity_type(ir_entity *ent);
+ir_type *get_entity_type(const ir_entity *ent);
/** Sets the type of an entity. */
void set_entity_type(ir_entity *ent, ir_type *tp);
-/** The allocation type. */
-typedef enum {
- allocation_automatic, /**< The entity is allocated during runtime, implicitly
- as component of a compound type. This is the default. */
- allocation_parameter, /**< The entity is a parameter. It is also automatic allocated.
- We distinguish the allocation of parameters from the allocation
- of local variables as their placement depends on the calling
- conventions. */
- allocation_dynamic, /**< The entity is allocated during runtime, explicitly
- by an Alloc node. */
- allocation_static /**< The entity is allocated statically. We can use a
- Const as address of the entity. This is the default for methods. */
-} ir_allocation;
+/** Returns the linkage of an entity. */
+ir_linkage get_entity_linkage(const ir_entity *entity);
-/** Returns the allocation type of an entity. */
-ir_allocation get_entity_allocation(const ir_entity *ent);
+/** Sets the linkage of an entity. */
+void set_entity_linkage(ir_entity *entity, ir_linkage linkage);
+void add_entity_linkage(ir_entity *entity, ir_linkage linkage);
+void remove_entity_linkage(ir_entity *entity, ir_linkage linkage);
-/** Sets the allocation type of an entity. */
-void set_entity_allocation(ir_entity *ent, ir_allocation al);
+/** Returns 1 if the value of a global symbol never changes in a program */
+int is_entity_constant(const ir_entity *ent);
-/** Return the name of the allocation type. */
-const char *get_allocation_name(ir_allocation vis);
-
-/** Returns the visibility of an entity. */
-ir_visibility get_entity_visibility(const ir_entity *ent);
-
-/** Sets the visibility of an entity. */
-void set_entity_visibility(ir_entity *ent, ir_visibility vis);
-
-/** Return the name of the visibility */
-const char *get_visibility_name(ir_visibility vis);
-
-/** This enumeration flags the variability of entities. */
-typedef enum {
- variability_uninitialized, /**< The content of the entity is completely unknown. Default. */
- variability_initialized, /**< After allocation the entity is initialized with the
- value given somewhere in the entity. */
- variability_part_constant, /**< For entities of compound types.
- The members of the entity are mixed constant,
- initialized or uninitialized. */
- variability_constant /**< The entity is constant. */
-} ir_variability;
-
-/** Returns the variability of an entity. */
-ir_variability get_entity_variability(const ir_entity *ent);
-
-/** Sets the variability of an entity. */
-void set_entity_variability(ir_entity *ent, ir_variability var);
-
-/** Return the name of the variability. */
-const char *get_variability_name(ir_variability var);
-
-/** This enumeration flags the volatility of entities and Loads/Stores. */
+/**
+ * This enumeration flags the volatility of entities and Loads/Stores.
+ * @deprecated
+ */
typedef enum {
volatility_non_volatile, /**< The entity is not volatile. Default. */
volatility_is_volatile /**< The entity is volatile. */
} ir_volatility;
-/** Returns the volatility of an entity. */
+/**
+ * Returns the volatility of an entity.
+ * @deprecated
+ */
ir_volatility get_entity_volatility(const ir_entity *ent);
-/** Sets the volatility of an entity. */
+/**
+ * Sets the volatility of an entity.
+ * @deprecated
+ */
void set_entity_volatility(ir_entity *ent, ir_volatility vol);
/** Return the name of the volatility. */
const char *get_volatility_name(ir_volatility var);
-/** This enumeration flags the align of Loads/Stores. */
+/** Returns alignment of entity in bytes */
+unsigned get_entity_alignment(const ir_entity *entity);
+
+/** Allows you to override the type alignment for an entity.
+ * @param entity the entity
+ * @param alignment alignment in bytes
+ */
+void set_entity_alignment(ir_entity *entity, unsigned alignment);
+
+
+/**
+ * This enumeration flags the align of Loads/Stores.
+ * @deprecated
+ */
typedef enum {
align_non_aligned, /**< The entity is not aligned. */
align_is_aligned /**< The entity is aligned. Default */
} ir_align;
-/** Returns the alignment of an entity. */
-ir_align get_entity_align(const ir_entity *ent);
+/**
+ * Returns indication wether entity is aligned in memory.
+ * @deprecated
+ */
+ir_align get_entity_aligned(const ir_entity *ent);
-/** Sets the alignment of an entity. */
-void set_entity_align(ir_entity *ent, ir_align a);
+/**
+ * Sets indication wether entity is aligned in memory
+ * @deprecated
+ */
+void set_entity_aligned(ir_entity *ent, ir_align a);
/** Return the name of the alignment. */
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. There might be external
- callers. */
-} ir_stickyness;
-
-/** Get the entity's stickyness. */
-ir_stickyness get_entity_stickyness(const ir_entity *ent);
-
-/** Set the entity's stickyness. */
-void set_entity_stickyness(ir_entity *ent, ir_stickyness stickyness);
-
/** Returns the offset of an entity (in a compound) in bytes. Only set if layout = fixed. */
int get_entity_offset(const ir_entity *ent);
/* -- Fields of method entities -- */
/** The entity knows the corresponding irg if the entity is a method.
- This allows to get from a Call to the called irg.
- Only entities of peculiarity "existent" can have a corresponding irg,
- else the field is fixed to NULL. (Get returns NULL, set asserts.) */
+ This allows to get from a Call to the called irg. */
ir_graph *get_entity_irg(const ir_entity *ent);
void set_entity_irg(ir_entity *ent, ir_graph *irg);
/** Sets the entity vtable number. */
void set_entity_vtable_number(ir_entity *ent, unsigned vtable_number);
-/** Return the peculiarity of an entity. */
-ir_peculiarity get_entity_peculiarity(const ir_entity *ent);
-
-/** Sets the peculiarity of an entity. */
-void set_entity_peculiarity(ir_entity *ent, ir_peculiarity pec);
-
-/** Checks if an entity cannot be overridden anymore. */
-int is_entity_final(const ir_entity *ent);
-
-/** Sets/resets the final flag of an entity. */
-void set_entity_final(ir_entity *ent, int final);
+/** Set label number of an entity with code type */
+void set_entity_label(ir_entity *ent, ir_label_t label);
+/** Return label number of an entity with code type */
+ir_label_t get_entity_label(const ir_entity *ent);
/** Checks if an entity is compiler generated. */
int is_entity_compiler_generated(const ir_entity *ent);
/** Sets/resets the compiler generated flag. */
void set_entity_compiler_generated(ir_entity *ent, int flag);
-/** Checks if an entity is marked by the backend. */
-int is_entity_backend_marked(const ir_entity *ent);
-
-/** Sets/resets the backend marker flag. */
-void set_entity_backend_marked(ir_entity *ent, int flag);
-
/**
* Bitfield type indicating the way an entity is used.
*/
/** returns kind of an initializer */
ir_initializer_kind_t get_initializer_kind(const ir_initializer_t *initializer);
+/** Return the name of the initializer kind. */
+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 )
*/
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);
-
-/** Returns non-zero if an object is a compound graph path */
-int is_compound_graph_path(const void *thing);
-
-/** Frees a graph path object */
-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);
-/** 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. */
-int is_proper_compound_graph_path(compound_graph_path *gr, int pos);
-
-/* A value of a compound entity is a pair of a value and the description of the
- corresponding access path to the member of the compound. */
-void add_compound_ent_value_w_path(ir_entity *ent, ir_node *val, compound_graph_path *path);
-void set_compound_ent_value_w_path(ir_entity *ent, ir_node *val, compound_graph_path *path, int pos);
-
-/** Returns the number of constant values needed to initialize the entity.
- *
- * Asserts if the entity has variability_uninitialized.
- * */
-int get_compound_ent_n_values(ir_entity *ent);
-/** Returns a constant value given the position. */
-ir_node *get_compound_ent_value(ir_entity *ent, int pos);
-/** Returns the access path for value at position pos. */
-compound_graph_path *get_compound_ent_value_path(ir_entity *ent, int pos);
-/** Returns a constant value given the access path.
- * The path must contain array indices for all array element entities. */
-ir_node *get_compound_ent_value_by_path(ir_entity *ent, compound_graph_path *path);
-
-/** Removes all constant entries where the path ends at value_ent. Does not
- free the memory of the paths. (The same path might be used for several
- constant entities. */
-void remove_compound_ent_value(ir_entity *ent, ir_entity *value_ent);
-
-/* Some languages support only trivial access paths, i.e., the member is a
- direct, atomic member of the constant entities type. In this case the
- corresponding entity can be accessed directly. The following functions
- allow direct access. */
-
-/** Generates a Path with length 1.
- Beware: Has a bad runtime for array elements (O(|array|) and should be
- avoided there. Use add_compound_ent_value_w_path() instead and create
- the path manually. */
-void add_compound_ent_value(ir_entity *ent, ir_node *val, ir_entity *member);
-
-/** Returns the last member in the path */
-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);
+/** Returns true, if an entity has new style initializers. */
+int has_entity_initializer(const ir_entity *entity);
+
/** 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
- order of values. Does not test whether the number of values
- fits into the given array size. Does not test whether the
- values have the proper mode for the array. */
-void set_array_entity_values(ir_entity *ent, tarval **values, int num_vals);
-
-/**
- * Return the offset in bits from the last byte address.
- *
- * This requires that the layout of all concerned types is fixed.
- *
- * @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.
- */
-unsigned get_compound_ent_value_offset_bit_remainder(ir_entity *ent, int pos);
-
-/** Return the overall offset of value at position pos in bytes.
- *
- * This requires that the layout of all concerned types is fixed.
- * Asserts if bit offset is not byte aligned.
- *
- * @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.
- */
-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
entity in the supertype must use this entity. It's a list as with
Overwrittenby is the inverse of overwrites. Both add routines add
both relations, they only differ in the order of arguments. */
void add_entity_overwrites(ir_entity *ent, ir_entity *overwritten);
-int get_entity_n_overwrites(ir_entity *ent);
-int get_entity_overwrites_index(ir_entity *ent, ir_entity *overwritten);
-ir_entity *get_entity_overwrites(ir_entity *ent, int pos);
+int get_entity_n_overwrites(const ir_entity *ent);
+int get_entity_overwrites_index(const ir_entity *ent, ir_entity *overwritten);
+ir_entity *get_entity_overwrites(const ir_entity *ent, int pos);
void set_entity_overwrites(ir_entity *ent, int pos, ir_entity *overwritten);
void remove_entity_overwrites(ir_entity *ent, ir_entity *overwritten);
void add_entity_overwrittenby(ir_entity *ent, ir_entity *overwrites);
-int get_entity_n_overwrittenby(ir_entity *ent);
-int get_entity_overwrittenby_index(ir_entity *ent, ir_entity *overwrites);
-ir_entity *get_entity_overwrittenby(ir_entity *ent, int pos);
+int get_entity_n_overwrittenby(const ir_entity *ent);
+int get_entity_overwrittenby_index(const ir_entity *ent, ir_entity *overwrites);
+ir_entity *get_entity_overwrittenby(const ir_entity *ent, int pos);
void set_entity_overwrittenby(ir_entity *ent, int pos, ir_entity *overwrites);
void remove_entity_overwrittenby(ir_entity *ent, ir_entity *overwrites);
/** Returns true if the type of the entity is a primitive, pointer
* enumeration or method type.
*
- * @Note This is a different classification than from is_primitive_type().
+ * @note This is a different classification than from is_primitive_type().
*/
-int is_atomic_entity(ir_entity *ent);
+int is_atomic_entity(const ir_entity *ent);
/** Returns true if the type of the entity is a class, structure,
array or union type. */
-int is_compound_entity(ir_entity *ent);
+int is_compound_entity(const ir_entity *ent);
/** Returns true if the type of the entity is a Method type. */
-int is_method_entity(ir_entity *ent);
-
-/** Returns non-zero if ent1 and ent2 have are equal except for their owner.
- Two entities are equal if
- - they have the same type (the same C-struct)
- - ...?
-*/
-int equal_entity(ir_entity *ent1, ir_entity *ent2);
+int is_method_entity(const ir_entity *ent);
/** Outputs a unique number for this entity if libfirm is compiled for
* debugging, (configure with --enable-debug) else returns the address
long get_entity_nr(const ir_entity *ent);
/** Returns the entities visited count. */
-ir_visited_t get_entity_visited(ir_entity *ent);
+ir_visited_t get_entity_visited(const ir_entity *ent);
/** Sets the entities visited count. */
void set_entity_visited(ir_entity *ent, ir_visited_t num);
void mark_entity_visited(ir_entity *ent);
/** Returns true if this entity was visited. */
-int entity_visited(ir_entity *ent);
+int entity_visited(const ir_entity *ent);
/** Returns true if this entity was not visited. */
-int entity_not_visited(ir_entity *ent);
+int entity_not_visited(const ir_entity *ent);
/**
* Returns the mask of the additional entity properties.
* set_entity_additional_properties() or
* set_entity_additional_property().
*/
-unsigned get_entity_additional_properties(ir_entity *ent);
+unsigned get_entity_additional_properties(const ir_entity *ent);
/** Sets the mask of the additional graph properties. */
void set_entity_additional_properties(ir_entity *ent, unsigned property_mask);
* - ld_name = "unknown_entity"
* - owner = unknown_type
* - type = unknown_type
- * - allocation = allocation_automatic
- * - visibility = visibility_external_allocated
* - offset = -1
- * - variability = variability_uninitialized
* - value = SymConst(unknown_entity)
* - values = NULL
* - val_paths = NULL
- * - peculiarity = peculiarity_existent
* - volatility = volatility_non_volatile
* - stickyness = stickyness_unsticky
* - ld_name = NULL
* - irg = NULL
* - link = NULL
*/
-/* A variable that contains the only unknown entity. */
+
+/** A variable that contains the only unknown entity. */
extern ir_entity *unknown_entity;
/** Returns the @link unknown_entity unknown entity @endlink. */
* arrays, enumerations, pointers and primitive types.
* Special types with own opcodes are the id type, a type representing an unknown
* type and a type used to specify that something has no type.
- *
- * @see type.h
*/
/**
tpo_enumeration, /**< An enumeration type. */
tpo_pointer, /**< A pointer type. */
tpo_primitive, /**< A primitive type. */
- tpo_id, /**< Special Id tag used for type replacement. */
+ tpo_code, /**< a piece of code (a basic block) */
tpo_none, /**< Special type for the None type. */
tpo_unknown, /**< Special code for the Unknown type. */
- tpo_max /* not a type opcode */
+ tpo_last = tpo_unknown /* not a type opcode */
} tp_opcode;
/**
* this is only the kind name, an enum for case-switching and some
* internal values.
*
- * @see get_tpop_name(), get_tpop_code(), get_tpop_ident()
+ * @see get_tpop_name(), get_tpop_code()
*/
typedef struct tp_op tp_op;
*/
tp_opcode get_tpop_code(const tp_op *op);
-/**
- * Returns the ident for the type opcode.
- *
- * @param op The type opcode to get the ident from.
- * @return The ident.
- */
-ident *get_tpop_ident(const tp_op *op);
-
/**
* This type opcode marks that the corresponding type is a class type.
*
* This struct is dynamically allocated but constant for the lifetime
* of the library.
*/
-extern tp_op *type_class;
-tp_op *get_tpop_class(void);
+extern const tp_op *type_class;
+const tp_op *get_tpop_class(void);
/**
* This type opcode marks that the corresponding type is a compound type
* This struct is dynamically allocated but constant for the lifetime
* of the library.
*/
-extern tp_op *type_struct;
-tp_op *get_tpop_struct(void);
+extern const tp_op *type_struct;
+const tp_op *get_tpop_struct(void);
/**
* This type opcode marks that the corresponding type is a method type.
* This struct is dynamically allocated but constant for the lifetime
* of the library.
*/
-extern tp_op *type_method;
-tp_op *get_tpop_method(void);
+extern const tp_op *type_method;
+const tp_op *get_tpop_method(void);
/**
* This type opcode marks that the corresponding type is a union type.
* This struct is dynamically allocated but constant for the lifetime
* of the library.
*/
-extern tp_op *type_union;
-tp_op *get_tpop_union(void);
+extern const tp_op *type_union;
+const tp_op *get_tpop_union(void);
/**
* This type opcode marks that the corresponding type is an array type.
* This struct is dynamically allocated but constant for the lifetime
* of the library.
*/
-extern tp_op *type_array;
-tp_op *get_tpop_array(void);
+extern const tp_op *type_array;
+const tp_op *get_tpop_array(void);
/**
* This type opcode marks that the corresponding type is an enumeration type.
* This struct is dynamically allocated but constant for the lifetime
* of the library.
*/
-extern tp_op *type_enumeration;
-tp_op *get_tpop_enumeration(void);
+extern const tp_op *type_enumeration;
+const tp_op *get_tpop_enumeration(void);
/**
* This type opcode marks that the corresponding type is a pointer type.
* This struct is dynamically allocated but constant for the lifetime
* of the library.
*/
-extern tp_op *type_pointer;
-tp_op *get_tpop_pointer(void);
+extern const tp_op *type_pointer;
+const tp_op *get_tpop_pointer(void);
/**
* This type opcode marks that the corresponding type is a primitive type.
* This struct is dynamically allocated but constant for the lifetime
* of the library.
*/
-extern tp_op *type_primitive;
-tp_op *get_tpop_primitive(void);
+extern const tp_op *type_primitive;
+const tp_op *get_tpop_primitive(void);
/**
- * This type opcode is an auxiliary opcode dedicated to support transformations
- * of the type structure.
- *
- * If a type is changed to another type with another
- * opcode the new type will be allocated with new memory. All nodes refering
- * to the old type need to be changed to refer to the new one. This is simplified
- * by turning the old type into an id type that merely forwards to the new type
- * that now replaces the old one.
- * type_ids should never be visible out of the type module. All access routines
- * should automatically check for type_id and eventually follow the forward in
- * type_id. Two types are exchanged by a call to exchange_types.
- * If a type_id is visible externally report this as bug. If it is assured that
- * this never happens this extern variable can be moved to tpop_t.h.
- * This struct is dynamically allocated but constant for the lifetime
- * of the library.
+ * The code type is used to mark pieces of code (basic blocks)
*/
-extern tp_op *type_id;
-tp_op *get_tpop_id(void);
+extern const tp_op *tpop_code;
+const tp_op *get_tpop_code_type(void);
/**
* This type opcode is an auxiliary opcode dedicated to support type analyses.
* contain a type or that are initialized for an analysis. There exists exactly
* one type with this opcode.
*/
-extern tp_op *tpop_none;
-tp_op *get_tpop_none(void);
+extern const tp_op *tpop_none;
+const tp_op *get_tpop_none(void);
/**
* This type opcode is an auxiliary opcode dedicated to support type analyses.
* yet) or to represent the top of a lattice (could not be determined). There exists
* exactly one type with this opcode.
*/
-extern tp_op *tpop_unknown;
-tp_op *get_tpop_unknown(void);
+extern const tp_op *tpop_unknown;
+const tp_op *get_tpop_unknown(void);
/* ----------------------------------------------------------------------- */
/* Classify pairs of types/entities in the inheritance relations. */
*
* Returns an ident that consists of the name of type followed by an
* underscore and the name (not ld_name) of the entity. */
-ident *default_mangle_inherited_name(ir_entity *ent, ir_type *clss);
+ident *default_mangle_inherited_name(const ir_entity *ent, const ir_type *clss);
/** Type of argument functions for inheritance resolver.
*
* used.
* @param clss The class type in which the new entity will be placed.
*/
-typedef ident *mangle_inherited_name_func(ir_entity *ent, ir_type *clss);
+typedef ident *mangle_inherited_name_func(const ir_entity *ent, const ir_type *clss);
/** Resolve implicit inheritance.
*
/** Compute transitive closure of the subclass/superclass and
* overwrites/overwrittenby relation.
*
- * This function walks over the ir (O(#types+#entities)) to compute the
+ * This function walks over the ir (O(\#types+\#entities)) to compute the
* transitive closure. */
void compute_inh_transitive_closure(void);
* relation. Example: (A)(new C()).
* any: Cast operations do not conform with the transitive inheritance
* relation. Example: (B2)(new B1())
- *
- * @see: tropt.h
*/
/* ----------------------------------------------------------------------- */
ir_class_casts_normalized = 2, /**< Class casts conform to inheritance edges. */
ir_class_casts_state_max
} ir_class_cast_state;
-char *get_class_cast_state_string(ir_class_cast_state s);
+const char *get_class_cast_state_string(ir_class_cast_state s);
void set_irg_class_cast_state(ir_graph *irg, ir_class_cast_state s);
-ir_class_cast_state get_irg_class_cast_state(ir_graph *irg);
+ir_class_cast_state get_irg_class_cast_state(const ir_graph *irg);
void set_irp_class_cast_state(ir_class_cast_state s);
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 warning if state is to low
+ * Asserts if state is to high, outputs debug warning if state is to low
* and firm verbosity is set.
*/
void verify_irg_class_cast_state(ir_graph *irg);
#define TR_VRFY() tr_vrfy()
#endif
-/**
- *
- * @file typegmod.h
- * This module supplies routines that support changing the type graph.
- */
-
-/** Replaces one type by the other.
- *
- * Old type is replaced by new_type. All references to old_type
- * now point to new_type. The memory for the old type is destroyed,
- * but still used. Therefore it is not freed.
- * All referenced to this memory will be lost after a certain while.
- * An exception is the list of types in irp (irprog.h).
- * In the future there might be a routine to recover the memory, but
- * this will be at considerable runtime cost.
- *
- * @param old_type - The old type that shall be replaced by the new type.
- * @param new_type - The new type that will replace old_type.
- *
- */
-void exchange_types(ir_type *old_type, ir_type *new_type);
-
-/** Skip id types until a useful type is reached.
- *
- * @param tp - A type of arbitrary kind.
- *
- * @return
- * tp if it is not an id type.
- * If tp is an id type returns the real type it stands for.
- */
-ir_type *skip_tid(ir_type *tp);
-
/**
* @page type representation of types
*
* Types are different from the modes defined in irmode: Types are
* on the level of the programming language, modes at the level of
* the target processor.
- *
- * @see tpop.h
*/
-#include "typerep.h"
-
/** Frees all entities associated with a type.
* Does not free the array entity.
* Warning: ensure these entities are not referenced anywhere else.
const char *get_type_tpop_name(const ir_type *tp);
tp_opcode get_type_tpop_code(const ir_type *tp);
-ident *get_type_ident(const ir_type *tp);
-void set_type_ident(ir_type *tp, ident* id);
-const char *get_type_name(const ir_type *tp);
-
-/** 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.
+/**
+ * construct a string representing the type.
+ * This uses the info retrieved by the type_dbg_info if available.
+ * Otherwise it tries to create an approximate textual representation of the
+ * type.
+ * Keep in mind that this representation is not unique for each type,
+ * might abstract away some details. The main intention of this is creating
+ * human redable strings giving an idea of the type.
*/
-ir_visibility get_type_visibility(const ir_type *tp);
-void set_type_visibility(ir_type *tp, ir_visibility v);
-
-
+void ir_print_type(char *buffer, size_t buffer_size, const ir_type *tp);
/** The state of the type layout. */
typedef enum {
* @param tp The type.
* @param db The debug info.
*/
-void set_type_dbg_info(ir_type *tp, dbg_info *db);
+void set_type_dbg_info(ir_type *tp, type_dbg_info *db);
/**
* Returns the debug information of a type.
*
* @param tp The type.
*/
-dbg_info *get_type_dbg_info(const ir_type *tp);
+type_dbg_info *get_type_dbg_info(const ir_type *tp);
/**
* Checks whether a pointer points to a type.
* - 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 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.
+ * (i.e., the same C-struct to represent the type.
* This is to avoid endless recursions; with pointer types cyclic
* type graphs are possible.)
*/
*
* - supertypes: A list of direct superclasses.
*
- * - peculiarity: The peculiarity of this class. If the class is of peculiarity
- * "description" it only is a description of requirements to a class,
- * as, e.g., a Java interface. The class will never be allocated.
- * Peculiarity 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.
- *
* - 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
ir_type *new_type_class(ident *name);
/** Creates a new class type with debug information. */
-ir_type *new_d_type_class(ident *name, dbg_info *db);
+ir_type *new_d_type_class(ident *name, type_dbg_info *db);
/* --- manipulate private fields of class type --- */
+/** return identifier of the class type */
+ident *get_class_ident(const ir_type *clss);
+
+/** return identifier of the class type */
+const char *get_class_name(const ir_type *clss);
+
/** Adds the entity as member of the class. */
void add_class_member(ir_type *clss, ir_entity *member);
#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)
-#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)
-
-/** Returns a human readable string for a peculiarity. */
-const char *get_peculiarity_name(ir_peculiarity p);
-
-/** Returns the peculiarity of the class. */
-ir_peculiarity get_class_peculiarity(const ir_type *clss);
-/** Sets the peculiarity of the class. */
-void set_class_peculiarity(ir_type *clss, ir_peculiarity pec);
-
/** Returns the type info entity of a class. */
ir_entity *get_class_type_info(const ir_type *clss);
/** Creates a new type struct */
ir_type *new_type_struct(ident *name);
/** Creates a new type struct with debug information. */
-ir_type *new_d_type_struct(ident *name, dbg_info* db);
+ir_type *new_d_type_struct(ident *name, type_dbg_info* db);
/* --- manipulate private fields of struct --- */
+/** return struct identifier */
+ident *get_struct_ident(const ir_type *strct);
+
+/** return struct identifier as c-string*/
+const char *get_struct_name(const ir_type *strct);
+
/** Adds the entity as member of the struct. */
void add_struct_member(ir_type *strct, ir_entity *member);
/** Create a new method type.
*
- * @param name the name (ident) of this type
* @param n_param the number of parameters
* @param n_res the number of results
*
* The arrays for the parameter and result types are not initialized by
* the constructor.
*/
-ir_type *new_type_method(ident *name, int n_param, int n_res);
+ir_type *new_type_method(int n_param, int n_res);
/** Create a new method type with debug information.
*
- * @param name the name (ident) of this type
* @param n_param the number of parameters
* @param n_res the number of results
* @param db user defined debug information
* 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);
-
-/** 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);
+ir_type *new_d_type_method(int n_param, int n_res, type_dbg_info *db);
/* -- manipulate private fields of method. -- */
/** Returns an entity that represents the copied value argument. Only necessary
for compounds passed by value. This information is constructed only on demand. */
ir_entity *get_method_value_param_ent(ir_type *method, int pos);
+/**
+ * Sets the type that represents the copied value arguments.
+ */
+void set_method_value_param_type(ir_type *method, ir_type *tp);
/**
* Returns a type that represents the copied value arguments if one
* was allocated, else NULL.
* variable amount of arguments (e.g. C's printf). Default is
* non_variadic.
*/
-typedef enum variadicity {
- variadicity_non_variadic, /**< non variadic */
- variadicity_variadic /**< variadic */
-} variadicity;
+typedef enum ir_variadicity {
+ variadicity_non_variadic, /**< non variadic */
+ variadicity_variadic /**< variadic */
+} ir_variadicity;
/** Returns the null-terminated name of this variadicity. */
-const char *get_variadicity_name(variadicity vari);
+const char *get_variadicity_name(ir_variadicity vari);
/** Returns the variadicity of a method. */
-variadicity get_method_variadicity(const ir_type *method);
+ir_variadicity get_method_variadicity(const ir_type *method);
/** Sets the variadicity of a method. */
-void set_method_variadicity(ir_type *method, variadicity vari);
+void set_method_variadicity(ir_type *method, ir_variadicity vari);
/**
* Returns the first variadic parameter index of a type.
ir_type *new_type_union(ident *name);
/** Creates a new type union with debug information. */
-ir_type *new_d_type_union(ident *name, dbg_info* db);
+ir_type *new_d_type_union(ident *name, type_dbg_info* db);
/* --- manipulate private fields of struct --- */
+/** return union identifier */
+ident *get_union_ident(const ir_type *uni);
+
+/** return union identifier as c-string */
+const char *get_union_name(const ir_type *uni);
+
/** Returns the number of unioned types of this union */
int get_union_n_members(const ir_type *uni);
* The entity for array elements is built automatically.
* Set dimension sizes after call to constructor with set_* routines.
*/
-ir_type *new_type_array(ident *name, int n_dims, ir_type *element_type);
+ir_type *new_type_array(int n_dims, ir_type *element_type);
/** Create a new type array with debug information.
*
* Set dimension sizes after call to constructor with set_* routines.
* A legal array type must have at least one dimension set.
*/
-ir_type *new_d_type_array(ident *name, int n_dims, ir_type *element_type, dbg_info* db);
+ir_type *new_d_type_array(int n_dims, ir_type *element_type, type_dbg_info* db);
/* --- manipulate private fields of array type --- */
void set_array_element_type(ir_type *array, ir_type* tp);
/** Gets the array element type. */
-ir_type *get_array_element_type(ir_type *array);
+ir_type *get_array_element_type(const ir_type *array);
/** Sets the array element entity. */
void set_array_element_entity(ir_type *array, ir_entity *ent);
ir_type *new_type_enumeration(ident *name, int n_enums);
/** Create a new type enumeration with debug information -- set the enumerators independently. */
-ir_type *new_d_type_enumeration(ident *name, int n_enums, dbg_info *db);
+ir_type *new_d_type_enumeration(ident *name, int n_enums, type_dbg_info *db);
/* --- manipulate fields of enumeration type. --- */
+/** return enumeration identifier */
+ident *get_enumeration_ident(const ir_type *enumeration);
+
+/** return enumeration identifier as c-string */
+const char *get_enumeration_name(const ir_type *enumeration);
+
/** Set an enumeration constant to a enumeration type at a given position. */
void set_enumeration_const(ir_type *enumeration, int pos, ident *nameid, tarval *con);
void set_enumeration_nameid(ir_enum_const *enum_cnst, ident *id);
/** Returns the assigned ident of an enumeration constant. */
-ident *get_enumeration_nameid(const ir_enum_const *enum_cnst);
+ident *get_enumeration_const_nameid(const ir_enum_const *enum_cnst);
/** Returns the assigned name of an enumeration constant. */
-const char *get_enumeration_name(const ir_enum_const *enum_cnst);
+const char *get_enumeration_const_name(const ir_enum_const *enum_cnst);
/** Returns true if a type is a enumeration type. */
int is_Enumeration_type(const ir_type *enumeration);
/**
* @page pointer_type Representation of a pointer type
*
- * 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. */
-ir_type *new_type_pointer(ident *name, ir_type *points_to, ir_mode *ptr_mode);
+ir_type *new_type_pointer(ir_type *points_to);
/** Creates a new type pointer with debug information. */
-ir_type *new_d_type_pointer(ident *name, ir_type *points_to, ir_mode *ptr_mode, dbg_info* db);
+ir_type *new_d_type_pointer(ir_type *points_to, type_dbg_info* db);
/* --- manipulate fields of type_pointer --- */
/** Sets the type to which a pointer points to. */
-void set_pointer_points_to_type(ir_type *pointer, ir_type *tp);
+void set_pointer_points_to_type(ir_type *pointer, ir_type *tp);
/** Returns the type to which a pointer points to. */
-ir_type *get_pointer_points_to_type(ir_type *pointer);
+ir_type *get_pointer_points_to_type(const ir_type *pointer);
/** Returns true if a type is a pointer type. */
int is_Pointer_type(const ir_type *pointer);
/** Returns the first pointer type that has as points_to tp.
- * Not efficient: O(#types).
+ * Not efficient: O(\#types).
* If not found returns firm_unknown_type. */
ir_type *find_pointer_type_to_type(ir_type *tp);
* important information they carry is held in the common mode field.
*/
/** Creates a new primitive type. */
-ir_type *new_type_primitive(ident *name, ir_mode *mode);
+ir_type *new_type_primitive(ir_mode *mode);
/** Creates a new primitive type with debug information. */
-ir_type *new_d_type_primitive(ident *name, ir_mode *mode, dbg_info* db);
+ir_type *new_d_type_primitive(ir_mode *mode, type_dbg_info* db);
/** Returns true if a type is a primitive type. */
int is_Primitive_type(const ir_type *primitive);
/** Return the base type of a primitive (bitfield) type or NULL if none. */
-ir_type *get_primitive_base_type(ir_type *tp);
+ir_type *get_primitive_base_type(const ir_type *tp);
/** Sets the base type of a primitive (bitfield) type. */
void set_primitive_base_type(ir_type *tp, ir_type *base_tp);
/** A variable that contains the only none type. */
extern ir_type *firm_none_type;
+/** A variable that contains the only code type. */
+extern ir_type *firm_code_type;
+
/** Returns the none type. */
ir_type *get_none_type(void);
+/** Returns the code type. */
+ir_type *get_code_type(void);
/**
* @page unknown_type The Unknown type
/* --- Support for compound types --- */
+/**
+ * Gets the identifier of a compound type
+ */
+ident *get_compound_ident(const ir_type *tp);
+
+/** return compound identifier as c-string */
+const char *get_compound_name(const ir_type *tp);
+
/**
* Gets the number of elements in a Firm compound type.
*
* @param pos The number of the member.
*
* @return The member entity at position pos.
- *
- * @see get_compound_n_members() for justification of existence.
*/
ir_entity *get_compound_member(const ir_type *tp, int pos);
/** Returns index of member in tp, -1 if not contained. */
int get_compound_member_index(const ir_type *tp, ir_entity *member);
+/**
+ * layout members of a struct/union or class type in a default way.
+ */
+void default_layout_compound_type(ir_type *tp);
+
/**
* Checks whether a type is a compound type.
*
*/
int is_compound_type(const ir_type *tp);
+/**
+ * Checks wether a type is a code type.
+ */
+int is_code_type(const ir_type *tp);
+
/**
* Checks, whether a type is a frame type.
*/
*/
int is_lowered_type(const ir_type *tp);
+/**
+ * Makes a new value type. Value types are struct types,
+ * so all struct access functions work.
+ * Value types are not in the global list of types.
+ */
+ir_type *new_type_value(void);
+
/**
* 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.
*/
-ir_type *new_type_frame(ident *name);
+ir_type *new_type_frame(void);
/**
* Makes a clone of a frame type.
/* ------------------------------------------------------------------------ */
-/** Type for a function that computes a hash value for a type.
- *
- * @param tp The type to compute a hash for.
- */
-typedef int (hash_types_func_t)(ir_type *tp);
-
/** Computes a hash value by the type name.
*
* Uses the name of the type and the type opcode to compute the hash.
*/
ir_type *mature_type_free_entities(ir_type *tp);
-/**
- * The interface type for the type identify module;
- */
-typedef struct _type_identify_if_t {
- compare_types_func_t *cmp; /**< The function that should be used to compare two types.
- If NULL, compare_strict() will be used. */
- hash_types_func_t *hash; /**< The function that should be used to calculate a hash
- value of a type. If NULL, hash_name() will be used. */
-} type_identify_if_t;
-
-/**
- * Initialise the type identifier module.
- *
- * @param ti_if The interface functions for this module.
- *
- * If the parameter ti_if is NULL, the default functions compare_strict() and
- * firm_hash_name() will be used.
- */
-void init_type_identify(type_identify_if_t *ti_if);
-
/** A data type to treat types and entities as the same. */
typedef union {
ir_type *typ; /**< points to a type */
* Does not touch frame types or types for value params ... */
void type_walk(type_walk_func *pre, type_walk_func *post, void *env);
+/** Touches every type, entity, frame type, and value param type in
+ * unspecified order (also all segment types). */
+void type_walk_prog(type_walk_func *pre, type_walk_func *post, void *env);
+
/** Walks over all type information reachable from an ir graph.
*
* Walks over all type information reachable from irg, i.e., starts a
Then iterates to subclasses. Executes post after return from
subclass.
Does not visit global type, frame types.
-
- @bug ?? something is wrong with this.
*/
void class_walk_super2sub(class_walk_func *pre, class_walk_func *post,
void *env);
*/
void types_calc_finalization(void);
+/** @deprecated */
+ir_visibility get_type_visibility(const ir_type *tp);
+/** @deprecated */
+void set_type_visibility(ir_type *tp, ir_visibility v);
+
+/** @deprecated */
+typedef enum {
+ allocation_automatic,
+ allocation_parameter,
+ allocation_dynamic,
+ allocation_static
+} ir_allocation;
+/** @deprecated */
+ir_allocation get_entity_allocation(const ir_entity *ent);
+/** @deprecated */
+void set_entity_allocation(ir_entity *ent, ir_allocation al);
+
+/** @deprecated */
+typedef enum {
+ peculiarity_existent,
+ peculiarity_description,
+ peculiarity_inherited
+} ir_peculiarity;
+/** @deprecated */
+ir_peculiarity get_entity_peculiarity(const ir_entity *ent);
+/** @deprecated */
+void set_entity_peculiarity(ir_entity *ent, ir_peculiarity pec);
+
+/** @deprecated */
+int is_entity_final(const ir_entity *ent);
+/** @deprecated */
+void set_entity_final(ir_entity *ent, int final);
+
+/** @deprecated */
+ir_peculiarity get_class_peculiarity(const ir_type *clss);
+/** @deprecated */
+void set_class_peculiarity(ir_type *clss, ir_peculiarity pec);
+
#endif