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