nsz Git - libfirm/blob - ir/ir/irnode.c

   1 /*
   2  * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   6  * This file may be distributed and/or modified under the terms of the
   7  * GNU General Public License version 2 as published by the Free Software
   8  * Foundation and appearing in the file LICENSE.GPL included in the
   9  * packaging of this file.
  10  *
  11  * Licensees holding valid libFirm Professional Edition licenses may use
  12  * this file in accordance with the libFirm Commercial License.
  13  * Agreement provided with the Software.
  14  *
  15  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief   Representation of an intermediate operation.
  23  * @author  Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Michael Beck
  24  */
  25 #include "config.h"
  26
  27 #include <string.h>
  28
  29 #include "pset_new.h"
  30 #include "ident.h"
  31 #include "irnode_t.h"
  32 #include "irgraph_t.h"
  33 #include "irmode_t.h"
  34 #include "irbackedge_t.h"
  35 #include "irdump.h"
  36 #include "irop_t.h"
  37 #include "irprog_t.h"
  38 #include "iredgekinds.h"
  39 #include "iredges_t.h"
  40 #include "ircons.h"
  41 #include "error.h"
  42
  43 #include "irhooks.h"
  44 #include "irtools.h"
  45 #include "util.h"
  46
  47 #include "beinfo.h"
  48
  49 /* some constants fixing the positions of nodes predecessors
  50    in the in array */
  51 #define CALL_PARAM_OFFSET     (n_Call_max+1)
  52 #define BUILTIN_PARAM_OFFSET  (n_Builtin_max+1)
  53 #define ASM_PARAM_OFFSET      (n_ASM_max+1)
  54 #define SEL_INDEX_OFFSET      (n_Sel_max+1)
  55 #define RETURN_RESULT_OFFSET  (n_Return_max+1)
  56 #define END_KEEPALIVE_OFFSET  0
  57
  58 static const char *relation_names [] = {
  59         "false",
  60         "equal",
  61         "less",
  62         "less_equal",
  63         "greater",
  64         "greater_equal",
  65         "less_greater",
  66         "less_equal_greater",
  67         "unordered",
  68         "unordered_equal",
  69         "unordered_less",
  70         "unordered_less_equal",
  71         "unordered_greater",
  72         "unordered_greater_equal",
  73         "not_equal",
  74         "true"
  75 };
  76
  77 const char *get_relation_string(ir_relation relation)
  78 {
  79         assert(relation < (ir_relation)ARRAY_SIZE(relation_names));
  80         return relation_names[relation];
  81 }
  82
  83 ir_relation get_negated_relation(ir_relation relation)
  84 {
  85         return relation ^ ir_relation_true;
  86 }
  87
  88 ir_relation get_inversed_relation(ir_relation relation)
  89 {
  90         ir_relation code    = relation & ~(ir_relation_less|ir_relation_greater);
  91         bool        less    = relation & ir_relation_less;
  92         bool        greater = relation & ir_relation_greater;
  93         code |= (less ? ir_relation_greater : ir_relation_false)
  94               | (greater ? ir_relation_less : ir_relation_false);
  95         return code;
  96 }
  97
  98 ir_node *new_ir_node(dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op,
  99                      ir_mode *mode, int arity, ir_node *const *in)
 100 {
 101         int i;
 102
 103         assert(irg);
 104         assert(op);
 105         assert(mode);
 106
 107         size_t   const node_size = offsetof(ir_node, attr) + op->attr_size;
 108         ir_node *const res       = (ir_node*)OALLOCNZ(get_irg_obstack(irg), char, node_size);
 109
 110         res->kind     = k_ir_node;
 111         res->op       = op;
 112         res->mode     = mode;
 113         res->visited  = 0;
 114         res->node_idx = irg_register_node_idx(irg, res);
 115         res->link     = NULL;
 116         res->deps     = NULL;
 117
 118         if (arity < 0) {
 119                 res->in = NEW_ARR_F(ir_node *, 1);  /* 1: space for block */
 120         } else {
 121                 /* not nice but necessary: End and Sync must always have a flexible array */
 122                 if (op == op_End || op == op_Sync)
 123                         res->in = NEW_ARR_F(ir_node *, (arity+1));
 124                 else
 125                         res->in = NEW_ARR_D(ir_node*, get_irg_obstack(irg), arity + 1);
 126                 memcpy(&res->in[1], in, sizeof(ir_node *) * arity);
 127         }
 128
 129         res->in[0]   = block;
 130         set_irn_dbg_info(res, db);
 131         res->node_nr = get_irp_new_node_nr();
 132
 133         for (i = 0; i < EDGE_KIND_LAST; ++i) {
 134                 INIT_LIST_HEAD(&res->edge_info[i].outs_head);
 135                 /* edges will be build immediately */
 136                 res->edge_info[i].edges_built = 1;
 137                 res->edge_info[i].out_count = 0;
 138         }
 139
 140         /* don't put this into the for loop, arity is -1 for some nodes! */
 141         if (block != NULL)
 142                 edges_notify_edge(res, -1, block, NULL, irg);
 143         for (i = 1; i <= arity; ++i)
 144                 edges_notify_edge(res, i - 1, res->in[i], NULL, irg);
 145
 146         hook_new_node(irg, res);
 147         if (irg_is_constrained(irg, IR_GRAPH_CONSTRAINT_BACKEND)) {
 148                 be_info_new_node(irg, res);
 149         }
 150
 151         return res;
 152 }
 153
 154 int (is_ir_node)(const void *thing)
 155 {
 156         return is_ir_node_(thing);
 157 }
 158
 159 int (get_irn_arity)(const ir_node *node)
 160 {
 161         return get_irn_arity_(node);
 162 }
 163
 164 ir_node **get_irn_in(const ir_node *node)
 165 {
 166         return node->in;
 167 }
 168
 169 void set_irn_in(ir_node *node, int arity, ir_node **in)
 170 {
 171         int i;
 172         ir_node *** pOld_in;
 173         ir_graph *irg = get_irn_irg(node);
 174
 175         pOld_in = &node->in;
 176
 177 #ifndef NDEBUG
 178         assert(node != NULL && node->kind == k_ir_node);
 179         assert(arity >= 0);
 180         for (i = 0; i < arity; ++i) {
 181                 assert(in[i] != NULL && in[0]->kind == k_ir_node);
 182         }
 183 #endif
 184
 185         for (i = 0; i < arity; i++) {
 186                 if (i < (int)ARR_LEN(*pOld_in)-1)
 187                         edges_notify_edge(node, i, in[i], (*pOld_in)[i+1], irg);
 188                 else
 189                         edges_notify_edge(node, i, in[i], NULL,            irg);
 190         }
 191         for (;i < (int)ARR_LEN(*pOld_in)-1; i++) {
 192                 edges_notify_edge(node, i, NULL, (*pOld_in)[i+1], irg);
 193         }
 194
 195         if (arity != (int)ARR_LEN(*pOld_in) - 1) {
 196                 ir_node * block = (*pOld_in)[0];
 197                 *pOld_in = NEW_ARR_D(ir_node*, get_irg_obstack(irg), arity + 1);
 198                 (*pOld_in)[0] = block;
 199         }
 200         fix_backedges(get_irg_obstack(irg), node);
 201
 202         memcpy((*pOld_in) + 1, in, sizeof(ir_node *) * arity);
 203
 204         /* update irg flags */
 205         clear_irg_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_OUTS | IR_GRAPH_PROPERTY_CONSISTENT_LOOPINFO);
 206 }
 207
 208 ir_node *(get_irn_n)(const ir_node *node, int n)
 209 {
 210         return get_irn_n_(node, n);
 211 }
 212
 213 void set_irn_n(ir_node *node, int n, ir_node *in)
 214 {
 215         ir_graph *irg = get_irn_irg(node);
 216         assert(node && node->kind == k_ir_node);
 217         assert(-1 <= n);
 218         assert(n < get_irn_arity(node));
 219         assert(in && in->kind == k_ir_node);
 220
 221         /* Call the hook */
 222         hook_set_irn_n(node, n, in, node->in[n + 1]);
 223
 224         /* Here, we rely on src and tgt being in the current ir graph */
 225         edges_notify_edge(node, n, in, node->in[n + 1], irg);
 226
 227         node->in[n + 1] = in;
 228
 229         /* update irg flags */
 230         clear_irg_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_OUTS | IR_GRAPH_PROPERTY_CONSISTENT_LOOPINFO);
 231 }
 232
 233 int add_irn_n(ir_node *node, ir_node *in)
 234 {
 235         int pos;
 236         ir_graph *irg = get_irn_irg(node);
 237
 238         assert(node->op->opar == oparity_dynamic);
 239         pos = ARR_LEN(node->in) - 1;
 240         ARR_APP1(ir_node *, node->in, in);
 241         edges_notify_edge(node, pos, node->in[pos + 1], NULL, irg);
 242
 243         /* Call the hook */
 244         hook_set_irn_n(node, pos, node->in[pos + 1], NULL);
 245
 246         /* update irg flags */
 247         clear_irg_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_OUTS);
 248
 249         return pos;
 250 }
 251
 252 static void del_irn_n(ir_node *node, int n)
 253 {
 254         ir_graph *irg = get_irn_irg(node);
 255
 256         /* remove the edge */
 257         ir_node *pred = node->in[n+1];
 258         edges_notify_edge(node, n, NULL, pred, irg);
 259
 260         int arity = get_irn_arity(node);
 261         if (n != arity-1) {
 262                 /* exchange with the last one */
 263                 ir_node *old = node->in[arity];
 264                 edges_notify_edge(node, arity-1, NULL, old, irg);
 265                 node->in[n+1] = old;
 266                 edges_notify_edge(node, n, old, NULL, irg);
 267         }
 268         ARR_SHRINKLEN(node->in, arity);
 269
 270         /* update irg flags */
 271         clear_irg_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_OUTS);
 272 }
 273
 274 void del_Sync_n(ir_node *n, int i)
 275 {
 276         del_irn_n(n, i);
 277 }
 278
 279 int (get_irn_deps)(const ir_node *node)
 280 {
 281         return get_irn_deps_(node);
 282 }
 283
 284 ir_node *(get_irn_dep)(const ir_node *node, int pos)
 285 {
 286         return get_irn_dep_(node, pos);
 287 }
 288
 289 void set_irn_dep(ir_node *node, int pos, ir_node *dep)
 290 {
 291         ir_node *old;
 292         ir_graph *irg;
 293
 294         assert(node->deps && "dependency array node yet allocated. use add_irn_dep()");
 295         assert(pos >= 0 && pos < (int)ARR_LEN(node->deps) && "dependency index out of range");
 296         assert(dep != NULL);
 297         old = node->deps[pos];
 298         node->deps[pos] = dep;
 299         irg = get_irn_irg(node);
 300         if (edges_activated_kind(irg, EDGE_KIND_DEP))
 301                 edges_notify_edge_kind(node, pos, dep, old, EDGE_KIND_DEP, irg);
 302 }
 303
 304 void add_irn_dep(ir_node *node, ir_node *dep)
 305 {
 306         ir_graph *irg;
 307         assert(dep != NULL);
 308         if (node->deps == NULL) {
 309                 node->deps = NEW_ARR_F(ir_node *, 0);
 310         }
 311         ARR_APP1(ir_node*, node->deps, dep);
 312         irg = get_irn_irg(node);
 313         if (edges_activated_kind(irg, EDGE_KIND_DEP))
 314                 edges_notify_edge_kind(node, ARR_LEN(node->deps)-1, dep, NULL, EDGE_KIND_DEP, irg);
 315 }
 316
 317 void delete_irn_dep(ir_node *node, ir_node *dep)
 318 {
 319         size_t i;
 320         size_t n_deps;
 321         if (node->deps == NULL)
 322                 return;
 323
 324         n_deps = ARR_LEN(node->deps);
 325         for (i = 0; i < n_deps; ++i) {
 326                 if (node->deps[i] == dep) {
 327                         set_irn_dep(node, i, node->deps[n_deps-1]);
 328                         edges_notify_edge(node, i, NULL, dep, get_irn_irg(node));
 329                         ARR_SHRINKLEN(node->deps, n_deps-1);
 330                         break;
 331                 }
 332         }
 333 }
 334
 335 void add_irn_deps(ir_node *tgt, ir_node *src)
 336 {
 337         int i, n;
 338
 339         for (i = 0, n = get_irn_deps(src); i < n; ++i)
 340                 add_irn_dep(tgt, get_irn_dep(src, i));
 341 }
 342
 343
 344 ir_mode *(get_irn_mode)(const ir_node *node)
 345 {
 346         return get_irn_mode_(node);
 347 }
 348
 349 void (set_irn_mode)(ir_node *node, ir_mode *mode)
 350 {
 351         set_irn_mode_(node, mode);
 352 }
 353
 354 ir_op *(get_irn_op)(const ir_node *node)
 355 {
 356         return get_irn_op_(node);
 357 }
 358
 359 void (set_irn_op)(ir_node *node, ir_op *op)
 360 {
 361         set_irn_op_(node, op);
 362 }
 363
 364 unsigned (get_irn_opcode)(const ir_node *node)
 365 {
 366         return get_irn_opcode_(node);
 367 }
 368
 369 const char *get_irn_opname(const ir_node *node)
 370 {
 371         return get_id_str(node->op->name);
 372 }
 373
 374 ident *get_irn_opident(const ir_node *node)
 375 {
 376         assert(node);
 377         return node->op->name;
 378 }
 379
 380 ir_visited_t (get_irn_visited)(const ir_node *node)
 381 {
 382         return get_irn_visited_(node);
 383 }
 384
 385 void (set_irn_visited)(ir_node *node, ir_visited_t visited)
 386 {
 387         set_irn_visited_(node, visited);
 388 }
 389
 390 void (mark_irn_visited)(ir_node *node)
 391 {
 392         mark_irn_visited_(node);
 393 }
 394
 395 int (irn_visited)(const ir_node *node)
 396 {
 397         return irn_visited_(node);
 398 }
 399
 400 int (irn_visited_else_mark)(ir_node *node)
 401 {
 402         return irn_visited_else_mark_(node);
 403 }
 404
 405 void (set_irn_link)(ir_node *node, void *link)
 406 {
 407         set_irn_link_(node, link);
 408 }
 409
 410 void *(get_irn_link)(const ir_node *node)
 411 {
 412         return get_irn_link_(node);
 413 }
 414
 415 op_pin_state (get_irn_pinned)(const ir_node *node)
 416 {
 417         return get_irn_pinned_(node);
 418 }
 419
 420 op_pin_state (is_irn_pinned_in_irg) (const ir_node *node)
 421 {
 422         return is_irn_pinned_in_irg_(node);
 423 }
 424
 425 void set_irn_pinned(ir_node *node, op_pin_state state)
 426 {
 427         /* due to optimization an opt may be turned into a Tuple */
 428         if (is_Tuple(node))
 429                 return;
 430
 431         assert(node && get_op_pinned(get_irn_op(node)) >= op_pin_state_exc_pinned);
 432         assert(state == op_pin_state_pinned || state == op_pin_state_floats);
 433
 434         node->attr.except.pin_state = state;
 435 }
 436
 437 long get_irn_node_nr(const ir_node *node)
 438 {
 439         assert(node);
 440         return node->node_nr;
 441 }
 442
 443 void *(get_irn_generic_attr)(ir_node *node)
 444 {
 445         assert(is_ir_node(node));
 446         return get_irn_generic_attr_(node);
 447 }
 448
 449 const void *(get_irn_generic_attr_const)(const ir_node *node)
 450 {
 451         assert(is_ir_node(node));
 452         return get_irn_generic_attr_const_(node);
 453 }
 454
 455 unsigned (get_irn_idx)(const ir_node *node)
 456 {
 457         assert(is_ir_node(node));
 458         return get_irn_idx_(node);
 459 }
 460
 461 ir_node *(get_nodes_block)(const ir_node *node)
 462 {
 463         return get_nodes_block_(node);
 464 }
 465
 466 void set_nodes_block(ir_node *node, ir_node *block)
 467 {
 468         assert(!is_Block(node));
 469         set_irn_n(node, -1, block);
 470 }
 471
 472 ir_type *is_frame_pointer(const ir_node *n)
 473 {
 474         if (is_Proj(n) && (get_Proj_proj(n) == pn_Start_P_frame_base)) {
 475                 ir_node *start = get_Proj_pred(n);
 476                 if (is_Start(start)) {
 477                         return get_irg_frame_type(get_irn_irg(start));
 478                 }
 479         }
 480         return NULL;
 481 }
 482
 483 ir_node **get_Block_cfgpred_arr(ir_node *node)
 484 {
 485         assert(is_Block(node));
 486         return (ir_node **)&(get_irn_in(node)[1]);
 487 }
 488
 489 int (get_Block_n_cfgpreds)(const ir_node *node)
 490 {
 491         return get_Block_n_cfgpreds_(node);
 492 }
 493
 494 ir_node *(get_Block_cfgpred)(const ir_node *node, int pos)
 495 {
 496         return get_Block_cfgpred_(node, pos);
 497 }
 498
 499 void set_Block_cfgpred(ir_node *node, int pos, ir_node *pred)
 500 {
 501         assert(is_Block(node));
 502         set_irn_n(node, pos, pred);
 503 }
 504
 505 int get_Block_cfgpred_pos(const ir_node *block, const ir_node *pred)
 506 {
 507         int i;
 508
 509         for (i = get_Block_n_cfgpreds(block) - 1; i >= 0; --i) {
 510                 if (get_Block_cfgpred_block(block, i) == pred)
 511                         return i;
 512         }
 513         return -1;
 514 }
 515
 516 ir_node *(get_Block_cfgpred_block)(const ir_node *node, int pos)
 517 {
 518         return get_Block_cfgpred_block_(node, pos);
 519 }
 520
 521 int get_Block_matured(const ir_node *node)
 522 {
 523         assert(is_Block(node));
 524         return (int)node->attr.block.is_matured;
 525 }
 526
 527 void set_Block_matured(ir_node *node, int matured)
 528 {
 529         assert(is_Block(node));
 530         node->attr.block.is_matured = matured;
 531 }
 532
 533 ir_visited_t (get_Block_block_visited)(const ir_node *node)
 534 {
 535         return get_Block_block_visited_(node);
 536 }
 537
 538 void (set_Block_block_visited)(ir_node *node, ir_visited_t visit)
 539 {
 540         set_Block_block_visited_(node, visit);
 541 }
 542
 543 void (mark_Block_block_visited)(ir_node *node)
 544 {
 545         mark_Block_block_visited_(node);
 546 }
 547
 548 int (Block_block_visited)(const ir_node *node)
 549 {
 550         return Block_block_visited_(node);
 551 }
 552
 553 ir_graph *(get_Block_irg)(const ir_node *block)
 554 {
 555         return get_Block_irg_(block);
 556 }
 557
 558 ir_entity *create_Block_entity(ir_node *block)
 559 {
 560         ir_entity *entity;
 561         assert(is_Block(block));
 562
 563         entity = block->attr.block.entity;
 564         if (entity == NULL) {
 565                 ir_label_t nr = get_irp_next_label_nr();
 566                 entity = new_label_entity(nr);
 567                 set_entity_visibility(entity, ir_visibility_local);
 568                 set_entity_linkage(entity, IR_LINKAGE_CONSTANT);
 569                 set_entity_compiler_generated(entity, 1);
 570
 571                 block->attr.block.entity = entity;
 572         }
 573         return entity;
 574 }
 575
 576 ir_node *(get_Block_phis)(const ir_node *block)
 577 {
 578         return get_Block_phis_(block);
 579 }
 580
 581 void (set_Block_phis)(ir_node *block, ir_node *phi)
 582 {
 583         set_Block_phis_(block, phi);
 584 }
 585
 586 void (add_Block_phi)(ir_node *block, ir_node *phi)
 587 {
 588         add_Block_phi_(block, phi);
 589 }
 590
 591 unsigned (get_Block_mark)(const ir_node *block)
 592 {
 593         return get_Block_mark_(block);
 594 }
 595
 596 void (set_Block_mark)(ir_node *block, unsigned mark)
 597 {
 598         set_Block_mark_(block, mark);
 599 }
 600
 601 int get_End_n_keepalives(const ir_node *end)
 602 {
 603         assert(is_End(end));
 604         return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
 605 }
 606
 607 ir_node *get_End_keepalive(const ir_node *end, int pos)
 608 {
 609         assert(is_End(end));
 610         return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
 611 }
 612
 613 void add_End_keepalive(ir_node *end, ir_node *ka)
 614 {
 615         assert(is_End(end));
 616         add_irn_n(end, ka);
 617 }
 618
 619 void set_End_keepalive(ir_node *end, int pos, ir_node *ka)
 620 {
 621         assert(is_End(end));
 622         set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
 623 }
 624
 625 void set_End_keepalives(ir_node *end, int n, ir_node *in[])
 626 {
 627         size_t e;
 628         int    i;
 629         ir_graph *irg = get_irn_irg(end);
 630
 631         /* notify that edges are deleted */
 632         for (e = END_KEEPALIVE_OFFSET; e < ARR_LEN(end->in) - 1; ++e) {
 633                 edges_notify_edge(end, e, NULL, end->in[e + 1], irg);
 634         }
 635         ARR_RESIZE(ir_node *, end->in, n + 1 + END_KEEPALIVE_OFFSET);
 636
 637         for (i = 0; i < n; ++i) {
 638                 end->in[1 + END_KEEPALIVE_OFFSET + i] = in[i];
 639                 edges_notify_edge(end, END_KEEPALIVE_OFFSET + i, end->in[1 + END_KEEPALIVE_OFFSET + i], NULL, irg);
 640         }
 641
 642         /* update irg flags */
 643         clear_irg_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_OUTS);
 644 }
 645
 646 void remove_End_keepalive(ir_node *end, ir_node *irn)
 647 {
 648         int n = get_End_n_keepalives(end);
 649         int idx = -1;
 650         for (int i = n;;) {
 651                 if (i-- == 0)
 652                         return;
 653
 654                 ir_node *old_ka = end->in[1 + END_KEEPALIVE_OFFSET + i];
 655
 656                 /* find irn */
 657                 if (old_ka == irn) {
 658                         idx = END_KEEPALIVE_OFFSET + i;
 659                         break;
 660                 }
 661         }
 662         assert(idx != -1);
 663         del_irn_n(end, idx);
 664 }
 665
 666 void remove_End_Bads_and_doublets(ir_node *end)
 667 {
 668         pset_new_t keeps;
 669         int        idx, n = get_End_n_keepalives(end);
 670         ir_graph   *irg;
 671         bool       changed = false;
 672
 673         if (n <= 0)
 674                 return;
 675
 676         irg = get_irn_irg(end);
 677         pset_new_init(&keeps);
 678
 679         for (idx = n - 1; idx >= 0; --idx) {
 680                 ir_node *ka = get_End_keepalive(end, idx);
 681
 682                 if (is_Bad(ka) || is_NoMem(ka) || pset_new_contains(&keeps, ka)) {
 683                         changed = true;
 684                         del_irn_n(end, idx - END_KEEPALIVE_OFFSET);
 685                         --n;
 686                 } else {
 687                         pset_new_insert(&keeps, ka);
 688                 }
 689         }
 690         pset_new_destroy(&keeps);
 691
 692         if (changed) {
 693                 clear_irg_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_OUTS);
 694         }
 695 }
 696
 697 void free_End(ir_node *end)
 698 {
 699         assert(is_End(end));
 700         end->kind = k_BAD;
 701         DEL_ARR_F(end->in);
 702         end->in = NULL;   /* @@@ make sure we get an error if we use the
 703                              in array afterwards ... */
 704 }
 705
 706 size_t get_Return_n_ress(const ir_node *node)
 707 {
 708         assert(is_Return(node));
 709         return (size_t)(get_irn_arity(node) - RETURN_RESULT_OFFSET);
 710 }
 711
 712 ir_node **get_Return_res_arr(ir_node *node)
 713 {
 714         assert(is_Return(node));
 715         if (get_Return_n_ress(node) > 0)
 716                 return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
 717         else
 718                 return NULL;
 719 }
 720
 721 ir_node *get_Return_res(const ir_node *node, int pos)
 722 {
 723         assert(is_Return(node));
 724         assert(pos >= 0);
 725         assert(get_Return_n_ress(node) > (size_t)pos);
 726         return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
 727 }
 728
 729 void set_Return_res(ir_node *node, int pos, ir_node *res)
 730 {
 731         assert(is_Return(node));
 732         set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
 733 }
 734
 735 int (is_Const_null)(const ir_node *node)
 736 {
 737         return is_Const_null_(node);
 738 }
 739
 740 int (is_Const_one)(const ir_node *node)
 741 {
 742         return is_Const_one_(node);
 743 }
 744
 745 int (is_Const_all_one)(const ir_node *node)
 746 {
 747         return is_Const_all_one_(node);
 748 }
 749
 750
 751
 752 symconst_kind get_SymConst_kind(const ir_node *node)
 753 {
 754         assert(is_SymConst(node));
 755         return node->attr.symc.kind;
 756 }
 757
 758 void set_SymConst_kind(ir_node *node, symconst_kind kind)
 759 {
 760         assert(is_SymConst(node));
 761         node->attr.symc.kind = kind;
 762 }
 763
 764 ir_type *get_SymConst_type(const ir_node *node)
 765 {
 766         /* the cast here is annoying, but we have to compensate for
 767            the skip_tip() */
 768         ir_node *irn = (ir_node *)node;
 769         assert(is_SymConst(node) &&
 770                (SYMCONST_HAS_TYPE(get_SymConst_kind(node))));
 771         return irn->attr.symc.sym.type_p;
 772 }
 773
 774 void set_SymConst_type(ir_node *node, ir_type *tp)
 775 {
 776         assert(is_SymConst(node) &&
 777                (SYMCONST_HAS_TYPE(get_SymConst_kind(node))));
 778         node->attr.symc.sym.type_p = tp;
 779 }
 780
 781 ir_entity *get_SymConst_entity(const ir_node *node)
 782 {
 783         assert(is_SymConst(node) && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
 784         return node->attr.symc.sym.entity_p;
 785 }
 786
 787 void set_SymConst_entity(ir_node *node, ir_entity *ent)
 788 {
 789         assert(is_SymConst(node) && SYMCONST_HAS_ENT(get_SymConst_kind(node)));
 790         node->attr.symc.sym.entity_p  = ent;
 791 }
 792
 793 ir_enum_const *get_SymConst_enum(const ir_node *node)
 794 {
 795         assert(is_SymConst(node) && SYMCONST_HAS_ENUM(get_SymConst_kind(node)));
 796         return node->attr.symc.sym.enum_p;
 797 }
 798
 799 void set_SymConst_enum(ir_node *node, ir_enum_const *ec)
 800 {
 801         assert(is_SymConst(node) && SYMCONST_HAS_ENUM(get_SymConst_kind(node)));
 802         node->attr.symc.sym.enum_p  = ec;
 803 }
 804
 805 union symconst_symbol
 806 get_SymConst_symbol(const ir_node *node)
 807 {
 808         assert(is_SymConst(node));
 809         return node->attr.symc.sym;
 810 }
 811
 812 void set_SymConst_symbol(ir_node *node, union symconst_symbol sym)
 813 {
 814         assert(is_SymConst(node));
 815         node->attr.symc.sym = sym;
 816 }
 817
 818 int get_Sel_n_indexs(const ir_node *node)
 819 {
 820         assert(is_Sel(node));
 821         return (get_irn_arity(node) - SEL_INDEX_OFFSET);
 822 }
 823
 824 ir_node **get_Sel_index_arr(ir_node *node)
 825 {
 826         assert(is_Sel(node));
 827         if (get_Sel_n_indexs(node) > 0)
 828                 return (ir_node **)& get_irn_in(node)[SEL_INDEX_OFFSET + 1];
 829         else
 830                 return NULL;
 831 }
 832
 833 ir_node *get_Sel_index(const ir_node *node, int pos)
 834 {
 835         assert(is_Sel(node));
 836         return get_irn_n(node, pos + SEL_INDEX_OFFSET);
 837 }
 838
 839 void set_Sel_index(ir_node *node, int pos, ir_node *index)
 840 {
 841         assert(is_Sel(node));
 842         set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
 843 }
 844
 845 ir_node **get_Call_param_arr(ir_node *node)
 846 {
 847         assert(is_Call(node));
 848         return &get_irn_in(node)[CALL_PARAM_OFFSET + 1];
 849 }
 850
 851 int get_Call_n_params(const ir_node *node)
 852 {
 853         assert(is_Call(node));
 854         return get_irn_arity(node) - CALL_PARAM_OFFSET;
 855 }
 856
 857 ir_node *get_Call_param(const ir_node *node, int pos)
 858 {
 859         assert(is_Call(node));
 860         return get_irn_n(node, pos + CALL_PARAM_OFFSET);
 861 }
 862
 863 void set_Call_param(ir_node *node, int pos, ir_node *param)
 864 {
 865         assert(is_Call(node));
 866         set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
 867 }
 868
 869 ir_node **get_Builtin_param_arr(ir_node *node)
 870 {
 871         assert(is_Builtin(node));
 872         return &get_irn_in(node)[BUILTIN_PARAM_OFFSET + 1];
 873 }
 874
 875 int get_Builtin_n_params(const ir_node *node)
 876 {
 877         assert(is_Builtin(node));
 878         return (get_irn_arity(node) - BUILTIN_PARAM_OFFSET);
 879 }
 880
 881 ir_node *get_Builtin_param(const ir_node *node, int pos)
 882 {
 883         assert(is_Builtin(node));
 884         return get_irn_n(node, pos + BUILTIN_PARAM_OFFSET);
 885 }
 886
 887 void set_Builtin_param(ir_node *node, int pos, ir_node *param)
 888 {
 889         assert(is_Builtin(node));
 890         set_irn_n(node, pos + BUILTIN_PARAM_OFFSET, param);
 891 }
 892
 893 const char *get_builtin_kind_name(ir_builtin_kind kind)
 894 {
 895 #define X(a)    case a: return #a
 896         switch (kind) {
 897                 X(ir_bk_trap);
 898                 X(ir_bk_debugbreak);
 899                 X(ir_bk_return_address);
 900                 X(ir_bk_frame_address);
 901                 X(ir_bk_prefetch);
 902                 X(ir_bk_ffs);
 903                 X(ir_bk_clz);
 904                 X(ir_bk_ctz);
 905                 X(ir_bk_popcount);
 906                 X(ir_bk_parity);
 907                 X(ir_bk_bswap);
 908                 X(ir_bk_inport);
 909                 X(ir_bk_outport);
 910                 X(ir_bk_inner_trampoline);
 911         }
 912         return "<unknown>";
 913 #undef X
 914 }
 915
 916
 917 int Call_has_callees(const ir_node *node)
 918 {
 919         assert(is_Call(node));
 920         return ((get_irg_callee_info_state(get_irn_irg(node)) != irg_callee_info_none) &&
 921                 (node->attr.call.callee_arr != NULL));
 922 }
 923
 924 size_t get_Call_n_callees(const ir_node *node)
 925 {
 926   assert(is_Call(node) && node->attr.call.callee_arr);
 927   return ARR_LEN(node->attr.call.callee_arr);
 928 }
 929
 930 ir_entity *get_Call_callee(const ir_node *node, size_t pos)
 931 {
 932         assert(pos < get_Call_n_callees(node));
 933         return node->attr.call.callee_arr[pos];
 934 }
 935
 936 void set_Call_callee_arr(ir_node *node, size_t n, ir_entity ** arr)
 937 {
 938         assert(is_Call(node));
 939         if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
 940                 ir_graph *const irg = get_irn_irg(node);
 941                 node->attr.call.callee_arr = NEW_ARR_D(ir_entity*, get_irg_obstack(irg), n);
 942         }
 943         memcpy(node->attr.call.callee_arr, arr, n * sizeof(ir_entity *));
 944 }
 945
 946 void remove_Call_callee_arr(ir_node *node)
 947 {
 948         assert(is_Call(node));
 949         node->attr.call.callee_arr = NULL;
 950 }
 951
 952 int is_Cast_upcast(ir_node *node)
 953 {
 954         ir_type *totype   = get_Cast_type(node);
 955         ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
 956
 957         assert(get_irg_typeinfo_state(get_irn_irg(node)) == ir_typeinfo_consistent);
 958         assert(fromtype);
 959
 960         while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
 961                 totype   = get_pointer_points_to_type(totype);
 962                 fromtype = get_pointer_points_to_type(fromtype);
 963         }
 964
 965         assert(fromtype);
 966
 967         if (!is_Class_type(totype)) return 0;
 968         return is_SubClass_of(fromtype, totype);
 969 }
 970
 971 int is_Cast_downcast(ir_node *node)
 972 {
 973         ir_type *totype   = get_Cast_type(node);
 974         ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
 975
 976         assert(get_irg_typeinfo_state(get_irn_irg(node)) == ir_typeinfo_consistent);
 977         assert(fromtype);
 978
 979         while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
 980                 totype   = get_pointer_points_to_type(totype);
 981                 fromtype = get_pointer_points_to_type(fromtype);
 982         }
 983
 984         assert(fromtype);
 985
 986         if (!is_Class_type(totype)) return 0;
 987         return is_SubClass_of(totype, fromtype);
 988 }
 989
 990 int (is_unop)(const ir_node *node)
 991 {
 992         return is_unop_(node);
 993 }
 994
 995 ir_node *get_unop_op(const ir_node *node)
 996 {
 997         if (node->op->opar == oparity_unary)
 998                 return get_irn_n(node, node->op->op_index);
 999
1000         assert(node->op->opar == oparity_unary);
1001         return NULL;
1002 }
1003
1004 void set_unop_op(ir_node *node, ir_node *op)
1005 {
1006         if (node->op->opar == oparity_unary)
1007                 set_irn_n(node, node->op->op_index, op);
1008
1009         assert(node->op->opar == oparity_unary);
1010 }
1011
1012 int (is_binop)(const ir_node *node)
1013 {
1014         return is_binop_(node);
1015 }
1016
1017 ir_node *get_binop_left(const ir_node *node)
1018 {
1019         assert(node->op->opar == oparity_binary);
1020         return get_irn_n(node, node->op->op_index);
1021 }
1022
1023 void set_binop_left(ir_node *node, ir_node *left)
1024 {
1025         assert(node->op->opar == oparity_binary);
1026         set_irn_n(node, node->op->op_index, left);
1027 }
1028
1029 ir_node *get_binop_right(const ir_node *node)
1030 {
1031         assert(node->op->opar == oparity_binary);
1032         return get_irn_n(node, node->op->op_index + 1);
1033 }
1034
1035 void set_binop_right(ir_node *node, ir_node *right)
1036 {
1037         assert(node->op->opar == oparity_binary);
1038         set_irn_n(node, node->op->op_index + 1, right);
1039 }
1040
1041 ir_node **get_Phi_preds_arr(ir_node *node)
1042 {
1043   assert(is_Phi(node));
1044   return (ir_node **)&(get_irn_in(node)[1]);
1045 }
1046
1047 int get_Phi_n_preds(const ir_node *node)
1048 {
1049         assert(is_Phi(node));
1050         return get_irn_arity(node);
1051 }
1052
1053 ir_node *get_Phi_pred(const ir_node *node, int pos)
1054 {
1055         assert(is_Phi(node));
1056         return get_irn_n(node, pos);
1057 }
1058
1059 void set_Phi_pred(ir_node *node, int pos, ir_node *pred)
1060 {
1061         assert(is_Phi(node));
1062         set_irn_n(node, pos, pred);
1063 }
1064
1065 ir_node *(get_Phi_next)(const ir_node *phi)
1066 {
1067         return get_Phi_next_(phi);
1068 }
1069
1070 void (set_Phi_next)(ir_node *phi, ir_node *next)
1071 {
1072         set_Phi_next_(phi, next);
1073 }
1074
1075 int is_memop(const ir_node *node)
1076 {
1077         return is_op_uses_memory(get_irn_op(node));
1078 }
1079
1080 ir_node *get_memop_mem(const ir_node *node)
1081 {
1082         const ir_op *op = get_irn_op(node);
1083         assert(is_memop(node));
1084         return get_irn_n(node, op->memory_index);
1085 }
1086
1087 void set_memop_mem(ir_node *node, ir_node *mem)
1088 {
1089         const ir_op *op = get_irn_op(node);
1090         assert(is_memop(node));
1091         set_irn_n(node, op->memory_index, mem);
1092 }
1093
1094 ir_node **get_Sync_preds_arr(ir_node *node)
1095 {
1096         assert(is_Sync(node));
1097         return (ir_node **)&(get_irn_in(node)[1]);
1098 }
1099
1100 int get_Sync_n_preds(const ir_node *node)
1101 {
1102         assert(is_Sync(node));
1103         return (get_irn_arity(node));
1104 }
1105
1106 ir_node *get_Sync_pred(const ir_node *node, int pos)
1107 {
1108         assert(is_Sync(node));
1109         return get_irn_n(node, pos);
1110 }
1111
1112 void set_Sync_pred(ir_node *node, int pos, ir_node *pred)
1113 {
1114         assert(is_Sync(node));
1115         set_irn_n(node, pos, pred);
1116 }
1117
1118 void add_Sync_pred(ir_node *node, ir_node *pred)
1119 {
1120         assert(is_Sync(node));
1121         add_irn_n(node, pred);
1122 }
1123
1124 int (is_arg_Proj)(const ir_node *node)
1125 {
1126         return is_arg_Proj_(node);
1127 }
1128
1129 int is_x_except_Proj(const ir_node *node)
1130 {
1131         ir_node *pred;
1132         if (!is_Proj(node))
1133                 return false;
1134         pred = get_Proj_pred(node);
1135         if (!is_fragile_op(pred))
1136                 return false;
1137         return get_Proj_proj(node) == pred->op->pn_x_except;
1138 }
1139
1140 int is_x_regular_Proj(const ir_node *node)
1141 {
1142         ir_node *pred;
1143         if (!is_Proj(node))
1144                 return false;
1145         pred = get_Proj_pred(node);
1146         if (!is_fragile_op(pred))
1147                 return false;
1148         return get_Proj_proj(node) == pred->op->pn_x_regular;
1149 }
1150
1151 void ir_set_throws_exception(ir_node *node, int throws_exception)
1152 {
1153         except_attr *attr = &node->attr.except;
1154         assert(is_fragile_op(node));
1155         attr->throws_exception = throws_exception;
1156 }
1157
1158 int ir_throws_exception(const ir_node *node)
1159 {
1160         const except_attr *attr = &node->attr.except;
1161         assert(is_fragile_op(node));
1162         return attr->throws_exception;
1163 }
1164
1165 ir_node **get_Tuple_preds_arr(ir_node *node)
1166 {
1167         assert(is_Tuple(node));
1168         return (ir_node **)&(get_irn_in(node)[1]);
1169 }
1170
1171 int get_Tuple_n_preds(const ir_node *node)
1172 {
1173         assert(is_Tuple(node));
1174         return get_irn_arity(node);
1175 }
1176
1177 ir_node *get_Tuple_pred(const ir_node *node, int pos)
1178 {
1179   assert(is_Tuple(node));
1180   return get_irn_n(node, pos);
1181 }
1182
1183 void set_Tuple_pred(ir_node *node, int pos, ir_node *pred)
1184 {
1185         assert(is_Tuple(node));
1186         set_irn_n(node, pos, pred);
1187 }
1188
1189 int get_ASM_n_inputs(const ir_node *node)
1190 {
1191         assert(is_ASM(node));
1192         return get_irn_arity(node) - ASM_PARAM_OFFSET;
1193 }
1194
1195 ir_node *get_ASM_input(const ir_node *node, int pos)
1196 {
1197         return get_irn_n(node, ASM_PARAM_OFFSET + pos);
1198 }
1199
1200 size_t get_ASM_n_output_constraints(const ir_node *node)
1201 {
1202         assert(is_ASM(node));
1203         return ARR_LEN(node->attr.assem.output_constraints);
1204 }
1205
1206 size_t get_ASM_n_clobbers(const ir_node *node)
1207 {
1208         assert(is_ASM(node));
1209         return ARR_LEN(node->attr.assem.clobbers);
1210 }
1211
1212 ir_graph *(get_irn_irg)(const ir_node *node)
1213 {
1214         return get_irn_irg_(node);
1215 }
1216
1217 ir_node *skip_Proj(ir_node *node)
1218 {
1219         /* don't assert node !!! */
1220         if (node == NULL)
1221                 return NULL;
1222
1223         if (is_Proj(node))
1224                 node = get_Proj_pred(node);
1225
1226         return node;
1227 }
1228
1229 const ir_node *
1230 skip_Proj_const(const ir_node *node)
1231 {
1232         /* don't assert node !!! */
1233         if (node == NULL)
1234                 return NULL;
1235
1236         if (is_Proj(node))
1237                 node = get_Proj_pred(node);
1238
1239         return node;
1240 }
1241
1242 ir_node *skip_Tuple(ir_node *node)
1243 {
1244   ir_node *pred;
1245
1246 restart:
1247         if (is_Proj(node)) {
1248             pred = get_Proj_pred(node);
1249
1250                 if (is_Proj(pred)) { /* nested Tuple ? */
1251                     pred = skip_Tuple(pred);
1252
1253                         if (is_Tuple(pred)) {
1254                                 node = get_Tuple_pred(pred, get_Proj_proj(node));
1255                                 goto restart;
1256                         }
1257                 } else if (is_Tuple(pred)) {
1258                         node = get_Tuple_pred(pred, get_Proj_proj(node));
1259                         goto restart;
1260                 }
1261         }
1262         return node;
1263 }
1264
1265 ir_node *skip_Cast(ir_node *node)
1266 {
1267         if (is_Cast(node))
1268                 return get_Cast_op(node);
1269         return node;
1270 }
1271
1272 const ir_node *skip_Cast_const(const ir_node *node)
1273 {
1274         if (is_Cast(node))
1275                 return get_Cast_op(node);
1276         return node;
1277 }
1278
1279 ir_node *skip_Pin(ir_node *node)
1280 {
1281         if (is_Pin(node))
1282                 return get_Pin_op(node);
1283         return node;
1284 }
1285
1286 ir_node *skip_Confirm(ir_node *node)
1287 {
1288         if (is_Confirm(node))
1289                 return get_Confirm_value(node);
1290         return node;
1291 }
1292
1293 ir_node *skip_HighLevel_ops(ir_node *node)
1294 {
1295         while (is_op_highlevel(get_irn_op(node))) {
1296                 node = get_irn_n(node, 0);
1297         }
1298         return node;
1299 }
1300
1301
1302 ir_node *skip_Id(ir_node *node)
1303 {
1304         /* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
1305          * than any other approach, as Id chains are resolved and all point to the real node, or
1306          * all id's are self loops.
1307          *
1308          * Note: This function takes 10% of mostly ANY the compiler run, so it's
1309          * a little bit "hand optimized".
1310          */
1311         ir_node *pred;
1312         /* don't assert node !!! */
1313
1314         if (!node || (node->op != op_Id)) return node;
1315
1316         /* Don't use get_Id_pred():  We get into an endless loop for
1317            self-referencing Ids. */
1318         pred = node->in[0+1];
1319
1320         if (pred->op != op_Id) return pred;
1321
1322         if (node != pred) {  /* not a self referencing Id. Resolve Id chain. */
1323                 ir_node *rem_pred, *res;
1324
1325                 if (pred->op != op_Id) return pred; /* shortcut */
1326                 rem_pred = pred;
1327
1328                 assert(get_irn_arity (node) > 0);
1329
1330                 node->in[0+1] = node;   /* turn us into a self referencing Id:  shorten Id cycles. */
1331                 res = skip_Id(rem_pred);
1332                 if (is_Id(res)) /* self-loop */ return node;
1333
1334                 node->in[0+1] = res;    /* Turn Id chain into Ids all referencing the chain end. */
1335                 return res;
1336         } else {
1337                 return node;
1338         }
1339 }
1340
1341 int (is_SymConst_addr_ent)(const ir_node *node)
1342 {
1343         return is_SymConst_addr_ent_(node);
1344 }
1345
1346 int is_cfop(const ir_node *node)
1347 {
1348         if (is_fragile_op(node) && ir_throws_exception(node))
1349                 return true;
1350
1351         return is_op_cfopcode(get_irn_op(node));
1352 }
1353
1354 int is_unknown_jump(const ir_node *node)
1355 {
1356         return is_op_unknown_jump(get_irn_op(node));
1357 }
1358
1359 int is_fragile_op(const ir_node *node)
1360 {
1361         return is_op_fragile(get_irn_op(node));
1362 }
1363
1364 int (is_irn_forking)(const ir_node *node)
1365 {
1366         return is_irn_forking_(node);
1367 }
1368
1369 void (copy_node_attr)(ir_graph *irg, const ir_node *old_node, ir_node *new_node)
1370 {
1371         copy_node_attr_(irg, old_node, new_node);
1372 }
1373
1374 ir_type *(get_irn_type_attr)(ir_node *node)
1375 {
1376         return get_irn_type_attr_(node);
1377 }
1378
1379 ir_entity *(get_irn_entity_attr)(ir_node *node)
1380 {
1381         return get_irn_entity_attr_(node);
1382 }
1383
1384 int (is_irn_constlike)(const ir_node *node)
1385 {
1386         return is_irn_constlike_(node);
1387 }
1388
1389 int (is_irn_keep)(const ir_node *node)
1390 {
1391         return is_irn_keep_(node);
1392 }
1393
1394 int (is_irn_start_block_placed)(const ir_node *node)
1395 {
1396         return is_irn_start_block_placed_(node);
1397 }
1398
1399 int (is_irn_cse_neutral)(const ir_node *node)
1400 {
1401         return is_irn_cse_neutral_(node);
1402 }
1403
1404 const char *get_cond_jmp_predicate_name(cond_jmp_predicate pred)
1405 {
1406 #define X(a)    case a: return #a
1407         switch (pred) {
1408                 X(COND_JMP_PRED_NONE);
1409                 X(COND_JMP_PRED_TRUE);
1410                 X(COND_JMP_PRED_FALSE);
1411         }
1412         return "<unknown>";
1413 #undef X
1414 }
1415
1416 /** Return the attribute type of a SymConst node if exists */
1417 static ir_type *get_SymConst_attr_type(const ir_node *self)
1418 {
1419         symconst_kind kind = get_SymConst_kind(self);
1420         if (SYMCONST_HAS_TYPE(kind))
1421                 return get_SymConst_type(self);
1422         return NULL;
1423 }
1424
1425 /** Return the attribute entity of a SymConst node if exists */
1426 static ir_entity *get_SymConst_attr_entity(const ir_node *self)
1427 {
1428         symconst_kind kind = get_SymConst_kind(self);
1429         if (SYMCONST_HAS_ENT(kind))
1430                 return get_SymConst_entity(self);
1431         return NULL;
1432 }
1433
1434 static void register_get_type_func(ir_op *op, get_type_attr_func func)
1435 {
1436         op->ops.get_type_attr = func;
1437 }
1438
1439 static void register_get_entity_func(ir_op *op, get_entity_attr_func func)
1440 {
1441         op->ops.get_entity_attr = func;
1442 }
1443
1444 void ir_register_getter_ops(void)
1445 {
1446         register_get_type_func(op_Alloc,    get_Alloc_type);
1447         register_get_type_func(op_Builtin,  get_Builtin_type);
1448         register_get_type_func(op_Call,     get_Call_type);
1449         register_get_type_func(op_Cast,     get_Cast_type);
1450         register_get_type_func(op_CopyB,    get_CopyB_type);
1451         register_get_type_func(op_Free,     get_Free_type);
1452         register_get_type_func(op_InstOf,   get_InstOf_type);
1453         register_get_type_func(op_SymConst, get_SymConst_attr_type);
1454
1455         register_get_entity_func(op_SymConst, get_SymConst_attr_entity);
1456         register_get_entity_func(op_Sel,      get_Sel_entity);
1457         register_get_entity_func(op_Block,    get_Block_entity);
1458 }
1459
1460 void (set_irn_dbg_info)(ir_node *n, dbg_info *db)
1461 {
1462         set_irn_dbg_info_(n, db);
1463 }
1464
1465 dbg_info *(get_irn_dbg_info)(const ir_node *n)
1466 {
1467         return get_irn_dbg_info_(n);
1468 }
1469
1470 ir_switch_table *ir_new_switch_table(ir_graph *irg, size_t n_entries)
1471 {
1472         struct obstack *obst = get_irg_obstack(irg);
1473         ir_switch_table *res = OALLOCFZ(obst, ir_switch_table, entries, n_entries);
1474         res->n_entries = n_entries;
1475         return res;
1476 }
1477
1478 void ir_switch_table_set(ir_switch_table *table, size_t n,
1479                          ir_tarval *min, ir_tarval *max, long pn)
1480 {
1481         ir_switch_table_entry *entry = ir_switch_table_get_entry(table, n);
1482         entry->min = min;
1483         entry->max = max;
1484         entry->pn  = pn;
1485 }
1486
1487 size_t (ir_switch_table_get_n_entries)(const ir_switch_table *table)
1488 {
1489         return ir_switch_table_get_n_entries_(table);
1490 }
1491
1492 ir_tarval *ir_switch_table_get_max(const ir_switch_table *table, size_t e)
1493 {
1494         return ir_switch_table_get_entry_const(table, e)->max;
1495 }
1496
1497 ir_tarval *ir_switch_table_get_min(const ir_switch_table *table, size_t e)
1498 {
1499         return ir_switch_table_get_entry_const(table, e)->min;
1500 }
1501
1502 long ir_switch_table_get_pn(const ir_switch_table *table, size_t e)
1503 {
1504         return ir_switch_table_get_entry_const(table, e)->pn;
1505 }
1506
1507 ir_switch_table *ir_switch_table_duplicate(ir_graph *irg,
1508                                            const ir_switch_table *table)
1509 {
1510         size_t n_entries = ir_switch_table_get_n_entries(table);
1511         size_t e;
1512         ir_switch_table *res = ir_new_switch_table(irg, n_entries);
1513         for (e = 0; e < n_entries; ++e) {
1514                 const ir_switch_table_entry *entry
1515                         = ir_switch_table_get_entry_const(table, e);
1516                 ir_switch_table_entry *new_entry = ir_switch_table_get_entry(res, e);
1517                 *new_entry = *entry;
1518         }
1519         return res;
1520 }
1521
1522 bool only_used_by_keepalive(const ir_node *node)
1523 {
1524         foreach_out_edge(node, edge) {
1525                 ir_node *succ = get_edge_src_irn(edge);
1526                 if (is_End(succ))
1527                         continue;
1528                 if (is_Proj(succ) && only_used_by_keepalive(succ))
1529                         return true;
1530                 /* found a real user */
1531                 return false;
1532         }
1533         return true;
1534 }
1535
1536 /* include generated code */
1537 #include "gen_irnode.c.inl"