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

   1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
   2 ** All rights reserved.
   3 **
   4 ** Authors: Martin Trapp, Christian Schaefer
   5 **
   6 */
   7
   8 /* $Id$ */
   9
  10 #ifdef HAVE_CONFIG_H
  11 # include <config.h>
  12 #endif
  13
  14 # include <stdlib.h>
  15 # include <stddef.h>
  16 # include "entity_t.h"
  17 # include "mangle.h"
  18 # include "typegmod_t.h"
  19 # include "array.h"
  20 /* All this is needed to build the constant node for methods: */
  21 # include "irprog.h"
  22 # include "ircons.h"
  23
  24 /*******************************************************************/
  25 /** general                                                       **/
  26 /*******************************************************************/
  27
  28 void
  29 init_entity (void)
  30 {
  31 }
  32
  33 /*******************************************************************/
  34 /** ENTITY                                                        **/
  35 /*******************************************************************/
  36
  37 inline void insert_entity_in_owner (entity *ent) {
  38   type *owner = ent->owner;
  39   switch (get_type_tpop_code(owner)) {
  40   case tpo_class: {
  41     add_class_member (owner, ent);
  42   } break;
  43   case tpo_struct: {
  44     add_struct_member (owner, ent);
  45   } break;
  46   case tpo_union: {
  47     add_union_member (owner, ent);
  48   } break;
  49   case tpo_array: {
  50     set_array_element_entity(owner, ent);
  51   } break;
  52   default: assert(0);
  53   }
  54 }
  55
  56 entity *
  57 new_entity (type *owner, ident *name, type *type)
  58 {
  59   entity *res;
  60   ir_graph *rem;
  61
  62   res = (entity *) malloc (sizeof (entity));
  63   res->kind = k_entity;
  64   assert_legal_owner_of_ent(owner);
  65   res->owner = owner;
  66   res->name = name;
  67   res->type = type;
  68   res->allocation = dynamic_allocated;
  69   res->visibility = local;
  70   if (is_method_type(type)) {
  71     res->variability = constant;
  72     rem = current_ir_graph;
  73     current_ir_graph = get_const_code_irg();
  74     res->value = new_Const(mode_p, tarval_p_from_entity(res));
  75     current_ir_graph = rem;
  76   } else {
  77     res->variability = uninitialized;
  78   }
  79   res->ld_name = NULL;
  80   res->overwrites = NEW_ARR_F(entity *, 1);
  81
  82   res->visit = 0;
  83
  84   /* Remember entity in it's owner. */
  85   insert_entity_in_owner (res);
  86   return res;
  87 }
  88 inline void free_entity_attrs(entity *ent) {
  89   assert(ent);
  90   DEL_ARR_F(ent->overwrites);
  91 }
  92
  93 entity *
  94 copy_entity_own (entity *old, type *new_owner) {
  95   entity *new;
  96
  97   assert_legal_owner_of_ent(new_owner);
  98   if (old->owner == new_owner) return old;
  99   new = (entity *) malloc (sizeof (entity));
 100   memcpy (new, old, sizeof (entity));
 101   new->owner = new_owner;
 102   new->overwrites = DUP_ARR_F(entity *, old->overwrites);
 103
 104   insert_entity_in_owner (new);
 105
 106   return new;
 107 }
 108
 109 entity *
 110 copy_entity_name (entity *old, ident *new_name) {
 111   entity *new;
 112
 113   if (old->name == new_name) return old;
 114   new = (entity *) malloc (sizeof (entity));
 115   memcpy (new, old, sizeof (entity));
 116   new->name = new_name;
 117   new->ld_name = NULL;
 118   new->overwrites = DUP_ARR_F(entity *, old->overwrites);
 119
 120   insert_entity_in_owner (new);
 121
 122   return new;
 123 }
 124
 125 inline const char *
 126 get_entity_name (entity *ent) {
 127   assert (ent);
 128   return id_to_str(get_entity_ident(ent));
 129 }
 130
 131 ident *
 132 get_entity_ident    (entity *ent) {
 133   assert(ent);
 134   return ent->name;
 135 }
 136
 137 /*
 138 void   set_entity_ld_name  (entity *, char *ld_name);
 139 void   set_entity_ld_ident (entity *, ident *ld_ident);
 140 */
 141
 142 inline type *
 143 get_entity_owner (entity *ent) {
 144   return ent->owner = skip_tid(ent->owner);
 145 }
 146
 147 inline void
 148 set_entity_owner (entity *ent, type *owner) {
 149   assert_legal_owner_of_ent(owner);
 150   ent->owner = owner;
 151 }
 152
 153 inline void   /* should this go into type.c? */
 154 assert_legal_owner_of_ent(type *owner) {
 155   assert (get_type_tpop_code(owner) == tpo_class ||
 156           get_type_tpop_code(owner) == tpo_union ||
 157           get_type_tpop_code(owner) == tpo_struct ||
 158           get_type_tpop_code(owner) == tpo_array);   /* Yes, array has an entity
 159                                                         -- to select fields! */
 160 }
 161
 162 inline ident *
 163 get_entity_ld_ident (entity *ent)
 164 {
 165   if (ent->ld_name == NULL)
 166     ent->ld_name = mangle_entity (ent);
 167   return ent->ld_name;
 168 }
 169
 170 inline void
 171 set_entity_ld_ident (entity *ent, ident *ld_ident) {
 172   ent->ld_name = ld_ident;
 173 }
 174
 175 /*
 176 char  *get_entity_ld_name  (entity *);
 177 void   set_entity_ld_name  (entity *, char *ld_name);
 178 */
 179
 180 inline type *
 181 get_entity_type (entity *ent) {
 182   return ent->type = skip_tid(ent->type);
 183 }
 184
 185 inline void
 186 set_entity_type (entity *ent, type *type) {
 187   ent->type = type;
 188 }
 189
 190
 191 inline ent_allocation
 192 get_entity_allocation (entity *ent) {
 193   return ent->allocation;
 194 }
 195
 196 inline void
 197 set_entity_allocation (entity *ent, ent_allocation al) {
 198   ent->allocation = al;
 199 }
 200
 201
 202 inline ent_visibility
 203 get_entity_visibility (entity *ent) {
 204   return ent->visibility;
 205 }
 206
 207 inline void
 208 set_entity_visibility (entity *ent, ent_visibility vis) {
 209   if (vis != local) assert(ent->allocation == static_allocated);
 210   ent->visibility = vis;
 211 }
 212
 213 inline ent_variability
 214 get_entity_variability (entity *ent) {
 215   return ent->variability;
 216 }
 217
 218 inline void
 219 set_entity_variability (entity *ent, ent_variability var){
 220   if (var == part_constant)
 221     assert(is_class_type(ent->type) || is_struct_type(ent->type));
 222   if ((is_compound_type(ent->type)) &&
 223       (ent->variability == uninitialized) && (var != uninitialized)) {
 224     /* Allocate datastructures for constant values */
 225     ent->values = NEW_ARR_F(ir_node *, 1);
 226     ent->val_ents = NEW_ARR_F(entity *, 1);
 227   }
 228   if ((is_compound_type(ent->type)) &&
 229       (var == uninitialized) && (ent->variability != uninitialized)) {
 230     /* Free datastructures for constant values */
 231     DEL_ARR_F(ent->values);
 232     DEL_ARR_F(ent->val_ents);
 233   }
 234   ent->variability = var;
 235 }
 236
 237 /* Set has no effect for entities of type method. */
 238 inline ir_node *
 239 get_atomic_ent_value(entity *ent) {
 240   assert(ent); assert(is_atomic_entity(ent)); assert((ent->variability != uninitialized));
 241   return ent->value;
 242 }
 243
 244 inline void
 245 set_atomic_ent_value(entity *ent, ir_node *val) {
 246   assert(ent && is_atomic_entity(ent) && (ent->variability != uninitialized));
 247   if (is_method_type(ent->type)) return;
 248   ent->value = val;
 249 }
 250
 251
 252 /* A value of a compound entity is a pair of value and the corresponding member of
 253    the compound. */
 254 inline void
 255 add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
 256   assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized));
 257   ARR_APP1 (ir_node *, ent->values, val);
 258   ARR_APP1 (entity *, ent->val_ents, member);
 259 }
 260
 261 inline int
 262 get_compound_ent_n_values(entity *ent) {
 263   assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized));
 264   return (ARR_LEN (ent->values))-1;
 265 }
 266
 267 inline ir_node  *
 268 get_compound_ent_value(entity *ent, int pos) {
 269   assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized));
 270   return ent->values[pos+1];
 271 }
 272
 273 inline entity   *
 274 get_compound_ent_value_member(entity *ent, int pos) {
 275   assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized));
 276   return ent->val_ents[pos+1];
 277 }
 278
 279 inline void
 280 set_compound_ent_value(entity *ent, ir_node *val, entity *member, int pos) {
 281   assert(ent && is_compound_entity(ent) && (ent->variability != uninitialized));
 282   ent->values[pos+1] = val;
 283   ent->val_ents[pos+1] = member;
 284 }
 285
 286 inline int
 287 get_entity_offset (entity *ent) {
 288   return ent->offset;
 289 }
 290
 291 inline void
 292 set_entity_offset (entity *ent, int offset) {
 293   ent->offset = offset;
 294 }
 295
 296 inline void
 297 add_entity_overwrites   (entity *ent, entity *overwritten) {
 298   assert(ent);
 299   ARR_APP1 (entity *, ent->overwrites, overwritten);
 300 }
 301
 302 inline int
 303 get_entity_n_overwrites (entity *ent){
 304   assert(ent);
 305   return (ARR_LEN (ent->overwrites))-1;
 306 }
 307
 308 inline entity *
 309 get_entity_overwrites   (entity *ent, int pos){
 310   assert(ent);
 311   return ent->overwrites[pos+1];
 312 }
 313
 314 inline void
 315 set_entity_overwrites   (entity *ent, int pos, entity *overwritten) {
 316   assert(ent);
 317   ent->overwrites[pos+1] = overwritten;
 318 }
 319
 320 /* A link to store intermediate information */
 321 void *
 322 get_entity_link(entity *ent) {
 323   assert(ent);
 324   return ent->link;
 325 }
 326
 327 void
 328 set_entity_link(entity *ent, void *l) {
 329   assert(ent);
 330   ent->link = l;
 331 }
 332
 333 inline ir_graph *
 334 get_entity_irg(entity *ent) {
 335   assert (ent);
 336   assert (is_method_type(ent->type));
 337   return ent->irg;
 338 }
 339
 340 inline void
 341 set_entity_irg(entity *ent, ir_graph *irg) {
 342   assert (ent && ent->type);
 343   assert (irg);
 344   assert (is_method_type(ent->type));
 345   ent->irg = irg;
 346 }
 347
 348 int is_atomic_entity(entity *ent) {
 349   type* t = ent->type;
 350   return (is_primitive_type(t) || is_pointer_type(t) ||
 351           is_enumeration_type(t) || is_method_type(t));
 352 }
 353
 354 int is_compound_entity(entity *ent) {
 355   type* t = ent->type;
 356   return (is_class_type(t) || is_struct_type(t) ||
 357           is_array_type(t) || is_union_type(t));
 358 }