- BugFix: arguments AND globals are not automatically alias free

[libfirm] / include / libfirm / typerep.h

diff --git a/include/libfirm/typerep.h b/include/libfirm/typerep.h
index 7ab96d4..efe353e 100644 (file)
--- a/include/libfirm/typerep.h
+++ b/include/libfirm/typerep.h
@@ -233,7 +233,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 +279,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);
@@ -444,6 +450,9 @@ typedef enum 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 )
  */
@@ -548,6 +557,9 @@ void set_compound_ent_value(ir_entity *ent, ir_node *val, ir_entity *member, int
 /** 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);
 
@@ -1675,14 +1687,6 @@ void remove_class_supertype(ir_type *clss, ir_type *supertype);
 #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);
 
@@ -1860,6 +1864,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.
@@ -1896,19 +1904,19 @@ ir_type *get_method_value_res_type(const ir_type *method);
  * 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.
@@ -2375,6 +2383,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.
@@ -2561,6 +2576,10 @@ 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, 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
@@ -2601,8 +2620,6 @@ void type_walk_super(type_walk_func *pre, type_walk_func *post, void *env);
    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);