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