*
* - 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_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_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);
* Bitfield type indicating the way an entity is used.
*/
typedef enum {
- ir_usage_address_taken = 1 << 0,
- ir_usage_write = 1 << 1,
- ir_usage_read = 1 << 2,
- ir_usage_reinterpret_cast = 1 << 3,
+ 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
/** 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);
#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 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.
*/
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.
/**
* 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.
* 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. */
+void type_walk_plus_frames(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);