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

   1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
   2 ** All rights reserved.
   3 **
   4 ** Authors: Martin Trapp, Christian Schaefer
   5 **
   6 ** ircons.c: basic and more detailed irnode constructors
   7 **           store, block and parameter administration.
   8 ** Adapted to extended FIRM nodes (exceptions...) and commented
   9 **   by Goetz Lindenmaier
  10 */
  11
  12 #ifdef HAVE_CONFIG_H
  13 # include <config.h>
  14 #endif
  15
  16 # include "irgraph_t.h"
  17 # include "irnode_t.h"
  18 # include "irmode_t.h"
  19 # include "ircons.h"
  20 # include "common.h"
  21 # include "irvrfy.h"
  22 # include "irop.h"
  23 # include "iropt.h"
  24 # include "irgmod.h"
  25 # include "array.h"
  26 /* memset belongs to string.h */
  27 # include "string.h"
  28
  29 #if USE_EXPICIT_PHI_IN_STACK
  30 /* A stack needed for the automatic Phi node construction in constructor
  31    Phi_in. Redefinition in irgraph.c!! */
  32 struct Phi_in_stack {
  33   ir_node **stack;
  34   int       pos;
  35 };
  36 typedef struct Phi_in_stack Phi_in_stack;
  37 #endif
  38
  39 /*** ******************************************** */
  40 /** privat interfaces, for professional use only */
  41
  42 /* Constructs a Block with a fixed number of predecessors.
  43    Does not set current_block.  Can not be used with automatic
  44    Phi node construction. */
  45 inline ir_node *
  46 new_r_Block (ir_graph *irg,  int arity, ir_node **in)
  47 {
  48   ir_node *res;
  49
  50   res = new_ir_node (irg, NULL, op_Block, mode_R, arity, in);
  51   set_Block_matured(res, 1);
  52   set_Block_block_visited(res, 0);
  53
  54   irn_vrfy (res);
  55   return res;
  56 }
  57
  58 ir_node *
  59 new_r_Start (ir_graph *irg, ir_node *block)
  60 {
  61   ir_node *res;
  62
  63   res = new_ir_node (irg, block, op_Start, mode_T, 0, NULL);
  64
  65   irn_vrfy (res);
  66   return res;
  67 }
  68
  69 ir_node *
  70 new_r_End (ir_graph *irg, ir_node *block)
  71 {
  72   ir_node *res;
  73
  74   res = new_ir_node (irg, block, op_End, mode_X, -1, NULL);
  75
  76   irn_vrfy (res);
  77   return res;
  78 }
  79
  80 /* Creates a Phi node with all predecessors.  Calling this constructor
  81    is only allowed if the corresponding block is mature.  */
  82 ir_node *
  83 new_r_Phi (ir_graph *irg, ir_node *block, int arity, ir_node **in, ir_mode *mode)
  84 {
  85   ir_node *res;
  86
  87   assert( get_Block_matured(block) );
  88   assert( get_irn_arity(block) == arity );
  89
  90   res = new_ir_node (irg, block, op_Phi, mode, arity, in);
  91
  92   res = optimize (res);
  93   irn_vrfy (res);
  94   return res;
  95 }
  96
  97 ir_node *
  98 new_r_Const (ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con)
  99 {
 100   ir_node *res;
 101   res = new_ir_node (irg, block, op_Const, mode, 0, NULL);
 102   res->attr.con = con;
 103   res = optimize (res);
 104   irn_vrfy (res);
 105
 106 #if 0
 107   res = local_optimize_newby (res);
 108 # endif
 109
 110   return res;
 111 }
 112
 113 ir_node *
 114 new_r_Id (ir_graph *irg, ir_node *block, ir_node *val, ir_mode *mode)
 115 {
 116   ir_node *in[1] = {val};
 117   ir_node *res;
 118   res = new_ir_node (irg, block, op_Id, mode, 1, in);
 119   res = optimize (res);
 120   irn_vrfy (res);
 121   return res;
 122 }
 123
 124 ir_node *
 125 new_r_Proj (ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
 126             long proj)
 127 {
 128   ir_node *in[1] = {arg};
 129   ir_node *res;
 130   res = new_ir_node (irg, block, op_Proj, mode, 1, in);
 131   res->attr.proj = proj;
 132
 133   assert(res);
 134   assert(get_Proj_pred(res));
 135   assert(get_nodes_Block(get_Proj_pred(res)));
 136
 137   res = optimize (res);
 138
 139   irn_vrfy (res);
 140   return res;
 141
 142 }
 143
 144 ir_node *
 145 new_r_Conv (ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode)
 146 {
 147   ir_node *in[1] = {op};
 148   ir_node *res;
 149   res = new_ir_node (irg, block, op_Conv, mode, 1, in);
 150   res = optimize (res);
 151   irn_vrfy (res);
 152   return res;
 153
 154 }
 155
 156 ir_node *
 157 new_r_Tuple (ir_graph *irg, ir_node *block, int arity, ir_node **in)
 158 {
 159   ir_node *res;
 160
 161   res = new_ir_node (irg, block, op_Tuple, mode_T, arity, in);
 162   res = optimize (res);
 163   irn_vrfy (res);
 164   return res;
 165 }
 166
 167 inline ir_node *
 168 new_r_Add (ir_graph *irg, ir_node *block,
 169            ir_node *op1, ir_node *op2, ir_mode *mode)
 170 {
 171   ir_node *in[2] = {op1, op2};
 172   ir_node *res;
 173   res = new_ir_node (irg, block, op_Add, mode, 2, in);
 174   res = optimize (res);
 175   irn_vrfy (res);
 176   return res;
 177 }
 178
 179 inline ir_node *
 180 new_r_Sub (ir_graph *irg, ir_node *block,
 181            ir_node *op1, ir_node *op2, ir_mode *mode)
 182 {
 183   ir_node *in[2] = {op1, op2};
 184   ir_node *res;
 185   res = new_ir_node (irg, block, op_Sub, mode, 2, in);
 186   res = optimize (res);
 187   irn_vrfy (res);
 188   return res;
 189 }
 190
 191 inline ir_node *
 192 new_r_Minus (ir_graph *irg, ir_node *block,
 193              ir_node *op,  ir_mode *mode)
 194 {
 195   ir_node *in[1] = {op};
 196   ir_node *res;
 197   res = new_ir_node (irg, block, op_Minus, mode, 1, in);
 198   res = optimize (res);
 199   irn_vrfy (res);
 200   return res;
 201 }
 202
 203 inline ir_node *
 204 new_r_Mul (ir_graph *irg, ir_node *block,
 205            ir_node *op1, ir_node *op2, ir_mode *mode)
 206 {
 207   ir_node *in[2] = {op1, op2};
 208   ir_node *res;
 209   res = new_ir_node (irg, block, op_Mul, mode, 2, in);
 210   res = optimize (res);
 211   irn_vrfy (res);
 212   return res;
 213 }
 214
 215 inline ir_node *
 216 new_r_Quot (ir_graph *irg, ir_node *block,
 217             ir_node *memop, ir_node *op1, ir_node *op2)
 218 {
 219   ir_node *in[3] = {memop, op1, op2};
 220   ir_node *res;
 221   res = new_ir_node (irg, block, op_Quot, mode_T, 3, in);
 222   res = optimize (res);
 223   irn_vrfy (res);
 224   return res;
 225 }
 226
 227 inline ir_node *
 228 new_r_DivMod (ir_graph *irg, ir_node *block,
 229               ir_node *memop, ir_node *op1, ir_node *op2)
 230 {
 231   ir_node *in[3] = {memop, op1, op2};
 232   ir_node *res;
 233   res = new_ir_node (irg, block, op_DivMod, mode_T, 3, in);
 234   res = optimize (res);
 235   irn_vrfy (res);
 236   return res;
 237 }
 238
 239 inline ir_node *
 240 new_r_Div (ir_graph *irg, ir_node *block,
 241            ir_node *memop, ir_node *op1, ir_node *op2)
 242 {
 243   ir_node *in[3] = {memop, op1, op2};
 244   ir_node *res;
 245   res = new_ir_node (irg, block, op_Div, mode_T, 3, in);
 246   res = optimize (res);
 247   irn_vrfy (res);
 248   return res;
 249 }
 250
 251 inline ir_node *
 252 new_r_Mod (ir_graph *irg, ir_node *block,
 253            ir_node *memop, ir_node *op1, ir_node *op2)
 254 {
 255   ir_node *in[3] = {memop, op1, op2};
 256   ir_node *res;
 257   res = new_ir_node (irg, block, op_Mod, mode_T, 3, in);
 258   res = optimize (res);
 259   irn_vrfy (res);
 260   return res;
 261 }
 262
 263 inline ir_node *
 264 new_r_And (ir_graph *irg, ir_node *block,
 265            ir_node *op1, ir_node *op2, ir_mode *mode)
 266 {
 267   ir_node *in[2] = {op1, op2};
 268   ir_node *res;
 269   res = new_ir_node (irg, block, op_And, mode, 2, in);
 270   res = optimize (res);
 271   irn_vrfy (res);
 272   return res;
 273 }
 274
 275 inline ir_node *
 276 new_r_Or (ir_graph *irg, ir_node *block,
 277           ir_node *op1, ir_node *op2, ir_mode *mode)
 278 {
 279   ir_node *in[2] = {op1, op2};
 280   ir_node *res;
 281   res = new_ir_node (irg, block, op_Or, mode, 2, in);
 282   res = optimize (res);
 283   irn_vrfy (res);
 284   return res;
 285 }
 286
 287 inline ir_node *
 288 new_r_Eor (ir_graph *irg, ir_node *block,
 289           ir_node *op1, ir_node *op2, ir_mode *mode)
 290 {
 291   ir_node *in[2] = {op1, op2};
 292   ir_node *res;
 293   res = new_ir_node (irg, block, op_Eor, mode, 2, in);
 294   res = optimize (res);
 295   irn_vrfy (res);
 296   return res;
 297 }
 298
 299 inline ir_node *
 300 new_r_Not    (ir_graph *irg, ir_node *block,
 301               ir_node *op, ir_mode *mode)
 302 {
 303   ir_node *in[1] = {op};
 304   ir_node *res;
 305   res = new_ir_node (irg, block, op_Not, mode, 1, in);
 306   res = optimize (res);
 307   irn_vrfy (res);
 308   return res;
 309 }
 310
 311 inline ir_node *
 312 new_r_Shl (ir_graph *irg, ir_node *block,
 313           ir_node *op, ir_node *k, ir_mode *mode)
 314 {
 315   ir_node *in[2] = {op, k};
 316   ir_node *res;
 317   res = new_ir_node (irg, block, op_Shl, mode, 2, in);
 318   res = optimize (res);
 319   irn_vrfy (res);
 320   return res;
 321 }
 322
 323 inline ir_node *
 324 new_r_Shr (ir_graph *irg, ir_node *block,
 325            ir_node *op, ir_node *k, ir_mode *mode)
 326 {
 327   ir_node *in[2] = {op, k};
 328   ir_node *res;
 329   res = new_ir_node (irg, block, op_Shr, mode, 2, in);
 330   res = optimize (res);
 331   irn_vrfy (res);
 332   return res;
 333 }
 334
 335 inline ir_node *
 336 new_r_Shrs (ir_graph *irg, ir_node *block,
 337            ir_node *op, ir_node *k, ir_mode *mode)
 338 {
 339   ir_node *in[2] = {op, k};
 340   ir_node *res;
 341   res = new_ir_node (irg, block, op_Shrs, mode, 2, in);
 342   res = optimize (res);
 343   irn_vrfy (res);
 344   return res;
 345 }
 346
 347 inline ir_node *
 348 new_r_Rot (ir_graph *irg, ir_node *block,
 349            ir_node *op, ir_node *k, ir_mode *mode)
 350 {
 351   ir_node *in[2] = {op, k};
 352   ir_node *res;
 353   res = new_ir_node (irg, block, op_Rot, mode, 2, in);
 354   res = optimize (res);
 355   irn_vrfy (res);
 356   return res;
 357 }
 358
 359 inline ir_node *
 360 new_r_Abs (ir_graph *irg, ir_node *block,
 361            ir_node *op, ir_mode *mode)
 362 {
 363   ir_node *in[1] = {op};
 364   ir_node *res;
 365   res = new_ir_node (irg, block, op_Abs, mode, 1, in);
 366   res = optimize (res);
 367   irn_vrfy (res);
 368   return res;
 369 }
 370
 371 inline ir_node *
 372 new_r_Cmp (ir_graph *irg, ir_node *block,
 373            ir_node *op1, ir_node *op2)
 374 {
 375   ir_node *in[2] = {op1, op2};
 376   ir_node *res;
 377   res = new_ir_node (irg, block, op_Cmp, mode_T, 2, in);
 378   res = optimize (res);
 379   irn_vrfy (res);
 380   return res;
 381 }
 382
 383 inline ir_node *
 384 new_r_Jmp (ir_graph *irg, ir_node *block)
 385 {
 386   ir_node *in[0] = {};
 387   ir_node *res;
 388   res = new_ir_node (irg, block, op_Jmp, mode_X, 0, in);
 389   res = optimize (res);
 390   irn_vrfy (res);
 391   return res;
 392 }
 393
 394 inline ir_node *
 395 new_r_Cond (ir_graph *irg, ir_node *block, ir_node *c)
 396 {
 397   ir_node *in[1] = {c};
 398   ir_node *res;
 399   res = new_ir_node (irg, block, op_Cond, mode_T, 1, in);
 400   res = optimize (res);
 401   irn_vrfy (res);
 402   return res;
 403 }
 404
 405 ir_node *
 406 new_r_Call (ir_graph *irg, ir_node *block, ir_node *store,
 407             ir_node *callee, int arity, ir_node **in, type *type)
 408 {
 409   ir_node **r_in;
 410   ir_node *res;
 411   int r_arity;
 412
 413   r_arity = arity+2;
 414   NEW_ARR_A (ir_node *, r_in, r_arity);
 415   r_in[0] = store;
 416   r_in[1] = callee;
 417   memcpy (&r_in[2], in, sizeof (ir_node *) * arity);
 418
 419   res = new_ir_node (irg, block, op_Call, mode_T, r_arity, r_in);
 420
 421   assert(is_method_type(type));
 422   set_Call_type(res, type);
 423   res = optimize (res);
 424   irn_vrfy (res);
 425   return res;
 426 }
 427
 428 ir_node *
 429 new_r_Return (ir_graph *irg, ir_node *block,
 430               ir_node *store, int arity, ir_node **in)
 431 {
 432   ir_node **r_in;
 433   ir_node *res;
 434   int r_arity;
 435
 436   r_arity = arity+1;
 437   NEW_ARR_A (ir_node *, r_in, r_arity);
 438   r_in[0] = store;
 439   memcpy (&r_in[1], in, sizeof (ir_node *) * arity);
 440   res = new_ir_node (irg, block, op_Return, mode_X, r_arity, r_in);
 441   res = optimize (res);
 442   irn_vrfy (res);
 443   return res;
 444 }
 445
 446 inline ir_node *
 447 new_r_Raise (ir_graph *irg, ir_node *block, ir_node *store, ir_node *obj)
 448 {
 449   ir_node *in[2] = {store, obj};
 450   ir_node *res;
 451   res = new_ir_node (irg, block, op_Raise, mode_X, 2, in);
 452
 453   res = optimize (res);
 454   irn_vrfy (res);
 455   return res;
 456 }
 457
 458 inline ir_node *
 459 new_r_Load (ir_graph *irg, ir_node *block,
 460             ir_node *store, ir_node *adr)
 461 {
 462   ir_node *in[2] = {store, adr};
 463   ir_node *res;
 464   res = new_ir_node (irg, block, op_Load, mode_T, 2, in);
 465
 466   res = optimize (res);
 467   irn_vrfy (res);
 468   return res;
 469 }
 470
 471 inline ir_node *
 472 new_r_Store (ir_graph *irg, ir_node *block,
 473              ir_node *store, ir_node *adr, ir_node *val)
 474 {
 475   ir_node *in[3] = {store, adr, val};
 476   ir_node *res;
 477   res = new_ir_node (irg, block, op_Store, mode_T, 3, in);
 478
 479   res = optimize (res);
 480   irn_vrfy (res);
 481   return res;
 482 }
 483
 484 inline ir_node *
 485 new_r_Alloc (ir_graph *irg, ir_node *block, ir_node *store,
 486             ir_node *size, type *alloc_type, where_alloc where)
 487 {
 488   ir_node *in[2] = {store, size};
 489   ir_node *res;
 490   res = new_ir_node (irg, block, op_Alloc, mode_T, 2, in);
 491
 492   res->attr.a.where = where;
 493   res->attr.a.type = alloc_type;
 494
 495   res = optimize (res);
 496   irn_vrfy (res);
 497   return res;
 498 }
 499
 500 inline ir_node *
 501 new_r_Free (ir_graph *irg, ir_node *block, ir_node *store,
 502             ir_node *ptr, ir_node *size, type *free_type)
 503 {
 504   ir_node *in[3] = {store, ptr, size};
 505   ir_node *res;
 506   res = new_ir_node (irg, block, op_Free, mode_T, 3, in);
 507
 508   res->attr.f = free_type;
 509
 510   res = optimize (res);
 511   irn_vrfy (res);
 512   return res;
 513 }
 514
 515 inline ir_node *
 516 new_r_Sel (ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
 517            int arity, ir_node **in, entity *ent)
 518 {
 519   ir_node **r_in;
 520   ir_node *res;
 521   int r_arity;
 522
 523   r_arity = arity + 2;
 524   NEW_ARR_A (ir_node *, r_in, r_arity);
 525   r_in[0] = store;
 526   r_in[1] = objptr;
 527   memcpy (&r_in[2], in, sizeof (ir_node *) * arity);
 528   res = new_ir_node (irg, block, op_Sel, mode_p, r_arity, r_in);
 529
 530   res->attr.s.ltyp = static_linkage;
 531   res->attr.s.ent = ent;
 532
 533   res = optimize (res);
 534   irn_vrfy (res);
 535   return res;
 536 }
 537
 538 inline ir_node *
 539 new_r_SymConst (ir_graph *irg, ir_node *block, type_or_id_p value,
 540                 symconst_kind symkind)
 541 {
 542   ir_node *in[0] = {};
 543   ir_node *res;
 544   ir_mode *mode;
 545   if (symkind == linkage_ptr_info)
 546     mode = mode_p;
 547   else
 548     mode = mode_I;
 549   res = new_ir_node (irg, block, op_SymConst, mode, 0, in);
 550
 551   res->attr.i.num = symkind;
 552   if (symkind == linkage_ptr_info) {
 553     res->attr.i.tori.ptrinfo = (ident *)value;
 554   } else {
 555     assert (   (   (symkind == type_tag)
 556                 || (symkind == size))
 557             && (is_type(value)));
 558     res->attr.i.tori.typ = (type *)value;
 559   }
 560   res = optimize (res);
 561   irn_vrfy (res);
 562   return res;
 563 }
 564
 565 ir_node *
 566 new_r_Sync (ir_graph *irg, ir_node *block, int arity, ir_node **in)
 567 {
 568   ir_node *res;
 569
 570   res = new_ir_node (irg, block, op_Sync, mode_M, arity, in);
 571
 572   res = optimize (res);
 573   irn_vrfy (res);
 574   return res;
 575 }
 576
 577 ir_node *
 578 new_r_Bad ()
 579 {
 580   return current_ir_graph->bad;
 581 }
 582
 583 /** ********************/
 584 /** public interfaces  */
 585 /** construction tools */
 586
 587 /****f* ircons/new_Start
 588  *
 589  * NAME
 590  *   new_Start -- create a new Start node in the current block
 591  *
 592  * SYNOPSIS
 593  *   s = new_Start(void);
 594  *   ir_node* new_Start(void);
 595  *
 596  * RESULT
 597  *   s - pointer to the created Start node
 598  *
 599  ****
 600  */
 601 ir_node *
 602 new_Start (void)
 603 {
 604   ir_node *res;
 605
 606   res = new_ir_node (current_ir_graph, current_ir_graph->current_block,
 607                      op_Start, mode_T, 0, NULL);
 608
 609   res = optimize (res);
 610   irn_vrfy (res);
 611   return res;
 612 }
 613
 614 ir_node *
 615 new_End (void)
 616 {
 617   ir_node *res;
 618
 619   res = new_ir_node (current_ir_graph,  current_ir_graph->current_block,
 620                      op_End, mode_X, -1, NULL);
 621
 622   res = optimize (res);
 623   irn_vrfy (res);
 624
 625   return res;
 626 }
 627
 628 /* Constructs a Block with a fixed number of predecessors.
 629    Does set current_block.  Can be used with automatic Phi
 630    node construction. */
 631 ir_node *
 632 new_Block (int arity, ir_node **in)
 633 {
 634   ir_node *res;
 635
 636   res = new_r_Block (current_ir_graph, arity, in);
 637   current_ir_graph->current_block = res;
 638
 639   /* Create and initialize array for Phi-node construction. */
 640   res->attr.block.graph_arr = NEW_ARR_D (ir_node *, current_ir_graph->obst,
 641                                          current_ir_graph->n_loc);
 642   memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
 643
 644   res = optimize (res);
 645   irn_vrfy (res);
 646
 647   return res;
 648 }
 649
 650 /* ***********************************************************************/
 651 /* Methods necessary for automatic Phi node creation                     */
 652 /*
 653   ir_node *phi_merge            (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
 654   ir_node *get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
 655   ir_node *new_r_Phi0           (ir_graph *irg, ir_node *block, ir_mode *mode)
 656   ir_node *new_r_Phi_in         (ir_graph *irg, ir_node *block, ir_mode *mode,  ir_node **in, int ins)
 657
 658   Call Graph:   ( A ---> B == A "calls" B)
 659
 660        get_value         mature_block
 661           |                   |
 662           |                   |
 663           |                   |
 664           |          ---> phi_merge
 665           |         /       /   \
 666           |        /       /     \
 667          \|/      /      |/_      \
 668        get_r_value_internal        |
 669                 |                  |
 670                 |                  |
 671                \|/                \|/
 672             new_r_Phi0          new_r_Phi_in
 673
 674 * *************************************************************************** */
 675
 676 /* Creates a Phi node with 0 predecessors */
 677 inline ir_node *
 678 new_r_Phi0 (ir_graph *irg, ir_node *block, ir_mode *mode)
 679 {
 680   ir_node *res;
 681   res = new_ir_node (irg, block, op_Phi, mode, 0, NULL);
 682   irn_vrfy (res);
 683   return res;
 684 }
 685
 686 /* There are two implementations of the Phi node construction.  The first
 687    is faster, but does not work for blocks with more than 2 predecessors.
 688    The second works always but is slower and causes more unnecessary Phi
 689    nodes.
 690    Select the implementations by the following preprocessor flag set in
 691    common/common.h: */
 692 #if USE_FAST_PHI_CONSTRUCTION
 693
 694 /* This is a stack used for allocating and deallocating nodes in
 695    new_r_Phi_in.  The original implementation used the obstack
 696    to model this stack, now it is explicit.  This reduces side effects.
 697 */
 698 #if USE_EXPICIT_PHI_IN_STACK
 699 Phi_in_stack *
 700 new_Phi_in_stack() {
 701   Phi_in_stack *res;
 702
 703   res = (Phi_in_stack *) malloc ( sizeof (Phi_in_stack));
 704
 705   res->stack = NEW_ARR_F (ir_node *, 1);
 706   res->pos = 0;
 707
 708   return res;
 709 }
 710
 711 void free_to_Phi_in_stack(ir_node *phi) {
 712   assert(get_irn_opcode(phi) == iro_Phi);
 713
 714   if (ARR_LEN(current_ir_graph->Phi_in_stack->stack) ==
 715       current_ir_graph->Phi_in_stack->pos)
 716     ARR_APP1 (ir_node *, current_ir_graph->Phi_in_stack->stack, phi);
 717   else
 718     current_ir_graph->Phi_in_stack->stack[current_ir_graph->Phi_in_stack->pos] = phi;
 719
 720   (current_ir_graph->Phi_in_stack->pos)++;
 721 }
 722
 723 ir_node *
 724 alloc_or_pop_from_Phi_in_stack(ir_graph *irg, ir_node *block, ir_mode *mode,
 725              int arity, ir_node **in) {
 726   ir_node *res;
 727   ir_node **stack = current_ir_graph->Phi_in_stack->stack;
 728   int pos = current_ir_graph->Phi_in_stack->pos;
 729
 730
 731   if (pos == 0) {
 732     /* We need to allocate a new node */
 733     res = new_ir_node (irg, block, op_Phi, mode, arity, in);
 734   } else {
 735     /* reuse the old node and initialize it again. */
 736     res = stack[pos-1];
 737
 738     assert (res->kind == k_ir_node);
 739     assert (res->op == op_Phi);
 740     res->mode = mode;
 741     res->visited = 0;
 742     res->link = NULL;
 743     assert (arity >= 0);
 744     /* ???!!! How to free the old in array??  */
 745     res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
 746     res->in[0] = block;
 747     memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
 748
 749     (current_ir_graph->Phi_in_stack->pos)--;
 750   }
 751   return res;
 752 }
 753 #endif /* USE_EXPICIT_PHI_IN_STACK */
 754
 755 /* Creates a Phi node with a given, fixed array **in of predecessors.
 756    If the Phi node is unnecessary, as the same value reaches the block
 757    through all control flow paths, it is eliminated and the value
 758    returned directly.  This constructor is only intended for use in
 759    the automatic Phi node generation triggered by get_value or mature.
 760    The implementation is quite tricky and depends on the fact, that
 761    the nodes are allocated on a stack:
 762    The in array contains predecessors and NULLs.  The NULLs appear,
 763    if get_r_value_internal, that computed the predecessors, reached
 764    the same block on two paths.  In this case the same value reaches
 765    this block on both paths, there is no definition in between.  We need
 766    not allocate a Phi where these path's merge, but we have to communicate
 767    this fact to the caller.  This happens by returning a pointer to the
 768    node the caller _will_ allocate.  (Yes, we predict the address. We can
 769    do so because the nodes are allocated on the obstack.)  The caller then
 770    finds a pointer to itself and, when this routine is called again,
 771    eliminates itself.
 772    */
 773 inline ir_node *
 774 new_r_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
 775               ir_node **in, int ins)
 776 {
 777   int i;
 778   ir_node *res, *known;
 779
 780   /* allocate a new node on the obstack.
 781      This can return a node to which some of the pointers in the in-array
 782      already point.
 783      Attention: the constructor copies the in array, i.e., the later changes
 784      to the array in this routine do not affect the constructed node!  If
 785      the in array contains NULLs, there will be missing predecessors in the
 786      returned node.
 787      Is this a possible internal state of the Phi node generation? */
 788 #if USE_EXPICIT_PHI_IN_STACK
 789   res = known = alloc_or_pop_from_Phi_in_stack(irg, block, mode, ins, in);
 790 #else
 791   res = known = new_ir_node (irg, block, op_Phi, mode, ins, in);
 792 #endif
 793   /* The in-array can contain NULLs.  These were returned by
 794      get_r_value_internal if it reached the same block/definition on a
 795      second path.
 796      The NULLs are replaced by the node itself to simplify the test in the
 797      next loop. */
 798   for (i=0;  i < ins;  ++i)
 799     if (in[i] == NULL) in[i] = res;
 800
 801   /* This loop checks whether the Phi has more than one predecessor.
 802      If so, it is a real Phi node and we break the loop.  Else the
 803      Phi node merges the same definition on several paths and therefore
 804      is not needed. */
 805   for (i=0;  i < ins;  ++i)
 806   {
 807     if (in[i]==res || in[i]==known) continue;
 808
 809     if (known==res)
 810       known = in[i];
 811     else
 812       break;
 813   }
 814
 815   /* i==ins: there is at most one predecessor, we don't need a phi node. */
 816   if (i==ins) {
 817 #if USE_EXPICIT_PHI_IN_STACK
 818     free_to_Phi_in_stack(res);
 819 #else
 820     obstack_free (current_ir_graph->obst, res);
 821 #endif
 822     res = known;
 823   } else {
 824     res = optimize (res);
 825     irn_vrfy (res);
 826   }
 827
 828   /* return the pointer to the Phi node.  This node might be deallocated! */
 829   return res;
 830 }
 831
 832 inline ir_node *
 833 get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
 834
 835 /** This function computes the predecessors for a real Phi node, and then
 836     allocates and returns this node.  The routine called to allocate the
 837     node might optimize it away and return a real value, or even a pointer
 838     to a deallocated Phi node on top of the obstack!
 839     This function is called with an in-array of proper size. **/
 840 static inline ir_node *
 841 phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
 842 {
 843   ir_node *prevBlock, *res;
 844   int i;
 845
 846   /* This loop goes to all predecessor blocks of the block the Phi node is in
 847      and there finds the operands of the Phi node by calling
 848      get_r_value_internal. */
 849   for (i = 1;  i <= ins;  ++i) {
 850     assert (block->in[i]);
 851     prevBlock = block->in[i]->in[0]; /* go past control flow op to prev block */
 852     assert (prevBlock);
 853     nin[i-1] = get_r_value_internal (prevBlock, pos, mode);
 854   }
 855
 856   /* After collecting all predecessors into the array nin a new Phi node
 857      with these predecessors is created.  This constructor contains an
 858      optimization: If all predecessors of the Phi node are identical it
 859      returns the only operand instead of a new Phi node.  If the value
 860      passes two different control flow edges without being defined, and
 861      this is the second path treated, a pointer to the node that will be
 862      allocated for the first path (recursion) is returned.  We already
 863      know the address of this node, as it is the next node to be allocated
 864      and will be placed on top of the obstack. (The obstack is a _stack_!) */
 865   res = new_r_Phi_in (current_ir_graph, block, mode, nin, ins);
 866
 867   /* Now we now the value for "pos" and can enter it in the array with
 868      all known local variables.  Attention: this might be a pointer to
 869      a node, that later will be allocated!!! See new_r_Phi_in.
 870      If this is called in mature, after some set_value in the same block,
 871      the proper value must not be overwritten:
 872      The call order
 873        get_value    (makes Phi0, put's it into graph_arr)
 874        set_value    (overwrites Phi0 in graph_arr)
 875        mature_block (upgrades Phi0, puts it again into graph_arr, overwriting
 876                      the proper value.)
 877      fails. */
 878   if (!block->attr.block.graph_arr[pos]) {
 879     block->attr.block.graph_arr[pos] = res;
 880   } else {
 881     /*  printf(" value already computed by %s\n",
 882         id_to_str(block->attr.block.graph_arr[pos]->op->name));  */
 883   }
 884
 885   return res;
 886 }
 887
 888 /* This function returns the last definition of a variable.  In case
 889    this variable was last defined in a previous block, Phi nodes are
 890    inserted.  If the part of the firm graph containing the definition
 891    is not yet constructed, a dummy Phi node is returned. */
 892 inline ir_node *
 893 get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
 894 {
 895   ir_node *res;
 896   /* There are 4 cases to treat.
 897
 898      1. The block is not mature and we visit it the first time.  We can not
 899         create a proper Phi node, therefore a Phi0, i.e., a Phi without
 900         predecessors is returned.  This node is added to the linked list (field
 901         "link") of the containing block to be completed when this block is
 902         matured. (Comlpletion will add a new Phi and turn the Phi0 into an Id
 903         node.)
 904
 905      2. The value is already known in this block, graph_arr[pos] is set and we
 906         visit the block the first time.  We can return the value without
 907         creating any new nodes.
 908
 909      3. The block is mature and we visit it the first time.  A Phi node needs
 910         to be created (phi_merge).  If the Phi is not needed, as all it's
 911         operands are the same value reaching the block through different
 912         paths, it's optimized away and the value itself is returned.
 913
 914      4. The block is mature, and we visit it the second time.  Now two
 915         subcases are possible:
 916         * The value was computed completely the last time we were here. This
 917           is the case if there is no loop.  We can return the proper value.
 918         * The recursion that visited this node and set the flag did not
 919           return yet.  We are computing a value in a loop and need to
 920           break the recursion without knowing the result yet.
 921           @@@ strange case.  Straight forward we would create a Phi before
 922           starting the computation of it's predecessors.  In this case we will find
 923           a Phi here in any case.  The problem is that this implementation only
 924           creates a Phi after computing the predecessors, so that it is hard to
 925           compute self references of this Phi.  @@@
 926         There is no simple check for the second subcase.  Therefore we check
 927         for a second visit and treat all such cases as the second subcase.
 928         Anyways, the basic situation is the same:  we reached a block
 929         on two paths without finding a definition of the value:  No Phi
 930         nodes are needed on both paths.
 931         We return this information "Two paths, no Phi needed" by a very tricky
 932         implementation that relies on the fact that an obstack is a stack and
 933         will return a node with the same address on different allocations.
 934         Look also at phi_merge and new_r_phi_in to understand this.
 935         @@@ Unfortunately this does not work, see testprogram three_cfpred_example.
 936
 937   */
 938
 939   /* case 4 -- already visited. */
 940   if (get_irn_visited(block) == get_irg_visited(current_ir_graph)) return NULL;
 941
 942   /* visited the first time */
 943   set_irn_visited(block, get_irg_visited(current_ir_graph));
 944
 945   /* Get the local valid value */
 946   res = block->attr.block.graph_arr[pos];
 947
 948   /* case 2 -- If the value is actually computed, return it. */
 949   if (res) { return res;};
 950
 951   if (block->attr.block.matured) { /* case 3 */
 952
 953     /* The Phi has the same amount of ins as the corresponding block. */
 954     int ins = get_irn_arity(block);
 955     ir_node **nin;
 956     NEW_ARR_A (ir_node *, nin, ins);
 957
 958     /* Phi merge collects the predecessors and then creates a node. */
 959     res = phi_merge (block, pos, mode, nin, ins);
 960
 961   } else {  /* case 1 */
 962     /* The block is not mature, we don't know how many in's are needed.  A Phi
 963        with zero predecessors is created.  Such a Phi node is called Phi0
 964        node.  (There is also an obsolete Phi0 opcode.) The Phi0 is then added
 965        to the list of Phi0 nodes in this block to be matured by mature_block
 966        later.
 967        The Phi0 has to remember the pos of it's internal value.  If the real
 968        Phi is computed, pos is used to update the array with the local
 969        values. */
 970
 971     res = new_r_Phi0 (current_ir_graph, block, mode);
 972     res->attr.phi0_pos = pos;
 973     res->link = block->link;
 974     block->link = res;
 975   }
 976
 977   /* If we get here, the frontend missed a use-before-definition error */
 978   if (!res) {
 979     /* Error Message */
 980     printf("Error: no value set.  Use of undefined variable.  Initializing
 981             to zero.\n");
 982     assert (mode->code >= irm_f && mode->code <= irm_p);
 983     res = new_r_Const (current_ir_graph, block, mode,
 984                        tarval_mode_null[mode->code]);
 985   }
 986
 987   /* The local valid value is available now. */
 988   block->attr.block.graph_arr[pos] = res;
 989
 990   return res;
 991 }
 992
 993 #else /* if 0 */
 994
 995 /** This is the simple algorithm.  If first generates a Phi0, then
 996     it starts the recursion.  This causes an Id at the entry of
 997     every block that has no definition of the value! **/
 998
 999 #if USE_EXPICIT_PHI_IN_STACK
1000 /* Just a dummy */
1001 Phi_in_stack * new_Phi_in_stack() {  return NULL; }
1002 #endif
1003
1004 inline ir_node *
1005 new_r_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
1006               ir_node **in, int ins)
1007 {
1008   int i;
1009   ir_node *res, *known;
1010
1011   /* Allocate a new node on the obstack.  The allocation copies the in
1012      array. */
1013   res = new_ir_node (irg, block, op_Phi, mode, ins, in);
1014
1015   /* This loop checks whether the Phi has more than one predecessor.
1016      If so, it is a real Phi node and we break the loop.  Else the
1017      Phi node merges the same definition on several paths and therefore
1018      is not needed. Don't consider Bad nodes! */
1019   known = res;
1020   for (i=0;  i < ins;  ++i)
1021   {
1022     if (in[i]==res || in[i]==known || is_Bad(in[i])) continue;
1023
1024     if (known==res)
1025       known = in[i];
1026     else
1027       break;
1028   }
1029
1030   /* i==ins: there is at most one predecessor, we don't need a phi node. */
1031   if (i==ins) {
1032     if (res != known) {
1033       obstack_free (current_ir_graph->obst, res);
1034       res = known;
1035     } else {
1036       /* A undefined value, e.g., in unreachable code. */
1037       res = new_Bad();
1038     }
1039   } else {
1040     res = optimize (res);
1041     irn_vrfy (res);
1042   }
1043
1044   return res;
1045 }
1046
1047 inline ir_node *
1048 get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
1049
1050 /** This function allocates a dummy Phi node to break recursions,
1051     computes the predecessors for the real phi node, and then
1052     allocates and returns this node.  The routine called to allocate the
1053     node might optimize it away and return a real value.
1054     This function is called with an in-array of proper size. **/
1055 static inline ir_node *
1056 phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
1057 {
1058   ir_node *prevBlock, *res, *phi0;
1059   int i;
1060
1061
1062   /* If this block has no value at pos create a Phi0 and remember it
1063      in graph_arr to break recursions. */
1064   phi0 = NULL;
1065   if (!block->attr.block.graph_arr[pos]) {
1066     /* Even if all variables are defined before use, it can happen that
1067        we get to the start block, if a cond has been replaced by a tuple
1068        (bad, jmp).  As the start has a self referencing control flow edge,
1069        we get a self referencing Id, which is hard to optimize away.  We avoid
1070        this by defining the value as a Bad node. *
1071     if (block == get_irg_start_block(current_ir_graph)) {
1072       block->attr.block.graph_arr[pos] = new_Bad();
1073       return new_Bad();
1074       } else */ {
1075       phi0 = new_r_Phi0(current_ir_graph, block, mode);
1076       block->attr.block.graph_arr[pos] = phi0;
1077     }
1078   }
1079
1080   /* This loop goes to all predecessor blocks of the block the Phi node
1081      is in and there finds the operands of the Phi node by calling
1082      get_r_value_internal.  */
1083   for (i = 1;  i <= ins;  ++i) {
1084     assert (block->in[i]);
1085     if (is_Bad(block->in[i])) {
1086       /* In case a Cond has been optimized we would get right to the start block
1087          with an invalid definition. */
1088       nin[i-1] = new_Bad();
1089       continue;
1090     }
1091     prevBlock = block->in[i]->in[0]; /* go past control flow op to prev block */
1092     assert (prevBlock);
1093     if (!is_Bad(prevBlock)) {
1094       nin[i-1] = get_r_value_internal (prevBlock, pos, mode);
1095     } else {
1096       nin[i-1] = new_Bad();
1097     }
1098   }
1099
1100   /* After collecting all predecessors into the array nin a new Phi node
1101      with these predecessors is created.  This constructor contains an
1102      optimization: If all predecessors of the Phi node are identical it
1103      returns the only operand instead of a new Phi node.  */
1104   res = new_r_Phi_in (current_ir_graph, block, mode, nin, ins);
1105
1106   /* In case we allocated a Phi0 node at the beginning of this procedure,
1107      we need to exchange this Phi0 with the real Phi. */
1108   if (phi0) {
1109     exchange(phi0, res);
1110     block->attr.block.graph_arr[pos] = res;
1111   }
1112
1113   return res;
1114 }
1115
1116 /* This function returns the last definition of a variable.  In case
1117    this variable was last defined in a previous block, Phi nodes are
1118    inserted.  If the part of the firm graph containing the definition
1119    is not yet constructed, a dummy Phi node is returned. */
1120 inline ir_node *
1121 get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
1122 {
1123   ir_node *res;
1124   /* There are 4 cases to treat.
1125
1126      1. The block is not mature and we visit it the first time.  We can not
1127         create a proper Phi node, therefore a Phi0, i.e., a Phi without
1128         predecessors is returned.  This node is added to the linked list (field
1129         "link") of the containing block to be completed when this block is
1130         matured. (Comlpletion will add a new Phi and turn the Phi0 into an Id
1131         node.)
1132
1133      2. The value is already known in this block, graph_arr[pos] is set and we
1134         visit the block the first time.  We can return the value without
1135         creating any new nodes.
1136
1137      3. The block is mature and we visit it the first time.  A Phi node needs
1138         to be created (phi_merge).  If the Phi is not needed, as all it's
1139         operands are the same value reaching the block through different
1140         paths, it's optimized away and the value itself is returned.
1141
1142      4. The block is mature, and we visit it the second time.  Now two
1143         subcases are possible:
1144         * The value was computed completely the last time we were here. This
1145           is the case if there is no loop.  We can return the proper value.
1146         * The recursion that visited this node and set the flag did not
1147           return yet.  We are computing a value in a loop and need to
1148           break the recursion.  This case only happens if we visited
1149           the same block with phi_merge before, which inserted a Phi0.
1150           So we return the Phi0.
1151   */
1152
1153   /* case 4 -- already visited. */
1154   if (get_irn_visited(block) == get_irg_visited(current_ir_graph)) {
1155     /* As phi_merge allocates a Phi0 this value is always defined. Here
1156      is the critical difference of the two algorithms. */
1157     assert(block->attr.block.graph_arr[pos]);
1158     return block->attr.block.graph_arr[pos];
1159   }
1160
1161   /* visited the first time */
1162   set_irn_visited(block, get_irg_visited(current_ir_graph));
1163
1164   /* Get the local valid value */
1165   res = block->attr.block.graph_arr[pos];
1166
1167   /* case 2 -- If the value is actually computed, return it. */
1168   if (res) { return res; };
1169
1170   if (block->attr.block.matured) { /* case 3 */
1171
1172     /* The Phi has the same amount of ins as the corresponding block. */
1173     int ins = get_irn_arity(block);
1174     ir_node **nin;
1175     NEW_ARR_A (ir_node *, nin, ins);
1176
1177     /* Phi merge collects the predecessors and then creates a node. */
1178     res = phi_merge (block, pos, mode, nin, ins);
1179
1180   } else {  /* case 1 */
1181     /* The block is not mature, we don't know how many in's are needed.  A Phi
1182        with zero predecessors is created.  Such a Phi node is called Phi0
1183        node.  The Phi0 is then added to the list of Phi0 nodes in this block
1184        to be matured by mature_block later.
1185        The Phi0 has to remember the pos of it's internal value.  If the real
1186        Phi is computed, pos is used to update the array with the local
1187        values. */
1188     res = new_r_Phi0 (current_ir_graph, block, mode);
1189     res->attr.phi0_pos = pos;
1190     res->link = block->link;
1191     block->link = res;
1192   }
1193
1194   /* If we get here, the frontend missed a use-before-definition error */
1195   if (!res) {
1196     /* Error Message */
1197     printf("Error: no value set.  Use of undefined variable.  Initializing
1198             to zero.\n");
1199     assert (mode->code >= irm_f && mode->code <= irm_p);
1200     res = new_r_Const (current_ir_graph, block, mode,
1201                        tarval_mode_null[mode->code]);
1202   }
1203
1204   /* The local valid value is available now. */
1205   block->attr.block.graph_arr[pos] = res;
1206
1207   return res;
1208 }
1209
1210 #endif /* USE_FAST_PHI_CONSTRUCTION */
1211
1212 /* ************************************************************************** */
1213
1214 /** Finalize a Block node, when all control flows are known.  */
1215 /** Acceptable parameters are only Block nodes.               */
1216 void
1217 mature_block (ir_node *block)
1218 {
1219
1220   int ins;
1221   ir_node *n, **nin;
1222   ir_node *next;
1223
1224   assert (get_irn_opcode(block) == iro_Block);
1225
1226   if (!get_Block_matured(block)) {
1227
1228     /* turn the dynamic in-array into a static one. */
1229     ins = ARR_LEN (block->in)-1;
1230     NEW_ARR_A (ir_node *, nin, ins);
1231     /*  @@@ something is strange here... why isn't the array copied? */
1232
1233     /* Traverse a chain of Phi nodes attached to this block and mature
1234        these, too. **/
1235     for (n = block->link;  n;  n=next) {
1236       inc_irg_visited(current_ir_graph);
1237       next = n->link;
1238       exchange (n, phi_merge (block, n->attr.phi0_pos, n->mode, nin, ins));
1239     }
1240
1241     block->attr.block.matured = 1;
1242
1243     /* Now, as the block is a finished firm node, we can optimize it.
1244        Since other nodes have been allocated since the block was created
1245        we can not free the node on the obstack.  Therefore we have to call
1246        optimize_in_place.
1247        Unfortunately the optimization does not change a lot, as all allocated
1248        nodes refer to the unoptimized node. */
1249     block = optimize_in_place(block);
1250     irn_vrfy(block);
1251   }
1252 }
1253
1254 ir_node *
1255 new_Phi (int arity, ir_node **in, ir_mode *mode)
1256 {
1257   return new_r_Phi (current_ir_graph, current_ir_graph->current_block,
1258                     arity, in, mode);
1259 }
1260
1261 ir_node *
1262 new_Const (ir_mode *mode, tarval *con)
1263 {
1264   return new_r_Const (current_ir_graph, current_ir_graph->start_block,
1265                       mode, con);
1266 }
1267
1268 ir_node *
1269 new_Id (ir_node *val, ir_mode *mode)
1270 {
1271   return new_r_Id (current_ir_graph, current_ir_graph->current_block,
1272                    val, mode);
1273 }
1274
1275 ir_node *
1276 new_Proj (ir_node *arg, ir_mode *mode, long proj)
1277 {
1278   return new_r_Proj (current_ir_graph, current_ir_graph->current_block,
1279                      arg, mode, proj);
1280 }
1281
1282 ir_node *
1283 new_Conv (ir_node *op, ir_mode *mode)
1284 {
1285   return new_r_Conv (current_ir_graph, current_ir_graph->current_block,
1286                      op, mode);
1287 }
1288
1289 ir_node *
1290 new_Tuple (int arity, ir_node **in)
1291 {
1292   return new_r_Tuple (current_ir_graph, current_ir_graph->current_block,
1293                       arity, in);
1294 }
1295
1296 ir_node *
1297 new_Add (ir_node *op1, ir_node *op2, ir_mode *mode)
1298 {
1299   return new_r_Add (current_ir_graph, current_ir_graph->current_block,
1300                     op1, op2, mode);
1301 }
1302
1303 ir_node *
1304 new_Sub (ir_node *op1, ir_node *op2, ir_mode *mode)
1305 {
1306   return new_r_Sub (current_ir_graph, current_ir_graph->current_block,
1307                     op1, op2, mode);
1308 }
1309
1310
1311 ir_node *
1312 new_Minus  (ir_node *op,  ir_mode *mode)
1313 {
1314   return new_r_Minus (current_ir_graph, current_ir_graph->current_block,
1315                       op, mode);
1316 }
1317
1318 ir_node *
1319 new_Mul (ir_node *op1, ir_node *op2, ir_mode *mode)
1320 {
1321   return new_r_Mul (current_ir_graph, current_ir_graph->current_block,
1322                     op1, op2, mode);
1323 }
1324
1325 ir_node *
1326 new_Quot (ir_node *memop, ir_node *op1, ir_node *op2)
1327 {
1328   return new_r_Quot (current_ir_graph, current_ir_graph->current_block,
1329                      memop, op1, op2);
1330 }
1331
1332 ir_node *
1333 new_DivMod (ir_node *memop, ir_node *op1, ir_node *op2)
1334 {
1335   return new_r_DivMod (current_ir_graph, current_ir_graph->current_block,
1336                        memop, op1, op2);
1337 }
1338
1339 ir_node *
1340 new_Div (ir_node *memop, ir_node *op1, ir_node *op2)
1341 {
1342   return new_r_Div (current_ir_graph, current_ir_graph->current_block,
1343                     memop, op1, op2);
1344 }
1345
1346 ir_node *
1347 new_Mod (ir_node *memop, ir_node *op1, ir_node *op2)
1348 {
1349   return new_r_Mod (current_ir_graph, current_ir_graph->current_block,
1350                     memop, op1, op2);
1351 }
1352
1353 ir_node *
1354 new_And (ir_node *op1, ir_node *op2, ir_mode *mode)
1355 {
1356   return new_r_And (current_ir_graph, current_ir_graph->current_block,
1357                     op1, op2, mode);
1358 }
1359
1360 ir_node *
1361 new_Or (ir_node *op1, ir_node *op2, ir_mode *mode)
1362 {
1363   return new_r_Or (current_ir_graph, current_ir_graph->current_block,
1364                    op1, op2, mode);
1365 }
1366
1367 ir_node *
1368 new_Eor (ir_node *op1, ir_node *op2, ir_mode *mode)
1369 {
1370   return new_r_Eor (current_ir_graph, current_ir_graph->current_block,
1371                     op1, op2, mode);
1372 }
1373
1374 ir_node *
1375 new_Not (ir_node *op, ir_mode *mode)
1376 {
1377   return new_r_Not (current_ir_graph, current_ir_graph->current_block,
1378                     op, mode);
1379 }
1380
1381 ir_node *
1382 new_Shl (ir_node *op, ir_node *k, ir_mode *mode)
1383 {
1384   return new_r_Shl (current_ir_graph, current_ir_graph->current_block,
1385                     op, k, mode);
1386 }
1387
1388 ir_node *
1389 new_Shr (ir_node *op, ir_node *k, ir_mode *mode)
1390 {
1391   return new_r_Shr (current_ir_graph, current_ir_graph->current_block,
1392                     op, k, mode);
1393 }
1394
1395 ir_node *
1396 new_Shrs (ir_node *op, ir_node *k, ir_mode *mode)
1397 {
1398   return new_r_Shrs (current_ir_graph, current_ir_graph->current_block,
1399                      op, k, mode);
1400 }
1401
1402 ir_node *
1403 new_Rotate (ir_node *op, ir_node *k, ir_mode *mode)
1404 {
1405   return new_r_Rot (current_ir_graph, current_ir_graph->current_block,
1406                      op, k, mode);
1407 }
1408
1409 ir_node *
1410 new_Abs (ir_node *op, ir_mode *mode)
1411 {
1412   return new_r_Abs (current_ir_graph, current_ir_graph->current_block,
1413                     op, mode);
1414 }
1415
1416 ir_node *
1417 new_Cmp (ir_node *op1, ir_node *op2)
1418 {
1419   return new_r_Cmp (current_ir_graph, current_ir_graph->current_block,
1420                     op1, op2);
1421 }
1422
1423 ir_node *
1424 new_Jmp (void)
1425 {
1426   return new_r_Jmp (current_ir_graph, current_ir_graph->current_block);
1427 }
1428
1429 ir_node *
1430 new_Cond (ir_node *c)
1431 {
1432   return new_r_Cond (current_ir_graph, current_ir_graph->current_block, c);
1433 }
1434
1435 ir_node *
1436 new_Call (ir_node *store, ir_node *callee, int arity, ir_node **in,
1437           type *type)
1438 {
1439   return new_r_Call (current_ir_graph, current_ir_graph->current_block,
1440                      store, callee, arity, in, type);
1441 }
1442
1443 ir_node *
1444 new_Return (ir_node* store, int arity, ir_node **in)
1445 {
1446   return new_r_Return (current_ir_graph, current_ir_graph->current_block,
1447                        store, arity, in);
1448 }
1449
1450 ir_node *
1451 new_Raise (ir_node *store, ir_node *obj)
1452 {
1453   return new_r_Raise (current_ir_graph, current_ir_graph->current_block,
1454                       store, obj);
1455 }
1456
1457 ir_node *
1458 new_Load (ir_node *store, ir_node *addr)
1459 {
1460   return new_r_Load (current_ir_graph, current_ir_graph->current_block,
1461                      store, addr);
1462 }
1463
1464 ir_node *
1465 new_Store (ir_node *store, ir_node *addr, ir_node *val)
1466 {
1467   return new_r_Store (current_ir_graph, current_ir_graph->current_block,
1468                       store, addr, val);
1469 }
1470
1471 ir_node *
1472 new_Alloc (ir_node *store, ir_node *size, type *alloc_type,
1473            where_alloc where)
1474 {
1475   return new_r_Alloc (current_ir_graph, current_ir_graph->current_block,
1476                       store, size, alloc_type, where);
1477 }
1478
1479 ir_node *
1480 new_Free (ir_node *store, ir_node *ptr, ir_node *size, type *free_type)
1481 {
1482   return new_r_Free (current_ir_graph, current_ir_graph->current_block,
1483                      store, ptr, size, free_type);
1484 }
1485
1486 ir_node *
1487 new_simpleSel (ir_node *store, ir_node *objptr, entity *ent)
1488 /* GL: objptr was called frame before.  Frame was a bad choice for the name
1489    as the operand could as well be a pointer to a dynamic object. */
1490 {
1491   return new_r_Sel (current_ir_graph, current_ir_graph->current_block,
1492                     store, objptr, 0, NULL, ent);
1493 }
1494
1495 ir_node *
1496 new_Sel (ir_node *store, ir_node *objptr, int n_index, ir_node **index, entity *sel)
1497 {
1498   return new_r_Sel (current_ir_graph, current_ir_graph->current_block,
1499                     store, objptr, n_index, index, sel);
1500 }
1501
1502 ir_node *
1503 new_SymConst (type_or_id_p value, symconst_kind kind)
1504 {
1505   return new_r_SymConst (current_ir_graph, current_ir_graph->current_block,
1506                          value, kind);
1507 }
1508
1509 ir_node *
1510 new_Sync (int arity, ir_node** in)
1511 {
1512   return new_r_Sync (current_ir_graph, current_ir_graph->current_block,
1513                      arity, in);
1514 }
1515
1516
1517 ir_node *
1518 new_Bad (void)
1519 {
1520   return current_ir_graph->bad;
1521 }
1522
1523 /* ********************************************************************* */
1524 /* Comfortable interface with automatic Phi node construction.           */
1525 /* (Uses also constructors of ?? interface, except new_Block.            */
1526 /* ********************************************************************* */
1527
1528 /** Block construction **/
1529 /* immature Block without predecessors */
1530 ir_node *new_immBlock (void) {
1531   ir_node *res;
1532
1533   /* creates a new dynamic in-array as length of in is -1 */
1534   res = new_ir_node (current_ir_graph, NULL, op_Block, mode_R, -1, NULL);
1535   current_ir_graph->current_block = res;
1536   res->attr.block.matured = 0;
1537   set_Block_block_visited(res, 0);
1538
1539   /* Create and initialize array for Phi-node construction. */
1540   res->attr.block.graph_arr = NEW_ARR_D (ir_node *, current_ir_graph->obst,
1541                                          current_ir_graph->n_loc);
1542   memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
1543
1544   /* Immature block may not be optimized! */
1545   irn_vrfy (res);
1546
1547   return res;
1548 }
1549
1550 /* add an adge to a jmp/control flow node */
1551 void
1552 add_in_edge (ir_node *block, ir_node *jmp)
1553 {
1554   if (block->attr.block.matured) {
1555     printf("Error: Block already matured!\n");
1556   }
1557   else {
1558     assert (jmp != NULL);
1559     ARR_APP1 (ir_node *, block->in, jmp);
1560   }
1561 }
1562
1563 /* changing the current block */
1564 void
1565 switch_block (ir_node *target)
1566 {
1567   current_ir_graph->current_block = target;
1568 }
1569
1570 /* ************************ */
1571 /* parameter administration */
1572
1573 /* get a value from the parameter array from the current block by its index */
1574 ir_node *
1575 get_value (int pos, ir_mode *mode)
1576 {
1577   inc_irg_visited(current_ir_graph);
1578   return get_r_value_internal (current_ir_graph->current_block, pos + 1, mode);
1579 }
1580
1581 /* set a value at position pos in the parameter array from the current block */
1582 inline void
1583 set_value (int pos, ir_node *value)
1584 {
1585   current_ir_graph->current_block->attr.block.graph_arr[pos + 1] = value;
1586 }
1587
1588 /* get the current store */
1589 inline ir_node *
1590 get_store (void)
1591 {
1592   /* GL: one could call get_value instead */
1593   inc_irg_visited(current_ir_graph);
1594   return get_r_value_internal (current_ir_graph->current_block, 0, mode_M);
1595 }
1596
1597 /* set the current store */
1598 inline void
1599 set_store (ir_node *store)
1600 {
1601   /* GL: one could call set_value instead */
1602   current_ir_graph->current_block->attr.block.graph_arr[0] = store;
1603 }
1604
1605 /* ********************************************************************* */
1606 /* initialize */
1607
1608 /* call once for each run of the library */
1609 void
1610 init_cons (void)
1611 {
1612 }