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_method *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   set_Call_type(res, type);
 422   res = optimize (res);
 423   irn_vrfy (res);
 424   return res;
 425 }
 426
 427 ir_node *
 428 new_r_Return (ir_graph *irg, ir_node *block,
 429               ir_node *store, int arity, ir_node **in)
 430 {
 431   ir_node **r_in;
 432   ir_node *res;
 433   int r_arity;
 434
 435   r_arity = arity+1;
 436   NEW_ARR_A (ir_node *, r_in, r_arity);
 437   r_in[0] = store;
 438   memcpy (&r_in[1], in, sizeof (ir_node *) * arity);
 439   res = new_ir_node (irg, block, op_Return, mode_X, r_arity, r_in);
 440   res = optimize (res);
 441   irn_vrfy (res);
 442   return res;
 443 }
 444
 445 inline ir_node *
 446 new_r_Raise (ir_graph *irg, ir_node *block, ir_node *store, ir_node *obj)
 447 {
 448   ir_node *in[2] = {store, obj};
 449   ir_node *res;
 450   res = new_ir_node (irg, block, op_Raise, mode_X, 2, in);
 451
 452   res = optimize (res);
 453   irn_vrfy (res);
 454   return res;
 455 }
 456
 457 inline ir_node *
 458 new_r_Load (ir_graph *irg, ir_node *block,
 459             ir_node *store, ir_node *adr)
 460 {
 461   ir_node *in[2] = {store, adr};
 462   ir_node *res;
 463   res = new_ir_node (irg, block, op_Load, mode_T, 2, in);
 464
 465   res = optimize (res);
 466   irn_vrfy (res);
 467   return res;
 468 }
 469
 470 inline ir_node *
 471 new_r_Store (ir_graph *irg, ir_node *block,
 472              ir_node *store, ir_node *adr, ir_node *val)
 473 {
 474   ir_node *in[3] = {store, adr, val};
 475   ir_node *res;
 476   res = new_ir_node (irg, block, op_Store, mode_T, 3, in);
 477
 478   res = optimize (res);
 479   irn_vrfy (res);
 480   return res;
 481 }
 482
 483 inline ir_node *
 484 new_r_Alloc (ir_graph *irg, ir_node *block, ir_node *store,
 485             ir_node *size, type *alloc_type, where_alloc where)
 486 {
 487   ir_node *in[2] = {store, size};
 488   ir_node *res;
 489   res = new_ir_node (irg, block, op_Alloc, mode_T, 2, in);
 490
 491   res->attr.a.where = where;
 492   res->attr.a.type = alloc_type;
 493
 494   res = optimize (res);
 495   irn_vrfy (res);
 496   return res;
 497 }
 498
 499 inline ir_node *
 500 new_r_Free (ir_graph *irg, ir_node *block, ir_node *store,
 501             ir_node *ptr, ir_node *size, type *free_type)
 502 {
 503   ir_node *in[3] = {store, ptr, size};
 504   ir_node *res;
 505   res = new_ir_node (irg, block, op_Free, mode_T, 3, in);
 506
 507   res->attr.f = free_type;
 508
 509   res = optimize (res);
 510   irn_vrfy (res);
 511   return res;
 512 }
 513
 514 inline ir_node *
 515 new_r_Sel (ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
 516            int arity, ir_node **in, entity *ent)
 517 {
 518   ir_node **r_in;
 519   ir_node *res;
 520   int r_arity;
 521
 522   r_arity = arity + 2;
 523   NEW_ARR_A (ir_node *, r_in, r_arity);
 524   r_in[0] = store;
 525   r_in[1] = objptr;
 526   memcpy (&r_in[2], in, sizeof (ir_node *) * arity);
 527   res = new_ir_node (irg, block, op_Sel, mode_p, r_arity, r_in);
 528
 529   res->attr.s.ltyp = static_linkage;
 530   res->attr.s.ent = ent;
 531
 532   res = optimize (res);
 533   irn_vrfy (res);
 534   return res;
 535 }
 536
 537 inline ir_node *
 538 new_r_SymConst (ir_graph *irg, ir_node *block, type_or_id_p value,
 539                 symconst_kind symkind)
 540 {
 541   ir_node *in[0] = {};
 542   ir_node *res;
 543   ir_mode *mode;
 544   if (symkind == linkage_ptr_info)
 545     mode = mode_p;
 546   else
 547     mode = mode_I;
 548   res = new_ir_node (irg, block, op_SymConst, mode, 0, in);
 549
 550   res->attr.i.num = symkind;
 551   if (symkind == linkage_ptr_info) {
 552     res->attr.i.tori.ptrinfo = (ident *)value;
 553   } else {
 554     assert (   (   (symkind == type_tag)
 555                 || (symkind == size))
 556             && (is_type(value)));
 557     res->attr.i.tori.typ = (type *)value;
 558   }
 559   res = optimize (res);
 560   irn_vrfy (res);
 561   return res;
 562 }
 563
 564 ir_node *
 565 new_r_Sync (ir_graph *irg, ir_node *block, int arity, ir_node **in)
 566 {
 567   ir_node *res;
 568
 569   res = new_ir_node (irg, block, op_Sync, mode_M, arity, in);
 570
 571   res = optimize (res);
 572   irn_vrfy (res);
 573   return res;
 574 }
 575
 576 ir_node *
 577 new_r_Bad ()
 578 {
 579   return current_ir_graph->bad;
 580 }
 581
 582 /** ********************/
 583 /** public interfaces  */
 584 /** construction tools */
 585
 586 /****f* ircons/new_Start
 587  *
 588  * NAME
 589  *   new_Start -- create a new Start node in the current block
 590  *
 591  * SYNOPSIS
 592  *   s = new_Start(void);
 593  *   ir_node* new_Start(void);
 594  *
 595  * RESULT
 596  *   s - pointer to the created Start node
 597  *
 598  ****
 599  */
 600 ir_node *
 601 new_Start (void)
 602 {
 603   ir_node *res;
 604
 605   res = new_ir_node (current_ir_graph, current_ir_graph->current_block,
 606                      op_Start, mode_T, 0, NULL);
 607
 608   res = optimize (res);
 609   irn_vrfy (res);
 610   return res;
 611 }
 612
 613 ir_node *
 614 new_End (void)
 615 {
 616   ir_node *res;
 617
 618   res = new_ir_node (current_ir_graph,  current_ir_graph->current_block,
 619                      op_End, mode_X, -1, NULL);
 620
 621   res = optimize (res);
 622   irn_vrfy (res);
 623
 624   return res;
 625 }
 626
 627 /* Constructs a Block with a fixed number of predecessors.
 628    Does set current_block.  Can be used with automatic Phi
 629    node construction. */
 630 ir_node *
 631 new_Block (int arity, ir_node **in)
 632 {
 633   ir_node *res;
 634
 635   res = new_r_Block (current_ir_graph, arity, in);
 636   current_ir_graph->current_block = res;
 637
 638   /* Create and initialize array for Phi-node construction. */
 639   res->attr.block.graph_arr = NEW_ARR_D (ir_node *, current_ir_graph->obst,
 640                                          current_ir_graph->n_loc);
 641   memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
 642
 643   res = optimize (res);
 644   irn_vrfy (res);
 645
 646   return res;
 647 }
 648
 649 /* ***********************************************************************/
 650 /* Methods necessary for automatic Phi node creation                     */
 651 /*
 652   ir_node *phi_merge            (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
 653   ir_node *get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
 654   ir_node *new_r_Phi0           (ir_graph *irg, ir_node *block, ir_mode *mode)
 655   ir_node *new_r_Phi_in         (ir_graph *irg, ir_node *block, ir_mode *mode,  ir_node **in, int ins)
 656
 657   Call Graph:   ( A ---> B == A "calls" B)
 658
 659        get_value         mature_block
 660           |                   |
 661           |                   |
 662           |                   |
 663           |          ---> phi_merge
 664           |         /       /   \
 665           |        /       /     \
 666          \|/      /      |/_      \
 667        get_r_value_internal        |
 668                 |                  |
 669                 |                  |
 670                \|/                \|/
 671             new_r_Phi0          new_r_Phi_in
 672
 673 * *************************************************************************** */
 674
 675 /* Creates a Phi node with 0 predecessors */
 676 inline ir_node *
 677 new_r_Phi0 (ir_graph *irg, ir_node *block, ir_mode *mode)
 678 {
 679   ir_node *res;
 680   res = new_ir_node (irg, block, op_Phi, mode, 0, NULL);
 681   irn_vrfy (res);
 682   return res;
 683 }
 684
 685 /* There are two implementations of the Phi node construction.  The first
 686    is faster, but does not work for blocks with more than 2 predecessors.
 687    The second works always but is slower and causes more unnecessary Phi
 688    nodes.
 689    Select the implementations by the following preprocessor flag set in
 690    common/common.h: */
 691 #if USE_FAST_PHI_CONSTRUCTION
 692
 693 /* This is a stack used for allocating and deallocating nodes in
 694    new_r_Phi_in.  The original implementation used the obstack
 695    to model this stack, now it is explicit.  This reduces side effects.
 696 */
 697 #if USE_EXPICIT_PHI_IN_STACK
 698 Phi_in_stack *
 699 new_Phi_in_stack() {
 700   Phi_in_stack *res;
 701
 702   res = (Phi_in_stack *) malloc ( sizeof (Phi_in_stack));
 703
 704   res->stack = NEW_ARR_F (ir_node *, 1);
 705   res->pos = 0;
 706
 707   return res;
 708 }
 709
 710 void free_to_Phi_in_stack(ir_node *phi) {
 711   assert(get_irn_opcode(phi) == iro_Phi);
 712
 713   if (ARR_LEN(current_ir_graph->Phi_in_stack->stack) ==
 714       current_ir_graph->Phi_in_stack->pos)
 715     ARR_APP1 (ir_node *, current_ir_graph->Phi_in_stack->stack, phi);
 716   else
 717     current_ir_graph->Phi_in_stack->stack[current_ir_graph->Phi_in_stack->pos] = phi;
 718
 719   (current_ir_graph->Phi_in_stack->pos)++;
 720 }
 721
 722 ir_node *
 723 alloc_or_pop_from_Phi_in_stack(ir_graph *irg, ir_node *block, ir_mode *mode,
 724              int arity, ir_node **in) {
 725   ir_node *res;
 726   ir_node **stack = current_ir_graph->Phi_in_stack->stack;
 727   int pos = current_ir_graph->Phi_in_stack->pos;
 728
 729
 730   if (pos == 0) {
 731     /* We need to allocate a new node */
 732     res = new_ir_node (irg, block, op_Phi, mode, arity, in);
 733   } else {
 734     /* reuse the old node and initialize it again. */
 735     res = stack[pos-1];
 736
 737     assert (res->kind == k_ir_node);
 738     assert (res->op == op_Phi);
 739     res->mode = mode;
 740     res->visited = 0;
 741     res->link = NULL;
 742     assert (arity >= 0);
 743     /* ???!!! How to free the old in array??  */
 744     res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
 745     res->in[0] = block;
 746     memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
 747
 748     (current_ir_graph->Phi_in_stack->pos)--;
 749   }
 750   return res;
 751 }
 752 #endif /* USE_EXPICIT_PHI_IN_STACK */
 753
 754 /* Creates a Phi node with a given, fixed array **in of predecessors.
 755    If the Phi node is unnecessary, as the same value reaches the block
 756    through all control flow paths, it is eliminated and the value
 757    returned directly.  This constructor is only intended for use in
 758    the automatic Phi node generation triggered by get_value or mature.
 759    The implementation is quite tricky and depends on the fact, that
 760    the nodes are allocated on a stack:
 761    The in array contains predecessors and NULLs.  The NULLs appear,
 762    if get_r_value_internal, that computed the predecessors, reached
 763    the same block on two paths.  In this case the same value reaches
 764    this block on both paths, there is no definition in between.  We need
 765    not allocate a Phi where these path's merge, but we have to communicate
 766    this fact to the caller.  This happens by returning a pointer to the
 767    node the caller _will_ allocate.  (Yes, we predict the address. We can
 768    do so because the nodes are allocated on the obstack.)  The caller then
 769    finds a pointer to itself and, when this routine is called again,
 770    eliminates itself.
 771    */
 772 inline ir_node *
 773 new_r_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
 774               ir_node **in, int ins)
 775 {
 776   int i;
 777   ir_node *res, *known;
 778
 779   /* allocate a new node on the obstack.
 780      This can return a node to which some of the pointers in the in-array
 781      already point.
 782      Attention: the constructor copies the in array, i.e., the later changes
 783      to the array in this routine do not affect the constructed node!  If
 784      the in array contains NULLs, there will be missing predecessors in the
 785      returned node.
 786      Is this a possible internal state of the Phi node generation? */
 787 #if USE_EXPICIT_PHI_IN_STACK
 788   res = known = alloc_or_pop_from_Phi_in_stack(irg, block, mode, ins, in);
 789 #else
 790   res = known = new_ir_node (irg, block, op_Phi, mode, ins, in);
 791 #endif
 792   /* The in-array can contain NULLs.  These were returned by
 793      get_r_value_internal if it reached the same block/definition on a
 794      second path.
 795      The NULLs are replaced by the node itself to simplify the test in the
 796      next loop. */
 797   for (i=0;  i < ins;  ++i)
 798     if (in[i] == NULL) in[i] = res;
 799
 800   /* This loop checks whether the Phi has more than one predecessor.
 801      If so, it is a real Phi node and we break the loop.  Else the
 802      Phi node merges the same definition on several paths and therefore
 803      is not needed. */
 804   for (i=0;  i < ins;  ++i)
 805   {
 806     if (in[i]==res || in[i]==known) continue;
 807
 808     if (known==res)
 809       known = in[i];
 810     else
 811       break;
 812   }
 813
 814   /* i==ins: there is at most one predecessor, we don't need a phi node. */
 815   if (i==ins) {
 816 #if USE_EXPICIT_PHI_IN_STACK
 817     free_to_Phi_in_stack(res);
 818 #else
 819     obstack_free (current_ir_graph->obst, res);
 820 #endif
 821     res = known;
 822   } else {
 823     res = optimize (res);
 824     irn_vrfy (res);
 825   }
 826
 827   /* return the pointer to the Phi node.  This node might be deallocated! */
 828   return res;
 829 }
 830
 831 inline ir_node *
 832 get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
 833
 834 /** This function computes the predecessors for a real Phi node, and then
 835     allocates and returns this node.  The routine called to allocate the
 836     node might optimize it away and return a real value, or even a pointer
 837     to a deallocated Phi node on top of the obstack!
 838     This function is called with an in-array of proper size. **/
 839 static inline ir_node *
 840 phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
 841 {
 842   ir_node *prevBlock, *res;
 843   int i;
 844
 845   /* This loop goes to all predecessor blocks of the block the Phi node is in
 846      and there finds the operands of the Phi node by calling
 847      get_r_value_internal. */
 848   for (i = 1;  i <= ins;  ++i) {
 849     assert (block->in[i]);
 850     prevBlock = block->in[i]->in[0]; /* go past control flow op to prev block */
 851     assert (prevBlock);
 852     nin[i-1] = get_r_value_internal (prevBlock, pos, mode);
 853   }
 854
 855   /* After collecting all predecessors into the array nin a new Phi node
 856      with these predecessors is created.  This constructor contains an
 857      optimization: If all predecessors of the Phi node are identical it
 858      returns the only operand instead of a new Phi node.  If the value
 859      passes two different control flow edges without being defined, and
 860      this is the second path treated, a pointer to the node that will be
 861      allocated for the first path (recursion) is returned.  We already
 862      know the address of this node, as it is the next node to be allocated
 863      and will be placed on top of the obstack. (The obstack is a _stack_!) */
 864   res = new_r_Phi_in (current_ir_graph, block, mode, nin, ins);
 865
 866   /* Now we now the value for "pos" and can enter it in the array with
 867      all known local variables.  Attention: this might be a pointer to
 868      a node, that later will be allocated!!! See new_r_Phi_in.
 869      If this is called in mature, after some set_value in the same block,
 870      the proper value must not be overwritten:
 871      The call order
 872        get_value    (makes Phi0, put's it into graph_arr)
 873        set_value    (overwrites Phi0 in graph_arr)
 874        mature_block (upgrades Phi0, puts it again into graph_arr, overwriting
 875                      the proper value.)
 876      fails. */
 877   if (!block->attr.block.graph_arr[pos]) {
 878     block->attr.block.graph_arr[pos] = res;
 879   } else {
 880     /*  printf(" value already computed by %s\n",
 881         id_to_str(block->attr.block.graph_arr[pos]->op->name));  */
 882   }
 883
 884   return res;
 885 }
 886
 887 /* This function returns the last definition of a variable.  In case
 888    this variable was last defined in a previous block, Phi nodes are
 889    inserted.  If the part of the firm graph containing the definition
 890    is not yet constructed, a dummy Phi node is returned. */
 891 inline ir_node *
 892 get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
 893 {
 894   ir_node *res;
 895   /* There are 4 cases to treat.
 896
 897      1. The block is not mature and we visit it the first time.  We can not
 898         create a proper Phi node, therefore a Phi0, i.e., a Phi without
 899         predecessors is returned.  This node is added to the linked list (field
 900         "link") of the containing block to be completed when this block is
 901         matured. (Comlpletion will add a new Phi and turn the Phi0 into an Id
 902         node.)
 903
 904      2. The value is already known in this block, graph_arr[pos] is set and we
 905         visit the block the first time.  We can return the value without
 906         creating any new nodes.
 907
 908      3. The block is mature and we visit it the first time.  A Phi node needs
 909         to be created (phi_merge).  If the Phi is not needed, as all it's
 910         operands are the same value reaching the block through different
 911         paths, it's optimized away and the value itself is returned.
 912
 913      4. The block is mature, and we visit it the second time.  Now two
 914         subcases are possible:
 915         * The value was computed completely the last time we were here. This
 916           is the case if there is no loop.  We can return the proper value.
 917         * The recursion that visited this node and set the flag did not
 918           return yet.  We are computing a value in a loop and need to
 919           break the recursion without knowing the result yet.
 920           @@@ strange case.  Straight forward we would create a Phi before
 921           starting the computation of it's predecessors.  In this case we will find
 922           a Phi here in any case.  The problem is that this implementation only
 923           creates a Phi after computing the predecessors, so that it is hard to
 924           compute self references of this Phi.  @@@
 925         There is no simple check for the second subcase.  Therefore we check
 926         for a second visit and treat all such cases as the second subcase.
 927         Anyways, the basic situation is the same:  we reached a block
 928         on two paths without finding a definition of the value:  No Phi
 929         nodes are needed on both paths.
 930         We return this information "Two paths, no Phi needed" by a very tricky
 931         implementation that relies on the fact that an obstack is a stack and
 932         will return a node with the same address on different allocations.
 933         Look also at phi_merge and new_r_phi_in to understand this.
 934         @@@ Unfortunately this does not work, see testprogram three_cfpred_example.
 935
 936   */
 937
 938   /* case 4 -- already visited. */
 939   if (get_irn_visited(block) == get_irg_visited(current_ir_graph)) return NULL;
 940
 941   /* visited the first time */
 942   set_irn_visited(block, get_irg_visited(current_ir_graph));
 943
 944   /* Get the local valid value */
 945   res = block->attr.block.graph_arr[pos];
 946
 947   /* case 2 -- If the value is actually computed, return it. */
 948   if (res) { return res;};
 949
 950   if (block->attr.block.matured) { /* case 3 */
 951
 952     /* The Phi has the same amount of ins as the corresponding block. */
 953     int ins = get_irn_arity(block);
 954     ir_node **nin;
 955     NEW_ARR_A (ir_node *, nin, ins);
 956
 957     /* Phi merge collects the predecessors and then creates a node. */
 958     res = phi_merge (block, pos, mode, nin, ins);
 959
 960   } else {  /* case 1 */
 961     /* The block is not mature, we don't know how many in's are needed.  A Phi
 962        with zero predecessors is created.  Such a Phi node is called Phi0
 963        node.  (There is also an obsolete Phi0 opcode.) The Phi0 is then added
 964        to the list of Phi0 nodes in this block to be matured by mature_block
 965        later.
 966        The Phi0 has to remember the pos of it's internal value.  If the real
 967        Phi is computed, pos is used to update the array with the local
 968        values. */
 969
 970     res = new_r_Phi0 (current_ir_graph, block, mode);
 971     res->attr.phi0_pos = pos;
 972     res->link = block->link;
 973     block->link = res;
 974   }
 975
 976   /* If we get here, the frontend missed a use-before-definition error */
 977   if (!res) {
 978     /* Error Message */
 979     printf("Error: no value set.  Use of undefined variable.  Initializing
 980             to zero.\n");
 981     assert (mode->code >= irm_f && mode->code <= irm_p);
 982     res = new_r_Const (current_ir_graph, block, mode,
 983                        tarval_mode_null[mode->code]);
 984   }
 985
 986   /* The local valid value is available now. */
 987   block->attr.block.graph_arr[pos] = res;
 988
 989   return res;
 990 }
 991
 992 #else /* if 0 */
 993
 994 /** This is the simple algorithm.  If first generates a Phi0, then
 995     it starts the recursion.  This causes an Id at the entry of
 996     every block that has no definition of the value! **/
 997
 998 #if USE_EXPICIT_PHI_IN_STACK
 999 /* Just a dummy */
1000 Phi_in_stack * new_Phi_in_stack() {  return NULL; }
1001 #endif
1002
1003 inline ir_node *
1004 new_r_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
1005               ir_node **in, int ins)
1006 {
1007   int i;
1008   ir_node *res, *known;
1009
1010   /* Allocate a new node on the obstack.  The allocation copies the in
1011      array. */
1012   res = new_ir_node (irg, block, op_Phi, mode, ins, in);
1013
1014   /* This loop checks whether the Phi has more than one predecessor.
1015      If so, it is a real Phi node and we break the loop.  Else the
1016      Phi node merges the same definition on several paths and therefore
1017      is not needed. Don't consider Bad nodes! */
1018   known = res;
1019   for (i=0;  i < ins;  ++i)
1020   {
1021     if (in[i]==res || in[i]==known || is_Bad(in[i])) continue;
1022
1023     if (known==res)
1024       known = in[i];
1025     else
1026       break;
1027   }
1028
1029   /* i==ins: there is at most one predecessor, we don't need a phi node. */
1030   if (i==ins) {
1031     if (res != known) {
1032       obstack_free (current_ir_graph->obst, res);
1033       res = known;
1034     } else {
1035       /* A undefined value, e.g., in unreachable code. */
1036       res = new_Bad();
1037     }
1038   } else {
1039     res = optimize (res);
1040     irn_vrfy (res);
1041   }
1042
1043   return res;
1044 }
1045
1046 inline ir_node *
1047 get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
1048
1049 /** This function allocates a dummy Phi node to break recursions,
1050     computes the predecessors for the real phi node, and then
1051     allocates and returns this node.  The routine called to allocate the
1052     node might optimize it away and return a real value.
1053     This function is called with an in-array of proper size. **/
1054 static inline ir_node *
1055 phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
1056 {
1057   ir_node *prevBlock, *res, *phi0;
1058   int i;
1059
1060
1061   /* If this block has no value at pos create a Phi0 and remember it
1062      in graph_arr to break recursions. */
1063   phi0 = NULL;
1064   if (!block->attr.block.graph_arr[pos]) {
1065     /* Even if all variables are defined before use, it can happen that
1066        we get to the start block, if a cond has been replaced by a tuple
1067        (bad, jmp).  As the start has a self referencing control flow edge,
1068        we get a self referencing Id, which is hard to optimize away.  We avoid
1069        this by defining the value as a Bad node. *
1070     if (block == get_irg_start_block(current_ir_graph)) {
1071       block->attr.block.graph_arr[pos] = new_Bad();
1072       return new_Bad();
1073       } else */ {
1074       phi0 = new_r_Phi0(current_ir_graph, block, mode);
1075       block->attr.block.graph_arr[pos] = phi0;
1076     }
1077   }
1078
1079   /* This loop goes to all predecessor blocks of the block the Phi node
1080      is in and there finds the operands of the Phi node by calling
1081      get_r_value_internal.  */
1082   for (i = 1;  i <= ins;  ++i) {
1083     assert (block->in[i]);
1084     if (is_Bad(block->in[i])) {
1085       /* In case a Cond has been optimized we would get right to the start block
1086          with an invalid definition. */
1087       nin[i-1] = new_Bad();
1088       continue;
1089     }
1090     prevBlock = block->in[i]->in[0]; /* go past control flow op to prev block */
1091     assert (prevBlock);
1092     if (!is_Bad(prevBlock)) {
1093       nin[i-1] = get_r_value_internal (prevBlock, pos, mode);
1094     } else {
1095       nin[i-1] = new_Bad();
1096     }
1097   }
1098
1099   /* After collecting all predecessors into the array nin a new Phi node
1100      with these predecessors is created.  This constructor contains an
1101      optimization: If all predecessors of the Phi node are identical it
1102      returns the only operand instead of a new Phi node.  */
1103   res = new_r_Phi_in (current_ir_graph, block, mode, nin, ins);
1104
1105   /* In case we allocated a Phi0 node at the beginning of this procedure,
1106      we need to exchange this Phi0 with the real Phi. */
1107   if (phi0) {
1108     exchange(phi0, res);
1109     block->attr.block.graph_arr[pos] = res;
1110   }
1111
1112   return res;
1113 }
1114
1115 /* This function returns the last definition of a variable.  In case
1116    this variable was last defined in a previous block, Phi nodes are
1117    inserted.  If the part of the firm graph containing the definition
1118    is not yet constructed, a dummy Phi node is returned. */
1119 inline ir_node *
1120 get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
1121 {
1122   ir_node *res;
1123   /* There are 4 cases to treat.
1124
1125      1. The block is not mature and we visit it the first time.  We can not
1126         create a proper Phi node, therefore a Phi0, i.e., a Phi without
1127         predecessors is returned.  This node is added to the linked list (field
1128         "link") of the containing block to be completed when this block is
1129         matured. (Comlpletion will add a new Phi and turn the Phi0 into an Id
1130         node.)
1131
1132      2. The value is already known in this block, graph_arr[pos] is set and we
1133         visit the block the first time.  We can return the value without
1134         creating any new nodes.
1135
1136      3. The block is mature and we visit it the first time.  A Phi node needs
1137         to be created (phi_merge).  If the Phi is not needed, as all it's
1138         operands are the same value reaching the block through different
1139         paths, it's optimized away and the value itself is returned.
1140
1141      4. The block is mature, and we visit it the second time.  Now two
1142         subcases are possible:
1143         * The value was computed completely the last time we were here. This
1144           is the case if there is no loop.  We can return the proper value.
1145         * The recursion that visited this node and set the flag did not
1146           return yet.  We are computing a value in a loop and need to
1147           break the recursion.  This case only happens if we visited
1148           the same block with phi_merge before, which inserted a Phi0.
1149           So we return the Phi0.
1150   */
1151
1152   /* case 4 -- already visited. */
1153   if (get_irn_visited(block) == get_irg_visited(current_ir_graph)) {
1154     /* As phi_merge allocates a Phi0 this value is always defined. Here
1155      is the critical difference of the two algorithms. */
1156     assert(block->attr.block.graph_arr[pos]);
1157     return block->attr.block.graph_arr[pos];
1158   }
1159
1160   /* visited the first time */
1161   set_irn_visited(block, get_irg_visited(current_ir_graph));
1162
1163   /* Get the local valid value */
1164   res = block->attr.block.graph_arr[pos];
1165
1166   /* case 2 -- If the value is actually computed, return it. */
1167   if (res) { return res; };
1168
1169   if (block->attr.block.matured) { /* case 3 */
1170
1171     /* The Phi has the same amount of ins as the corresponding block. */
1172     int ins = get_irn_arity(block);
1173     ir_node **nin;
1174     NEW_ARR_A (ir_node *, nin, ins);
1175
1176     /* Phi merge collects the predecessors and then creates a node. */
1177     res = phi_merge (block, pos, mode, nin, ins);
1178
1179   } else {  /* case 1 */
1180     /* The block is not mature, we don't know how many in's are needed.  A Phi
1181        with zero predecessors is created.  Such a Phi node is called Phi0
1182        node.  The Phi0 is then added to the list of Phi0 nodes in this block
1183        to be matured by mature_block later.
1184        The Phi0 has to remember the pos of it's internal value.  If the real
1185        Phi is computed, pos is used to update the array with the local
1186        values. */
1187     res = new_r_Phi0 (current_ir_graph, block, mode);
1188     res->attr.phi0_pos = pos;
1189     res->link = block->link;
1190     block->link = res;
1191   }
1192
1193   /* If we get here, the frontend missed a use-before-definition error */
1194   if (!res) {
1195     /* Error Message */
1196     printf("Error: no value set.  Use of undefined variable.  Initializing
1197             to zero.\n");
1198     assert (mode->code >= irm_f && mode->code <= irm_p);
1199     res = new_r_Const (current_ir_graph, block, mode,
1200                        tarval_mode_null[mode->code]);
1201   }
1202
1203   /* The local valid value is available now. */
1204   block->attr.block.graph_arr[pos] = res;
1205
1206   return res;
1207 }
1208
1209 #endif /* USE_FAST_PHI_CONSTRUCTION */
1210
1211 /* ************************************************************************** */
1212
1213 /** Finalize a Block node, when all control flows are known.  */
1214 /** Acceptable parameters are only Block nodes.               */
1215 void
1216 mature_block (ir_node *block)
1217 {
1218
1219   int ins;
1220   ir_node *n, **nin;
1221   ir_node *next;
1222
1223   assert (get_irn_opcode(block) == iro_Block);
1224
1225   if (!get_Block_matured(block)) {
1226
1227     /* turn the dynamic in-array into a static one. */
1228     ins = ARR_LEN (block->in)-1;
1229     NEW_ARR_A (ir_node *, nin, ins);
1230
1231     /* Traverse a chain of Phi nodes attached to this block and mature
1232        these, too. **/
1233     for (n = block->link;  n;  n=next) {
1234       inc_irg_visited(current_ir_graph);
1235       next = n->link;
1236       exchange (n, phi_merge (block, n->attr.phi0_pos, n->mode, nin, ins));
1237     }
1238
1239     block->attr.block.matured = 1;
1240
1241     /* Now, as the block is a finished firm node, we can optimize it.
1242        Since other nodes have been allocated since the block was created
1243        we can not free the node on the obstack.  Therefore we have to call
1244        optimize_in_place.
1245        Unfortunately the optimization does not change a lot, as all allocated
1246        nodes refer to the unoptimized node. */
1247     block = optimize_in_place(block);
1248     irn_vrfy(block);
1249   }
1250 }
1251
1252 ir_node *
1253 new_Phi (int arity, ir_node **in, ir_mode *mode)
1254 {
1255   return new_r_Phi (current_ir_graph, current_ir_graph->current_block,
1256                     arity, in, mode);
1257 }
1258
1259 ir_node *
1260 new_Const (ir_mode *mode, tarval *con)
1261 {
1262   return new_r_Const (current_ir_graph, current_ir_graph->start_block,
1263                       mode, con);
1264 }
1265
1266 ir_node *
1267 new_Id (ir_node *val, ir_mode *mode)
1268 {
1269   return new_r_Id (current_ir_graph, current_ir_graph->current_block,
1270                    val, mode);
1271 }
1272
1273 ir_node *
1274 new_Proj (ir_node *arg, ir_mode *mode, long proj)
1275 {
1276   return new_r_Proj (current_ir_graph, current_ir_graph->current_block,
1277                      arg, mode, proj);
1278 }
1279
1280 ir_node *
1281 new_Conv (ir_node *op, ir_mode *mode)
1282 {
1283   return new_r_Conv (current_ir_graph, current_ir_graph->current_block,
1284                      op, mode);
1285 }
1286
1287 ir_node *
1288 new_Tuple (int arity, ir_node **in)
1289 {
1290   return new_r_Tuple (current_ir_graph, current_ir_graph->current_block,
1291                       arity, in);
1292 }
1293
1294 ir_node *
1295 new_Add (ir_node *op1, ir_node *op2, ir_mode *mode)
1296 {
1297   return new_r_Add (current_ir_graph, current_ir_graph->current_block,
1298                     op1, op2, mode);
1299 }
1300
1301 ir_node *
1302 new_Sub (ir_node *op1, ir_node *op2, ir_mode *mode)
1303 {
1304   return new_r_Sub (current_ir_graph, current_ir_graph->current_block,
1305                     op1, op2, mode);
1306 }
1307
1308
1309 ir_node *
1310 new_Minus  (ir_node *op,  ir_mode *mode)
1311 {
1312   return new_r_Minus (current_ir_graph, current_ir_graph->current_block,
1313                       op, mode);
1314 }
1315
1316 ir_node *
1317 new_Mul (ir_node *op1, ir_node *op2, ir_mode *mode)
1318 {
1319   return new_r_Mul (current_ir_graph, current_ir_graph->current_block,
1320                     op1, op2, mode);
1321 }
1322
1323 ir_node *
1324 new_Quot (ir_node *memop, ir_node *op1, ir_node *op2)
1325 {
1326   return new_r_Quot (current_ir_graph, current_ir_graph->current_block,
1327                      memop, op1, op2);
1328 }
1329
1330 ir_node *
1331 new_DivMod (ir_node *memop, ir_node *op1, ir_node *op2)
1332 {
1333   return new_r_DivMod (current_ir_graph, current_ir_graph->current_block,
1334                        memop, op1, op2);
1335 }
1336
1337 ir_node *
1338 new_Div (ir_node *memop, ir_node *op1, ir_node *op2)
1339 {
1340   return new_r_Div (current_ir_graph, current_ir_graph->current_block,
1341                     memop, op1, op2);
1342 }
1343
1344 ir_node *
1345 new_Mod (ir_node *memop, ir_node *op1, ir_node *op2)
1346 {
1347   return new_r_Mod (current_ir_graph, current_ir_graph->current_block,
1348                     memop, op1, op2);
1349 }
1350
1351 ir_node *
1352 new_And (ir_node *op1, ir_node *op2, ir_mode *mode)
1353 {
1354   return new_r_And (current_ir_graph, current_ir_graph->current_block,
1355                     op1, op2, mode);
1356 }
1357
1358 ir_node *
1359 new_Or (ir_node *op1, ir_node *op2, ir_mode *mode)
1360 {
1361   return new_r_Or (current_ir_graph, current_ir_graph->current_block,
1362                    op1, op2, mode);
1363 }
1364
1365 ir_node *
1366 new_Eor (ir_node *op1, ir_node *op2, ir_mode *mode)
1367 {
1368   return new_r_Eor (current_ir_graph, current_ir_graph->current_block,
1369                     op1, op2, mode);
1370 }
1371
1372 ir_node *
1373 new_Not (ir_node *op, ir_mode *mode)
1374 {
1375   return new_r_Not (current_ir_graph, current_ir_graph->current_block,
1376                     op, mode);
1377 }
1378
1379 ir_node *
1380 new_Shl (ir_node *op, ir_node *k, ir_mode *mode)
1381 {
1382   return new_r_Shl (current_ir_graph, current_ir_graph->current_block,
1383                     op, k, mode);
1384 }
1385
1386 ir_node *
1387 new_Shr (ir_node *op, ir_node *k, ir_mode *mode)
1388 {
1389   return new_r_Shr (current_ir_graph, current_ir_graph->current_block,
1390                     op, k, mode);
1391 }
1392
1393 ir_node *
1394 new_Shrs (ir_node *op, ir_node *k, ir_mode *mode)
1395 {
1396   return new_r_Shrs (current_ir_graph, current_ir_graph->current_block,
1397                      op, k, mode);
1398 }
1399
1400 ir_node *
1401 new_Rotate (ir_node *op, ir_node *k, ir_mode *mode)
1402 {
1403   return new_r_Rot (current_ir_graph, current_ir_graph->current_block,
1404                      op, k, mode);
1405 }
1406
1407 ir_node *
1408 new_Abs (ir_node *op, ir_mode *mode)
1409 {
1410   return new_r_Abs (current_ir_graph, current_ir_graph->current_block,
1411                     op, mode);
1412 }
1413
1414 ir_node *
1415 new_Cmp (ir_node *op1, ir_node *op2)
1416 {
1417   return new_r_Cmp (current_ir_graph, current_ir_graph->current_block,
1418                     op1, op2);
1419 }
1420
1421 ir_node *
1422 new_Jmp (void)
1423 {
1424   return new_r_Jmp (current_ir_graph, current_ir_graph->current_block);
1425 }
1426
1427 ir_node *
1428 new_Cond (ir_node *c)
1429 {
1430   return new_r_Cond (current_ir_graph, current_ir_graph->current_block, c);
1431 }
1432
1433 ir_node *
1434 new_Call (ir_node *store, ir_node *callee, int arity, ir_node **in,
1435           type_method *type)
1436 {
1437   return new_r_Call (current_ir_graph, current_ir_graph->current_block,
1438                      store, callee, arity, in, type);
1439 }
1440
1441 ir_node *
1442 new_Return (ir_node* store, int arity, ir_node **in)
1443 {
1444   return new_r_Return (current_ir_graph, current_ir_graph->current_block,
1445                        store, arity, in);
1446 }
1447
1448 ir_node *
1449 new_Raise (ir_node *store, ir_node *obj)
1450 {
1451   return new_r_Raise (current_ir_graph, current_ir_graph->current_block,
1452                       store, obj);
1453 }
1454
1455 ir_node *
1456 new_Load (ir_node *store, ir_node *addr)
1457 {
1458   return new_r_Load (current_ir_graph, current_ir_graph->current_block,
1459                      store, addr);
1460 }
1461
1462 ir_node *
1463 new_Store (ir_node *store, ir_node *addr, ir_node *val)
1464 {
1465   return new_r_Store (current_ir_graph, current_ir_graph->current_block,
1466                       store, addr, val);
1467 }
1468
1469 ir_node *
1470 new_Alloc (ir_node *store, ir_node *size, type *alloc_type,
1471            where_alloc where)
1472 {
1473   return new_r_Alloc (current_ir_graph, current_ir_graph->current_block,
1474                       store, size, alloc_type, where);
1475 }
1476
1477 ir_node *
1478 new_Free (ir_node *store, ir_node *ptr, ir_node *size, type *free_type)
1479 {
1480   return new_r_Free (current_ir_graph, current_ir_graph->current_block,
1481                      store, ptr, size, free_type);
1482 }
1483
1484 ir_node *
1485 new_simpleSel (ir_node *store, ir_node *objptr, entity *ent)
1486 /* GL: objptr was called frame before.  Frame was a bad choice for the name
1487    as the operand could as well be a pointer to a dynamic object. */
1488 {
1489   return new_r_Sel (current_ir_graph, current_ir_graph->current_block,
1490                     store, objptr, 0, NULL, ent);
1491 }
1492
1493 ir_node *
1494 new_Sel (ir_node *store, ir_node *objptr, int n_index, ir_node **index, entity *sel)
1495 {
1496   return new_r_Sel (current_ir_graph, current_ir_graph->current_block,
1497                     store, objptr, n_index, index, sel);
1498 }
1499
1500 ir_node *
1501 new_SymConst (type_or_id_p value, symconst_kind kind)
1502 {
1503   return new_r_SymConst (current_ir_graph, current_ir_graph->current_block,
1504                          value, kind);
1505 }
1506
1507 ir_node *
1508 new_Sync (int arity, ir_node** in)
1509 {
1510   return new_r_Sync (current_ir_graph, current_ir_graph->current_block,
1511                      arity, in);
1512 }
1513
1514
1515 ir_node *
1516 new_Bad (void)
1517 {
1518   return current_ir_graph->bad;
1519 }
1520
1521 /* ********************************************************************* */
1522 /* Comfortable interface with automatic Phi node construction.           */
1523 /* (Uses also constructors of ?? interface, except new_Block.            */
1524 /* ********************************************************************* */
1525
1526 /** Block construction **/
1527 /* immature Block without predecessors */
1528 ir_node *new_immBlock (void) {
1529   ir_node *res;
1530
1531   /* creates a new dynamic in-array as length of in is -1 */
1532   res = new_ir_node (current_ir_graph, NULL, op_Block, mode_R, -1, NULL);
1533   current_ir_graph->current_block = res;
1534   res->attr.block.matured = 0;
1535   set_Block_block_visited(res, 0);
1536
1537   /* Create and initialize array for Phi-node construction. */
1538   res->attr.block.graph_arr = NEW_ARR_D (ir_node *, current_ir_graph->obst,
1539                                          current_ir_graph->n_loc);
1540   memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
1541
1542   /* Immature block may not be optimized! */
1543   irn_vrfy (res);
1544
1545   return res;
1546 }
1547
1548 /* add an adge to a jmp/control flow node */
1549 void
1550 add_in_edge (ir_node *block, ir_node *jmp)
1551 {
1552   if (block->attr.block.matured) {
1553     printf("Error: Block already matured!\n");
1554   }
1555   else {
1556     assert (jmp != NULL);
1557     ARR_APP1 (ir_node *, block->in, jmp);
1558   }
1559 }
1560
1561 /* changing the current block */
1562 void
1563 switch_block (ir_node *target)
1564 {
1565   current_ir_graph->current_block = target;
1566 }
1567
1568 /* ************************ */
1569 /* parameter administration */
1570
1571 /* get a value from the parameter array from the current block by its index */
1572 ir_node *
1573 get_value (int pos, ir_mode *mode)
1574 {
1575   inc_irg_visited(current_ir_graph);
1576   return get_r_value_internal (current_ir_graph->current_block, pos + 1, mode);
1577 }
1578
1579 /* set a value at position pos in the parameter array from the current block */
1580 inline void
1581 set_value (int pos, ir_node *value)
1582 {
1583   current_ir_graph->current_block->attr.block.graph_arr[pos + 1] = value;
1584 }
1585
1586 /* get the current store */
1587 inline ir_node *
1588 get_store (void)
1589 {
1590   /* GL: one could call get_value instead */
1591   inc_irg_visited(current_ir_graph);
1592   return get_r_value_internal (current_ir_graph->current_block, 0, mode_M);
1593 }
1594
1595 /* set the current store */
1596 inline void
1597 set_store (ir_node *store)
1598 {
1599   /* GL: one could call set_value instead */
1600   current_ir_graph->current_block->attr.block.graph_arr[0] = store;
1601 }
1602
1603 /* ********************************************************************* */
1604 /* initialize */
1605
1606 /* call once for each run of the library */
1607 void
1608 init_cons (void)
1609 {
1610 }