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