Added FuncCall Node, a call to a procedure that did NOT change the memory

[libfirm] / ir / tr / entity.h

diff --git a/ir/tr/entity.h b/ir/tr/entity.h
index 8d96727..72ac0bf 100644 (file)
--- a/ir/tr/entity.h
+++ b/ir/tr/entity.h
@@ -212,16 +212,16 @@ void      set_entity_type (entity *ent, type *tp);
 
 /** The allocation type. */
 typedef enum {
-  automatic_allocated, /**< The entity is allocated during runtime, implicitly
-                         as component of a compound type.   This is the default. */
-  parameter_allocated, /**< The entity is a parameter.  It is also automatic allocated.
-                         We distinguish the allocation of paramters from the allocation
-                         of local variables as their placement depends on the calling
-                         conventions. */
-  dynamic_allocated,   /**< The entity is allocated during runtime, explicitly
-                         by an Alloc node. */
-  static_allocated     /**< The entity is allocated statically.  We can use a
-                          SymConst(?) as address of the entity. */
+  allocation_automatic, /**< The entity is allocated during runtime, implicitly
+                            as component of a compound type.   This is the default. */
+  allocation_parameter, /**< The entity is a parameter.  It is also automatic allocated.
+                            We distinguish the allocation of paramters from the allocation
+                            of local variables as their placement depends on the calling
+                            conventions. */
+  allocation_dynamic,   /**< The entity is allocated during runtime, explicitly
+                            by an Alloc node. */
+  allocation_static     /**< The entity is allocated statically.  We can use a
+                             Const as address of the entity. */
 } ent_allocation;
 
 /** Returns the allocation type of an entity. */
@@ -230,7 +230,7 @@ ent_allocation get_entity_allocation (entity *ent);
 /** Sets the allocation type of an entity. */
 void           set_entity_allocation (entity *ent, ent_allocation al);
 
-/** Return the name of the visibility */
+/** Return the name of the allocation type. */
 const char *get_allocation_name(ent_allocation vis);
 
 /**
@@ -238,14 +238,14 @@ const char *get_allocation_name(ent_allocation vis);
  * for partial compilation.
  */
 typedef enum {
-  local,              /**< The entity is only visible locally.  This is the default. */
-  external_visible,   /**< The entity is visible to other external program parts, but
-                        it is defined here.  It may not be optimized away.  The entity must
-                        be static_allocated. */
-  external_allocated  /**< The entity is defined and allocated externally.  This compilation
-                        must not allocate memory for this entity. The entity must
-                        be static_allocated.  This can also be an external defined
-                        method. */
+  visibility_local,              /**< The entity is only visible locally.  This is the default. */
+  visibility_external_visible,   /**< The entity is visible to other external program parts, but
+                                     it is defined here.  It may not be optimized away.  The entity must
+                                     be static_allocated. */
+  visibility_external_allocated  /**< The entity is defined and allocated externally.  This compilation
+                                     must not allocate memory for this entity. The entity must
+                                     be static_allocated.  This can also be an external defined
+                                     method. */
 } ent_visibility;
 
 /** Returns the visibility of an entity. */
@@ -259,13 +259,13 @@ const char *get_visibility_name(ent_visibility vis);
 
 /** This enumeration flags the variability of entities. */
 typedef enum {
-  uninitialized,    /**< The content of the entity is completely unknown. */
-  initialized,      /**< After allocation the entity is initalized with the
-                      value given somewhere in the entity. */
-  part_constant,    /**< For entities of compound types.  Some members of the entity
-                      are constant.  The others are uninitialized.  Those members
-                      given a value for are constant. */
-  constant          /**< The entity is constant. */
+  variability_uninitialized,    /**< The content of the entity is completely unknown. */
+  variability_initialized,      /**< After allocation the entity is initalized with the
+                                    value given somewhere in the entity. */
+  variability_part_constant,    /**< For entities of compound types.  Some members of the entity
+                                    are constant.  The others are uninitialized.  Those members
+                                    given a value for are constant. */
+  variability_constant          /**< The entity is constant. */
 } ent_variability;
 
 /** Returns the variability of an entity. */
@@ -279,8 +279,8 @@ const char *get_variability_name(ent_variability var);
 
 /** This enumeration flags the volatility of entities. */
 typedef enum {
-  non_volatile,    /**< The entity is not volatile */
-  is_volatile      /**< The entity is volatile */
+  volatility_non_volatile,    /**< The entity is not volatile */
+  volatility_is_volatile      /**< The entity is volatile */
 } ent_volatility;
 
 /** Returns the volatility of an entity. */
@@ -322,6 +322,9 @@ void        set_entity_peculiarity (entity *ent, peculiarity pec);
 const char *get_peculiarity_name(peculiarity var);
 
 /* -- Representation of constant values of entites -- */
+/** Returns true if the the node is representable as code on
+ *  const_code_irg. */
+int      is_irn_const_expression(ir_node *n);
 /* Set current_ir_graph to get_const_code_irg() to generate a constant
    expression. */
 /* Copies a firm subgraph that complies to the restrictions for