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

   1 /*
   2  * Project:     libFIRM
   3  * File name:   ir/tr/entity.c
   4  * Purpose:     Representation of all program known entities.
   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 #include "firm_common_t.h"
  14
  15 # include <stdlib.h>
  16 # include <stddef.h>
  17 # include <string.h>
  18
  19 # include "entity_t.h"
  20 # include "mangle.h"
  21 # include "typegmod.h"
  22 # include "array.h"
  23
  24 /* All this is needed to build the constant node for methods: */
  25 # include "irprog_t.h"
  26 # include "ircons.h"
  27 # include "tv_t.h"
  28
  29 #if DEBUG_libfirm
  30 # include "irdump.h"  /* for output if errors occur. */
  31 #endif
  32
  33 # include "callgraph.h"  /* for dumping debug output */
  34
  35 /*******************************************************************/
  36 /** general                                                       **/
  37 /*******************************************************************/
  38
  39 void
  40 init_entity (void)
  41 {
  42 }
  43
  44 /*-----------------------------------------------------------------*/
  45 /* ENTITY                                                          */
  46 /*-----------------------------------------------------------------*/
  47
  48 static void insert_entity_in_owner (entity *ent) {
  49   type *owner = ent->owner;
  50   switch (get_type_tpop_code(owner)) {
  51   case tpo_class: {
  52     add_class_member (owner, ent);
  53   } break;
  54   case tpo_struct: {
  55     add_struct_member (owner, ent);
  56   } break;
  57   case tpo_union: {
  58     add_union_member (owner, ent);
  59   } break;
  60   case tpo_array: {
  61     set_array_element_entity(owner, ent);
  62   } break;
  63   default: assert(0);
  64   }
  65 }
  66
  67 entity *
  68 new_entity (type *owner, ident *name, type *type)
  69 {
  70   entity *res;
  71   ir_graph *rem;
  72
  73   assert(!id_contains_char(name, ' ') && "entity name should not contain spaces");
  74
  75   res = (entity *) xmalloc (sizeof (entity));
  76   res->kind = k_entity;
  77   assert_legal_owner_of_ent(owner);
  78   res->owner = owner;
  79   res->name = name;
  80   res->type = type;
  81
  82   if (get_type_tpop(type) == type_method)
  83     res->allocation = allocation_static;
  84   else
  85     res->allocation = allocation_automatic;
  86
  87   res->visibility = visibility_local;
  88   res->offset = -1;
  89   if (is_method_type(type)) {
  90     symconst_symbol sym;
  91     sym.entity_p = res;
  92     res->variability = variability_constant;
  93     rem = current_ir_graph;
  94     current_ir_graph = get_const_code_irg();
  95     res->value = new_SymConst(sym, symconst_addr_ent);
  96     current_ir_graph = rem;
  97   } else {
  98     res->variability = variability_uninitialized;
  99     res->value  = NULL;
 100     res->values = NULL;
 101     res->val_paths = NULL;
 102   }
 103   res->peculiarity   = peculiarity_existent;
 104   res->volatility    = volatility_non_volatile;
 105   res->stickyness    = stickyness_unsticky;
 106   res->ld_name       = NULL;
 107   if (is_class_type(owner)) {
 108     res->overwrites    = NEW_ARR_F(entity *, 0);
 109     res->overwrittenby = NEW_ARR_F(entity *, 0);
 110   } else {
 111     res->overwrites    = NULL;
 112     res->overwrittenby = NULL;
 113   }
 114   res->irg = NULL;
 115
 116   res->accesses = NULL;
 117
 118 #ifdef DEBUG_libfirm
 119   res->nr = get_irp_new_node_nr();
 120 #endif
 121
 122   res->visit = 0;
 123
 124   /* Remember entity in it's owner. */
 125   insert_entity_in_owner (res);
 126   return res;
 127 }
 128 entity *
 129 new_d_entity (type *owner, ident *name, type *type, dbg_info *db) {
 130   entity *res = new_entity(owner, name, type);
 131   set_entity_dbg_info(res, db);
 132   return res;
 133 }
 134
 135 static void free_entity_attrs(entity *ent) {
 136   int i;
 137   if (get_type_tpop(get_entity_owner(ent)) == type_class) {
 138     DEL_ARR_F(ent->overwrites);    ent->overwrites = NULL;
 139     DEL_ARR_F(ent->overwrittenby); ent->overwrittenby = NULL;
 140   } else {
 141     assert(ent->overwrites == NULL);
 142     assert(ent->overwrittenby == NULL);
 143   }
 144   /* if (ent->values) DEL_ARR_F(ent->values); *//* @@@ warum nich? */
 145   if (ent->val_paths) {
 146     if (is_compound_entity(ent))
 147       for (i = 0; i < get_compound_ent_n_values(ent); i++)
 148     if (ent->val_paths[i]) ;
 149     /* free_compound_graph_path(ent->val_paths[i]) ;  * @@@ warum nich? */
 150     /* Geht nich: wird mehrfach verwendet!!! ==> mehrfach frei gegeben. */
 151     /* DEL_ARR_F(ent->val_paths); */
 152   }
 153   ent->val_paths = NULL;
 154   ent->values = NULL;
 155 }
 156
 157 entity *
 158 copy_entity_own (entity *old, type *new_owner) {
 159   entity *new;
 160   assert(old && old->kind == k_entity);
 161   assert_legal_owner_of_ent(new_owner);
 162
 163   if (old->owner == new_owner) return old;
 164   new = (entity *) xmalloc (sizeof (entity));
 165   memcpy (new, old, sizeof (entity));
 166   new->owner = new_owner;
 167   if (is_class_type(new_owner)) {
 168     new->overwrites    = NEW_ARR_F(entity *, 0);
 169     new->overwrittenby = NEW_ARR_F(entity *, 0);
 170   }
 171 #ifdef DEBUG_libfirm
 172   new->nr = get_irp_new_node_nr();
 173 #endif
 174
 175   insert_entity_in_owner (new);
 176
 177   return new;
 178 }
 179
 180 entity *
 181 copy_entity_name (entity *old, ident *new_name) {
 182   entity *new;
 183   assert(old && old->kind == k_entity);
 184
 185   if (old->name == new_name) return old;
 186   new = (entity *) xmalloc (sizeof (entity));
 187   memcpy (new, old, sizeof (entity));
 188   new->name = new_name;
 189   new->ld_name = NULL;
 190   if (is_class_type(new->owner)) {
 191     new->overwrites    = DUP_ARR_F(entity *, old->overwrites);
 192     new->overwrittenby = DUP_ARR_F(entity *, old->overwrittenby);
 193   }
 194 #ifdef DEBUG_libfirm
 195   new->nr = get_irp_new_node_nr();
 196 #endif
 197
 198   insert_entity_in_owner (new);
 199
 200   return new;
 201 }
 202
 203
 204 void
 205 free_entity (entity *ent) {
 206   assert(ent && ent->kind == k_entity);
 207   free_entity_attrs(ent);
 208   ent->kind = k_BAD;
 209   free(ent);
 210 }
 211
 212 /* Outputs a unique number for this node */
 213 long
 214 get_entity_nr(entity *ent) {
 215   assert(ent && ent->kind == k_entity);
 216 #ifdef DEBUG_libfirm
 217   return ent->nr;
 218 #else
 219   return 0;
 220 #endif
 221 }
 222
 223 const char *
 224 (get_entity_name)(entity *ent) {
 225   return __get_entity_name(ent);
 226 }
 227
 228 ident *
 229 (get_entity_ident)(entity *ent) {
 230   return get_entity_ident(ent);
 231 }
 232
 233 /*
 234 void   set_entitye_ld_name  (entity *, char *ld_name);
 235 void   set_entity_ld_ident (entity *, ident *ld_ident);
 236 */
 237
 238 type *
 239 (get_entity_owner)(entity *ent) {
 240   return __get_entity_owner(ent);
 241 }
 242
 243 void
 244 set_entity_owner (entity *ent, type *owner) {
 245   assert(ent && ent->kind == k_entity);
 246   assert_legal_owner_of_ent(owner);
 247   ent->owner = owner;
 248 }
 249
 250 void   /* should this go into type.c? */
 251 assert_legal_owner_of_ent(type *owner) {
 252   assert(get_type_tpop_code(owner) == tpo_class ||
 253           get_type_tpop_code(owner) == tpo_union ||
 254           get_type_tpop_code(owner) == tpo_struct ||
 255       get_type_tpop_code(owner) == tpo_array);   /* Yes, array has an entity
 256                             -- to select fields! */
 257 }
 258
 259 ident *
 260 (get_entity_ld_ident)(entity *ent) {
 261   return __get_entity_ld_ident(ent);
 262 }
 263
 264 void
 265 (set_entity_ld_ident)(entity *ent, ident *ld_ident) {
 266    __set_entity_ld_ident(ent, ld_ident);
 267 }
 268
 269 const char *
 270 (get_entity_ld_name)(entity *ent) {
 271   return __get_entity_ld_name(ent);
 272 }
 273
 274 type *
 275 (get_entity_type)(entity *ent) {
 276   return __get_entity_type(ent);
 277 }
 278
 279 void
 280 (set_entity_type)(entity *ent, type *type) {
 281   __set_entity_type(ent, type);
 282 }
 283
 284 ent_allocation
 285 (get_entity_allocation)(entity *ent) {
 286   return __get_entity_allocation(ent);
 287 }
 288
 289 void
 290 (set_entity_allocation)(entity *ent, ent_allocation al) {
 291   __set_entity_allocation(ent, al);
 292 }
 293
 294 /* return the name of the visibility */
 295 const char *get_allocation_name(ent_allocation all)
 296 {
 297 #define X(a)    case a: return #a
 298   switch (all) {
 299     X(allocation_automatic);
 300     X(allocation_parameter);
 301     X(allocation_dynamic);
 302     X(allocation_static);
 303     default: return "BAD VALUE";
 304   }
 305 #undef X
 306 }
 307
 308
 309 ent_visibility
 310 (get_entity_visibility)(entity *ent) {
 311   return __get_entity_visibility(ent);
 312 }
 313
 314 void
 315 set_entity_visibility (entity *ent, ent_visibility vis) {
 316   assert(ent && ent->kind == k_entity);
 317   if (vis != visibility_local)
 318     assert((ent->allocation == allocation_static) ||
 319        (ent->allocation == allocation_automatic));
 320   /* @@@ Test that the owner type is not local, but how??
 321          && get_class_visibility(get_entity_owner(ent)) != local));*/
 322   ent->visibility = vis;
 323 }
 324
 325 /* return the name of the visibility */
 326 const char *get_visibility_name(ent_visibility vis)
 327 {
 328 #define X(a)    case a: return #a
 329   switch (vis) {
 330     X(visibility_local);
 331     X(visibility_external_visible);
 332     X(visibility_external_allocated);
 333     default: return "BAD VALUE";
 334   }
 335 #undef X
 336 }
 337
 338 ent_variability
 339 (get_entity_variability)(entity *ent) {
 340   return __get_entity_variability(ent);
 341 }
 342
 343 void
 344 set_entity_variability (entity *ent, ent_variability var)
 345 {
 346   assert(ent && ent->kind == k_entity);
 347   if (var == variability_part_constant)
 348     assert(is_class_type(ent->type) || is_struct_type(ent->type));
 349
 350   if ((is_compound_type(ent->type)) &&
 351       (ent->variability == variability_uninitialized) && (var != variability_uninitialized)) {
 352     /* Allocate datastructures for constant values */
 353     ent->values    = NEW_ARR_F(ir_node *, 0);
 354     ent->val_paths = NEW_ARR_F(compound_graph_path *, 0);
 355   }
 356   if ((is_atomic_type(ent->type)) &&
 357       (ent->variability == variability_uninitialized) && (var != variability_uninitialized)) {
 358     /* Set default constant value. */
 359     ent->value = new_rd_Unknown(get_const_code_irg(), get_type_mode(ent->type));
 360   }
 361
 362   if ((is_compound_type(ent->type)) &&
 363       (var == variability_uninitialized) && (ent->variability != variability_uninitialized)) {
 364     /* Free datastructures for constant values */
 365     DEL_ARR_F(ent->values);    ent->values    = NULL;
 366     DEL_ARR_F(ent->val_paths); ent->val_paths = NULL;
 367   }
 368   ent->variability = var;
 369 }
 370
 371 /* return the name of the variablity */
 372 const char *get_variability_name(ent_variability var)
 373 {
 374 #define X(a)    case a: return #a
 375   switch (var) {
 376     X(variability_uninitialized);
 377     X(variability_initialized);
 378     X(variability_part_constant);
 379     X(variability_constant);
 380     default: return "BAD VALUE";
 381   }
 382 #undef X
 383 }
 384
 385 ent_volatility
 386 (get_entity_volatility)(entity *ent) {
 387   return __get_entity_volatility(ent);
 388 }
 389
 390 void
 391 (set_entity_volatility)(entity *ent, ent_volatility vol) {
 392   __set_entity_volatility(ent, vol);
 393 }
 394
 395 /* return the name of the volatility */
 396 const char *get_volatility_name(ent_volatility var)
 397 {
 398 #define X(a)    case a: return #a
 399   switch (var) {
 400     X(volatility_non_volatile);
 401     X(volatility_is_volatile);
 402     default: return "BAD VALUE";
 403   }
 404 #undef X
 405 }
 406
 407 peculiarity
 408 (get_entity_peculiarity)(entity *ent) {
 409   return __get_entity_peculiarity(ent);
 410 }
 411
 412 void
 413 (set_entity_peculiarity)(entity *ent, peculiarity pec) {
 414   __set_entity_peculiarity(ent, pec);
 415 }
 416
 417 /* return the name of the peculiarity */
 418 const char *get_peculiarity_name(peculiarity var)
 419 {
 420 #define X(a)    case a: return #a
 421   switch (var) {
 422     X(peculiarity_description);
 423     X(peculiarity_inherited);
 424     X(peculiarity_existent);
 425     default: return "BAD VALUE";
 426   }
 427 #undef X
 428 }
 429
 430 /* Get the entity's stickyness */
 431 ent_stickyness
 432 (get_entity_stickyness)(entity *ent) {
 433   return __get_entity_stickyness(ent);
 434 }
 435
 436 /* Set the entity's stickyness */
 437 void
 438 (set_entity_stickyness)(entity *ent, ent_stickyness stickyness) {
 439   __set_entity_stickyness(ent, stickyness);
 440 }
 441
 442 /* Set has no effect for existent entities of type method. */
 443 ir_node *
 444 get_atomic_ent_value(entity *ent)
 445 {
 446   assert(ent && is_atomic_entity(ent));
 447   assert(ent->variability != variability_uninitialized);
 448   return skip_Id (ent->value);
 449 }
 450
 451 void
 452 set_atomic_ent_value(entity *ent, ir_node *val) {
 453   assert(is_atomic_entity(ent) && (ent->variability != variability_uninitialized));
 454   if (is_method_type(ent->type) && (ent->peculiarity == peculiarity_existent))
 455     return;
 456   ent->value = val;
 457 }
 458
 459 /* Returns true if the the node is representable as code on
 460  *  const_code_irg. */
 461 int is_irn_const_expression(ir_node *n) {
 462   ir_mode *m;
 463
 464   m = get_irn_mode(n);
 465   switch(get_irn_opcode(n)) {
 466   case iro_Const:
 467   case iro_SymConst:
 468   case iro_Unknown:
 469     return true; break;
 470   case iro_Add:
 471   case iro_Sub:
 472   case iro_Mul:
 473   case iro_And:
 474   case iro_Or:
 475   case iro_Eor:
 476     if (is_irn_const_expression(get_binop_left(n)))
 477       return is_irn_const_expression(get_binop_right(n));
 478   case iro_Conv:
 479   case iro_Cast:
 480     return is_irn_const_expression(get_irn_n(n, 0));
 481   default:
 482     return false;
 483     break;
 484   }
 485   return false;
 486 }
 487
 488
 489 ir_node *copy_const_value(ir_node *n) {
 490   ir_node *nn;
 491   ir_mode *m;
 492
 493   m = get_irn_mode(n);
 494   switch(get_irn_opcode(n)) {
 495   case iro_Const:
 496     nn = new_Const(m, get_Const_tarval(n)); break;
 497   case iro_SymConst:
 498
 499     nn = new_SymConst(get_SymConst_symbol(n), get_SymConst_kind(n));
 500     break;
 501   case iro_Add:
 502     nn = new_Add(copy_const_value(get_Add_left(n)),
 503          copy_const_value(get_Add_right(n)), m); break;
 504   case iro_Sub:
 505     nn = new_Sub(copy_const_value(get_Sub_left(n)),
 506          copy_const_value(get_Sub_right(n)), m); break;
 507   case iro_Mul:
 508     nn = new_Mul(copy_const_value(get_Mul_left(n)),
 509          copy_const_value(get_Mul_right(n)), m); break;
 510   case iro_And:
 511     nn = new_And(copy_const_value(get_And_left(n)),
 512          copy_const_value(get_And_right(n)), m); break;
 513   case iro_Or:
 514     nn = new_Or(copy_const_value(get_Or_left(n)),
 515          copy_const_value(get_Or_right(n)), m); break;
 516   case iro_Eor:
 517     nn = new_Eor(copy_const_value(get_Eor_left(n)),
 518          copy_const_value(get_Eor_right(n)), m); break;
 519   case iro_Cast:
 520     nn = new_Cast(copy_const_value(get_Cast_op(n)), get_Cast_type(n)); break;
 521   case iro_Conv:
 522     nn = new_Conv(copy_const_value(get_Conv_op(n)), m); break;
 523   case iro_Unknown:
 524     nn = new_Unknown(m); break;
 525   default:
 526     DDMN(n);
 527     assert(0 && "opdope invalid or not implemented");
 528     nn = NULL;
 529     break;
 530   }
 531   return nn;
 532 }
 533
 534 compound_graph_path *
 535 new_compound_graph_path(type *tp, int length) {
 536   compound_graph_path *res;
 537   assert(is_type(tp) && is_compound_type(tp));
 538   assert(length > 0);
 539
 540   res = (compound_graph_path *) calloc (1, sizeof(compound_graph_path) + (length-1) * sizeof(entity *));
 541   res->kind          = k_ir_compound_graph_path;
 542   res->tp            = tp;
 543   res->len           = length;
 544   res ->arr_indicees = (int *) calloc(length, sizeof(int));
 545   return res;
 546 }
 547
 548 void
 549 free_compound_graph_path (compound_graph_path *gr) {
 550   assert(gr && is_compound_graph_path(gr));
 551   gr->kind = k_BAD;
 552   free(gr ->arr_indicees);
 553   free(gr);
 554 }
 555
 556 int
 557 is_compound_graph_path(void *thing) {
 558   return (get_kind(thing) == k_ir_compound_graph_path);
 559 }
 560
 561 /* checks whether nodes 0..pos are correct (all lie on a path.) */
 562 /* @@@ not implemented */
 563 int is_proper_compound_graph_path(compound_graph_path *gr, int pos) {
 564   int i;
 565   entity *node;
 566   type *owner = gr->tp;
 567   for (i = 0; i <= pos; i++) {
 568     node = get_compound_graph_path_node(gr, i);
 569     if (get_entity_owner(node) != owner) return false;
 570     owner = get_entity_type(node);
 571   }
 572   if (pos == get_compound_graph_path_length(gr))
 573     if (!is_atomic_type(owner)) return false;
 574   return true;
 575 }
 576
 577 int
 578 get_compound_graph_path_length(compound_graph_path *gr) {
 579   assert(gr && is_compound_graph_path(gr));
 580   return gr->len;
 581 }
 582
 583 entity *
 584 get_compound_graph_path_node(compound_graph_path *gr, int pos) {
 585   assert(gr && is_compound_graph_path(gr));
 586   assert(pos >= 0 && pos < gr->len);
 587   return gr->nodes[pos];
 588 }
 589
 590 void
 591 set_compound_graph_path_node(compound_graph_path *gr, int pos, entity *node) {
 592   assert(gr && is_compound_graph_path(gr));
 593   assert(pos >= 0 && pos < gr->len);
 594   assert(is_entity(node));
 595   gr->nodes[pos] = node;
 596   assert(is_proper_compound_graph_path(gr, pos));
 597 }
 598
 599 int
 600 get_compound_graph_path_array_index(compound_graph_path *gr, int pos) {
 601   assert(gr && is_compound_graph_path(gr));
 602   assert(pos >= 0 && pos < gr->len);
 603   return gr->arr_indicees[pos];
 604 }
 605
 606 void
 607 set_compound_graph_path_array_index(compound_graph_path *gr, int pos, int index) {
 608   assert(gr && is_compound_graph_path(gr));
 609   assert(pos >= 0 && pos < gr->len);
 610   gr->arr_indicees[pos] = index;
 611 }
 612
 613 /* A value of a compound entity is a pair of value and the corresponding path to a member of
 614    the compound. */
 615 void
 616 add_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path) {
 617   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
 618   ARR_APP1 (ir_node *, ent->values, val);
 619   ARR_APP1 (compound_graph_path *, ent->val_paths, path);
 620 }
 621
 622 void
 623 set_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path, int pos) {
 624   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
 625   ent->values[pos] = val;
 626   ent->val_paths[pos] = path;
 627 }
 628
 629 int
 630 get_compound_ent_n_values(entity *ent) {
 631   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
 632   return (ARR_LEN (ent->values));
 633 }
 634
 635 ir_node  *
 636 get_compound_ent_value(entity *ent, int pos) {
 637   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
 638   return ent->values[pos];
 639 }
 640
 641 compound_graph_path *
 642 get_compound_ent_value_path(entity *ent, int pos) {
 643   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
 644   return ent->val_paths[pos];
 645 }
 646
 647 void
 648 remove_compound_ent_value(entity *ent, entity *value_ent) {
 649   int i;
 650   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
 651   for (i = 0; i < (ARR_LEN (ent->val_paths)); i++) {
 652     compound_graph_path *path = ent->val_paths[i];
 653     if (path->nodes[path->len-1] == value_ent) {
 654       for(; i < (ARR_LEN (ent->val_paths))-1; i++) {
 655     ent->val_paths[i] = ent->val_paths[i+1];
 656     ent->values[i]   = ent->values[i+1];
 657       }
 658       ARR_SETLEN(entity*,  ent->val_paths, ARR_LEN(ent->val_paths) - 1);
 659       ARR_SETLEN(ir_node*, ent->values,    ARR_LEN(ent->values)    - 1);
 660       break;
 661     }
 662   }
 663 }
 664
 665 void
 666 add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
 667   compound_graph_path *path;
 668   type *owner_tp = get_entity_owner(ent);
 669   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
 670   path = new_compound_graph_path(owner_tp, 1);
 671   path->nodes[0] = member;
 672   if (is_array_type(owner_tp)) {
 673     int max;
 674     int i;
 675
 676     assert(get_array_n_dimensions(owner_tp) == 1 && has_array_lower_bound(owner_tp, 0));
 677     max = get_array_lower_bound_int(owner_tp, 0) -1;
 678     for (i = 0; i < get_compound_ent_n_values(ent); ++i) {
 679       int index = get_compound_graph_path_array_index(get_compound_ent_value_path(ent, i), 0);
 680       if (index > max) {
 681         max = index;
 682       }
 683     }
 684     path->arr_indicees[0] = max + 1;
 685   }
 686   add_compound_ent_value_w_path(ent, val, path);
 687 }
 688
 689 /* Copies the firm subgraph referenced by val to const_code_irg and adds
 690    the node as constant initialization to ent.
 691    The subgraph may not contain control flow operations.
 692 void
 693 copy_and_add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
 694   ir_graph *rem = current_ir_graph;
 695
 696   assert(get_entity_variability(ent) != variability_uninitialized);
 697   current_ir_graph = get_const_code_irg();
 698
 699   val = copy_const_value(val);
 700   add_compound_ent_value(ent, val, member);
 701   current_ir_graph = rem;
 702   }*/
 703
 704 /* Copies the value i of the entity to current_block in current_ir_graph.
 705 ir_node *
 706 copy_compound_ent_value(entity *ent, int pos) {
 707   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
 708   return copy_const_value(ent->values[pos+1]);
 709   }*/
 710
 711 entity   *
 712 get_compound_ent_value_member(entity *ent, int pos) {
 713   compound_graph_path *path;
 714   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
 715   path = get_compound_ent_value_path(ent, pos);
 716
 717   return get_compound_graph_path_node(path, get_compound_graph_path_length(path)-1);
 718 }
 719
 720 void
 721 set_compound_ent_value(entity *ent, ir_node *val, entity *member, int pos) {
 722   compound_graph_path *path;
 723   assert(is_compound_entity(ent) && (ent->variability != variability_uninitialized));
 724   path = get_compound_ent_value_path(ent, pos);
 725   set_compound_graph_path_node(path, 0, member);
 726   set_compound_ent_value_w_path(ent, val, path, pos);
 727 }
 728
 729 void
 730 set_array_entity_values(entity *ent, tarval **values, int num_vals) {
 731   int i;
 732   ir_graph *rem = current_ir_graph;
 733   type *arrtp = get_entity_type(ent);
 734   ir_node *val;
 735
 736   assert(is_array_type(arrtp));
 737   assert(get_array_n_dimensions(arrtp) == 1);
 738   /* One bound is sufficient, the nunmber of constant fields makes the
 739      size. */
 740   assert(get_array_lower_bound (arrtp, 0) || get_array_upper_bound (arrtp, 0));
 741   assert(get_entity_variability(ent) != variability_uninitialized);
 742   current_ir_graph = get_const_code_irg();
 743
 744   for (i = 0; i < num_vals; i++) {
 745     val = new_Const(get_tarval_mode (values[i]), values[i]);
 746     add_compound_ent_value(ent, val, get_array_element_entity(arrtp));
 747     set_compound_graph_path_array_index(get_compound_ent_value_path(ent, i), 0, i);
 748   }
 749   current_ir_graph = rem;
 750 }
 751
 752 int  get_compound_ent_value_offset_bits(entity *ent, int pos) {
 753   assert(get_type_state(get_entity_type(ent)) == layout_fixed);
 754
 755   compound_graph_path *path = get_compound_ent_value_path(ent, pos);
 756   int i, path_len = get_compound_graph_path_length(path);
 757   int offset = 0;
 758
 759   for (i = 0; i < path_len; ++i) {
 760     entity *node = get_compound_graph_path_node(path, i);
 761     type *node_tp = get_entity_type(node);
 762     type *owner_tp = get_entity_owner(node);
 763     if (is_array_type(owner_tp)) {
 764       int size  = get_mode_size_bits (get_type_mode(node_tp));
 765       int align = get_mode_align_bits(get_type_mode(node_tp));
 766       if (size < align)
 767     size = align;
 768       else {
 769     assert(size % align == 0);
 770     /* ansonsten aufrunden */
 771       }
 772       offset += size * get_compound_graph_path_array_index(path, i);
 773     } else {
 774       offset += get_entity_offset_bits(node);
 775     }
 776   }
 777   return offset;
 778 }
 779
 780 int  get_compound_ent_value_offset_bytes(entity *ent, int pos) {
 781   int offset = get_compound_ent_value_offset_bits(ent, pos);
 782   assert(offset % 8 == 0);
 783   return offset >> 3;
 784 }
 785
 786
 787 static void init_index(type *arr) {
 788   int init;
 789   int dim = 0;
 790
 791   assert(get_array_n_dimensions(arr) == 1);
 792
 793   if (has_array_lower_bound(arr, dim))
 794     init = get_array_lower_bound_int(arr, 0) -1;
 795   else
 796     init = get_array_upper_bound_int(arr, 0) +1;
 797
 798   set_entity_link(get_array_element_entity(arr), (void *)init);
 799 }
 800
 801
 802 static int get_next_index(entity *elem_ent) {
 803   type *arr = get_entity_owner(elem_ent);
 804   int next;
 805   int dim = 0;
 806
 807   assert(get_array_n_dimensions(arr) == 1);
 808
 809   if (has_array_lower_bound(arr, dim)) {
 810     next = (int)get_entity_link(elem_ent) +1;
 811     if (has_array_upper_bound(arr, dim)) {
 812       int upper = get_array_upper_bound_int(arr, dim);
 813       if (next == upper) next = get_array_lower_bound_int(arr, dim);
 814     }
 815   } else {
 816     next = (int)get_entity_link(elem_ent) -1;
 817     if (has_array_lower_bound(arr, dim)) {
 818       int upper = get_array_upper_bound_int(arr, dim);
 819       if (next == upper) next = get_array_upper_bound_int(arr, dim);
 820     }
 821   }
 822
 823   set_entity_link(elem_ent, (void *)next);
 824   return next;
 825 }
 826
 827 /* Compute the array indicees in compound graph paths of initialized entities.
 828  *
 829  *  All arrays must have fixed lower and upper bounds.  One array can
 830  *  have an open bound.  If there are several open bounds, we do
 831  *  nothing.  There must be initializer elements for all array
 832  *  elements.  Uses the link field in the array element entities.  The
 833  *  array bounds must be representable as ints.
 834  *
 835  *  (If the bounds are not representable as ints we have to represent
 836  *  the indicees as firm nodes.  But the still we must be able to
 837  *  evaluate the index against the upper bound.)
 838  */
 839 void compute_compound_ent_array_indicees(entity *ent) {
 840   type *tp = get_entity_type(ent);
 841   int i, n_vals;
 842   entity *unknown_bound_entity = NULL;
 843
 844   if (!is_compound_type(tp) ||
 845       (ent->variability == variability_uninitialized)) return ;
 846
 847   n_vals = get_compound_ent_n_values(ent);
 848   if (n_vals == 0) return;
 849
 850   /* We can not compute the indicees if there is more than one array
 851      with an unknown bound.  For this remember the first entity that
 852      represents such an array. It could be ent. */
 853   if (is_array_type(tp)) {
 854     assert(get_array_n_dimensions(tp) == 1 && "other not implemented");
 855     int dim = 0;
 856     if (!has_array_lower_bound(tp, dim) || !has_array_upper_bound(tp, dim))
 857      unknown_bound_entity = ent;
 858   }
 859
 860   /* Initialize the entity links to lower bound -1 and test all path elements
 861      for known bounds. */
 862   for (i = 0; i < n_vals; ++i) {
 863     compound_graph_path *path = get_compound_ent_value_path(ent, i);
 864     int j, path_len =  get_compound_graph_path_length(path);
 865     for (j = 0; j < path_len; ++j) {
 866       entity *node = get_compound_graph_path_node(path, j);
 867       type *elem_tp = get_entity_type(node);
 868
 869       if (is_array_type(elem_tp)) {
 870     assert(get_array_n_dimensions(elem_tp) == 1 && "other not implemented");
 871     int dim = 0;
 872     if (!has_array_lower_bound(elem_tp, dim) || !has_array_upper_bound(elem_tp, dim)) {
 873       if (!unknown_bound_entity) unknown_bound_entity = node;
 874       if (node != unknown_bound_entity) return;
 875     }
 876
 877     init_index(elem_tp);
 878       }
 879     }
 880   }
 881
 882   /* Finally compute the indicees ... */
 883   for (i = 0; i < n_vals; ++i) {
 884     compound_graph_path *path = get_compound_ent_value_path(ent, i);
 885     int j, path_len =  get_compound_graph_path_length(path);
 886     for (j = 0; j < path_len; ++j) {
 887       entity *node = get_compound_graph_path_node(path, j);
 888       type *owner_tp = get_entity_owner(node);
 889       if (is_array_type(owner_tp))
 890     set_compound_graph_path_array_index (path, j, get_next_index(node));
 891     }
 892   }
 893
 894 }
 895
 896
 897 static int *resize (int *buf, int new_size) {
 898   int *new_buf = (int *)calloc(new_size, 4);
 899   memcpy(new_buf, buf, new_size>1);
 900   free(buf);
 901   return new_buf;
 902 }
 903
 904 /* We sort the elements by placing them at their bit offset in an
 905    array where each entry represents one bit called permutation.  In
 906    fact, we do not place the values themselves, as we would have to
 907    copy two things, the value and the path.  We only remember the
 908    position in the old order. Each value should have a distinct
 909    position in the permutation.
 910
 911    A second iteration now permutes the actual elements into two
 912    new arrays. */
 913 void sort_compound_ent_values(entity *ent) {
 914   assert(get_type_state(get_entity_type(ent)) == layout_fixed);
 915
 916   type *tp = get_entity_type(ent);
 917   int i, n_vals = get_compound_ent_n_values(ent);
 918   int tp_size = get_type_size_bits(tp);
 919   int size;
 920   int *permutation;
 921
 922   if (!is_compound_type(tp)                           ||
 923       (ent->variability == variability_uninitialized) ||
 924       (get_type_state(tp) != layout_fixed)            ||
 925       (n_vals == 0)                                     ) return;
 926
 927   /* estimated upper bound for size. Better: use flexible array ... */
 928   size = ((tp_size > (n_vals * 32)) ? tp_size : (n_vals * 32)) * 4;
 929   permutation = (int *)calloc(size, 4);
 930   for (i = 0; i < n_vals; ++i) {
 931     int pos = get_compound_ent_value_offset_bits(ent, i);
 932     while (pos >= size) {
 933       size = size + size;
 934       permutation = resize(permutation, size);
 935     }
 936     assert(pos < size);
 937     assert(permutation[pos] == 0 && "two values with the same offset");
 938     permutation[pos] = i + 1;         /* We initialized with 0, so we can not distinguish entry 0.
 939                      So inc all entries by one. */
 940     //fprintf(stderr, "i: %d, pos: %d \n", i, pos);
 941   }
 942
 943   int next = 0;
 944   ir_node **my_values = NEW_ARR_F(ir_node *, n_vals);
 945   compound_graph_path **my_paths  = NEW_ARR_F(compound_graph_path *, n_vals);
 946   for (i = 0; i < size; ++i) {
 947     int pos = permutation[i];
 948     if (pos) {
 949       //fprintf(stderr, "pos: %d i: %d  next %d \n", i, pos, next);
 950       assert(next < n_vals);
 951       pos--;   /* We increased the pos by one */
 952       my_values[next] = get_compound_ent_value     (ent, pos);
 953       my_paths [next] = get_compound_ent_value_path(ent, pos);
 954       next++;
 955     }
 956   }
 957   free(permutation);
 958
 959   DEL_ARR_F(ent->values);
 960   ent->values = my_values;
 961   DEL_ARR_F(ent->val_paths);
 962   ent->val_paths = my_paths;
 963 }
 964
 965 int
 966 (get_entity_offset_bytes)(entity *ent) {
 967   return __get_entity_offset_bytes(ent);
 968 }
 969
 970 int
 971 (get_entity_offset_bits)(entity *ent) {
 972   return __get_entity_offset_bits(ent);
 973 }
 974
 975 void
 976 (set_entity_offset_bytes)(entity *ent, int offset) {
 977   __set_entity_offset_bytes(ent, offset);
 978 }
 979
 980 void
 981 (set_entity_offset_bits)(entity *ent, int offset) {
 982   __set_entity_offset_bits(ent, offset);
 983 }
 984
 985 void
 986 add_entity_overwrites(entity *ent, entity *overwritten) {
 987   assert(ent && is_class_type(get_entity_owner(ent)));
 988   ARR_APP1(entity *, ent->overwrites, overwritten);
 989   ARR_APP1(entity *, overwritten->overwrittenby, ent);
 990 }
 991
 992 int
 993 get_entity_n_overwrites(entity *ent) {
 994   assert(ent && is_class_type(get_entity_owner(ent)));
 995   return (ARR_LEN(ent->overwrites));
 996 }
 997
 998 int
 999 get_entity_overwrites_index(entity *ent, entity *overwritten) {
1000   int i;
1001   assert(ent && is_class_type(get_entity_owner(ent)));
1002   for (i = 0; i < get_entity_n_overwrites(ent); i++)
1003     if (get_entity_overwrites(ent, i) == overwritten)
1004       return i;
1005   return -1;
1006 }
1007
1008 entity *
1009 get_entity_overwrites   (entity *ent, int pos) {
1010   assert(ent && is_class_type(get_entity_owner(ent)));
1011   assert(pos < get_entity_n_overwrites(ent));
1012   return ent->overwrites[pos];
1013 }
1014
1015 void
1016 set_entity_overwrites   (entity *ent, int pos, entity *overwritten) {
1017   assert(ent && is_class_type(get_entity_owner(ent)));
1018   assert(pos < get_entity_n_overwrites(ent));
1019   ent->overwrites[pos] = overwritten;
1020 }
1021
1022 void
1023 remove_entity_overwrites(entity *ent, entity *overwritten) {
1024   int i;
1025   assert(ent && is_class_type(get_entity_owner(ent)));
1026   for (i = 0; i < (ARR_LEN (ent->overwrites)); i++)
1027     if (ent->overwrites[i] == overwritten) {
1028       for(; i < (ARR_LEN (ent->overwrites))-1; i++)
1029     ent->overwrites[i] = ent->overwrites[i+1];
1030       ARR_SETLEN(entity*, ent->overwrites, ARR_LEN(ent->overwrites) - 1);
1031       break;
1032     }
1033 }
1034
1035 void
1036 add_entity_overwrittenby   (entity *ent, entity *overwrites) {
1037   assert(ent && is_class_type(get_entity_owner(ent)));
1038   add_entity_overwrites(overwrites, ent);
1039 }
1040
1041 int
1042 get_entity_n_overwrittenby (entity *ent) {
1043   assert(ent && is_class_type(get_entity_owner(ent)));
1044   return (ARR_LEN (ent->overwrittenby));
1045 }
1046
1047 int
1048 get_entity_overwrittenby_index(entity *ent, entity *overwrites) {
1049   int i;
1050   assert(ent && is_class_type(get_entity_owner(ent)));
1051   for (i = 0; i < get_entity_n_overwrittenby(ent); i++)
1052     if (get_entity_overwrittenby(ent, i) == overwrites)
1053       return i;
1054   return -1;
1055 }
1056
1057 entity *
1058 get_entity_overwrittenby   (entity *ent, int pos) {
1059   assert(ent && is_class_type(get_entity_owner(ent)));
1060   assert(pos < get_entity_n_overwrittenby(ent));
1061   return ent->overwrittenby[pos];
1062 }
1063
1064 void
1065 set_entity_overwrittenby   (entity *ent, int pos, entity *overwrites) {
1066   assert(ent && is_class_type(get_entity_owner(ent)));
1067   assert(pos < get_entity_n_overwrittenby(ent));
1068   ent->overwrittenby[pos] = overwrites;
1069 }
1070
1071 void    remove_entity_overwrittenby(entity *ent, entity *overwrites) {
1072   int i;
1073   assert(ent  && is_class_type(get_entity_owner(ent)));
1074   for (i = 0; i < (ARR_LEN (ent->overwrittenby)); i++)
1075     if (ent->overwrittenby[i] == overwrites) {
1076       for(; i < (ARR_LEN (ent->overwrittenby))-1; i++)
1077     ent->overwrittenby[i] = ent->overwrittenby[i+1];
1078       ARR_SETLEN(entity*, ent->overwrittenby, ARR_LEN(ent->overwrittenby) - 1);
1079       break;
1080     }
1081 }
1082
1083 /* A link to store intermediate information */
1084 void *
1085 (get_entity_link)(entity *ent) {
1086   return __get_entity_link(ent);
1087 }
1088
1089 void
1090 (set_entity_link)(entity *ent, void *l) {
1091   __set_entity_link(ent, l);
1092 }
1093
1094 ir_graph *
1095 (get_entity_irg)(entity *ent) {
1096   return __get_entity_irg(ent);
1097 }
1098
1099 void
1100 set_entity_irg(entity *ent, ir_graph *irg) {
1101   assert(ent && is_method_type(get_entity_type(ent)));
1102   /* Wie kann man die Referenz auf einen IRG löschen, z.B. wenn die
1103    * Methode selbst nicht mehr aufgerufen werden kann, die Entität
1104    * aber erhalten bleiben soll. */
1105   /* assert(irg); */
1106   assert((irg  && ent->peculiarity == peculiarity_existent) ||
1107          (!irg && ent->peculiarity == peculiarity_description) ||
1108          (!irg && ent->peculiarity == peculiarity_inherited));
1109   ent->irg = irg;
1110 }
1111
1112 int
1113 (is_entity)(void *thing) {
1114   return __is_entity(thing);
1115 }
1116
1117 int is_atomic_entity(entity *ent) {
1118   type* t = get_entity_type(ent);
1119   assert(ent && ent->kind == k_entity);
1120   return (is_primitive_type(t) || is_pointer_type(t) ||
1121       is_enumeration_type(t) || is_method_type(t));
1122 }
1123
1124 int is_compound_entity(entity *ent) {
1125   type* t = get_entity_type(ent);
1126   assert(ent && ent->kind == k_entity);
1127   return (is_class_type(t) || is_struct_type(t) ||
1128       is_array_type(t) || is_union_type(t));
1129 }
1130
1131 /**
1132  * @todo not implemnted!!! */
1133 bool equal_entity(entity *ent1, entity *ent2) {
1134   fprintf(stderr, " calling unimplemented equal entity!!! \n");
1135   return true;
1136 }
1137
1138
1139 unsigned long get_entity_visited(entity *ent) {
1140   assert(ent && ent->kind == k_entity);
1141   return ent->visit;
1142 }
1143 void        set_entity_visited(entity *ent, unsigned long num) {
1144   assert(ent && ent->kind == k_entity);
1145   ent->visit = num;
1146 }
1147 /* Sets visited field in entity to entity_visited. */
1148 void        mark_entity_visited(entity *ent) {
1149   assert(ent && ent->kind == k_entity);
1150   ent->visit = type_visited;
1151 }
1152
1153
1154 bool entity_visited(entity *ent) {
1155   assert(ent && ent->kind == k_entity);
1156   return get_entity_visited(ent) >= type_visited;
1157 }
1158
1159 bool entity_not_visited(entity *ent) {
1160   assert(ent && ent->kind == k_entity);
1161   return get_entity_visited(ent) < type_visited;
1162 }
1163
1164 /* Need two routines because I want to assert the result. */
1165 static entity *resolve_ent_polymorphy2 (type *dynamic_class, entity* static_ent) {
1166   int i, n_overwrittenby;
1167   entity *res = NULL;
1168
1169   if (get_entity_owner(static_ent) == dynamic_class) return static_ent;
1170
1171   n_overwrittenby = get_entity_n_overwrittenby(static_ent);
1172   for (i = 0; i < n_overwrittenby; ++i) {
1173     res = resolve_ent_polymorphy2(dynamic_class, get_entity_overwrittenby(static_ent, i));
1174     if (res) break;
1175   }
1176
1177   return res;
1178 }
1179
1180 /** Resolve polymorphy in the inheritance relation.
1181  *
1182  * Returns the dynamically referenced entity if the static entity and the
1183  * dynamic type are given.
1184  * Search downwards in overwritten tree. */
1185 entity *resolve_ent_polymorphy(type *dynamic_class, entity* static_ent) {
1186   entity *res;
1187   assert(static_ent && static_ent->kind == k_entity);
1188
1189   res = resolve_ent_polymorphy2(dynamic_class, static_ent);
1190 #if DEBUG_libfirm
1191   if (!res) {
1192     printf(" Could not find entity "); DDME(static_ent);
1193     printf("  in "); DDMT(dynamic_class);
1194     printf("\n");
1195     dump_entity(static_ent);
1196     dump_type(get_entity_owner(static_ent));
1197     dump_type(dynamic_class);
1198   }
1199 #endif
1200   assert(res);
1201   return res;
1202 }