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. (Completion 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 #if PRECISE_EXC_CONTEXT
1074 static inline ir_node *
1075 phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins);
1076
1077 inline ir_node **
1078 new_frag_arr (ir_node *n) {
1079   ir_node **arr;
1080   arr = NEW_ARR_D (ir_node *, current_ir_graph->obst, current_ir_graph->n_loc);
1081   memcpy(arr, current_ir_graph->current_block->attr.block.graph_arr,
1082          sizeof(ir_node *)*current_ir_graph->n_loc);
1083   /* Here we rely on the fact that all frag ops have Memory as first result! */
1084   if (get_irn_op(n) == op_Call)
1085     arr[0] = new_Proj(n, mode_M, 3);
1086   else
1087     arr[0] = new_Proj(n, mode_M, 0);
1088   current_ir_graph->current_block->attr.block.graph_arr[current_ir_graph->n_loc-1] = n;
1089   return arr;
1090 }
1091
1092 inline ir_node **
1093 get_frag_arr (ir_node *n) {
1094   if (get_irn_op(n) == op_Call) {
1095     return n->attr.call.frag_arr;
1096   } else if (get_irn_op(n) == op_Alloc) {
1097     return n->attr.a.frag_arr;
1098   } else {
1099     return n->attr.frag_arr;
1100   }
1101 }
1102
1103 inline ir_node *
1104 set_frag_value(ir_node **frag_arr, int pos, ir_node *val) {
1105   if (!frag_arr[pos]) frag_arr[pos] = val;
1106   if (frag_arr[current_ir_graph->n_loc - 1])
1107     set_frag_value (get_frag_arr(frag_arr[current_ir_graph->n_loc - 1]), pos, val);
1108 }
1109
1110 inline ir_node *
1111 get_r_frag_value_internal (ir_node *block, ir_node *cfOp, int pos, ir_mode *mode) {
1112   ir_node *res;
1113   ir_node **rem;
1114   ir_node **frag_arr;
1115
1116   DDMSG2(cfOp);
1117   assert(is_fragile_op(cfOp));
1118
1119   frag_arr = get_frag_arr(cfOp);
1120   res = frag_arr[pos];
1121   if (!res) {
1122     if (block->attr.block.graph_arr[pos]) {
1123       /* There was a set_value after the cfOp and no get_value before that
1124          set_value.  We must build a Phi node now. */
1125       if (block->attr.block.matured) {
1126         int ins = get_irn_arity(block);
1127         ir_node **nin;
1128         NEW_ARR_A (ir_node *, nin, ins);
1129         phi_merge(block, pos, mode, nin, ins);
1130       } else {
1131         res = new_r_Phi0 (current_ir_graph, block, mode);
1132         res->attr.phi0_pos = pos;
1133         res->link = block->link;
1134         block->link = res;
1135       }
1136       set_frag_value(frag_arr, pos, res);
1137     } else {
1138       res = get_r_value_internal(block, pos, mode);
1139     }
1140   }
1141   return res;
1142 }
1143 #endif
1144
1145 /** This function allocates a dummy Phi node to break recursions,
1146     computes the predecessors for the real phi node, and then
1147     allocates and returns this node.  The routine called to allocate the
1148     node might optimize it away and return a real value.
1149     This function is called with an in-array of proper size. **/
1150 static inline ir_node *
1151 phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
1152 {
1153   ir_node *prevBlock, *prevCfOp, *res, *phi0;
1154   int i;
1155
1156
1157   /* If this block has no value at pos create a Phi0 and remember it
1158      in graph_arr to break recursions.
1159      Else we may not set graph_arr as there a later value is remembered. */
1160   phi0 = NULL;
1161   if (!block->attr.block.graph_arr[pos]) {
1162     /* This is commented out as collapsing to Bads is no good idea.
1163        Either we need an assert here, or we need to call a routine
1164        that deals with this case as appropriate for the given language.
1165        Right now a self referencing Id is created which will crash irg_vrfy().
1166
1167        Even if all variables are defined before use, it can happen that
1168        we get to the start block, if a cond has been replaced by a tuple
1169        (bad, jmp).  As the start has a self referencing control flow edge,
1170        we get a self referencing Id, which is hard to optimize away.  We avoid
1171        this by defining the value as a Bad node.
1172        Returning a const with tarval_bad is a preliminary solution.  In some
1173        situations we might want a Warning or an Error. */
1174
1175     if (block == get_irg_start_block(current_ir_graph)) {
1176       block->attr.block.graph_arr[pos] = new_Const(mode, tarval_bad);
1177       /* We don't need to care about exception ops in the start block.
1178          There are none by definition. */
1179       return block->attr.block.graph_arr[pos];
1180     } else  {
1181       phi0 = new_r_Phi0(current_ir_graph, block, mode);
1182       block->attr.block.graph_arr[pos] = phi0;
1183 #if PRECISE_EXC_CONTEXT
1184       /* Set graph_arr for fragile ops.  Also here we should break recursion. */
1185       set_frag_value(block->attr.block.graph_arr, pos, phi0);
1186 #endif
1187     }
1188   }
1189
1190   /* This loop goes to all predecessor blocks of the block the Phi node
1191      is in and there finds the operands of the Phi node by calling
1192      get_r_value_internal.  */
1193   for (i = 1;  i <= ins;  ++i) {
1194     prevCfOp = skip_Proj(block->in[i]);
1195     assert (prevCfOp);
1196     if (is_Bad(prevCfOp)) {
1197       /* In case a Cond has been optimized we would get right to the start block
1198          with an invalid definition. */
1199       nin[i-1] = new_Bad();
1200       continue;
1201     }
1202     prevBlock = block->in[i]->in[0]; /* go past control flow op to prev block */
1203     assert (prevBlock);
1204     if (!is_Bad(prevBlock)) {
1205 #if PRECISE_EXC_CONTEXT
1206       if (is_fragile_op(prevCfOp))
1207         nin[i-1] = get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode);
1208       else
1209 #endif
1210         nin[i-1] = get_r_value_internal (prevBlock, pos, mode);
1211     } else {
1212       nin[i-1] = new_Bad();
1213     }
1214   }
1215
1216   /* After collecting all predecessors into the array nin a new Phi node
1217      with these predecessors is created.  This constructor contains an
1218      optimization: If all predecessors of the Phi node are identical it
1219      returns the only operand instead of a new Phi node.  */
1220   res = new_r_Phi_in (current_ir_graph, block, mode, nin, ins);
1221
1222   /* In case we allocated a Phi0 node at the beginning of this procedure,
1223      we need to exchange this Phi0 with the real Phi. */
1224   if (phi0) {
1225     exchange(phi0, res);
1226     block->attr.block.graph_arr[pos] = res;
1227     /* Don't set_frag_value as it does not overwrite.  Doesn't matter, is
1228        only an optimization. */
1229   }
1230
1231   return res;
1232 }
1233
1234 /* This function returns the last definition of a variable.  In case
1235    this variable was last defined in a previous block, Phi nodes are
1236    inserted.  If the part of the firm graph containing the definition
1237    is not yet constructed, a dummy Phi node is returned. */
1238 inline ir_node *
1239 get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
1240 {
1241   ir_node *res;
1242   /* There are 4 cases to treat.
1243
1244      1. The block is not mature and we visit it the first time.  We can not
1245         create a proper Phi node, therefore a Phi0, i.e., a Phi without
1246         predecessors is returned.  This node is added to the linked list (field
1247         "link") of the containing block to be completed when this block is
1248         matured. (Comlpletion will add a new Phi and turn the Phi0 into an Id
1249         node.)
1250
1251      2. The value is already known in this block, graph_arr[pos] is set and we
1252         visit the block the first time.  We can return the value without
1253         creating any new nodes.
1254
1255      3. The block is mature and we visit it the first time.  A Phi node needs
1256         to be created (phi_merge).  If the Phi is not needed, as all it's
1257         operands are the same value reaching the block through different
1258         paths, it's optimized away and the value itself is returned.
1259
1260      4. The block is mature, and we visit it the second time.  Now two
1261         subcases are possible:
1262         * The value was computed completely the last time we were here. This
1263           is the case if there is no loop.  We can return the proper value.
1264         * The recursion that visited this node and set the flag did not
1265           return yet.  We are computing a value in a loop and need to
1266           break the recursion.  This case only happens if we visited
1267           the same block with phi_merge before, which inserted a Phi0.
1268           So we return the Phi0.
1269   */
1270
1271   /* case 4 -- already visited. */
1272   if (get_irn_visited(block) == get_irg_visited(current_ir_graph)) {
1273     /* As phi_merge allocates a Phi0 this value is always defined. Here
1274      is the critical difference of the two algorithms. */
1275     assert(block->attr.block.graph_arr[pos]);
1276     return block->attr.block.graph_arr[pos];
1277   }
1278
1279   /* visited the first time */
1280   set_irn_visited(block, get_irg_visited(current_ir_graph));
1281
1282   /* Get the local valid value */
1283   res = block->attr.block.graph_arr[pos];
1284
1285   /* case 2 -- If the value is actually computed, return it. */
1286   if (res) { return res; };
1287
1288   if (block->attr.block.matured) { /* case 3 */
1289
1290     /* The Phi has the same amount of ins as the corresponding block. */
1291     int ins = get_irn_arity(block);
1292     ir_node **nin;
1293     NEW_ARR_A (ir_node *, nin, ins);
1294
1295     /* Phi merge collects the predecessors and then creates a node. */
1296     res = phi_merge (block, pos, mode, nin, ins);
1297
1298   } else {  /* case 1 */
1299     /* The block is not mature, we don't know how many in's are needed.  A Phi
1300        with zero predecessors is created.  Such a Phi node is called Phi0
1301        node.  The Phi0 is then added to the list of Phi0 nodes in this block
1302        to be matured by mature_block later.
1303        The Phi0 has to remember the pos of it's internal value.  If the real
1304        Phi is computed, pos is used to update the array with the local
1305        values. */
1306     res = new_r_Phi0 (current_ir_graph, block, mode);
1307     res->attr.phi0_pos = pos;
1308     res->link = block->link;
1309     block->link = res;
1310   }
1311
1312   /* If we get here, the frontend missed a use-before-definition error */
1313   if (!res) {
1314     /* Error Message */
1315     printf("Error: no value set.  Use of undefined variable.  Initializing
1316             to zero.\n");
1317     assert (mode->code >= irm_f && mode->code <= irm_p);
1318     res = new_r_Const (current_ir_graph, block, mode,
1319                        tarval_mode_null[mode->code]);
1320   }
1321
1322   /* The local valid value is available now. */
1323   block->attr.block.graph_arr[pos] = res;
1324
1325   return res;
1326 }
1327
1328 #endif /* USE_FAST_PHI_CONSTRUCTION */
1329
1330 /* ************************************************************************** */
1331
1332 /** Finalize a Block node, when all control flows are known.  */
1333 /** Acceptable parameters are only Block nodes.               */
1334 void
1335 mature_block (ir_node *block)
1336 {
1337
1338   int ins;
1339   ir_node *n, **nin;
1340   ir_node *next;
1341
1342   assert (get_irn_opcode(block) == iro_Block);
1343
1344   if (!get_Block_matured(block)) {
1345
1346     /* turn the dynamic in-array into a static one. */
1347     ins = ARR_LEN (block->in)-1;
1348     NEW_ARR_A (ir_node *, nin, ins);
1349     /*  @@@ something is strange here... why isn't the array copied? */
1350
1351     /* Traverse a chain of Phi nodes attached to this block and mature
1352        these, too. **/
1353     for (n = block->link;  n;  n=next) {
1354       inc_irg_visited(current_ir_graph);
1355       next = n->link;
1356       exchange (n, phi_merge (block, n->attr.phi0_pos, n->mode, nin, ins));
1357     }
1358
1359     block->attr.block.matured = 1;
1360
1361     /* Now, as the block is a finished firm node, we can optimize it.
1362        Since other nodes have been allocated since the block was created
1363        we can not free the node on the obstack.  Therefore we have to call
1364        optimize_in_place.
1365        Unfortunately the optimization does not change a lot, as all allocated
1366        nodes refer to the unoptimized node. */
1367     block = optimize_in_place(block);
1368     irn_vrfy(block);
1369   }
1370 }
1371
1372 ir_node *
1373 new_Phi (int arity, ir_node **in, ir_mode *mode)
1374 {
1375   return new_r_Phi (current_ir_graph, current_ir_graph->current_block,
1376                     arity, in, mode);
1377 }
1378
1379 ir_node *
1380 new_Const (ir_mode *mode, tarval *con)
1381 {
1382   return new_r_Const (current_ir_graph, current_ir_graph->start_block,
1383                       mode, con);
1384 }
1385
1386 ir_node *
1387 new_Id (ir_node *val, ir_mode *mode)
1388 {
1389   return new_r_Id (current_ir_graph, current_ir_graph->current_block,
1390                    val, mode);
1391 }
1392
1393 ir_node *
1394 new_Proj (ir_node *arg, ir_mode *mode, long proj)
1395 {
1396   return new_r_Proj (current_ir_graph, current_ir_graph->current_block,
1397                      arg, mode, proj);
1398 }
1399
1400 ir_node *
1401 new_defaultProj (ir_node *arg, long max_proj)
1402 {
1403   ir_node *res;
1404   assert((arg->op==op_Cond) && (get_irn_mode(arg->in[1]) == mode_I));
1405   arg->attr.c.kind = fragmentary;
1406   arg->attr.c.default_proj = max_proj;
1407   res = new_Proj (arg, mode_X, max_proj);
1408   return res;
1409 }
1410
1411 ir_node *
1412 new_Conv (ir_node *op, ir_mode *mode)
1413 {
1414   return new_r_Conv (current_ir_graph, current_ir_graph->current_block,
1415                      op, mode);
1416 }
1417
1418 ir_node *
1419 new_Tuple (int arity, ir_node **in)
1420 {
1421   return new_r_Tuple (current_ir_graph, current_ir_graph->current_block,
1422                       arity, in);
1423 }
1424
1425 ir_node *
1426 new_Add (ir_node *op1, ir_node *op2, ir_mode *mode)
1427 {
1428   return new_r_Add (current_ir_graph, current_ir_graph->current_block,
1429                     op1, op2, mode);
1430 }
1431
1432 ir_node *
1433 new_Sub (ir_node *op1, ir_node *op2, ir_mode *mode)
1434 {
1435   return new_r_Sub (current_ir_graph, current_ir_graph->current_block,
1436                     op1, op2, mode);
1437 }
1438
1439
1440 ir_node *
1441 new_Minus  (ir_node *op,  ir_mode *mode)
1442 {
1443   return new_r_Minus (current_ir_graph, current_ir_graph->current_block,
1444                       op, mode);
1445 }
1446
1447 ir_node *
1448 new_Mul (ir_node *op1, ir_node *op2, ir_mode *mode)
1449 {
1450   return new_r_Mul (current_ir_graph, current_ir_graph->current_block,
1451                     op1, op2, mode);
1452 }
1453
1454 ir_node *
1455 new_Quot (ir_node *memop, ir_node *op1, ir_node *op2)
1456 {
1457   ir_node *res;
1458   res = new_r_Quot (current_ir_graph, current_ir_graph->current_block,
1459                      memop, op1, op2);
1460 #if PRECISE_EXC_CONTEXT
1461   res->attr.frag_arr = new_frag_arr(res);
1462 #endif
1463
1464   return res;
1465 }
1466
1467 ir_node *
1468 new_DivMod (ir_node *memop, ir_node *op1, ir_node *op2)
1469 {
1470   ir_node *res;
1471   res = new_r_DivMod (current_ir_graph, current_ir_graph->current_block,
1472                        memop, op1, op2);
1473 #if PRECISE_EXC_CONTEXT
1474   res->attr.frag_arr = new_frag_arr(res);
1475 #endif
1476
1477   return res;
1478 }
1479
1480 ir_node *
1481 new_Div (ir_node *memop, ir_node *op1, ir_node *op2)
1482 {
1483   ir_node *res;
1484   res = new_r_Div (current_ir_graph, current_ir_graph->current_block,
1485                     memop, op1, op2);
1486 #if PRECISE_EXC_CONTEXT
1487   res->attr.frag_arr = new_frag_arr(res);
1488 #endif
1489
1490   return res;
1491 }
1492
1493 ir_node *
1494 new_Mod (ir_node *memop, ir_node *op1, ir_node *op2)
1495 {
1496   ir_node *res;
1497   res = new_r_Mod (current_ir_graph, current_ir_graph->current_block,
1498                     memop, op1, op2);
1499 #if PRECISE_EXC_CONTEXT
1500   res->attr.frag_arr = new_frag_arr(res);
1501 #endif
1502
1503   return res;
1504 }
1505
1506 ir_node *
1507 new_And (ir_node *op1, ir_node *op2, ir_mode *mode)
1508 {
1509   return new_r_And (current_ir_graph, current_ir_graph->current_block,
1510                     op1, op2, mode);
1511 }
1512
1513 ir_node *
1514 new_Or (ir_node *op1, ir_node *op2, ir_mode *mode)
1515 {
1516   return new_r_Or (current_ir_graph, current_ir_graph->current_block,
1517                    op1, op2, mode);
1518 }
1519
1520 ir_node *
1521 new_Eor (ir_node *op1, ir_node *op2, ir_mode *mode)
1522 {
1523   return new_r_Eor (current_ir_graph, current_ir_graph->current_block,
1524                     op1, op2, mode);
1525 }
1526
1527 ir_node *
1528 new_Not (ir_node *op, ir_mode *mode)
1529 {
1530   return new_r_Not (current_ir_graph, current_ir_graph->current_block,
1531                     op, mode);
1532 }
1533
1534 ir_node *
1535 new_Shl (ir_node *op, ir_node *k, ir_mode *mode)
1536 {
1537   return new_r_Shl (current_ir_graph, current_ir_graph->current_block,
1538                     op, k, mode);
1539 }
1540
1541 ir_node *
1542 new_Shr (ir_node *op, ir_node *k, ir_mode *mode)
1543 {
1544   return new_r_Shr (current_ir_graph, current_ir_graph->current_block,
1545                     op, k, mode);
1546 }
1547
1548 ir_node *
1549 new_Shrs (ir_node *op, ir_node *k, ir_mode *mode)
1550 {
1551   return new_r_Shrs (current_ir_graph, current_ir_graph->current_block,
1552                      op, k, mode);
1553 }
1554
1555 ir_node *
1556 new_Rotate (ir_node *op, ir_node *k, ir_mode *mode)
1557 {
1558   return new_r_Rot (current_ir_graph, current_ir_graph->current_block,
1559                      op, k, mode);
1560 }
1561
1562 ir_node *
1563 new_Abs (ir_node *op, ir_mode *mode)
1564 {
1565   return new_r_Abs (current_ir_graph, current_ir_graph->current_block,
1566                     op, mode);
1567 }
1568
1569 ir_node *
1570 new_Cmp (ir_node *op1, ir_node *op2)
1571 {
1572   return new_r_Cmp (current_ir_graph, current_ir_graph->current_block,
1573                     op1, op2);
1574 }
1575
1576 ir_node *
1577 new_Jmp (void)
1578 {
1579   return new_r_Jmp (current_ir_graph, current_ir_graph->current_block);
1580 }
1581
1582 ir_node *
1583 new_Cond (ir_node *c)
1584 {
1585   return new_r_Cond (current_ir_graph, current_ir_graph->current_block, c);
1586 }
1587
1588 ir_node *
1589 new_Call (ir_node *store, ir_node *callee, int arity, ir_node **in,
1590           type *type)
1591 {
1592   ir_node *res;
1593   res = new_r_Call (current_ir_graph, current_ir_graph->current_block,
1594                      store, callee, arity, in, type);
1595 #if PRECISE_EXC_CONTEXT
1596   res->attr.call.frag_arr = new_frag_arr(res);
1597 #endif
1598
1599   return res;
1600 }
1601
1602 ir_node *
1603 new_Return (ir_node* store, int arity, ir_node **in)
1604 {
1605   return new_r_Return (current_ir_graph, current_ir_graph->current_block,
1606                        store, arity, in);
1607 }
1608
1609 ir_node *
1610 new_Raise (ir_node *store, ir_node *obj)
1611 {
1612   return new_r_Raise (current_ir_graph, current_ir_graph->current_block,
1613                       store, obj);
1614 }
1615
1616 ir_node *
1617 new_Load (ir_node *store, ir_node *addr)
1618 {
1619   ir_node *res;
1620   res = new_r_Load (current_ir_graph, current_ir_graph->current_block,
1621                      store, addr);
1622 #if PRECISE_EXC_CONTEXT
1623   res->attr.frag_arr = new_frag_arr(res);
1624 #endif
1625
1626   return res;
1627 }
1628
1629 ir_node *
1630 new_Store (ir_node *store, ir_node *addr, ir_node *val)
1631 {
1632   ir_node *res;
1633   res = new_r_Store (current_ir_graph, current_ir_graph->current_block,
1634                       store, addr, val);
1635 #if PRECISE_EXC_CONTEXT
1636   res->attr.frag_arr = new_frag_arr(res);
1637 #endif
1638
1639   return res;
1640 }
1641
1642 ir_node *
1643 new_Alloc (ir_node *store, ir_node *size, type *alloc_type,
1644            where_alloc where)
1645 {
1646   ir_node *res;
1647   res = new_r_Alloc (current_ir_graph, current_ir_graph->current_block,
1648                       store, size, alloc_type, where);
1649 #if PRECISE_EXC_CONTEXT
1650   res->attr.a.frag_arr = new_frag_arr(res);
1651 #endif
1652
1653   return res;
1654 }
1655
1656 ir_node *
1657 new_Free (ir_node *store, ir_node *ptr, ir_node *size, type *free_type)
1658 {
1659   return new_r_Free (current_ir_graph, current_ir_graph->current_block,
1660                      store, ptr, size, free_type);
1661 }
1662
1663 ir_node *
1664 new_simpleSel (ir_node *store, ir_node *objptr, entity *ent)
1665 /* GL: objptr was called frame before.  Frame was a bad choice for the name
1666    as the operand could as well be a pointer to a dynamic object. */
1667 {
1668   return new_r_Sel (current_ir_graph, current_ir_graph->current_block,
1669                     store, objptr, 0, NULL, ent);
1670 }
1671
1672 ir_node *
1673 new_Sel (ir_node *store, ir_node *objptr, int n_index, ir_node **index, entity *sel)
1674 {
1675   return new_r_Sel (current_ir_graph, current_ir_graph->current_block,
1676                     store, objptr, n_index, index, sel);
1677 }
1678
1679 ir_node *
1680 new_SymConst (type_or_id_p value, symconst_kind kind)
1681 {
1682   return new_r_SymConst (current_ir_graph, current_ir_graph->current_block,
1683                          value, kind);
1684 }
1685
1686 ir_node *
1687 new_Sync (int arity, ir_node** in)
1688 {
1689   return new_r_Sync (current_ir_graph, current_ir_graph->current_block,
1690                      arity, in);
1691 }
1692
1693
1694 ir_node *
1695 new_Bad (void)
1696 {
1697   return current_ir_graph->bad;
1698 }
1699
1700 /* ********************************************************************* */
1701 /* Comfortable interface with automatic Phi node construction.           */
1702 /* (Uses also constructors of ?? interface, except new_Block.            */
1703 /* ********************************************************************* */
1704
1705 /** Block construction **/
1706 /* immature Block without predecessors */
1707 ir_node *new_immBlock (void) {
1708   ir_node *res;
1709
1710   /* creates a new dynamic in-array as length of in is -1 */
1711   res = new_ir_node (current_ir_graph, NULL, op_Block, mode_R, -1, NULL);
1712   current_ir_graph->current_block = res;
1713   res->attr.block.matured = 0;
1714   set_Block_block_visited(res, 0);
1715
1716   /* Create and initialize array for Phi-node construction. */
1717   res->attr.block.graph_arr = NEW_ARR_D (ir_node *, current_ir_graph->obst,
1718                                          current_ir_graph->n_loc);
1719   memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
1720
1721   /* Immature block may not be optimized! */
1722   irn_vrfy (res);
1723
1724   return res;
1725 }
1726
1727 /* add an adge to a jmp/control flow node */
1728 void
1729 add_in_edge (ir_node *block, ir_node *jmp)
1730 {
1731   if (block->attr.block.matured) {
1732     assert(0 && "Error: Block already matured!\n");
1733   }
1734   else {
1735     assert (jmp != NULL);
1736     ARR_APP1 (ir_node *, block->in, jmp);
1737   }
1738 }
1739
1740 /* changing the current block */
1741 void
1742 switch_block (ir_node *target)
1743 {
1744   current_ir_graph->current_block = target;
1745 }
1746
1747 /* ************************ */
1748 /* parameter administration */
1749
1750 /* get a value from the parameter array from the current block by its index */
1751 ir_node *
1752 get_value (int pos, ir_mode *mode)
1753 {
1754   inc_irg_visited(current_ir_graph);
1755   return get_r_value_internal (current_ir_graph->current_block, pos + 1, mode);
1756 }
1757
1758
1759 /* set a value at position pos in the parameter array from the current block */
1760 inline void
1761 set_value (int pos, ir_node *value)
1762 {
1763   current_ir_graph->current_block->attr.block.graph_arr[pos + 1] = value;
1764 }
1765
1766 /* get the current store */
1767 inline ir_node *
1768 get_store (void)
1769 {
1770   /* GL: one could call get_value instead */
1771   inc_irg_visited(current_ir_graph);
1772   return get_r_value_internal (current_ir_graph->current_block, 0, mode_M);
1773 }
1774
1775 /* set the current store */
1776 inline void
1777 set_store (ir_node *store)
1778 {
1779   /* GL: one could call set_value instead */
1780   current_ir_graph->current_block->attr.block.graph_arr[0] = store;
1781 }
1782
1783 /* ********************************************************************* */
1784 /* initialize */
1785
1786 /* call once for each run of the library */
1787 void
1788 init_cons (void)
1789 {
1790 }