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