/**
* @file
- * Declarations for functions and datastructures to represent types
+ * @brief Declarations for functions and datastructures to represent types
*/
#ifndef FIRM_TYPEREP_H
#define FIRM_TYPEREP_H
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);
/** 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
/** 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);
/** Returns true if the type of the entity is a class, structure,
/** 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);
-
/** Outputs a unique number for this entity if libfirm is compiled for
* debugging, (configure with --enable-debug) else returns the address
* of the type cast to long.
* - 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.
*
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.
- */
-extern const tp_op *type_id;
-const tp_op *get_tpop_id(void);
-
/**
* The code type is used to mark pieces of code (basic blocks)
*/
/** 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
*/
/* ----------------------------------------------------------------------- */
#define TR_VRFY() tr_vrfy()
#endif
-/** 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.
* - 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.)
*/
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);
*/
ir_type *mature_type_free_entities(ir_type *tp);
-/**
- * The interface type for the type identify module;
- */
-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. */
-};
-
-/**
- * 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 */
projects / libfirm / blobdiff