nsz Git - libfirm/blob - ir/ir/irnode_t.h

   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 -- private header.
  23  * @author  Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Michael Beck
  24  * @version $Id$
  25  */
  26 #ifndef FIRM_IR_IRNODE_T_H
  27 #define FIRM_IR_IRNODE_T_H
  28
  29 #include "irtypes.h"
  30 #include "irnode.h"
  31 #include "irop_t.h"
  32 #include "irgraph_t.h"
  33 #include "irflag_t.h"
  34 #include "array.h"
  35 #include "iredges_t.h"
  36
  37 /**
  38  * Returns the array with the ins.  The content of the array may not be
  39  * changed.
  40  * Note that this function returns the whole in array including the
  41  * block predecessor. So, it is NOT symmetric with set_irn_in().
  42  */
  43 ir_node     **get_irn_in            (const ir_node *node);
  44
  45 /**
  46  * The amount of additional space for custom data to be allocated upon creating a new node.
  47  */
  48 extern unsigned firm_add_node_size;
  49
  50 /**
  51  * Sets the get_type_attr operation for an ir_op_ops.
  52  *
  53  * @param code   the opcode for the default operation
  54  * @param ops    the operations initialized
  55  *
  56  * @return
  57  *    The operations.
  58  */
  59 ir_op_ops *firm_set_default_get_type_attr(unsigned code, ir_op_ops *ops);
  60
  61 /**
  62  * Sets the get_entity_attr operation for an ir_op_ops.
  63  *
  64  * @param code   the opcode for the default operation
  65  * @param ops    the operations initialized
  66  *
  67  * @return
  68  *    The operations.
  69  */
  70 ir_op_ops *firm_set_default_get_entity_attr(unsigned code, ir_op_ops *ops);
  71
  72 /**
  73  * Returns an array with the predecessors of the Block. Depending on
  74  * the implementation of the graph data structure this can be a copy of
  75  * the internal representation of predecessors as well as the internal
  76  * array itself. Therefore writing to this array might obstruct the IR.
  77  */
  78 ir_node **get_Block_cfgpred_arr(ir_node *node);
  79
  80 /*-------------------------------------------------------------------*/
  81 /*  These function are most used in libfirm.  Give them as static    */
  82 /*  functions so they can be inlined.                                */
  83 /*-------------------------------------------------------------------*/
  84
  85 /**
  86  * Checks whether a pointer points to a ir node.
  87  * Intern version for libFirm.
  88  */
  89 static inline int _is_ir_node(const void *thing)
  90 {
  91         return (get_kind(thing) == k_ir_node);
  92 }
  93
  94 /**
  95  * Gets the op of a node.
  96  * Intern version for libFirm.
  97  */
  98 static inline ir_op *_get_irn_op(const ir_node *node)
  99 {
 100         assert(node);
 101         return node->op;
 102 }
 103
 104 static inline void _set_irn_op(ir_node *node, ir_op *op)
 105 {
 106         assert(node);
 107         node->op = op;
 108 }
 109
 110 /** Copies all attributes stored in the old node  to the new node.
 111     Assumes both have the same opcode and sufficient size. */
 112 static inline void _copy_node_attr(ir_graph *irg, const ir_node *old_node,
 113                                    ir_node *new_node)
 114 {
 115         ir_op *op = _get_irn_op(old_node);
 116
 117         /* must always exist */
 118         op->ops.copy_attr(irg, old_node, new_node);
 119 }
 120
 121 /**
 122  * Gets the opcode of a node.
 123  * Intern version for libFirm.
 124  */
 125 static inline unsigned _get_irn_opcode(const ir_node *node)
 126 {
 127         assert(k_ir_node == get_kind(node));
 128         assert(node->op);
 129         return node->op->code;
 130 }
 131
 132 /**
 133  * Returns the number of predecessors without the block predecessor.
 134  * Intern version for libFirm.
 135  */
 136 static inline int _get_irn_arity(const ir_node *node)
 137 {
 138         return (int)(ARR_LEN(node->in) - 1);
 139 }
 140
 141 /**
 142  * Intern version for libFirm.
 143  */
 144 static inline ir_node *_get_irn_n(const ir_node *node, int n)
 145 {
 146         ir_node *nn;
 147
 148         assert(-1 <= n && n < _get_irn_arity(node));
 149
 150         nn = node->in[n + 1];
 151         if (nn->op != op_Id) return nn;
 152
 153         return (node->in[n + 1] = skip_Id(nn));
 154 }
 155
 156 /**
 157  * returns a hash value for a node
 158  */
 159 static inline unsigned hash_irn(const ir_node *node)
 160 {
 161         return (unsigned) get_irn_idx(node);
 162 }
 163
 164 static inline int _get_irn_deps(const ir_node *node) {
 165         return node->deps ? (int)ARR_LEN(node->deps) : 0;
 166 }
 167
 168 static inline ir_node *_get_irn_dep(const ir_node *node, int pos) {
 169         assert(node->deps && "dependency array node yet allocated. use add_irn_dep()");
 170         assert(pos >= 0 && pos < (int)ARR_LEN(node->deps) && "dependency index out of range");
 171         return node->deps[pos];
 172 }
 173
 174 /* forward declaration outside iredges_t.h to avoid circular include problems */
 175 void edges_notify_edge_kind(ir_node *src, int pos, ir_node *tgt, ir_node *old_tgt, ir_edge_kind_t kind, ir_graph *irg);
 176
 177 static inline void _set_irn_dep(ir_node *node, int pos, ir_node *dep)
 178 {
 179         ir_node *old;
 180
 181         assert(node->deps && "dependency array node yet allocated. use add_irn_dep()");
 182         assert(pos >= 0 && pos < (int)ARR_LEN(node->deps) && "dependency index out of range");
 183         old = node->deps[pos];
 184         node->deps[pos] = dep;
 185         edges_notify_edge_kind(node, pos, dep, old, EDGE_KIND_DEP, get_irn_irg(node));
 186 }
 187
 188
 189 static inline int _get_irn_ins_or_deps(const ir_node *irn)
 190 {
 191         return _get_irn_deps(irn) + _get_irn_arity(irn);
 192 }
 193
 194 static inline ir_node *_get_irn_in_or_dep(const ir_node *irn, int pos)
 195 {
 196         int n_in = get_irn_arity(irn);
 197         return pos < n_in ? get_irn_n(irn, pos) : get_irn_dep(irn, pos - n_in);
 198 }
 199
 200 /**
 201  * Gets the mode of a node.
 202  * Intern version for libFirm.
 203  */
 204 static inline ir_mode *_get_irn_mode(const ir_node *node)
 205 {
 206         assert(node);
 207         return node->mode;
 208 }
 209
 210 /**
 211  * Sets the mode of a node.
 212  * Intern version of libFirm.
 213  */
 214 static inline void _set_irn_mode(ir_node *node, ir_mode *mode)
 215 {
 216         assert(node);
 217         node->mode = mode;
 218 }
 219
 220 static inline int ir_has_irg_ref(const ir_node *node)
 221 {
 222         return is_Block(node) || is_Bad(node) || is_Anchor(node);
 223 }
 224
 225 static inline ir_graph *_get_irn_irg(const ir_node *node)
 226 {
 227         /*
 228          * Do not use get_nodes_block() here, because this
 229          * will check the pinned state.
 230          * However even a 'wrong' block is always in the proper irg.
 231          */
 232         if (! is_Block(node))
 233                 node = get_irn_n(node, -1);
 234         assert(ir_has_irg_ref(node));
 235         return node->attr.irg.irg;
 236 }
 237
 238 static inline ir_node *_get_nodes_block(const ir_node *node)
 239 {
 240         assert(!is_Block(node));
 241         return get_irn_n(node, -1);
 242 }
 243
 244 /**
 245  * Gets the visited counter of a node.
 246  * Intern version for libFirm.
 247  */
 248 static inline ir_visited_t _get_irn_visited(const ir_node *node)
 249 {
 250         assert(node);
 251         return node->visited;
 252 }
 253
 254 /**
 255  * Sets the visited counter of a node.
 256  * Intern version for libFirm.
 257  */
 258 static inline void _set_irn_visited(ir_node *node, ir_visited_t visited)
 259 {
 260         assert(node);
 261         node->visited = visited;
 262 }
 263
 264 /**
 265  * Mark a node as visited in a graph.
 266  * Intern version for libFirm.
 267  */
 268 static inline void _mark_irn_visited(ir_node *node)
 269 {
 270         node->visited = get_irn_irg(node)->visited;
 271 }
 272
 273 /**
 274  * Returns non-zero if a node of was visited.
 275  * Intern version for libFirm.
 276  */
 277 static inline int _irn_visited(const ir_node *node)
 278 {
 279         ir_graph *irg = get_irn_irg(node);
 280         return node->visited >= irg->visited;
 281 }
 282
 283 static inline int _irn_visited_else_mark(ir_node *node)
 284 {
 285         if (_irn_visited(node))
 286                 return 1;
 287         _mark_irn_visited(node);
 288         return 0;
 289 }
 290
 291 /**
 292  * Sets the link of a node.
 293  * Intern version of libFirm.
 294  */
 295 static inline void _set_irn_link(ir_node *node, void *link)
 296 {
 297         assert(node);
 298         node->link = link;
 299 }
 300
 301 /**
 302  * Returns the link of a node.
 303  * Intern version of libFirm.
 304  */
 305 static inline void *_get_irn_link(const ir_node *node)
 306 {
 307         assert(node && _is_ir_node(node));
 308         return node->link;
 309 }
 310
 311 /**
 312  * Returns whether the node _always_ must be pinned.
 313  * I.e., the node is not floating after global cse.
 314  *
 315  * Intern version of libFirm.
 316  */
 317 static inline op_pin_state _get_irn_pinned(const ir_node *node)
 318 {
 319         op_pin_state state;
 320         assert(node && _is_ir_node(node));
 321         /* Check opcode */
 322         state = _get_op_pinned(_get_irn_op(node));
 323
 324         if (state >= op_pin_state_exc_pinned)
 325                 return (op_pin_state)node->attr.except.pin_state;
 326
 327         return state;
 328 }
 329
 330 static inline op_pin_state _is_irn_pinned_in_irg(const ir_node *node)
 331 {
 332         if (get_irg_pinned(get_irn_irg(node)) == op_pin_state_floats)
 333                 return get_irn_pinned(node);
 334         return op_pin_state_pinned;
 335 }
 336
 337 /* include generated code */
 338 #include "gen_irnode.h"
 339
 340 static inline int _is_unop(const ir_node *node)
 341 {
 342         assert(node && _is_ir_node(node));
 343         return (node->op->opar == oparity_unary);
 344 }
 345
 346 static inline int _is_binop(const ir_node *node)
 347 {
 348         assert(node && _is_ir_node(node));
 349         return (node->op->opar == oparity_binary);
 350 }
 351
 352 static inline int _is_strictConv(const ir_node *node)
 353 {
 354         return _is_Conv(node) && get_Conv_strict(node);
 355 }
 356
 357 static inline int _is_SymConst_addr_ent(const ir_node *node)
 358 {
 359         return is_SymConst(node) && get_SymConst_kind(node) == symconst_addr_ent;
 360 }
 361
 362 static inline int _get_Block_n_cfgpreds(const ir_node *node)
 363 {
 364         assert(_is_Block(node));
 365         return _get_irn_arity(node);
 366 }
 367
 368 static inline ir_node *_get_Block_cfgpred(const ir_node *node, int pos)
 369 {
 370         assert(0 <= pos && pos < get_irn_arity(node));
 371         assert(_is_Block(node));
 372         return _get_irn_n(node, pos);
 373 }
 374
 375 /* Get the predecessor block.
 376  *
 377  *  Returns the block corresponding to the predecessor pos.
 378  *
 379  *  There are several ambiguities we resolve with this function:
 380  *  - The direct predecessor can be a Proj, which is not pinned.
 381  *    We walk from the predecessor to the next pinned node
 382  *    (skip_Proj) and return the block that node is in.
 383  *  - If we encounter the Bad node, this function does not return
 384  *    the Start block, but the Bad node.
 385  */
 386 static inline ir_node  *_get_Block_cfgpred_block(const ir_node *node, int pos)
 387 {
 388         ir_node *res = get_Block_cfgpred(node, pos);
 389         if (is_Bad(res)) {
 390                 /* must return a Bad with mode_BB! */
 391                 ir_graph *irg = get_irn_irg(node);
 392                 return new_r_Bad(irg, mode_BB);
 393         } else {
 394                 return get_nodes_block(skip_Proj(res));
 395         }
 396 }
 397
 398 static inline ir_visited_t _get_Block_block_visited(const ir_node *node)
 399 {
 400         assert(is_Block(node));
 401         return node->attr.block.block_visited;
 402 }
 403
 404 static inline void _set_Block_block_visited(ir_node *node, ir_visited_t visit)
 405 {
 406         assert(is_Block(node));
 407         node->attr.block.block_visited = visit;
 408 }
 409
 410 static inline void _mark_Block_block_visited(ir_node *node)
 411 {
 412         ir_graph *irg = get_Block_irg(node);
 413         node->attr.block.block_visited = get_irg_block_visited(irg);
 414 }
 415
 416 static inline int _Block_block_visited(const ir_node *node)
 417 {
 418         ir_graph *irg = get_Block_irg(node);
 419         return node->attr.block.block_visited >= get_irg_block_visited(irg);
 420 }
 421
 422 static inline ir_graph *_get_Block_irg(const ir_node *block)
 423 {
 424         assert(is_Block(block));
 425         return block->attr.irg.irg;
 426 }
 427
 428 static inline ir_tarval *_get_Const_tarval(const ir_node *node) {
 429         assert(_get_irn_op(node) == op_Const);
 430         return node->attr.con.tarval;
 431 }
 432
 433 static inline int _is_Const_null(const ir_node *node) {
 434         return tarval_is_null(_get_Const_tarval(node));
 435 }
 436
 437 static inline int _is_Const_one(const ir_node *node) {
 438         return tarval_is_one(_get_Const_tarval(node));
 439 }
 440
 441 static inline int _is_Const_all_one(const ir_node *node) {
 442         return tarval_is_all_one(_get_Const_tarval(node));
 443 }
 444
 445 static inline int _is_irn_forking(const ir_node *node) {
 446         return is_op_forking(_get_irn_op(node));
 447 }
 448
 449 static inline ir_type *_get_irn_type_attr(ir_node *node) {
 450         return _get_irn_op(node)->ops.get_type_attr(node);
 451 }
 452
 453 static inline ir_entity *_get_irn_entity_attr(ir_node *node) {
 454   return _get_irn_op(node)->ops.get_entity_attr(node);
 455 }
 456
 457 static inline int _is_irn_constlike(const ir_node *node) {
 458         return is_op_constlike(_get_irn_op(node));
 459 }
 460
 461 static inline int _is_irn_always_opt(const ir_node *node) {
 462         return is_op_always_opt(_get_irn_op(node));
 463 }
 464
 465 static inline int _is_irn_keep(const ir_node *node) {
 466         return is_op_keep(_get_irn_op(node));
 467 }
 468
 469 static inline int _is_irn_start_block_placed(const ir_node *node) {
 470         return is_op_start_block_placed(_get_irn_op(node));
 471 }
 472
 473 static inline int _is_irn_machine_op(const ir_node *node) {
 474         return is_op_machine(_get_irn_op(node));
 475 }
 476
 477 static inline int _is_irn_machine_operand(const ir_node *node) {
 478         return is_op_machine_operand(_get_irn_op(node));
 479 }
 480
 481 static inline int _is_irn_machine_user(const ir_node *node, unsigned n) {
 482         return is_op_machine_user(_get_irn_op(node), n);
 483 }
 484
 485 static inline int _is_irn_cse_neutral(const ir_node *node) {
 486         return is_op_cse_neutral(_get_irn_op(node));
 487 }
 488
 489 static inline cond_jmp_predicate _get_Cond_jmp_pred(const ir_node *node) {
 490         assert(_get_irn_op(node) == op_Cond);
 491         return node->attr.cond.jmp_pred;
 492 }
 493
 494 static inline void _set_Cond_jmp_pred(ir_node *node, cond_jmp_predicate pred) {
 495         assert(_get_irn_op(node) == op_Cond);
 496         node->attr.cond.jmp_pred = pred;
 497 }
 498
 499 static inline void *_get_irn_generic_attr(ir_node *node) {
 500         return &node->attr;
 501 }
 502
 503 static inline const void *_get_irn_generic_attr_const(const ir_node *node) {
 504         return &node->attr;
 505 }
 506
 507 static inline unsigned _get_irn_idx(const ir_node *node) {
 508         return node->node_idx;
 509 }
 510
 511 static inline dbg_info *_get_irn_dbg_info(const ir_node *n) {
 512         return n->dbi;
 513 }
 514
 515 static inline void _set_irn_dbg_info(ir_node *n, dbg_info *db) {
 516         n->dbi = db;
 517 }
 518
 519 /**
 520  * Sets the Phi list of a block.
 521  */
 522 static inline void _set_Block_phis(ir_node *block, ir_node *phi)
 523 {
 524         assert(_is_Block(block));
 525         assert(phi == NULL || _is_Phi(phi));
 526         block->attr.block.phis = phi;
 527 }
 528
 529 /**
 530  * Returns the link of a node.
 531  * Intern version of libFirm.
 532  */
 533 static inline ir_node *_get_Block_phis(const ir_node *block)
 534 {
 535         assert(_is_Block(block));
 536         return block->attr.block.phis;
 537 }
 538
 539 static inline void _set_Phi_next(ir_node *phi, ir_node *next)
 540 {
 541         assert(_is_Phi(phi));
 542         phi->attr.phi.next = next;
 543 }
 544
 545 static inline ir_node *_get_Phi_next(const ir_node *phi)
 546 {
 547         assert(_is_Phi(phi));
 548         return phi->attr.phi.next;
 549 }
 550
 551 /** Add a Phi node to the list of Block Phi's. */
 552 static inline void _add_Block_phi(ir_node *block, ir_node *phi)
 553 {
 554         assert(_is_Block(block));
 555         _set_Phi_next(phi, _get_Block_phis(block));
 556         _set_Block_phis(block, phi);
 557 }
 558
 559 /** Get the Block mark (single bit). */
 560 static inline unsigned _get_Block_mark(const ir_node *block)
 561 {
 562         assert(_is_Block(block));
 563         return block->attr.block.marked;
 564 }
 565
 566 /** Set the Block mark (single bit). */
 567 static inline void _set_Block_mark(ir_node *block, unsigned mark)
 568 {
 569         assert(_is_Block(block));
 570         block->attr.block.marked = mark;
 571 }
 572
 573 /** Returns non-zero if a node is a routine parameter. */
 574 static inline int _is_arg_Proj(const ir_node *node)
 575 {
 576         if (! is_Proj(node))
 577                 return 0;
 578         node = get_Proj_pred(node);
 579         if (! is_Proj(node))
 580                 return 0;
 581         return pn_Start_T_args == get_Proj_proj(node) && is_Start(get_Proj_pred(node));
 582 }
 583
 584 /** initialize ir_node module */
 585 void init_irnode(void);
 586
 587 /* this section MUST contain all inline functions */
 588 #define is_ir_node(thing)                     _is_ir_node(thing)
 589 #define get_irn_arity(node)                   _get_irn_arity(node)
 590 #define get_irn_n(node, n)                    _get_irn_n(node, n)
 591 #define get_irn_mode(node)                    _get_irn_mode(node)
 592 #define set_irn_mode(node, mode)              _set_irn_mode(node, mode)
 593 #define get_irn_irg(node)                     _get_irn_irg(node)
 594 #define get_nodes_block(node)                 _get_nodes_block(node)
 595 #define get_irn_op(node)                      _get_irn_op(node)
 596 #define set_irn_op(node, op)                  _set_irn_op(node, op)
 597 #define get_irn_opcode(node)                  _get_irn_opcode(node)
 598 #define get_irn_visited(node)                 _get_irn_visited(node)
 599 #define set_irn_visited(node, v)              _set_irn_visited(node, v)
 600 #define mark_irn_visited(node)                _mark_irn_visited(node)
 601 #define irn_visited(node)                     _irn_visited(node)
 602 #define irn_visited_else_mark(node)           _irn_visited_else_mark(node)
 603 #define set_irn_link(node, link)              _set_irn_link(node, link)
 604 #define get_irn_link(node)                    _get_irn_link(node)
 605 #define get_irn_pinned(node)                  _get_irn_pinned(node)
 606 #define is_irn_pinned_in_irg(node)            _is_irn_pinned_in_irg(node)
 607 #define is_unop(node)                         _is_unop(node)
 608 #define is_binop(node)                        _is_binop(node)
 609 #define is_Proj(node)                         _is_Proj(node)
 610 #define is_Phi(node)                          _is_Phi(node)
 611 #define is_strictConv(node)                   _is_strictConv(node)
 612 #define is_SymConst_addr_ent(node)            _is_SymConst_addr_ent(node)
 613 #define get_Block_n_cfgpreds(node)            _get_Block_n_cfgpreds(node)
 614 #define get_Block_cfgpred(node, pos)          _get_Block_cfgpred(node, pos)
 615 #define get_Block_cfgpred_block(node, pos)    _get_Block_cfgpred_block(node, pos)
 616 #define get_Block_block_visited(node)         _get_Block_block_visited(node)
 617 #define set_Block_block_visited(node, visit)  _set_Block_block_visited(node, visit)
 618 #define mark_Block_block_visited(node)        _mark_Block_block_visited(node)
 619 #define Block_block_visited(node)             _Block_block_visited(node)
 620 #define get_Block_irg(block)                  _get_Block_irg(block)
 621 #define get_Const_tarval(node)                _get_Const_tarval(node)
 622 #define is_Const_null(node)                   _is_Const_null(node)
 623 #define is_Const_one(node)                    _is_Const_one(node)
 624 #define is_Const_all_one(node)                _is_Const_all_one(node)
 625 #define is_irn_forking(node)                  _is_irn_forking(node)
 626 #define copy_node_attr(irg,oldn,newn)         _copy_node_attr(irg,oldn,newn)
 627 #define get_irn_type(node)                    _get_irn_type(node)
 628 #define get_irn_type_attr(node)               _get_irn_type_attr(node)
 629 #define get_irn_entity_attr(node)             _get_irn_entity_attr(node)
 630 #define is_irn_constlike(node)                _is_irn_constlike(node)
 631 #define is_irn_always_opt(node)               _is_irn_always_opt(node)
 632 #define is_irn_keep(node)                     _is_irn_keep(node)
 633 #define is_irn_start_block_placed(node)       _is_irn_start_block_placed(node)
 634 #define is_irn_machine_op(node)               _is_irn_machine_op(node)
 635 #define is_irn_machine_operand(node)          _is_irn_machine_operand(node)
 636 #define is_irn_machine_user(node, n)          _is_irn_machine_user(node, n)
 637 #define is_irn_cse_neutral(node)              _is_irn_cse_neutral(node)
 638 #define get_Cond_jmp_pred(node)               _get_Cond_jmp_pred(node)
 639 #define set_Cond_jmp_pred(node, pred)         _set_Cond_jmp_pred(node, pred)
 640 #define get_irn_generic_attr(node)            _get_irn_generic_attr(node)
 641 #define get_irn_generic_attr_const(node)      _get_irn_generic_attr_const(node)
 642 #define get_irn_idx(node)                     _get_irn_idx(node)
 643
 644 #define get_irn_deps(node)                    _get_irn_deps(node)
 645 #define set_irn_dep(node, pos, dep)           _set_irn_dep(node, pos, dep)
 646 #define get_irn_dep(node, pos)                _get_irn_dep(node, pos)
 647
 648 #define get_irn_ins_or_deps(node)             _get_irn_ins_or_deps(node)
 649 #define get_irn_in_or_dep(node, pos)          _get_irn_in_or_dep(node, pos)
 650
 651 #define get_irn_dbg_info(node)                _get_irn_dbg_info(node)
 652 #define set_irn_dbg_info(node, db)            _set_irn_dbg_info(node, db)
 653
 654 #define set_Block_phis(block, phi)            _set_Block_phis(block, phi)
 655 #define get_Block_phis(block)                 _get_Block_phis(block)
 656 #define add_Block_phi(block, phi)             _add_Block_phi(block, phi)
 657 #define get_Block_mark(block)                 _get_Block_mark(block)
 658 #define set_Block_mark(block, mark)           _set_Block_mark(block, mark)
 659
 660 #define set_Phi_next(node, phi)               _set_Phi_next(node, phi)
 661 #define get_Phi_next(node)                    _get_Phi_next(node)
 662
 663 #define is_arg_Proj(node)                     _is_arg_Proj(node)
 664
 665 #endif