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

   1 /*
   2  * Project:     libFIRM
   3  * File name:   ir/tr/entity_t.h
   4  * Purpose:     Representation of all program known entities -- private header.
   5  * Author:      Martin Trapp, Christian Schaefer
   6  * Modified by: Goetz Lindenmaier
   7  * Created:
   8  * CVS-ID:      $Id$
   9  * Copyright:   (c) 1998-2003 Universität Karlsruhe
  10  * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
  11  */
  12
  13 /**
  14  * @file entity_t.h
  15  *
  16  * entity.h:  entities represent all program known objects.
  17  *
  18  * @author Martin Trapp, Christian Schaefer, Goetz Lindenmaier
  19  *
  20  *  An entity is the representation of program known objects in Firm.
  21  *  The primary concept of entities is to represent members of complex
  22  *  types, i.e., fields and methods of classes.  As not all programming
  23  *  language model all variables and methods as members of some class,
  24  *  the concept of entities is extended to cover also local and global
  25  *  variables, and arbitrary procedures.
  26  *
  27  *  An entity always specifies the type of the object it represents and
  28  *  the type of the object it is a part of, the owner of the entity.
  29  *  Originally this is the type of the class of which the entity is a
  30  *  member.
  31  *  The owner of local variables is the procedure they are defined in.
  32  *  The owner of global variables and procedures visible in the whole
  33  *  program is a universally defined class type "GlobalType".  The owner
  34  *  of procedures defined in the scope of an other procedure is the
  35  *  enclosing procedure.
  36  */
  37
  38 #ifndef _FIRM_TR_ENTITY_T_H_
  39 #define _FIRM_TR_ENTITY_T_H_
  40
  41 #include "firm_common_t.h"
  42 #include "firm_config.h"
  43
  44 #include "type_t.h"
  45 #include "entity.h"
  46 #include "typegmod.h"
  47 #include "mangle.h"
  48 #include "pseudo_irg.h"
  49
  50 /** A path in a compound graph. */
  51 struct compound_graph_path {
  52   firm_kind kind;       /**< dynamic type tag for compound graph path. */
  53   ir_type *tp;          /**< The type this path belongs to. */
  54   int len;              /**< length of the path */
  55   struct tuple {
  56     int    index;       /**< Array index.  To compute position of array elements */
  57     entity *node;       /**< entity */
  58   } list[1];            /**< List of entity/index tuple of length len to express the
  59                              access path. */
  60 };
  61
  62 /** attributes for atomic entities */
  63 typedef struct atomic_ent_attr {
  64   ir_node *value;            /**< value if entity is not of variability uninitialized.
  65                                Only for atomic entities. */
  66 } atomic_ent_attr;
  67
  68 /** attributes for compound entities */
  69 typedef struct compound_ent_attr {
  70   ir_node **values;     /**< constant values of compound entities. Only available if
  71                              variability not uninitialized.  Must be set for variability constant. */
  72   compound_graph_path **val_paths; /**< paths corresponding to constant values. Only available if
  73                                         variability not uninitialized.  Must be set for variability constant. */
  74 } compound_ent_attr;
  75
  76 /** a reserved value for "not yet set" */
  77 #define VTABLE_NUM_NOT_SET ((unsigned)(-1))
  78
  79 /** attributes for methods */
  80 typedef struct method_ent_attr {
  81   ir_graph *irg;        /**< The corresponding irg if known.
  82                              The ir_graph constructor automatically sets this field. */
  83   unsigned irg_add_properties;   /**< Additional graph properties can be
  84                                       stored in a entity if no irg is available. */
  85
  86   unsigned vtable_number;        /**< For a dynamically called method, the number assigned
  87                                       in the virtual function table. */
  88
  89   ptr_access_kind *param_access; /**< the parameter access */
  90   float *param_weight; /**< The weight of method's parameters. Parameters
  91                           with a high weight are good for procedure cloning. */
  92 } method_ent_attr;
  93
  94
  95 /** the type of an entity */
  96 struct entity {
  97   firm_kind kind;       /**< The dynamic type tag for entity. */
  98   ident *name;          /**< The name of this entity. */
  99   ident *ld_name;       /**< Unique name of this entity, i.e., the mangled
 100                              name.  If the field is read before written a default
 101                              mangling is applies.  The name of the owner is prepended
 102                              to the name of the entity, separated by a underscore.
 103                              E.g.,  for a class `A' with field `a' this
 104                              is the ident for `A_a'. */
 105   ir_type *type;        /**< The type of this entity, e.g., a method type, a
 106                              basic type of the language or a class itself. */
 107   ir_type *owner;              /**< The compound type (e.g. class type) this entity belongs to. */
 108   ent_allocation allocation;   /**< Distinguishes static and dynamically allocated
 109                                     entities and some further cases. */
 110   visibility visibility;       /**< Specifies visibility to external program
 111                                     fragments. */
 112   ent_variability variability; /**< Specifies variability of entities content. */
 113   ent_volatility volatility;   /**< Specifies volatility of entities content. */
 114   ent_stickyness stickyness;   /**< Specifies whether this entity is sticky.  */
 115   int  offset;                 /**< Offset in bits for this entity.  Fixed when layout
 116                                     of owner is determined. */
 117   peculiarity peculiarity;     /**< The peculiarity of this entity. */
 118   unsigned long visit;         /**< visited counter for walks of the type information. */
 119   struct dbg_info *dbi;        /**< A pointer to information for debug support. */
 120   void *link;                  /**< To store some intermediate information. */
 121
 122   /* ------------- fields for entities owned by a class type ---------------*/
 123
 124   entity **overwrites;     /**< A list of entities this entity overwrites. */
 125   entity **overwrittenby;  /**< A list of entities that overwrite this entity.  */
 126
 127   /* ------------- fields for atomic entities  --------------- */
 128   ir_node *value;          /**< value if entity is not of variability uninitialized.
 129                                 Only for atomic entities. */
 130   union {
 131     /* ------------- fields for compound entities -------------- */
 132     compound_ent_attr cmpd_attr;
 133     /* ------------- fields for method entities ---------------- */
 134     method_ent_attr   mtd_attr;
 135   } attr; /**< type specific attributes */
 136
 137   /* ------------- fields for analyses ---------------*/
 138
 139 #ifdef DEBUG_libfirm
 140   long nr;             /**< A unique node number for each node to make output
 141                             readable. */
 142 # endif /* DEBUG_libfirm */
 143 };
 144
 145 /** Initialize entity module. */
 146 void firm_init_entity(void);
 147
 148
 149 /* ----------------------- inline functions ------------------------ */
 150 static INLINE int
 151 _is_entity(const void *thing) {
 152   return get_kind(thing) == k_entity;
 153 }
 154
 155 static INLINE const char *
 156 _get_entity_name(const entity *ent) {
 157   assert(ent && ent->kind == k_entity);
 158   return get_id_str(get_entity_ident(ent));
 159 }
 160
 161 static INLINE ident *
 162 _get_entity_ident(const entity *ent) {
 163   assert(ent && ent->kind == k_entity);
 164   return ent->name;
 165 }
 166
 167 static INLINE void
 168 _set_entity_ident(entity *ent, ident *id) {
 169   assert(ent && ent->kind == k_entity);
 170   ent->name = id;
 171 }
 172
 173 static INLINE ir_type *
 174 _get_entity_owner(entity *ent) {
 175   assert(ent && ent->kind == k_entity);
 176   return ent->owner = skip_tid(ent->owner);
 177 }
 178
 179 static INLINE ident *
 180 _get_entity_ld_ident(entity *ent)
 181 {
 182   assert(ent && ent->kind == k_entity);
 183   if (ent->ld_name == NULL)
 184     ent->ld_name = mangle_entity(ent);
 185   return ent->ld_name;
 186 }
 187
 188 static INLINE void
 189 _set_entity_ld_ident(entity *ent, ident *ld_ident) {
 190   assert(ent && ent->kind == k_entity);
 191   ent->ld_name = ld_ident;
 192 }
 193
 194 static INLINE const char *
 195 _get_entity_ld_name(entity *ent) {
 196   assert(ent && ent->kind == k_entity);
 197   return get_id_str(get_entity_ld_ident(ent));
 198 }
 199
 200 static INLINE ir_type *
 201 _get_entity_type(entity *ent) {
 202   assert(ent && ent->kind == k_entity);
 203   return ent->type = skip_tid(ent->type);
 204 }
 205
 206 static INLINE void
 207 _set_entity_type(entity *ent, ir_type *type) {
 208   assert(ent && ent->kind == k_entity);
 209   ent->type = type;
 210 }
 211
 212 static INLINE ent_allocation
 213 _get_entity_allocation(const entity *ent) {
 214   assert(ent && ent->kind == k_entity);
 215   return ent->allocation;
 216 }
 217
 218 static INLINE void
 219 _set_entity_allocation(entity *ent, ent_allocation al) {
 220   assert(ent && ent->kind == k_entity);
 221   ent->allocation = al;
 222 }
 223
 224 static INLINE visibility
 225 _get_entity_visibility(const entity *ent) {
 226   assert(ent && ent->kind == k_entity);
 227   return ent->visibility;
 228 }
 229
 230 static INLINE ent_variability
 231 _get_entity_variability(const entity *ent) {
 232   assert(ent && ent->kind == k_entity);
 233   return ent->variability;
 234 }
 235
 236 static INLINE ent_volatility
 237 _get_entity_volatility(const entity *ent) {
 238   assert(ent && ent->kind == k_entity);
 239   return ent->volatility;
 240 }
 241
 242 static INLINE void
 243 _set_entity_volatility(entity *ent, ent_volatility vol) {
 244   assert(ent && ent->kind == k_entity);
 245   ent->volatility = vol;
 246 }
 247
 248 static INLINE peculiarity
 249 _get_entity_peculiarity(const entity *ent) {
 250   assert(ent && ent->kind == k_entity);
 251   return ent->peculiarity;
 252 }
 253
 254 /**
 255  * @todo Why peculiarity only for methods?
 256  *       Good question.  Originally, there were only description and
 257  *       existent.  The thought was, what sense does it make to
 258  *       describe a field?  With inherited the situation changed.  So
 259  *       I removed the assertion.  GL, 28.2.05
 260  */
 261 static INLINE void
 262 _set_entity_peculiarity(entity *ent, peculiarity pec) {
 263   assert(ent && ent->kind == k_entity);
 264   /* @@@ why peculiarity only for methods? */
 265   //assert(is_Method_type(ent->type));
 266
 267   ent->peculiarity = pec;
 268 }
 269
 270 static INLINE ent_stickyness
 271 _get_entity_stickyness(const entity *ent) {
 272   assert(ent && ent->kind == k_entity);
 273   return ent->stickyness;
 274 }
 275
 276 static INLINE void
 277 _set_entity_stickyness(entity *ent, ent_stickyness stickyness)
 278 {
 279   assert(ent && ent->kind == k_entity);
 280   ent->stickyness = stickyness;
 281 }
 282
 283 static INLINE int
 284 _get_entity_offset_bits(const entity *ent) {
 285   assert(ent && ent->kind == k_entity);
 286   return ent->offset;
 287 }
 288
 289 static INLINE int
 290 _get_entity_offset_bytes(const entity *ent) {
 291   int bits = _get_entity_offset_bits(ent);
 292
 293   if (bits & 7) return -1;
 294   return bits >> 3;
 295 }
 296
 297 static INLINE void
 298 _set_entity_offset_bits(entity *ent, int offset) {
 299   assert(ent && ent->kind == k_entity);
 300   ent->offset = offset;
 301 }
 302
 303 static INLINE void
 304 _set_entity_offset_bytes(entity *ent, int offset) {
 305   _set_entity_offset_bits(ent, offset * 8);
 306 }
 307
 308 static INLINE void *
 309 _get_entity_link(const entity *ent) {
 310   assert(ent && ent->kind == k_entity);
 311   return ent->link;
 312 }
 313
 314 static INLINE void
 315 _set_entity_link(entity *ent, void *l) {
 316   assert(ent && ent->kind == k_entity);
 317   ent->link = l;
 318 }
 319
 320 static INLINE ir_graph *
 321 _get_entity_irg(const entity *ent) {
 322   assert(ent && ent->kind == k_entity);
 323   assert(ent == unknown_entity || is_Method_type(ent->type));
 324   if (!get_visit_pseudo_irgs() && ent->attr.mtd_attr.irg
 325       && is_pseudo_ir_graph(ent->attr.mtd_attr.irg))
 326     return NULL;
 327   return ent->attr.mtd_attr.irg;
 328 }
 329
 330 static INLINE unsigned long
 331 _get_entity_visited(entity *ent) {
 332   assert(ent && ent->kind == k_entity);
 333   return ent->visit;
 334 }
 335
 336 static INLINE void
 337 _set_entity_visited(entity *ent, unsigned long num) {
 338   assert(ent && ent->kind == k_entity);
 339   ent->visit = num;
 340 }
 341
 342 static INLINE void
 343 _mark_entity_visited(entity *ent) {
 344   assert(ent && ent->kind == k_entity);
 345   ent->visit = firm_type_visited;
 346 }
 347
 348 static INLINE int
 349 _entity_visited(entity *ent) {
 350   return _get_entity_visited(ent) >= firm_type_visited;
 351 }
 352
 353 static INLINE int
 354 _entity_not_visited(entity *ent) {
 355   return _get_entity_visited(ent) < firm_type_visited;
 356 }
 357
 358 #define is_entity(thing)                         _is_entity(thing)
 359 #define get_entity_name(ent)                     _get_entity_name(ent)
 360 #define get_entity_ident(ent)                    _get_entity_ident(ent)
 361 #define set_entity_ident(ent, id)                _set_entity_ident(ent, id)
 362 #define get_entity_owner(ent)                    _get_entity_owner(ent)
 363 #define get_entity_ld_ident(ent)                 _get_entity_ld_ident(ent)
 364 #define set_entity_ld_ident(ent, ld_ident)       _set_entity_ld_ident(ent, ld_ident)
 365 #define get_entity_ld_name(ent)                  _get_entity_ld_name(ent)
 366 #define get_entity_type(ent)                     _get_entity_type(ent)
 367 #define set_entity_type(ent, type)               _set_entity_type(ent, type)
 368 #define get_entity_allocation(ent)               _get_entity_allocation(ent)
 369 #define set_entity_allocation(ent, al)           _set_entity_allocation(ent, al)
 370 #define get_entity_visibility(ent)               _get_entity_visibility(ent)
 371 #define get_entity_variability(ent)              _get_entity_variability(ent)
 372 #define get_entity_volatility(ent)               _get_entity_volatility(ent)
 373 #define set_entity_volatility(ent, vol)          _set_entity_volatility(ent, vol)
 374 #define get_entity_peculiarity(ent)              _get_entity_peculiarity(ent)
 375 #define set_entity_peculiarity(ent, pec)         _set_entity_peculiarity(ent, pec)
 376 #define get_entity_stickyness(ent)               _get_entity_stickyness(ent)
 377 #define set_entity_stickyness(ent, stickyness)   _set_entity_stickyness(ent, stickyness)
 378 #define get_entity_offset_bits(ent)              _get_entity_offset_bits(ent)
 379 #define get_entity_offset_bytes(ent)             _get_entity_offset_bytes(ent)
 380 #define set_entity_offset_bits(ent, offset)      _set_entity_offset_bits(ent, offset)
 381 #define set_entity_offset_bytes(ent, offset)     _set_entity_offset_bytes(ent, offset)
 382 #define get_entity_link(ent)                     _get_entity_link(ent)
 383 #define set_entity_link(ent, l)                  _set_entity_link(ent, l)
 384 #define get_entity_irg(ent)                      _get_entity_irg(ent)
 385 #define get_entity_visited(ent)                  _get_entity_visited(ent)
 386 #define set_entity_visited(ent, num)             _set_entity_visited(ent, num)
 387 #define mark_entity_visited(ent)                 _mark_entity_visited(ent)
 388 #define entity_visited(ent)                      _entity_visited(ent)
 389 #define entity_not_visited(ent)                  _entity_not_visited(ent)
 390
 391 #endif /* _FIRM_TR_ENTITY_T_H_ */