/*
- * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
* WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE.
*/
+
+/**
+ * @file
+ * Declarations for functions and datastructures to represent types
+ */
#ifndef FIRM_TYPEREP_H
#define FIRM_TYPEREP_H
*
* - 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,
+ * - 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)
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.
- */
-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_intrinsic = 0x00000040, /**< This method is intrinsic. It is expected that
- a lowering phase will remove all calls to it. */
- mtp_property_runtime = 0x00000080, /**< This method represents a runtime routine. */
- mtp_property_private = 0x00000100, /**< All method invocations are known, the backend is free to
- optimize the call in any possible way. */
- mtp_property_inherited = (1<<31) /**< Internal. Used only in irg's, means property is
- inherited from type. */
-} mtp_additional_property;
-
/**
* Creates a new entity.
*
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);
/** 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. */
+ 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. */
/** 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);
void set_entity_backend_marked(ir_entity *ent, int flag);
/**
- * The state of the address_taken flag.
+ * Bitfield type indicating the way an entity is used.
*/
typedef enum {
- ir_address_not_taken = 0, /**< The address is NOT taken. */
- ir_address_taken_unknown = 1, /**< The state of the address taken flag is unknown. */
- ir_address_taken = 2 /**< The address IS taken. */
-} ir_address_taken_state;
-
-/** Return the state of the address taken flag of an entity. */
-ir_address_taken_state get_entity_address_taken(const ir_entity *ent);
+ ir_usage_none = 0, /**< This entity is unused. */
+ ir_usage_address_taken = 1 << 0, /**< The address of this entity was taken. */
+ ir_usage_write = 1 << 1, /**< The entity was written to. */
+ ir_usage_read = 1 << 2, /**< The entity was read. */
+ ir_usage_reinterpret_cast = 1 << 3, /**< The entity was read but with a wrong mode
+ (an implicit reinterpret cast) */
+ /** Unknown access */
+ ir_usage_unknown
+ = ir_usage_address_taken | ir_usage_write | ir_usage_read
+ | ir_usage_reinterpret_cast
+} ir_entity_usage;
+
+/** Return the entity usage */
+ir_entity_usage get_entity_usage(const ir_entity *ent);
/** Sets/resets the state of the address taken flag of an entity. */
-void set_entity_address_taken(ir_entity *ent, ir_address_taken_state flag);
-
-/** Return the name of the address_taken state. */
-const char *get_address_taken_state_name(ir_address_taken_state state);
+void set_entity_usage(ir_entity *ent, ir_entity_usage flag);
/**
* Returns the debug information of an entity.
ir_node *get_atomic_ent_value(ir_entity *ent);
void set_atomic_ent_value(ir_entity *ent, ir_node *val);
+/** the kind (type) of an initializer */
+typedef enum ir_initializer_kind_t {
+ /** initializer containing an ir_node from the const-code irg */
+ IR_INITIALIZER_CONST,
+ /** initializer containing a tarval */
+ IR_INITIALIZER_TARVAL,
+ /** initializes type with default values (usually 0) */
+ IR_INITIALIZER_NULL,
+ /** list of initializers used to initializer a compound or array type */
+ IR_INITIALIZER_COMPOUND
+} ir_initializer_kind_t;
+
+/** 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_null(void);
+
+/**
+ * creates an initializer containing a reference to a node on the const-code
+ * irg.
+ */
+ir_initializer_t *create_initializer_const(ir_node *value);
+
+/** creates an initializer containing a single tarval value */
+ir_initializer_t *create_initializer_tarval(tarval *tv);
+
+/** return value contained in a const initializer */
+ir_node *get_initializer_const_value(const ir_initializer_t *initializer);
+
+/** return value contained in a tarval initializer */
+tarval *get_initializer_tarval_value(const ir_initializer_t *initialzier);
+
+/** creates a compound initializer which holds @p n_entries entries */
+ir_initializer_t *create_initializer_compound(unsigned n_entries);
+
+/** returns the number of entries in a compound initializer */
+unsigned get_initializer_compound_n_entries(const ir_initializer_t *initializer);
+
+/** sets entry with index @p index to the initializer @p value */
+void set_initializer_compound_value(ir_initializer_t *initializer,
+ unsigned index, ir_initializer_t *value);
+
+/** returns the value with index @p index of a compound 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 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);
-void set_compound_graph_path_node(compound_graph_path *gr, int pos, ir_entity *node);
-int get_compound_graph_path_array_index(const compound_graph_path *gr, int pos);
-void set_compound_graph_path_array_index(compound_graph_path *gr, int pos, int index);
+/** 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. */
/** 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
* @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.
*/
-int get_compound_ent_value_offset_bit_remainder(ir_entity *ent, int pos);
+unsigned get_compound_ent_value_offset_bit_remainder(ir_entity *ent, int pos);
/** Return the overall offset of value at position pos in bytes.
*
* @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.
*/
-int get_compound_ent_value_offset_bytes(ir_entity *ent, int pos);
+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
/** 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,
long get_entity_nr(const ir_entity *ent);
/** Returns the entities visited count. */
-unsigned long get_entity_visited(ir_entity *ent);
+ir_visited_t get_entity_visited(ir_entity *ent);
/** Sets the entities visited count. */
-void set_entity_visited(ir_entity *ent, unsigned long num);
+void set_entity_visited(ir_entity *ent, ir_visited_t num);
/** Sets visited field in entity to entity_visited. */
void mark_entity_visited(ir_entity *ent);
#define IS_WRITTEN(a) ((a) & ptr_access_write)
#define IS_STORED(a) ((a) & ptr_access_store)
-/**
- * Supported image sections.
- * Currently only methods can be placed in different sections.
- */
-typedef enum {
- section_text, /**< The code segment. This is the default for methods. */
- section_constructors /**< The constructor section. */
-} ir_img_section;
-
-/** Returns the section of a method. */
-ir_img_section get_method_img_section(const ir_entity *method);
-
-/** Sets the section of a method. */
-void set_method_img_section(ir_entity *method, ir_img_section section);
-
-
/**
* @page tyop type operations
* This module specifies the kinds of types available in firm.
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.
*
/** 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);
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
*/
void set_type_mode(ir_type *tp, ir_mode* m);
-/** Returns the size of a type in bytes, returns -1 if the size is NOT
- * a byte size, i.e. not dividable by 8. */
-int get_type_size_bytes(const ir_type *tp);
-
-/** Returns the size of a type in bits. */
-int get_type_size_bits(const ir_type *tp);
+/** Returns the size of a type in bytes. */
+unsigned get_type_size_bytes(const ir_type *tp);
/** Sets the size of a type in bytes.
*
* For primitive, enumeration, pointer and method types the size
* is always fixed. This call is legal but has no effect.
*/
-void set_type_size_bytes(ir_type *tp, int size);
+void set_type_size_bytes(ir_type *tp, unsigned size);
-/** Sets the size of a type in bits.
- *
- * For primitive, enumeration, pointer and method types the size
- * is always fixed. This call is legal but has no effect.
- */
-void set_type_size_bits(ir_type *tp, int size);
-
-/** Returns the alignment of a type in bytes.
- *
- * Returns -1 if the alignment is NOT
- * a byte size, i.e. not dividable by 8. Calls get_type_alignment_bits(). */
-int get_type_alignment_bytes(ir_type *tp);
+/** Returns the alignment of a type in bytes. */
+unsigned get_type_alignment_bytes(ir_type *tp);
/** Returns the alignment of a type in bits.
*
* -#.) compound types have the alignment of there biggest member.
* -#.) array types have the alignment of there element type.
* -#.) method types return 0 here.
- * -#.) all other types return 8 here (i.e. aligned at byte).
+ * -#.) all other types return 1 here (i.e. aligned at byte).
*/
-int get_type_alignment_bits(ir_type *tp);
-
-/** Sets the alignment of a type in bytes. */
-void set_type_alignment_bytes(ir_type *tp, int size);
-
-/** Sets the alignment of a type in bits.
- *
- * For method types the alignment is always fixed.
- * This call is legal but has no effect.
- */
-void set_type_alignment_bits(ir_type *tp, int size);
+void set_type_alignment_bytes(ir_type *tp, unsigned align);
/** Returns the visited count of a type. */
-unsigned long get_type_visited(const ir_type *tp);
+ir_visited_t get_type_visited(const ir_type *tp);
/** Sets the visited count of a type to num. */
-void set_type_visited(ir_type *tp, unsigned long num);
+void set_type_visited(ir_type *tp, ir_visited_t num);
/** Sets visited field in type to type_visited. */
void mark_type_visited(ir_type *tp);
/** Returns non-zero if the type is already visited */
*
* @see typewalk
*/
-void set_master_type_visited(unsigned long val);
-unsigned long get_master_type_visited(void);
-void inc_master_type_visited(void);
+void set_master_type_visited(ir_visited_t val);
+ir_visited_t get_master_type_visited(void);
+void inc_master_type_visited(void);
/**
* Sets the debug information of a type.
#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);
* 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);
+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);
/* -- 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.
* upper 8 encode the calling conventions.
*/
typedef enum {
- cc_reg_param = 0x01000000, /**< Transmit parameters in registers, else the stack is used.
- This flag may be set as default on some architectures. */
- cc_last_on_top = 0x02000000, /**< The last non-register parameter is transmitted on top of
- the stack. This is equivalent to the pascal
- calling convention. If this flag is not set, the first
- non-register parameter is used (stdcall or cdecl
- calling convention) */
- cc_callee_clear_stk = 0x04000000, /**< The callee clears the stack. This forbids variadic
- function calls (stdcall). */
- cc_this_call = 0x08000000, /**< The first parameter is a this pointer and is transmitted
- in a special way. */
- cc_compound_ret = 0x10000000, /**< the method returns a compound
- type */
-
- cc_bits = (0xFF << 24) /**< the calling convention bits */
+ cc_reg_param = 0x01000000, /**< Transmit parameters in registers, else the stack is used.
+ This flag may be set as default on some architectures. */
+ cc_last_on_top = 0x02000000, /**< The last non-register parameter is transmitted on top of
+ the stack. This is equivalent to the pascal
+ calling convention. If this flag is not set, the first
+ non-register parameter is used (stdcall or cdecl
+ calling convention) */
+ cc_callee_clear_stk = 0x04000000, /**< The callee clears the stack. This forbids variadic
+ function calls (stdcall). */
+ cc_this_call = 0x08000000, /**< The first parameter is a this pointer and is transmitted
+ in a special way. */
+ cc_compound_ret = 0x10000000, /**< The method returns a compound type. */
+ cc_frame_on_caller_stk = 0x20000000, /**< The method did not allocate an own stack frame, instead the
+ caller must reserve size on its own stack. */
+ cc_fpreg_param = 0x40000000, /**< Transmit floating point parameters in registers, else the stack is used. */
+ cc_bits = (0xFF << 24)/**< The calling convention bits. */
} calling_convention;
/* some often used cases: made as defines because firmjni cannot handle two
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);
/** 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.
*/
ir_type *new_type_frame(ident *name);
+/**
+ * Makes a clone of a frame type.
+ * Sets entity links from old frame entities to new onces and
+ * vice versa.
+ */
+ir_type *clone_frame_type(ir_type *type);
+
/**
* Sets a lowered type for a type. This sets both associations
* and marks lowered_type as a "lowered" one.
*
* @return the entity representing the area
*/
-ir_entity *frame_alloc_area(ir_type *frame_type, int size, int alignment, int at_start);
+ir_entity *frame_alloc_area(ir_type *frame_type, int size, unsigned alignment, int at_start);
/*-----------------------------------------------------------------*/
/** Debug aides **/
/**
* The interface type for the type identify module;
*/
-typedef struct _type_identify_if_t {
+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 tore points to the visited type or entity
* @param env free environment pointer
*/
-typedef void type_walk_func(type_or_ent *tore, void *env);
+typedef void type_walk_func(type_or_ent tore, void *env);
/** The class walk function
*
* 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);
projects / libfirm / blobdiff