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  *   offset     The offset of the entity within the compound object.  Only set
  87  *              if IR in the state "@@@"  Wie nennen wir den??
  88  *   overwrites A list of entities overwritten by this entity.  This list is only
  89  *              existent if the owner of this entity is a class.  The members in
  90  *              this list must be entities of super classes.
  91  *   link       A void* to associate some additional inforamtion with the entity.
  92  *   irg        If the entity is a method this is the ir graph that represents the
  93  *              code of the method.
  94  *
  95  *
  96  *  These fields can only be accessed via access functions.
  97  *
  98  * SEE ALSO
  99  *   type
 100  * SOURCE
 101  */
 102
 103 #ifndef _ENTITY_TYPEDEF_
 104 #define _ENTITY_TYPEDEF_
 105 /* to resolve recursion between entity.h and type.h */
 106 typedef struct entity entity;
 107 #endif
 108
 109 /* Creates a new entity.
 110    Automatically inserts the entity as a member of owner. */
 111 entity     *new_entity (type *owner, ident *name, type *type);
 112 /* Copies the entity if the new_owner is different from the
 113    owner of the old entity.  Else returns the old entity.
 114    Automatically inserts the new entity as a member of owner. */
 115 entity     *copy_entity_own (entity *old, type *new_owner);
 116 /* Copies the entity if the new_name is different from the
 117    name of the old entity.  Else returns the old entity.
 118    Automatically inserts the new entity as a member of owner.
 119    The mangled name ld_name is set to NULL. */
 120 entity     *copy_entity_name (entity *old, ident *new_name);
 121
 122 /** manipulate fields of entity **/
 123 const char *get_entity_name     (entity *ent);
 124 ident      *get_entity_ident    (entity *ent);
 125 /* returns the mangled name of the entity.  If the mangled name is
 126    set it returns the existing name.  Else it generates a name
 127    with mangle_entity() and remembers this new name internally. */
 128 ident      *get_entity_ld_ident (entity *ent);
 129 void        set_entity_ld_ident (entity *ent, ident *ld_ident);
 130
 131 /*
 132 char       *get_entity_ld_name  (entity *ent);
 133 void        set_entity_ld_name  (entity *ent, char *ld_name);
 134 */
 135
 136 type       *get_entity_owner (entity *ent);
 137 /* Sets the owner field in entity to owner. */
 138 void        set_entity_owner (entity *ent, type *owner);
 139 inline void assert_legal_owner_of_ent(type *owner);
 140
 141 type     *get_entity_type (entity *ent);
 142 void      set_entity_type (entity *ent, type *type);
 143
 144 typedef enum {
 145   dynamic_allocated,  /* The entity is allocated during runtime, either explicitly
 146                          by an Alloc node or implicitly as component of a compound
 147                          type.  This is the default. */
 148   static_allocated    /* The entity is allocated statically.  We can use a
 149                           SymConst as address of the entity. */
 150 } ent_allocation;
 151
 152 ent_allocation get_entity_allocation (entity *ent);
 153 void           set_entity_allocation (entity *ent, ent_allocation al);
 154
 155 /* This enumeration flags the visibility of entities.  This is necessary
 156    for partial compilation. */
 157 typedef enum {
 158   local,              /* The entity is only visible locally.  This is the default. */
 159   external_visible,   /* The entity is visible to other external program parts, but
 160                          it is defined here.  It may not be optimized away.  The entity must
 161                          be static_allocated. */
 162   external_allocated  /* The entity is defined and allocated externaly.  This compilation
 163                          must not allocate memory for this entity. The entity must
 164                          be static_allocated. */
 165 } ent_visibility;
 166
 167 ent_visibility get_entity_visibility (entity *ent);
 168 void           set_entity_visibility (entity *ent, ent_visibility vis);
 169
 170 int       get_entity_offset (entity *ent);
 171 void      set_entity_offset (entity *ent, int offset);
 172
 173 /* Overwrites is a field that specifies that an access to the overwritten
 174    entity in the supertype must use this entity.  It's a list as with
 175    multiple inheritance several enitites can be overwritten.  This field
 176    is mostly useful for method entities.
 177    If a Sel node selects an entity that is overwritten by other entities it
 178    must return a pointer to the entity of the dynamic type of the pointer
 179    that is passed to it.  Lowering of the Sel node must assure this. */
 180 void    add_entity_overwrites   (entity *ent, entity *overwritten);
 181 int     get_entity_n_overwrites (entity *ent);
 182 entity *get_entity_overwrites   (entity *ent, int pos);
 183 void    set_entity_overwrites   (entity *ent, int pos, entity *overwritten);
 184 /* Do we need a second relation "overwritten"? */
 185
 186 /* A link to store intermediate information */
 187 void*   get_entity_link(entity *ent);
 188 void    set_entity_link(entity *ent, void *l);
 189
 190 /* The entity knows the corresponding irg if the entity is a method.
 191    This allows to get from a Call to the called irg. */
 192 ir_graph *get_entity_irg(entity *ent);
 193 void      set_entity_irg(entity *ent, ir_graph *irg);
 194
 195
 196
 197 /*****/
 198
 199 # endif /* _ENTITY_H_ */