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);
/** 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);
/** 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);
/** 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 )
*/
/** 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);
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 */
* 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
* This struct is dynamically allocated but constant for the lifetime
* of the library.
*/
-extern tp_op *type_id;
-tp_op *get_tpop_id(void);
+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)
+ */
+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.
*
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);
/** 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.
/** 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
*/
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(ident *name);
+
/**
* Makes a new frame type. Frame types are class types,
* so all class access functions work.
* 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
projects / libfirm / blobdiff