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

   1 /*
   2  * This file is part of libFirm.
   3  * Copyright (C) 2012 University of Karlsruhe.
   4  */
   5
   6 /**
   7  * @file
   8  * @brief   Representation of all program known entities.
   9  * @author  Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Michael Beck
  10  */
  11 #include "config.h"
  12
  13 #include <string.h>
  14 #include <stdlib.h>
  15 #include <stddef.h>
  16
  17 #include "xmalloc.h"
  18 #include "entity_t.h"
  19 #include "array.h"
  20 #include "util.h"
  21 #include "irhooks.h"
  22 #include "irprintf.h"
  23
  24 #include "irprog_t.h"
  25 #include "ircons.h"
  26 #include "tv_t.h"
  27 #include "irdump.h"
  28 #include "irgraph_t.h"
  29 #include "callgraph.h"
  30 #include "error.h"
  31
  32 /** The name of the unknown entity. */
  33 #define UNKNOWN_ENTITY_NAME "unknown_entity"
  34
  35 ir_entity *get_unknown_entity(void)
  36 {
  37         return irp->unknown_entity;
  38 }
  39
  40 /*-----------------------------------------------------------------*/
  41 /* ENTITY                                                          */
  42 /*-----------------------------------------------------------------*/
  43
  44 static ir_entity *intern_new_entity(ir_type *owner, ir_entity_kind kind,
  45                                     ident *name, ir_type *type, dbg_info *dbgi)
  46 {
  47         assert(owner);
  48
  49         ir_entity *res = XMALLOCZ(ir_entity);
  50
  51         res->kind    = k_entity;
  52         res->name    = name;
  53         res->ld_name = NULL;
  54         res->type    = type;
  55         res->owner   = owner;
  56
  57         res->entity_kind          = kind;
  58         res->volatility           = volatility_non_volatile;
  59         res->aligned              = align_is_aligned;
  60         res->usage                = ir_usage_unknown;
  61         res->compiler_gen         = 0;
  62         res->visibility           = ir_visibility_external;
  63         res->offset               = -1;
  64         res->offset_bit_remainder = 0;
  65         res->alignment            = 0;
  66         res->link                 = NULL;
  67 #ifdef DEBUG_libfirm
  68         res->nr = get_irp_new_node_nr();
  69 #endif
  70
  71         /* Remember entity in its owner. */
  72         if (is_compound_type(owner))
  73                 add_compound_member(owner, res);
  74
  75         res->visit = 0;
  76         set_entity_dbg_info(res, dbgi);
  77
  78         return res;
  79 }
  80
  81 ir_entity *new_d_entity(ir_type *owner, ident *name, ir_type *type,
  82                         dbg_info *db)
  83 {
  84         ir_entity *res;
  85
  86         if (is_Method_type(type)) {
  87                 ir_graph *irg = get_const_code_irg();
  88                 symconst_symbol sym;
  89                 res = intern_new_entity(owner, IR_ENTITY_METHOD, name, type, db);
  90                 sym.entity_p            = res;
  91                 set_atomic_ent_value(res, new_r_SymConst(irg, mode_P_code, sym, symconst_addr_ent));
  92                 res->linkage                     = IR_LINKAGE_CONSTANT;
  93                 res->attr.mtd_attr.properties    = get_method_additional_properties(type);
  94                 res->attr.mtd_attr.vtable_number = IR_VTABLE_NUM_NOT_SET;
  95                 res->attr.mtd_attr.param_access  = NULL;
  96                 res->attr.mtd_attr.param_weight  = NULL;
  97                 res->attr.mtd_attr.irg           = NULL;
  98         } else if (is_compound_type(owner) && !(owner->flags & tf_segment)) {
  99                 res = intern_new_entity(owner, IR_ENTITY_COMPOUND_MEMBER, name, type, db);
 100         } else {
 101                 res = intern_new_entity(owner, IR_ENTITY_NORMAL, name, type, db);
 102         }
 103
 104         hook_new_entity(res);
 105         return res;
 106 }
 107
 108 ir_entity *new_entity(ir_type *owner, ident *name, ir_type *type)
 109 {
 110         return new_d_entity(owner, name, type, NULL);
 111 }
 112
 113 static ident *make_parameter_entity_name(size_t pos)
 114 {
 115         char buf[64];
 116         snprintf(buf, sizeof(buf), "parameter.%lu", (unsigned long) pos);
 117         return new_id_from_str(buf);
 118 }
 119
 120 ir_entity *new_d_parameter_entity(ir_type *owner, size_t pos, ir_type *type,
 121                                   dbg_info *dbgi)
 122 {
 123         ident     *name = make_parameter_entity_name(pos);
 124         ir_entity *res
 125                 = intern_new_entity(owner, IR_ENTITY_PARAMETER, name, type, dbgi);
 126         res->attr.parameter.number = pos;
 127         hook_new_entity(res);
 128         return res;
 129 }
 130
 131 ir_entity *new_parameter_entity(ir_type *owner, size_t pos, ir_type *type)
 132 {
 133         return new_d_parameter_entity(owner, pos, type, NULL);
 134 }
 135
 136 ir_entity *new_d_label_entity(ir_label_t label, dbg_info *dbgi)
 137 {
 138         ident *name = id_unique("label_%u");
 139         ir_type *global_type = get_glob_type();
 140         ir_entity *res
 141                 = intern_new_entity(global_type, IR_ENTITY_LABEL, name, get_code_type(),
 142                                     dbgi);
 143         res->attr.code_attr.label = label;
 144         hook_new_entity(res);
 145         return res;
 146 }
 147
 148 ir_entity *new_label_entity(ir_label_t label)
 149 {
 150         return new_d_label_entity(label, NULL);
 151 }
 152
 153 /**
 154  * Free entity attributes.
 155  *
 156  * @param ent  the entity
 157  */
 158 static void free_entity_attrs(ir_entity *ent)
 159 {
 160         if (ent->overwrites != NULL) {
 161                 DEL_ARR_F(ent->overwrites);
 162                 ent->overwrites = NULL;
 163         }
 164         if (ent->overwrittenby != NULL) {
 165                 DEL_ARR_F(ent->overwrittenby);
 166                 ent->overwrittenby = NULL;
 167         }
 168
 169         if (ent->initializer != NULL) {
 170                 /* TODO: free initializers */
 171         }
 172         if (ent->entity_kind == IR_ENTITY_METHOD) {
 173                 if (ent->attr.mtd_attr.param_access) {
 174                         DEL_ARR_F(ent->attr.mtd_attr.param_access);
 175                         ent->attr.mtd_attr.param_access = NULL;
 176                 }
 177                 if (ent->attr.mtd_attr.param_weight) {
 178                         DEL_ARR_F(ent->attr.mtd_attr.param_weight);
 179                         ent->attr.mtd_attr.param_weight = NULL;
 180                 }
 181         }
 182 }
 183
 184 /**
 185  * Creates a deep copy of an entity.
 186  */
 187 static ir_entity *deep_entity_copy(ir_entity *old)
 188 {
 189         ir_entity *newe = XMALLOC(ir_entity);
 190
 191         *newe = *old;
 192         if (old->initializer != NULL) {
 193                 /* FIXME: the initializers are NOT copied */
 194         } else if (is_method_entity(old)) {
 195                 /* do NOT copy them, reanalyze. This might be the best solution */
 196                 newe->attr.mtd_attr.param_access = NULL;
 197                 newe->attr.mtd_attr.param_weight = NULL;
 198         }
 199         newe->overwrites    = NULL;
 200         newe->overwrittenby = NULL;
 201
 202 #ifdef DEBUG_libfirm
 203         newe->nr = get_irp_new_node_nr();
 204 #endif
 205         hook_new_entity(newe);
 206         return newe;
 207 }
 208
 209 ir_entity *copy_entity_own(ir_entity *old, ir_type *new_owner)
 210 {
 211         ir_entity *newe;
 212         assert(is_entity(old));
 213         assert(is_compound_type(new_owner));
 214         assert(get_type_state(new_owner) != layout_fixed);
 215
 216         if (old->owner == new_owner)
 217                 return old;
 218
 219         /* create a deep copy so we are safe of aliasing and double-freeing. */
 220         newe        = deep_entity_copy(old);
 221         newe->owner = new_owner;
 222         add_compound_member(new_owner, newe);
 223
 224         return newe;
 225 }
 226
 227 ir_entity *copy_entity_name(ir_entity *old, ident *new_name)
 228 {
 229         ir_entity *newe;
 230         assert(old && old->kind == k_entity);
 231
 232         if (old->name == new_name)
 233                 return old;
 234
 235         newe       = deep_entity_copy(old);
 236         newe->name = new_name;
 237         newe->ld_name = NULL;
 238         add_compound_member(old->owner, newe);
 239
 240         return newe;
 241 }
 242
 243 void free_entity(ir_entity *ent)
 244 {
 245         if (is_compound_type(ent->owner))
 246                 remove_compound_member(ent->owner, ent);
 247
 248         assert(ent && ent->kind == k_entity);
 249         free_entity_attrs(ent);
 250 #ifdef DEBUG_libfirm
 251         ent->kind = k_BAD;
 252 #endif
 253         xfree(ent);
 254 }
 255
 256 long get_entity_nr(const ir_entity *ent)
 257 {
 258         assert(ent && ent->kind == k_entity);
 259 #ifdef DEBUG_libfirm
 260         return ent->nr;
 261 #else
 262         return (long)PTR_TO_INT(ent);
 263 #endif
 264 }
 265
 266 const char *(get_entity_name)(const ir_entity *ent)
 267 {
 268         return _get_entity_name(ent);
 269 }
 270
 271 ident *(get_entity_ident)(const ir_entity *ent)
 272 {
 273         return _get_entity_ident(ent);
 274 }
 275
 276 void (set_entity_ident)(ir_entity *ent, ident *id)
 277 {
 278         _set_entity_ident(ent, id);
 279 }
 280
 281 ir_type *(get_entity_owner)(const ir_entity *ent)
 282 {
 283         return _get_entity_owner(ent);
 284 }
 285
 286 void set_entity_owner(ir_entity *ent, ir_type *owner)
 287 {
 288         assert(is_entity(ent));
 289         assert(is_compound_type(owner));
 290
 291         remove_compound_member(ent->owner, ent);
 292         add_compound_member(owner, ent);
 293         ent->owner = owner;
 294 }
 295
 296 ident *(get_entity_ld_ident)(const ir_entity *ent)
 297 {
 298         return _get_entity_ld_ident(ent);
 299 }
 300
 301 void (set_entity_ld_ident)(ir_entity *ent, ident *ld_ident)
 302 {
 303         _set_entity_ld_ident(ent, ld_ident);
 304 }
 305
 306 const char *(get_entity_ld_name)(const ir_entity *ent)
 307 {
 308         return _get_entity_ld_name(ent);
 309 }
 310
 311 int entity_has_ld_ident(const ir_entity *entity)
 312 {
 313         return entity->ld_name != NULL;
 314 }
 315
 316 ir_type *(get_entity_type)(const ir_entity *ent)
 317 {
 318         return _get_entity_type(ent);
 319 }
 320
 321 void set_entity_type(ir_entity *ent, ir_type *type)
 322 {
 323         switch (ent->entity_kind) {
 324         case IR_ENTITY_METHOD:
 325                 assert(is_Method_type(type));
 326                 break;
 327         case IR_ENTITY_NORMAL:
 328                 assert(!is_Method_type(type));
 329                 break;
 330         case IR_ENTITY_LABEL:
 331                 assert(type == get_code_type());
 332                 break;
 333         case IR_ENTITY_COMPOUND_MEMBER:
 334                 break;
 335         }
 336         ent->type = type;
 337 }
 338
 339 ir_volatility (get_entity_volatility)(const ir_entity *ent)
 340 {
 341         return _get_entity_volatility(ent);
 342 }
 343
 344 void (set_entity_volatility)(ir_entity *ent, ir_volatility vol)
 345 {
 346         _set_entity_volatility(ent, vol);
 347 }
 348
 349 const char *get_volatility_name(ir_volatility var)
 350 {
 351 #define X(a)    case a: return #a
 352         switch (var) {
 353         X(volatility_non_volatile);
 354         X(volatility_is_volatile);
 355     default: return "BAD VALUE";
 356         }
 357 #undef X
 358 }
 359
 360 ir_align (get_entity_aligned)(const ir_entity *ent)
 361 {
 362         return _get_entity_aligned(ent);
 363 }
 364
 365 void (set_entity_aligned)(ir_entity *ent, ir_align a)
 366 {
 367         _set_entity_aligned(ent, a);
 368 }
 369
 370 unsigned (get_entity_alignment)(const ir_entity *ent)
 371 {
 372         return _get_entity_alignment(ent);
 373 }
 374
 375 void (set_entity_alignment)(ir_entity *ent, unsigned alignment)
 376 {
 377         _set_entity_alignment(ent, alignment);
 378 }
 379
 380 const char *get_align_name(ir_align a)
 381 {
 382 #define X(a)    case a: return #a
 383         switch (a) {
 384         X(align_non_aligned);
 385         X(align_is_aligned);
 386         default: return "BAD VALUE";
 387         }
 388 #undef X
 389 }
 390
 391 void set_entity_label(ir_entity *ent, ir_label_t label)
 392 {
 393         assert(ent->entity_kind == IR_ENTITY_LABEL);
 394         ent->attr.code_attr.label = label;
 395 }
 396
 397 ir_label_t get_entity_label(const ir_entity *ent)
 398 {
 399         assert(ent->entity_kind == IR_ENTITY_LABEL);
 400         return ent->attr.code_attr.label;
 401 }
 402
 403 void set_entity_visibility(ir_entity *entity, ir_visibility visibility)
 404 {
 405         entity->visibility = visibility;
 406 }
 407
 408 ir_visibility get_entity_visibility(const ir_entity *entity)
 409 {
 410         return (ir_visibility)entity->visibility;
 411 }
 412
 413 void set_entity_linkage(ir_entity *entity, ir_linkage linkage)
 414 {
 415         entity->linkage = linkage;
 416 }
 417
 418 ir_linkage (get_entity_linkage)(const ir_entity *entity)
 419 {
 420         return get_entity_linkage(entity);
 421 }
 422
 423 void add_entity_linkage(ir_entity *entity, ir_linkage linkage)
 424 {
 425         entity->linkage |= linkage;
 426 }
 427
 428 void remove_entity_linkage(ir_entity *entity, ir_linkage linkage)
 429 {
 430         entity->linkage &= ~linkage;
 431 }
 432
 433 int (is_entity_compiler_generated)(const ir_entity *ent)
 434 {
 435         return _is_entity_compiler_generated(ent);
 436 }
 437
 438 void (set_entity_compiler_generated)(ir_entity *ent, int flag)
 439 {
 440         _set_entity_compiler_generated(ent, flag);
 441 }
 442
 443 ir_entity_usage (get_entity_usage)(const ir_entity *ent)
 444 {
 445         return _get_entity_usage(ent);
 446 }
 447
 448 void (set_entity_usage)(ir_entity *ent, ir_entity_usage flags)
 449 {
 450         _set_entity_usage(ent, flags);
 451 }
 452
 453 ir_node *get_atomic_ent_value(const ir_entity *entity)
 454 {
 455         ir_initializer_t *initializer = get_entity_initializer(entity);
 456
 457         assert(entity && is_atomic_entity(entity));
 458         if (initializer == NULL) {
 459                 ir_type *type = get_entity_type(entity);
 460                 return new_r_Unknown(get_const_code_irg(), get_type_mode(type));
 461         }
 462
 463         switch (get_initializer_kind(initializer)) {
 464         case IR_INITIALIZER_NULL: {
 465                 ir_type *type = get_entity_type(entity);
 466                 ir_mode *mode = get_type_mode(type);
 467                 return new_r_Const(get_const_code_irg(), get_mode_null(mode));
 468         }
 469         case IR_INITIALIZER_TARVAL: {
 470                 ir_tarval *tv = get_initializer_tarval_value(initializer);
 471                 return new_r_Const(get_const_code_irg(), tv);
 472         }
 473         case IR_INITIALIZER_CONST:
 474                 return get_initializer_const_value(initializer);
 475         case IR_INITIALIZER_COMPOUND:
 476                 panic("compound initializer in atomic entity not allowed (%+F)", entity);
 477         }
 478
 479         panic("invalid initializer kind (%+F)", entity);
 480 }
 481
 482 void set_atomic_ent_value(ir_entity *entity, ir_node *val)
 483 {
 484         ir_initializer_t *initializer;
 485
 486         assert(is_atomic_entity(entity));
 487
 488         assert(is_Dummy(val) || get_irn_mode(val) == get_type_mode(entity->type));
 489         initializer = create_initializer_const(val);
 490         entity->initializer = initializer;
 491 }
 492
 493 int is_irn_const_expression(ir_node *n)
 494 {
 495         /* we are in danger iff an exception will arise. TODO: be more precisely,
 496          * for instance Div. will NOT rise if divisor != 0
 497          */
 498         if (is_binop(n) && !is_fragile_op(n))
 499                 return is_irn_const_expression(get_binop_left(n)) && is_irn_const_expression(get_binop_right(n));
 500
 501         switch (get_irn_opcode(n)) {
 502         case iro_Const:
 503         case iro_SymConst:
 504         case iro_Unknown:
 505                 return 1;
 506         case iro_Conv:
 507                 return is_irn_const_expression(get_irn_n(n, 0));
 508         default:
 509                 break;
 510         }
 511         return 0;
 512 }
 513
 514 ir_node *copy_const_value(dbg_info *dbg, ir_node *n, ir_node *block)
 515 {
 516         ir_graph *irg = get_irn_irg(block);
 517         ir_node *nn;
 518         ir_mode *m;
 519
 520         /* @@@ GL I think  we should implement this using the routines from irgopt for
 521                dead node elimination/inlineing. */
 522
 523         m = get_irn_mode(n);
 524         switch (get_irn_opcode(n)) {
 525         case iro_Const:
 526                 nn = new_rd_Const(dbg, irg, get_Const_tarval(n));
 527                 break;
 528         case iro_SymConst:
 529                 nn = new_rd_SymConst(dbg, irg, get_irn_mode(n), get_SymConst_symbol(n), get_SymConst_kind(n));
 530                 break;
 531         case iro_Add:
 532                 nn = new_rd_Add(dbg, block,
 533                                 copy_const_value(dbg, get_Add_left(n), block),
 534                                 copy_const_value(dbg, get_Add_right(n), block), m);
 535                 break;
 536         case iro_Sub:
 537                 nn = new_rd_Sub(dbg, block,
 538                                 copy_const_value(dbg, get_Sub_left(n), block),
 539                                 copy_const_value(dbg, get_Sub_right(n), block), m);
 540                 break;
 541         case iro_Mul:
 542                 nn = new_rd_Mul(dbg, block,
 543                                 copy_const_value(dbg, get_Mul_left(n), block),
 544                                 copy_const_value(dbg, get_Mul_right(n), block), m);
 545                 break;
 546         case iro_And:
 547                 nn = new_rd_And(dbg, block,
 548                                 copy_const_value(dbg, get_And_left(n), block),
 549                                 copy_const_value(dbg, get_And_right(n), block), m);
 550                 break;
 551         case iro_Or:
 552                 nn = new_rd_Or(dbg, block,
 553                                copy_const_value(dbg, get_Or_left(n), block),
 554                                copy_const_value(dbg, get_Or_right(n), block), m);
 555                 break;
 556         case iro_Eor:
 557                 nn = new_rd_Eor(dbg, block,
 558                                 copy_const_value(dbg, get_Eor_left(n), block),
 559                                 copy_const_value(dbg, get_Eor_right(n), block), m);
 560                 break;
 561         case iro_Conv:
 562                 nn = new_rd_Conv(dbg, block,
 563                                  copy_const_value(dbg, get_Conv_op(n), block), m);
 564                 break;
 565         case iro_Minus:
 566                 nn = new_rd_Minus(dbg, block,
 567                                   copy_const_value(dbg, get_Minus_op(n), block), m);
 568                 break;
 569         case iro_Not:
 570                 nn = new_rd_Not(dbg, block,
 571                                 copy_const_value(dbg, get_Not_op(n), block), m);
 572                 break;
 573         case iro_Unknown:
 574                 nn = new_r_Unknown(irg, m); break;
 575         default:
 576                 panic("opcode invalid or not implemented %+F", n);
 577         }
 578         return nn;
 579 }
 580
 581 const char *get_initializer_kind_name(ir_initializer_kind_t ini)
 582 {
 583 #define X(a)    case a: return #a
 584         switch (ini) {
 585         X(IR_INITIALIZER_CONST);
 586         X(IR_INITIALIZER_TARVAL);
 587         X(IR_INITIALIZER_NULL);
 588         X(IR_INITIALIZER_COMPOUND);
 589     default: return "BAD VALUE";
 590         }
 591 #undef X
 592 }
 593
 594 static ir_initializer_t null_initializer = { IR_INITIALIZER_NULL };
 595
 596 ir_initializer_t *get_initializer_null(void)
 597 {
 598         return &null_initializer;
 599 }
 600
 601 ir_initializer_t *create_initializer_const(ir_node *value)
 602 {
 603         struct obstack *obst = get_irg_obstack(get_const_code_irg());
 604
 605         ir_initializer_t *initializer
 606                 = (ir_initializer_t*)OALLOC(obst, ir_initializer_const_t);
 607         initializer->kind         = IR_INITIALIZER_CONST;
 608         initializer->consti.value = value;
 609
 610         return initializer;
 611 }
 612
 613 ir_initializer_t *create_initializer_tarval(ir_tarval *tv)
 614 {
 615         struct obstack *obst = get_irg_obstack(get_const_code_irg());
 616
 617         ir_initializer_t *initializer
 618                 = (ir_initializer_t*)OALLOC(obst, ir_initializer_tarval_t);
 619         initializer->kind         = IR_INITIALIZER_TARVAL;
 620         initializer->tarval.value = tv;
 621
 622         return initializer;
 623 }
 624
 625 ir_initializer_t *create_initializer_compound(size_t n_entries)
 626 {
 627         struct obstack *obst = get_irg_obstack(get_const_code_irg());
 628
 629         size_t i;
 630         size_t size  = sizeof(ir_initializer_compound_t)
 631                      + n_entries * sizeof(ir_initializer_t*)
 632                      - sizeof(ir_initializer_t*);
 633
 634         ir_initializer_t *initializer
 635                 = (ir_initializer_t*)obstack_alloc(obst, size);
 636         initializer->kind                    = IR_INITIALIZER_COMPOUND;
 637         initializer->compound.n_initializers = n_entries;
 638
 639         for (i = 0; i < n_entries; ++i) {
 640                 initializer->compound.initializers[i] = get_initializer_null();
 641         }
 642
 643         return initializer;
 644 }
 645
 646 ir_node *get_initializer_const_value(const ir_initializer_t *initializer)
 647 {
 648         assert(initializer->kind == IR_INITIALIZER_CONST);
 649         return skip_Id(initializer->consti.value);
 650 }
 651
 652 ir_tarval *get_initializer_tarval_value(const ir_initializer_t *initializer)
 653 {
 654         assert(initializer->kind == IR_INITIALIZER_TARVAL);
 655         return initializer->tarval.value;
 656 }
 657
 658 size_t get_initializer_compound_n_entries(const ir_initializer_t *initializer)
 659 {
 660         assert(initializer->kind == IR_INITIALIZER_COMPOUND);
 661         return initializer->compound.n_initializers;
 662 }
 663
 664 void set_initializer_compound_value(ir_initializer_t *initializer,
 665                                     size_t index, ir_initializer_t *value)
 666 {
 667         assert(initializer->kind == IR_INITIALIZER_COMPOUND);
 668         assert(index < initializer->compound.n_initializers);
 669
 670         initializer->compound.initializers[index] = value;
 671 }
 672
 673 ir_initializer_t *get_initializer_compound_value(
 674                 const ir_initializer_t *initializer, size_t index)
 675 {
 676         assert(initializer->kind == IR_INITIALIZER_COMPOUND);
 677         assert(index < initializer->compound.n_initializers);
 678
 679         return initializer->compound.initializers[index];
 680 }
 681
 682 ir_initializer_kind_t get_initializer_kind(const ir_initializer_t *initializer)
 683 {
 684         return initializer->kind;
 685 }
 686
 687 static void check_entity_initializer(ir_entity *entity)
 688 {
 689 #ifndef NDEBUG
 690         ir_initializer_t *initializer = entity->initializer;
 691         ir_type          *entity_tp   = get_entity_type(entity);
 692         switch (initializer->kind) {
 693         case IR_INITIALIZER_COMPOUND:
 694                 assert(is_compound_type(entity_tp) || is_Array_type(entity_tp));
 695                 break;
 696         case IR_INITIALIZER_CONST:
 697                 /* methods are initialized by a SymConst */
 698                 assert(is_atomic_type(entity_tp) || is_Method_type(entity_tp));
 699                 break;
 700         case IR_INITIALIZER_TARVAL:
 701                 assert(is_atomic_type(entity_tp));
 702                 break;
 703         case IR_INITIALIZER_NULL:
 704                 break;
 705         }
 706 #endif
 707 }
 708
 709 void set_entity_initializer(ir_entity *entity, ir_initializer_t *initializer)
 710 {
 711         entity->initializer = initializer;
 712         check_entity_initializer(entity);
 713 }
 714
 715 int has_entity_initializer(const ir_entity *entity)
 716 {
 717         return entity->initializer != NULL;
 718 }
 719
 720 ir_initializer_t *get_entity_initializer(const ir_entity *entity)
 721 {
 722         return entity->initializer;
 723 }
 724
 725 int (get_entity_offset)(const ir_entity *ent)
 726 {
 727         return _get_entity_offset(ent);
 728 }
 729
 730 void (set_entity_offset)(ir_entity *ent, int offset)
 731 {
 732         _set_entity_offset(ent, offset);
 733 }
 734
 735 unsigned char (get_entity_offset_bits_remainder)(const ir_entity *ent)
 736 {
 737         return _get_entity_offset_bits_remainder(ent);
 738 }
 739
 740 void (set_entity_offset_bits_remainder)(ir_entity *ent, unsigned char offset)
 741 {
 742         _set_entity_offset_bits_remainder(ent, offset);
 743 }
 744
 745 void add_entity_overwrites(ir_entity *ent, ir_entity *overwritten)
 746 {
 747         if (ent->overwrites == NULL) {
 748                 ent->overwrites = NEW_ARR_F(ir_entity*, 0);
 749         }
 750         ARR_APP1(ir_entity *, ent->overwrites, overwritten);
 751         if (overwritten->overwrittenby == NULL) {
 752                 overwritten->overwrittenby = NEW_ARR_F(ir_entity*, 0);
 753         }
 754         ARR_APP1(ir_entity *, overwritten->overwrittenby, ent);
 755 }
 756
 757 size_t get_entity_n_overwrites(const ir_entity *ent)
 758 {
 759         if (ent->overwrites == NULL)
 760                 return 0;
 761         return ARR_LEN(ent->overwrites);
 762 }
 763
 764 size_t get_entity_overwrites_index(const ir_entity *ent, ir_entity *overwritten)
 765 {
 766         size_t i;
 767         size_t n = get_entity_n_overwrites(ent);
 768         for (i = 0; i < n; ++i) {
 769                 if (get_entity_overwrites(ent, i) == overwritten)
 770                         return i;
 771         }
 772         return (size_t)-1;
 773 }
 774
 775 ir_entity *get_entity_overwrites(const ir_entity *ent, size_t pos)
 776 {
 777         assert(pos < get_entity_n_overwrites(ent));
 778         return ent->overwrites[pos];
 779 }
 780
 781 void set_entity_overwrites(ir_entity *ent, size_t pos, ir_entity *overwritten)
 782 {
 783         assert(pos < get_entity_n_overwrites(ent));
 784         ent->overwrites[pos] = overwritten;
 785 }
 786
 787 void remove_entity_overwrites(ir_entity *ent, ir_entity *overwritten)
 788 {
 789         size_t i;
 790         size_t n = get_entity_n_overwrites(ent);
 791         for (i = 0; i < n; ++i) {
 792                 if (ent->overwrites[i] == overwritten) {
 793                         for (; i < n - 1; i++)
 794                                 ent->overwrites[i] = ent->overwrites[i+1];
 795                         ARR_SETLEN(ir_entity*, ent->overwrites, n - 1);
 796                         break;
 797                 }
 798         }
 799 }
 800
 801
 802 size_t get_entity_n_overwrittenby(const ir_entity *ent)
 803 {
 804         if (ent->overwrittenby == NULL)
 805                 return 0;
 806         return ARR_LEN(ent->overwrittenby);
 807 }
 808
 809 size_t get_entity_overwrittenby_index(const ir_entity *ent,
 810                                       ir_entity *overwrites)
 811 {
 812         size_t i;
 813         size_t n = get_entity_n_overwrittenby(ent);
 814         for (i = 0; i < n; ++i) {
 815                 if (get_entity_overwrittenby(ent, i) == overwrites)
 816                         return i;
 817         }
 818         return (size_t)-1;
 819 }
 820
 821 ir_entity *get_entity_overwrittenby(const ir_entity *ent, size_t pos)
 822 {
 823         assert(pos < get_entity_n_overwrittenby(ent));
 824         return ent->overwrittenby[pos];
 825 }
 826
 827 void set_entity_overwrittenby(ir_entity *ent, size_t pos, ir_entity *overwrites)
 828 {
 829         assert(pos < get_entity_n_overwrittenby(ent));
 830         ent->overwrittenby[pos] = overwrites;
 831 }
 832
 833 void remove_entity_overwrittenby(ir_entity *ent, ir_entity *overwrites)
 834 {
 835         size_t i;
 836         size_t n = get_entity_n_overwrittenby(ent);
 837         for (i = 0; i < n; ++i) {
 838                 if (ent->overwrittenby[i] == overwrites) {
 839                         for (; i < n - 1; ++i)
 840                                 ent->overwrittenby[i] = ent->overwrittenby[i+1];
 841                         ARR_SETLEN(ir_entity*, ent->overwrittenby, n - 1);
 842                         break;
 843                 }
 844         }
 845 }
 846
 847 void *(get_entity_link)(const ir_entity *ent)
 848 {
 849         return _get_entity_link(ent);
 850 }
 851
 852 void (set_entity_link)(ir_entity *ent, void *l)
 853 {
 854         _set_entity_link(ent, l);
 855 }
 856
 857 ir_graph *(get_entity_irg)(const ir_entity *ent)
 858 {
 859         return _get_entity_irg(ent);
 860 }
 861
 862 void set_entity_irg(ir_entity *ent, ir_graph *irg)
 863 {
 864         assert(is_method_entity(ent));
 865         assert(get_entity_peculiarity(ent) == peculiarity_existent);
 866         ent->attr.mtd_attr.irg = irg;
 867 }
 868
 869 int (is_parameter_entity)(const ir_entity *entity)
 870 {
 871         return _is_parameter_entity(entity);
 872 }
 873
 874 size_t (get_entity_parameter_number)(const ir_entity *entity)
 875 {
 876         return _get_entity_parameter_number(entity);
 877 }
 878
 879 void set_entity_parameter_number(ir_entity *entity, size_t n)
 880 {
 881         assert(is_parameter_entity(entity));
 882         entity->attr.parameter.number = n;
 883 }
 884
 885 unsigned get_entity_vtable_number(const ir_entity *ent)
 886 {
 887         assert(is_method_entity((ir_entity *)ent));
 888         return ent->attr.mtd_attr.vtable_number;
 889 }
 890
 891 void set_entity_vtable_number(ir_entity *ent, unsigned vtable_number)
 892 {
 893         assert(is_method_entity(ent));
 894         ent->attr.mtd_attr.vtable_number = vtable_number;
 895 }
 896
 897 int is_unknown_entity(const ir_entity *entity)
 898 {
 899         return entity->entity_kind == IR_ENTITY_UNKNOWN;
 900 }
 901
 902 int (is_entity)(const void *thing)
 903 {
 904         return _is_entity(thing);
 905 }
 906
 907 int is_atomic_entity(const ir_entity *ent)
 908 {
 909         ir_type *t      = get_entity_type(ent);
 910         const tp_op *op = get_type_tpop(t);
 911         return (op == type_primitive || op == type_pointer ||
 912                 op == type_enumeration || op == type_method);
 913 }
 914
 915 int is_compound_entity(const ir_entity *ent)
 916 {
 917         ir_type     *t  = get_entity_type(ent);
 918         const tp_op *op = get_type_tpop(t);
 919         return (op == type_class || op == type_struct ||
 920                 op == type_array || op == type_union);
 921 }
 922
 923 int is_method_entity(const ir_entity *ent)
 924 {
 925         ir_type *t = get_entity_type(ent);
 926         return is_Method_type(t);
 927 }
 928
 929 ir_visited_t (get_entity_visited)(const ir_entity *ent)
 930 {
 931         return _get_entity_visited(ent);
 932 }
 933
 934 void (set_entity_visited)(ir_entity *ent, ir_visited_t num)
 935 {
 936         _set_entity_visited(ent, num);
 937 }
 938
 939 void (mark_entity_visited)(ir_entity *ent)
 940 {
 941         _mark_entity_visited(ent);
 942 }
 943
 944 int (entity_visited)(const ir_entity *ent)
 945 {
 946         return _entity_visited(ent);
 947 }
 948
 949 int (entity_not_visited)(const ir_entity *ent)
 950 {
 951         return _entity_not_visited(ent);
 952 }
 953
 954 mtp_additional_properties get_entity_additional_properties(const ir_entity *ent)
 955 {
 956         assert(is_method_entity(ent));
 957         return ent->attr.mtd_attr.properties;
 958 }
 959
 960 void set_entity_additional_properties(ir_entity *ent, mtp_additional_properties property_mask)
 961 {
 962         assert(is_method_entity(ent));
 963         /* you mustn't set less properties than the entities type */
 964         assert((get_method_additional_properties(get_entity_type(ent)) & ~property_mask) == 0);
 965
 966         /* do not allow to set the mtp_property_inherited flag or
 967          * the automatic inheritance of flags will not work */
 968         ent->attr.mtd_attr.properties = property_mask;
 969 }
 970
 971 void add_entity_additional_properties(ir_entity *ent, mtp_additional_properties properties)
 972 {
 973         assert(is_method_entity(ent));
 974
 975         /* do not allow to set the mtp_property_inherited flag or
 976          * the automatic inheritance of flags will not work */
 977         ent->attr.mtd_attr.properties |= properties;
 978 }
 979
 980 dbg_info *(get_entity_dbg_info)(const ir_entity *ent)
 981 {
 982         return _get_entity_dbg_info(ent);
 983 }
 984
 985 void (set_entity_dbg_info)(ir_entity *ent, dbg_info *db)
 986 {
 987         _set_entity_dbg_info(ent, db);
 988 }
 989
 990 int entity_is_externally_visible(const ir_entity *entity)
 991 {
 992         return get_entity_visibility(entity) != ir_visibility_local
 993                 || (get_entity_linkage(entity) & IR_LINKAGE_HIDDEN_USER);
 994 }
 995
 996 int entity_has_definition(const ir_entity *entity)
 997 {
 998         if (is_method_entity(entity)) {
 999                 return get_entity_irg(entity) != NULL
1000                     && (get_entity_linkage(entity) & IR_LINKAGE_NO_CODEGEN) == 0;
1001         } else {
1002                 return entity->initializer != NULL;
1003         }
1004 }
1005
1006 void ir_init_entity(ir_prog *irp)
1007 {
1008         ident   *const id    = new_id_from_str(UNKNOWN_ENTITY_NAME);
1009         ir_type *const utype = get_unknown_type();
1010         irp->unknown_entity = intern_new_entity(utype, IR_ENTITY_UNKNOWN, id, utype, NULL);
1011         set_entity_visibility(irp->unknown_entity, ir_visibility_external);
1012         set_entity_ld_ident(irp->unknown_entity, id);
1013         hook_new_entity(irp->unknown_entity);
1014 }
1015
1016 void ir_finish_entity(ir_prog *irp)
1017 {
1018         free_entity(irp->unknown_entity);
1019 }
1020
1021 ir_allocation get_entity_allocation(const ir_entity *entity)
1022 {
1023         return (ir_allocation)entity->allocation;
1024 }
1025
1026 void set_entity_allocation(ir_entity *entity, ir_allocation allocation)
1027 {
1028         entity->allocation = allocation;
1029 }
1030
1031 ir_peculiarity get_entity_peculiarity(const ir_entity *entity)
1032 {
1033         return (ir_peculiarity)entity->peculiarity;
1034 }
1035
1036 void set_entity_peculiarity(ir_entity *entity, ir_peculiarity peculiarity)
1037 {
1038         entity->peculiarity = peculiarity;
1039 }
1040
1041 void set_entity_final(ir_entity *entity, int final)
1042 {
1043         entity->final = final;
1044 }
1045
1046 int is_entity_final(const ir_entity *entity)
1047 {
1048         return entity->final;
1049 }