nsz Git - libfirm/blob - ir/tr/entity.h

   1 /*
   2 **  Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
   3 **  All rights reserved.
   4 **
   5 **  Authors: Martin Trapp, Christian Schaefer,
   6 **           Goetz Lindenmaier
   7 **
   8 **  entity.h:  entities represent all program known objects.
   9 **
  10 **  An entity is the representation of program known objects in Firm.
  11 **  The primary concept of entities is to represent members of complex
  12 **  types, i.e., fields and methods of classes.  As not all programming
  13 **  language model all variables and methods as members of some class,
  14 **  the concept of entities is extended to cover also local and global
  15 **  variables, and arbitrary procedures.
  16 **
  17 **  An entity always specifies the type of the object it represents and
  18 **  the type of the object it is a part of, the owner of the entity.
  19 **  Originally this is the type of the class of which the entity is a
  20 **  member.
  21 **  The owner of local variables is the procedure they are defined in.
  22 **  The owner of global variables and procedures visible in the whole
  23 **  program is a universally defined class type "GlobalType".  The owner
  24 **  of procedures defined in the scope of an other procedure is the
  25 **  enclosing procedure.
  26 **
  27 **  In detail the datastructure entity has the following fields:
  28 **
  29 **  ident *name     Name of this entity as specified in the source code.
  30 **                  Only unequivocal in conjuction with scope.
  31 **  ident *ld_name  Unique name of this entity, i.e., the mangled
  32 **                  name.  E.g., for a class `A' with field `a' this
  33 **                  is the ident for `A_a'.
  34 **  type *type      The type of this entity, e.g., a method type, a
  35 **                  basic type of the language or a class itself.
  36 **  type *owner;    The class this entity belongs to.  In case of local
  37 **                  variables the method they are defined in.
  38 **  int offset;     Offset in byte for this entity.  Fixed when layout
  39 **                  of owner is determined.
  40 **  ir_graph *irg;  If (type == method_type) this is the corresponding irg.
  41 **                  The ir_graph constructor automatically sets this field.
  42 **                  If (type !- method_type) access of this field will cause
  43 **                  an assertion.
  44 */
  45
  46 /* $Id$ */
  47
  48 # ifndef _ENTITY_H_
  49 # define _ENTITY_H_
  50
  51 # include "ident.h"
  52 # include "type.h"
  53
  54 /*******************************************************************/
  55 /** general                                                       **/
  56 /*******************************************************************/
  57
  58 /* initalize entity module */
  59 void init_entity (void);
  60
  61 /*******************************************************************/
  62 /** ENTITY                                                        **/
  63 /*******************************************************************/
  64
  65 #ifndef _IR_GRAPH_TYPEDEF_
  66 #define _IR_GRAPH_TYPEDEF_
  67 /* to resolve recursion between entity.h and irgraph.h */
  68 typedef struct ir_graph ir_graph;
  69 #endif
  70
  71 /****s* entity/entity
  72  *
  73  * NAME
  74  *   entity - An abstract data type to represent program entites.
  75  * NOTE
  76  *
  77  * ATTRIBUTES
  78  *   owner      A compound type this entity is a part of.
  79  *   type       The type of this entity.
  80  *   name       The string that represents this entity in the source program.
  81  *   allocation A flag saying whether the entity is dynamically or statically
  82  *              allocated (values: dynamic_allocated,  static_allocated).
  83  *              @@@ Does this make sense???
  84  *   visibility A flag indicating the visibility of this entity (values: local,
  85  *              external_visible,  external_allocated)
  86  *   variability A flag indicating the variability of this entity (values:
  87  *              uninitialized, initalized, part_constant, constant)
  88  *   offset     The offset of the entity within the compound object.  Only set
  89  *              if IR in the state "@@@"  Wie nennen wir den??
  90  *   overwrites A list of entities overwritten by this entity.  This list is only
  91  *              existent if the owner of this entity is a class.  The members in
  92  *              this list must be entities of super classes.
  93  *   link       A void* to associate some additional inforamtion with the entity.
  94  *   irg        If the entity is a method this is the ir graph that represents the
  95  *              code of the method.
  96  *
  97  *
  98  *  These fields can only be accessed via access functions.
  99  *
 100  * SEE ALSO
 101  *   type
 102  * SOURCE
 103  */
 104
 105 #ifndef _ENTITY_TYPEDEF_
 106 #define _ENTITY_TYPEDEF_
 107 /* to resolve recursion between entity.h and type.h */
 108 typedef struct entity entity;
 109 #endif
 110
 111 /* Creates a new entity.
 112    Automatically inserts the entity as a member of owner. */
 113 entity     *new_entity (type *owner, ident *name, type *type);
 114 /* Copies the entity if the new_owner is different from the
 115    owner of the old entity.  Else returns the old entity.
 116    Automatically inserts the new entity as a member of owner. */
 117 entity     *copy_entity_own (entity *old, type *new_owner);
 118 /* Copies the entity if the new_name is different from the
 119    name of the old entity.  Else returns the old entity.
 120    Automatically inserts the new entity as a member of owner.
 121    The mangled name ld_name is set to NULL. */
 122 entity     *copy_entity_name (entity *old, ident *new_name);
 123
 124 /** manipulate fields of entity **/
 125 const char *get_entity_name     (entity *ent);
 126 ident      *get_entity_ident    (entity *ent);
 127 /* returns the mangled name of the entity.  If the mangled name is
 128    set it returns the existing name.  Else it generates a name
 129    with mangle_entity() and remembers this new name internally. */
 130 ident      *get_entity_ld_ident (entity *ent);
 131 void        set_entity_ld_ident (entity *ent, ident *ld_ident);
 132 const char *get_entity_ld_name (entity *end);
 133
 134 /*
 135 char       *get_entity_ld_name  (entity *ent);
 136 void        set_entity_ld_name  (entity *ent, char *ld_name);
 137 */
 138
 139 type       *get_entity_owner (entity *ent);
 140 /* Sets the owner field in entity to owner. */
 141 void        set_entity_owner (entity *ent, type *owner);
 142 inline void assert_legal_owner_of_ent(type *owner);
 143
 144 type     *get_entity_type (entity *ent);
 145 void      set_entity_type (entity *ent, type *type);
 146
 147 typedef enum {
 148   automatic_allocated,/* The entity is allocated during runtime, implicitly
 149                          as component of a compound type.   This is the default. */
 150   dynamic_allocated,  /* The entity is allocated during runtime, explicitly
 151                          by an Alloc node. */
 152   static_allocated    /* The entity is allocated statically.  We can use a
 153                          SymConst(?) as address of the entity. */
 154 } ent_allocation;
 155
 156 ent_allocation get_entity_allocation (entity *ent);
 157 void           set_entity_allocation (entity *ent, ent_allocation al);
 158
 159 /* This enumeration flags the visibility of entities.  This is necessary
 160    for partial compilation. */
 161 typedef enum {
 162   local,              /* The entity is only visible locally.  This is the default. */
 163   external_visible,   /* The entity is visible to other external program parts, but
 164                          it is defined here.  It may not be optimized away.  The entity must
 165                          be static_allocated. */
 166   external_allocated  /* The entity is defined and allocated externaly.  This compilation
 167                          must not allocate memory for this entity. The entity must
 168                          be static_allocated. */
 169 } ent_visibility;
 170
 171 ent_visibility get_entity_visibility (entity *ent);
 172 void           set_entity_visibility (entity *ent, ent_visibility vis);
 173
 174 /* This enumeration flags the variability of entities. */
 175 typedef enum {
 176   uninitialized,    /* The content of the entity is completely unknown. */
 177   initialized,       /* After allocation the entity is initalized with the
 178                        value given somewhere in the entity. */
 179   part_constant,    /* For entities of compound types.  Some members of the entity
 180                        are constant.  The others are uninitialized.  Those members
 181                        given a value for are constant. */
 182   constant          /* The entity is constant. */
 183 } ent_variability;
 184
 185 ent_variability get_entity_variability (entity *ent);
 186 void            set_entity_variability (entity *ent, ent_variability var);
 187
 188 /* This enumeration flags the volatility of entities. */
 189 typedef enum {
 190   non_volatile,    /* The entity is not volatile */
 191   is_volatile      /* The entity is volatile */
 192 } ent_volatility;
 193
 194 ent_volatility get_entity_volatility (entity *ent);
 195 void           set_entity_volatility (entity *ent, ent_volatility vol);
 196
 197 /* Set has no effect for entities of type method. */
 198 ir_node *get_atomic_ent_value(entity *ent);
 199 void     set_atomic_ent_value(entity *ent, ir_node *val);
 200 /* Copies the value represented by the entity to current_block
 201    in current_ir_graph. */
 202 ir_node *copy_atomic_ent_value(entity *ent);
 203
 204 /* A value of a compound entity is a pair of value and the corresponding
 205    member of the compound. */
 206 void     add_compound_ent_value(entity *ent, ir_node *val, entity *member);
 207 int      get_compound_ent_n_values(entity *ent);
 208 ir_node *get_compound_ent_value(entity *ent, int pos);
 209 entity  *get_compound_ent_value_member(entity *ent, int pos);
 210 void     set_compound_ent_value(entity *ent, ir_node *val, entity *member, int pos);
 211 /* Copies the value pos of the entity to current_block in current_ir_graph. */
 212 ir_node *copy_compound_ent_value(entity *ent, int pos);
 213
 214 /* Only set if layout = fixed. */
 215 int       get_entity_offset (entity *ent);
 216 void      set_entity_offset (entity *ent, int offset);
 217
 218 /* Overwrites is a field that specifies that an access to the overwritten
 219    entity in the supertype must use this entity.  It's a list as with
 220    multiple inheritance several enitites can be overwritten.  This field
 221    is mostly useful for method entities.
 222    If a Sel node selects an entity that is overwritten by other entities it
 223    must return a pointer to the entity of the dynamic type of the pointer
 224    that is passed to it.  Lowering of the Sel node must assure this. */
 225 void    add_entity_overwrites   (entity *ent, entity *overwritten);
 226 int     get_entity_n_overwrites (entity *ent);
 227 entity *get_entity_overwrites   (entity *ent, int pos);
 228 void    set_entity_overwrites   (entity *ent, int pos, entity *overwritten);
 229 /* Do we need a second relation "overwritten"? */
 230
 231 /* A link to store intermediate information */
 232 void*   get_entity_link(entity *ent);
 233 void    set_entity_link(entity *ent, void *l);
 234
 235 /* The entity knows the corresponding irg if the entity is a method.
 236    This allows to get from a Call to the called irg. */
 237 ir_graph *get_entity_irg(entity *ent);
 238 void      set_entity_irg(entity *ent, ir_graph *irg);
 239
 240
 241 /* Returns true if the type of the entity is a primitive, pointer
 242    enumeration or method type. */
 243 int is_atomic_entity(entity *ent);
 244 /* Returns true if the type of the entity is a class, structure,
 245    array or union type. */
 246 int is_compound_entity(entity *ent);
 247
 248
 249 /*****/
 250
 251 # endif /* _ENTITY_H_ */