X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=include%2Flibfirm%2Ftyperep.h;h=9b081f8c255399b5a238049a9e99b33acec4f543;hb=e2e929ea04eb563b5fffadfd84bd61eb1f85735f;hp=5dbc3fb8423b8cdc5abb902e601aa6345915ea56;hpb=71ac39d709c0e8baef0fcda635f2708e43a1ac7e;p=libfirm

diff --git a/include/libfirm/typerep.h b/include/libfirm/typerep.h
index 5dbc3fb84..9b081f8c2 100644
--- a/include/libfirm/typerep.h
+++ b/include/libfirm/typerep.h
@@ -16,6 +16,11 @@
  * 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
 
@@ -233,7 +238,7 @@ ir_allocation get_entity_allocation(const ir_entity *ent);
 void set_entity_allocation(ir_entity *ent, ir_allocation al);
 
 /** Return the name of the allocation type. */
-const char *get_allocation_name(ir_allocation vis);
+const char *get_allocation_name(ir_allocation al);
 
 /** Returns the visibility of an entity. */
 ir_visibility get_entity_visibility(const ir_entity *ent);
@@ -279,17 +284,23 @@ void set_entity_volatility(ir_entity *ent, ir_volatility vol);
 /** Return the name of the volatility. */
 const char *get_volatility_name(ir_volatility var);
 
+/** Returns alignment of entity in bytes */
+unsigned get_entity_alignment(const ir_entity *entity);
+
+/** Sets alignment for entity in bytes */
+void set_entity_alignment(ir_entity *entity, unsigned alignment);
+
 /** This enumeration flags the align of Loads/Stores. */
 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. */
+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 */
+void set_entity_aligned(ir_entity *ent, ir_align a);
 
 /** Return the name of the alignment. */
 const char *get_align_name(ir_align a);
@@ -354,6 +365,11 @@ 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);
 
@@ -481,73 +497,6 @@ void set_initializer_compound_value(ir_initializer_t *initializer,
 ir_initializer_t *get_initializer_compound_value(
 		const ir_initializer_t *initializer, unsigned index);
 
-/** Creates a new compound graph path of given length. */
-compound_graph_path *new_compound_graph_path(ir_type *tp, int length);
-
-/** 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);
 
@@ -557,34 +506,6 @@ 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
@@ -622,7 +543,7 @@ int is_entity(const void *thing);
 /** 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,
@@ -631,13 +552,6 @@ int is_compound_entity(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);
-
 /** 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.
@@ -714,7 +628,8 @@ ir_type *get_entity_repr_class(const ir_entity *ent);
  * - 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. */
@@ -742,8 +657,6 @@ typedef enum acc_bits {
  *  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
  */
 
 /**
@@ -760,10 +673,10 @@ typedef enum {
 	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;
 
 /**
@@ -772,7 +685,7 @@ typedef enum {
  * 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;
 
@@ -793,14 +706,6 @@ const char *get_tpop_name(const tp_op *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.
  *
@@ -810,8 +715,8 @@ ident *get_tpop_ident(const tp_op *op);
  * 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
@@ -822,8 +727,8 @@ tp_op *get_tpop_class(void);
  * 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.
@@ -832,8 +737,8 @@ tp_op *get_tpop_struct(void);
  * 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.
@@ -842,8 +747,8 @@ tp_op *get_tpop_method(void);
  * 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.
@@ -853,8 +758,8 @@ tp_op *get_tpop_union(void);
  * 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.
@@ -865,8 +770,8 @@ tp_op *get_tpop_array(void);
  * 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.
@@ -875,8 +780,8 @@ tp_op *get_tpop_enumeration(void);
  * 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.
@@ -886,28 +791,14 @@ tp_op *get_tpop_pointer(void);
  * 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.
@@ -917,8 +808,8 @@ tp_op *get_tpop_id(void);
  * 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.
@@ -928,8 +819,8 @@ tp_op *get_tpop_none(void);
  * 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.          */
@@ -987,7 +878,7 @@ ir_entity *resolve_ent_polymorphy(ir_type *dynamic_class, ir_entity* static_ent)
  *
  *  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.
  *
@@ -996,7 +887,7 @@ ident *default_mangle_inherited_name(ir_entity *ent, ir_type *clss);
  *                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.
  *
@@ -1051,7 +942,7 @@ inh_transitive_closure_state get_irp_inh_transitive_closure_state(void);
 /** 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);
 
@@ -1103,8 +994,6 @@ ir_entity *get_entity_trans_overwrites_next(const ir_entity *ent);
  *   relation. Example: (A)(new C()).
  * any:  Cast operations do not conform with the transitive inheritance
  *   relation.  Example: (B2)(new B1())
- *
- *  @see: tropt.h
  */
 /* ----------------------------------------------------------------------- */
 
@@ -1121,16 +1010,16 @@ typedef enum {
 	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);
@@ -1192,38 +1081,6 @@ int tr_vrfy(void);
 #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
  *
@@ -1243,12 +1100,8 @@ ir_type *skip_tid(ir_type *tp);
  *  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.
@@ -1471,7 +1324,7 @@ int is_type(const void *thing);
  *      - 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.)
  */
@@ -1858,6 +1711,10 @@ void set_method_param_type(ir_type *method, int pos, ir_type *tp);
 /** 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.
@@ -2239,7 +2096,7 @@ ir_type *get_pointer_points_to_type(ir_type *pointer);
 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);
 
@@ -2285,8 +2142,13 @@ 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
@@ -2358,6 +2220,11 @@ int get_compound_member_index(const ir_type *tp, ir_entity *member);
  */
 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.
  */
@@ -2373,6 +2240,13 @@ int is_value_param_type(const ir_type *tp);
  */
 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(ident *name);
+
 /**
  * Makes a new frame type. Frame types are class types,
  * so all class access functions work.
@@ -2513,26 +2387,6 @@ ir_type *mature_type_free(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 */
@@ -2559,11 +2413,9 @@ typedef void class_walk_func(ir_type *clss, void *env);
  *  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, and frame types in unspecified order.  If new
- *  types/entities are created during the traversal these will
- *  be visited, too.
- *  Does not touch types for value params ... (??) */
-void type_walk_plus_frames(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.
  *