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 _ENTITY_T_H_
  39 # define _ENTITY_T_H_
  40
  41 #include "firm_common_t.h"
  42
  43 # include "entity.h"
  44 # include "typegmod.h"
  45 # include "mangle.h"
  46
  47
  48 /** A path in a compund graph. */
  49 struct compound_graph_path {
  50   firm_kind kind;       /**< dynamic type tag for compound graph path. */
  51   type *tp;             /**< The type this path belongs to. */
  52   int len;              /**< length of the path */
  53   int *arr_indicees;    /**< List of array indicees.  To compute position of
  54                              array elements */
  55   entity *nodes[1];     /**< List of entities of length len to express the
  56                              access path. */
  57 };
  58
  59 /** the type of an entity */
  60 struct entity {
  61   firm_kind kind;       /**< dynamic type tag for entity. */
  62   ident *name;          /**< name of this entity */
  63   ident *ld_name;       /**< Unique name of this entity, i.e., the mangled
  64                            name.  If the field is read before written a default
  65                            magling is applies.  The name of the owner is prepended
  66                            to the name of the entity, separated by a underscore.
  67                            E.g.,  for a class `A' with field `a' this
  68                            is the ident for `A_a'. */
  69   type *type;           /**< The type of this entity, e.g., a method type, a
  70                            basic type of the language or a class itself */
  71   type *owner;          /**< The compound type (e.g. class type) this entity belongs to. */
  72   ent_allocation allocation;  /**< Distinguishes static and dynamically allocated
  73                  entities and some further cases. */
  74   ent_visibility visibility;  /**< Specifies visibility to external program
  75                  fragments */
  76   ent_variability variability;  /**< Specifies variability of entities content */
  77   ent_volatility volatility;    /**< Specifies volatility of entities content */
  78   ent_stickyness stickyness;    /**< Specifies whether this entity is sticky  */
  79   int  offset;          /**< Offset in bits for this entity.  Fixed when layout
  80                            of owner is determined.  */
  81   void *link;           /**< To store some intermediate information */
  82   unsigned long visit;  /**< visited counter for walks of the type information */
  83   struct dbg_info* dbi;    /**< A pointer to information for debug support. */
  84
  85   /* ------------- fields for atomic entities  ---------------*/
  86
  87   ir_node *value;            /**< value if entity is not of variability uninitialized.
  88                                Only for atomic entities. */
  89
  90   /* ------------- fields for compound entities ---------------*/
  91
  92   ir_node **values;     /**< constant values of compound entities. Only available if
  93                            variablility not uninitialized.  Must be set for variability constant
  94                            */
  95   compound_graph_path **val_paths; /**< paths corresponding to constant values. Only available if
  96                                       variablility not uninitialized.  Must be set for variability constant */
  97
  98   /* ------------- fields for entities owned by a class type ---------------*/
  99
 100   entity **overwrites;     /**< A list of entities this entity overwrites. */
 101   entity **overwrittenby;  /**< A list of entities that overwrite this entity.  */
 102
 103   /* ------------- fields for methods ---------------*/
 104
 105   enum peculiarity peculiarity;
 106   ir_graph *irg;        /**< If (type == method_type) this is the corresponding irg.
 107                            The ir_graph constructor automatically sets this field.
 108                            Yes, it must be here. */
 109
 110   /* ------------- fields for analyses ---------------*/
 111
 112   ir_node **accesses;                      /**< accessing nodes: loads, stores. */
 113
 114 #ifdef DEBUG_libfirm
 115   int nr;             /**< a unique node number for each node to make output
 116                          readable. */
 117 #endif
 118 };
 119
 120 /* ----------------------- inline functions ------------------------ */
 121 static INLINE int
 122 __is_entity(void *thing) {
 123   return get_kind(thing) == k_entity;
 124 }
 125
 126 static INLINE const char *
 127 __get_entity_name(entity *ent) {
 128   assert(ent && ent->kind == k_entity);
 129   return get_id_str(get_entity_ident(ent));
 130 }
 131
 132 static INLINE ident *
 133 __get_entity_ident(entity *ent) {
 134   assert(ent && ent->kind == k_entity);
 135   return ent->name;
 136 }
 137
 138 static INLINE type *
 139 __get_entity_owner(entity *ent) {
 140   assert(ent && ent->kind == k_entity);
 141   return ent->owner = skip_tid(ent->owner);
 142 }
 143
 144 static INLINE ident *
 145 __get_entity_ld_ident(entity *ent)
 146 {
 147   assert(ent && ent->kind == k_entity);
 148   if (ent->ld_name == NULL)
 149     ent->ld_name = mangle_entity(ent);
 150   return ent->ld_name;
 151 }
 152
 153 static INLINE void
 154 __set_entity_ld_ident(entity *ent, ident *ld_ident) {
 155   assert(ent && ent->kind == k_entity);
 156   ent->ld_name = ld_ident;
 157 }
 158
 159 static INLINE const char *
 160 __get_entity_ld_name(entity *ent) {
 161   assert(ent && ent->kind == k_entity);
 162   return get_id_str(get_entity_ld_ident(ent));
 163 }
 164
 165 static INLINE type *
 166 __get_entity_type(entity *ent) {
 167   assert(ent && ent->kind == k_entity);
 168   return ent->type = skip_tid(ent->type);
 169 }
 170
 171 static INLINE void
 172 __set_entity_type(entity *ent, type *type) {
 173   assert(ent && ent->kind == k_entity);
 174   ent->type = type;
 175 }
 176
 177 static INLINE ent_allocation
 178 __get_entity_allocation(entity *ent) {
 179   assert(ent && ent->kind == k_entity);
 180   return ent->allocation;
 181 }
 182
 183 static INLINE void
 184 __set_entity_allocation(entity *ent, ent_allocation al) {
 185   assert(ent && ent->kind == k_entity);
 186   ent->allocation = al;
 187 }
 188
 189 static INLINE ent_visibility
 190 __get_entity_visibility(entity *ent) {
 191   assert(ent && ent->kind == k_entity);
 192   return ent->visibility;
 193 }
 194
 195 static INLINE ent_variability
 196 __get_entity_variability(entity *ent) {
 197   assert(ent && ent->kind == k_entity);
 198   return ent->variability;
 199 }
 200
 201 static INLINE ent_volatility
 202 __get_entity_volatility(entity *ent) {
 203   assert(ent && ent->kind == k_entity);
 204   return ent->volatility;
 205 }
 206
 207 static INLINE void
 208 __set_entity_volatility(entity *ent, ent_volatility vol) {
 209   assert(ent && ent->kind == k_entity);
 210   ent->volatility = vol;
 211 }
 212
 213 static INLINE peculiarity
 214 __get_entity_peculiarity(entity *ent) {
 215   assert(ent && ent->kind == k_entity);
 216   return ent->peculiarity;
 217 }
 218
 219 /**
 220  * @todo why peculiarity only for methods
 221  */
 222 static INLINE void
 223 __set_entity_peculiarity(entity *ent, peculiarity pec) {
 224   assert(ent && ent->kind == k_entity);
 225   /* @@@ why peculiarity only for methods? */
 226   assert(is_method_type(ent->type));
 227   ent->peculiarity = pec;
 228 }
 229
 230 static INLINE ent_stickyness
 231 __get_entity_stickyness(entity *ent) {
 232   assert(ent && ent->kind == k_entity);
 233   return ent->stickyness;
 234 }
 235
 236 static INLINE void
 237 __set_entity_stickyness(entity *ent, ent_stickyness stickyness)
 238 {
 239   assert(ent && ent->kind == k_entity);
 240   ent->stickyness = stickyness;
 241 }
 242
 243 static INLINE int
 244 __get_entity_offset_bits(entity *ent) {
 245   assert(ent && ent->kind == k_entity);
 246   return ent->offset;
 247 }
 248
 249 static INLINE int
 250 __get_entity_offset_bytes(entity *ent) {
 251   int bits = __get_entity_offset_bits(ent);
 252
 253   if (bits & 7) return -1;
 254   return bits >> 3;
 255 }
 256
 257 static INLINE void
 258 __set_entity_offset_bits(entity *ent, int offset) {
 259   assert(ent && ent->kind == k_entity);
 260   ent->offset = offset;
 261 }
 262
 263 static INLINE void
 264 __set_entity_offset_bytes(entity *ent, int offset) {
 265   __set_entity_offset_bits(ent, offset * 8);
 266 }
 267
 268 static INLINE void *
 269 __get_entity_link(entity *ent) {
 270   assert(ent && ent->kind == k_entity);
 271   return ent->link;
 272 }
 273
 274 static INLINE void
 275 __set_entity_link(entity *ent, void *l) {
 276   assert(ent && ent->kind == k_entity);
 277   ent->link = l;
 278 }
 279
 280 static INLINE ir_graph *
 281 __get_entity_irg(entity *ent) {
 282   assert(ent && ent->kind == k_entity);
 283   assert(is_method_type(ent->type));
 284   return ent->irg;
 285 }
 286
 287 #define is_entity(thing)                        __is_entity(thing)
 288 #define get_entity_name(ent)                    __get_entity_name(ent)
 289 #define get_entity_ident(ent)                   __get_entity_ident(ent)
 290 #define get_entity_owner(ent)                   __get_entity_owner(ent)
 291 #define get_entity_ld_ident(ent)                __get_entity_ld_ident(ent)
 292 #define set_entity_ld_ident(ent, ld_ident)      __set_entity_ld_ident(ent, ld_ident)
 293 #define get_entity_ld_name(ent)                 __get_entity_ld_name(ent)
 294 #define get_entity_type(ent)                    __get_entity_type(ent)
 295 #define set_entity_type(ent, type)              __set_entity_type(ent, type)
 296 #define get_entity_allocation(ent)              __get_entity_allocation(ent)
 297 #define set_entity_allocation(ent, al)          __set_entity_allocation(ent, al)
 298 #define get_entity_visibility(ent)              __get_entity_visibility(ent)
 299 #define get_entity_variability(ent)             __get_entity_variability(ent)
 300 #define get_entity_volatility(ent)              __get_entity_volatility(ent)
 301 #define set_entity_volatility(ent, vol)         __set_entity_volatility(ent, vol)
 302 #define get_entity_peculiarity(ent)             __get_entity_peculiarity(ent)
 303 #define set_entity_peculiarity(ent, pec)        __set_entity_peculiarity(ent, pec)
 304 #define get_entity_stickyness(ent)              __get_entity_stickyness(ent)
 305 #define set_entity_stickyness(ent, stickyness)  __set_entity_stickyness(ent, stickyness)
 306 #define get_entity_offset_bits(ent)             __get_entity_offset_bits(ent)
 307 #define get_entity_offset_bytes(ent)            __get_entity_offset_bytes(ent)
 308 #define set_entity_offset_bits(ent, offset)     __set_entity_offset_bits(ent, offset)
 309 #define set_entity_offset_bytes(ent, offset)    __set_entity_offset_bytes(ent, offset)
 310 #define get_entity_link(ent)                    __get_entity_link(ent)
 311 #define set_entity_link(ent, l)                 __set_entity_link(ent, l)
 312 #define get_entity_irg(ent)                     __get_entity_irg(ent)
 313
 314 # endif /* _ENTITY_T_H_ */