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 # include "ircons.h"
  13 # include "array.h"
  14 # include "iropt.h"
  15 /* memset belongs to string.h */
  16 # include "string.h"
  17
  18
  19 /*********************************************** */
  20 /** privat interfaces, for professional use only */
  21
  22 /*CS*/
  23 inline ir_node *
  24 new_r_Block (ir_graph *irg,  int arity, ir_node **in)
  25 {
  26   ir_node *res;
  27
  28   res = new_ir_node (current_ir_graph, NULL, op_Block, mode_R, -1, NULL);
  29
  30   return res;
  31
  32 }
  33
  34 ir_node *
  35 new_r_Start (ir_graph *irg, ir_node *block)
  36 {
  37   ir_node *res;
  38
  39   res = new_ir_node (irg, block, op_Start, mode_T, 0, NULL);
  40
  41   ir_vrfy (res);
  42   return res;
  43 }
  44
  45
  46 ir_node *
  47 new_r_End (ir_graph *irg, ir_node *block)
  48 {
  49   ir_node *res;
  50
  51   res = new_ir_node (irg, block, op_End, mode_X, -1, NULL);
  52
  53   ir_vrfy (res);
  54   return res;
  55
  56 }
  57
  58
  59 /* Creates a Phi node with 0 predecessors */
  60 inline ir_node *
  61 new_r_Phi0 (ir_graph *irg, ir_node *block, ir_mode *mode)
  62 {
  63   ir_node *res;
  64
  65   res = new_ir_node (irg, block, op_Phi, mode, 0, NULL);
  66
  67   /* GL I'm not sure whether we should optimize this guy. *
  68      res = optimize (res); ??? */
  69   ir_vrfy (res);
  70   return res;
  71 }
  72
  73 /* Creates a Phi node with all predecessors.  Calling this constructor
  74    is only allowed if the corresponding block is mature.  */
  75 ir_node *
  76 new_r_Phi (ir_graph *irg, ir_node *block, int arity, ir_node **in, ir_mode *mode)
  77 {
  78   ir_node *res;
  79
  80   assert( get_Block_matured(block) );
  81   assert( get_irn_arity(block) == arity );
  82
  83   res = new_ir_node (irg, block, op_Phi, mode, arity, in);
  84
  85   res = optimize (res);
  86   ir_vrfy (res);
  87   return res;
  88 }
  89
  90 /* This is a stack used for allocating and deallocating nodes in
  91    new_r_Phi_in.  The original implementation used the obstack
  92    to model this stack, now it is explicit.  This reduces side effects.
  93 */
  94 #if USE_EXPICIT_PHI_IN_STACK
  95 Phi_in_stack *
  96 new_Phi_in_stack() {
  97   Phi_in_stack *res;
  98
  99   res = (Phi_in_stack *) malloc ( sizeof (Phi_in_stack));
 100
 101   res->stack = NEW_ARR_F (ir_node *, 1);
 102   res->pos = 0;
 103
 104   return res;
 105 }
 106
 107
 108 void free_to_Phi_in_stack(ir_node *phi) {
 109   assert(get_irn_opcode(phi) == iro_Phi);
 110
 111   if (ARR_LEN(current_ir_graph->Phi_in_stack->stack) ==
 112       current_ir_graph->Phi_in_stack->pos)
 113     ARR_APP1 (ir_node *, current_ir_graph->Phi_in_stack->stack, phi);
 114   else
 115     current_ir_graph->Phi_in_stack->stack[current_ir_graph->Phi_in_stack->pos] = phi;
 116
 117   (current_ir_graph->Phi_in_stack->pos)++;
 118 }
 119
 120 ir_node *
 121 alloc_or_pop_from_Phi_in_stack(ir_graph *irg, ir_node *block, ir_mode *mode,
 122              int arity, ir_node **in) {
 123   ir_node *res;
 124   ir_node **stack = current_ir_graph->Phi_in_stack->stack;
 125   int pos = current_ir_graph->Phi_in_stack->pos;
 126
 127
 128   if (pos == 0) {
 129     /* We need to allocate a new node */
 130     res = new_ir_node (irg, block, op_Phi, mode, arity, in);
 131   } else {
 132     /* reuse the old node and initialize it again. */
 133     res = stack[pos-1];
 134
 135     assert (res->kind == k_ir_node);
 136     assert (res->op == op_Phi);
 137     res->mode = mode;
 138     res->visit = 0;
 139     res->link = NULL;
 140     assert (arity >= 0);
 141     /* ???!!! How to free the old in array??  */
 142     res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
 143     res->in[0] = block;
 144     memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
 145
 146     (current_ir_graph->Phi_in_stack->pos)--;
 147   }
 148   return res;
 149 }
 150 #endif
 151
 152
 153
 154 /* Creates a Phi node with a given, fixed array **in of predecessors.
 155    If the Phi node is unnecessary, as the same value reaches the block
 156    through all control flow paths, it is eliminated and the value
 157    returned directly.  This constructor is only intended for use in
 158    the automatic Phi node generation triggered by get_value or mature.
 159    The implementation is quite tricky and depends on the fact, that
 160    the nodes are allocated on a stack:
 161    The in array contains predecessors and NULLs.  The NULLs appear,
 162    if get_r_value_internal, that computed the predecessors, reached
 163    the same block on two paths.  In this case the same value reaches
 164    this block on both paths, there is no definition in between.  We need
 165    not allocate a Phi where these path's merge, but we have to communicate
 166    this fact to the caller.  This happens by returning a pointer to the
 167    node the caller _will_ allocate.  (Yes, we predict the address. We can
 168    do so because the nodes are allocated on the obstack.)  The caller then
 169    finds a pointer to itself and, when this routine is called again,
 170    eliminates itself.
 171    */
 172 inline ir_node *
 173 new_r_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
 174               ir_node **in, int ins)
 175 {
 176   int i;
 177   ir_node *res, *known;
 178
 179   /* allocate a new node on the obstack.
 180      This can return a node to which some of the pointers in the in-array
 181      already point.
 182      Attention: the constructor copies the in array, i.e., the later changes
 183      to the array in this routine do not affect the constructed node!  If
 184      the in array contains NULLs, there will be missing predecessors in the
 185      returned node.
 186      Is this a possible internal state of the Phi node generation? */
 187 #if USE_EXPICIT_PHI_IN_STACK
 188   res = known = alloc_or_pop_from_Phi_in_stack(irg, block, mode, ins, in);
 189 #else
 190   res = known = new_ir_node (irg, block, op_Phi, mode, ins, in);
 191 #endif
 192   /* The in-array can contain NULLs.  These were returned by get_r_value_internal
 193      if it reached the same block/definition on a second path.
 194      The NULLs are replaced by the node itself to simplify the test in the
 195      next loop. */
 196   for (i=0;  i < ins;  ++i)
 197     if (in[i] == NULL) in[i] = res;
 198
 199   /* This loop checks whether the Phi has more than one predecessor.
 200      If so, it is a real Phi node and we break the loop.  Else the
 201      Phi node merges the same definition on several paths and therefore
 202      is not needed. */
 203   for (i=0;  i < ins;  ++i)
 204   {
 205     if (in[i]==res || in[i]==known) continue;
 206
 207     if (known==res)
 208       known = in[i];
 209     else
 210       break;
 211   }
 212
 213   /* i==ins: there is at most one predecessor, we don't need a phi node. */
 214   if (i==ins) {
 215 #if USE_EXPICIT_PHI_IN_STACK
 216     free_to_Phi_in_stack(res);
 217 #else
 218     obstack_free (current_ir_graph->obst, res);
 219 #endif
 220     res = known;
 221   } else {
 222     res = optimize (res);
 223     ir_vrfy (res);
 224   }
 225
 226   /* return the pointer to the Phi node.  This node might be deallocated! */
 227   return res;
 228 }
 229
 230 ir_node *
 231 new_r_Const (ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con)
 232 {
 233   ir_node *res;
 234   res = new_ir_node (irg, block, op_Const, mode, 0, NULL);
 235   res->attr.con = con;
 236   res = optimize (res);
 237   ir_vrfy (res);
 238
 239 #if 0
 240   res = local_optimize_newby (res);
 241 # endif
 242
 243   return res;
 244 }
 245
 246 ir_node *
 247 new_r_Id (ir_graph *irg, ir_node *block, ir_node *val, ir_mode *mode)
 248 {
 249   ir_node *in[1] = {val};
 250   ir_node *res;
 251   res = new_ir_node (irg, block, op_Id, mode, 1, in);
 252   res = optimize (res);
 253   ir_vrfy (res);
 254   return res;
 255 }
 256
 257 ir_node *
 258 new_r_Proj (ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode, long proj)
 259 {
 260   ir_node *in[1] = {arg};
 261   ir_node *res;
 262   res = new_ir_node (irg, block, op_Proj, mode, 1, in);
 263   res->attr.proj = proj;
 264   res = optimize (res);
 265   ir_vrfy (res);
 266   return res;
 267
 268 }
 269
 270 ir_node *
 271 new_r_Conv (ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode)
 272 {
 273   ir_node *in[1] = {op};
 274   ir_node *res;
 275   res = new_ir_node (irg, block, op_Conv, mode, 1, in);
 276   res = optimize (res);
 277   ir_vrfy (res);
 278   return res;
 279
 280 }
 281
 282 ir_node *
 283 new_r_Tuple (ir_graph *irg, ir_node *block, int arity, ir_node **in)
 284 {
 285   ir_node *res;
 286
 287   res = new_ir_node (irg, block, op_Tuple, mode_T, arity, in);
 288   res = optimize (res);
 289   ir_vrfy (res);
 290   return res;
 291 }
 292
 293 inline ir_node *
 294 new_r_Add (ir_graph *irg, ir_node *block,
 295            ir_node *op1, ir_node *op2, ir_mode *mode)
 296 {
 297   ir_node *in[2] = {op1, op2};
 298   ir_node *res;
 299   res = new_ir_node (irg, block, op_Add, mode, 2, in);
 300   res = optimize (res);
 301   ir_vrfy (res);
 302   return res;
 303 }
 304
 305 inline ir_node *
 306 new_r_Sub (ir_graph *irg, ir_node *block,
 307            ir_node *op1, ir_node *op2, ir_mode *mode)
 308 {
 309   ir_node *in[2] = {op1, op2};
 310   ir_node *res;
 311   res = new_ir_node (irg, block, op_Sub, mode, 2, in);
 312   res = optimize (res);
 313   ir_vrfy (res);
 314   return res;
 315 }
 316
 317 inline ir_node *
 318 new_r_Minus (ir_graph *irg, ir_node *block,
 319              ir_node *op,  ir_mode *mode)
 320 {
 321   ir_node *in[1] = {op};
 322   ir_node *res;
 323   res = new_ir_node (irg, block, op_Minus, mode, 1, in);
 324   res = optimize (res);
 325   ir_vrfy (res);
 326   return res;
 327 }
 328
 329 inline ir_node *
 330 new_r_Mul (ir_graph *irg, ir_node *block,
 331            ir_node *op1, ir_node *op2, ir_mode *mode)
 332 {
 333   ir_node *in[2] = {op1, op2};
 334   ir_node *res;
 335   res = new_ir_node (irg, block, op_Mul, mode, 2, in);
 336   res = optimize (res);
 337   ir_vrfy (res);
 338   return res;
 339 }
 340
 341 inline ir_node *
 342 new_r_Quot (ir_graph *irg, ir_node *block,
 343             ir_node *memop, ir_node *op1, ir_node *op2)
 344 {
 345   ir_node *in[3] = {memop, op1, op2};
 346   ir_node *res;
 347   res = new_ir_node (irg, block, op_Quot, mode_T, 2, in);
 348   res = optimize (res);
 349   ir_vrfy (res);
 350   return res;
 351 }
 352
 353 inline ir_node *
 354 new_r_DivMod (ir_graph *irg, ir_node *block,
 355               ir_node *memop, ir_node *op1, ir_node *op2)
 356 {
 357   ir_node *in[3] = {memop, op1, op2};
 358   ir_node *res;
 359   res = new_ir_node (irg, block, op_DivMod, mode_T, 2, in);
 360   res = optimize (res);
 361   ir_vrfy (res);
 362   return res;
 363 }
 364
 365 inline ir_node *
 366 new_r_Div (ir_graph *irg, ir_node *block,
 367            ir_node *memop, ir_node *op1, ir_node *op2)
 368 {
 369   ir_node *in[3] = {memop, op1, op2};
 370   ir_node *res;
 371   res = new_ir_node (irg, block, op_Div, mode_T, 2, in);
 372   res = optimize (res);
 373   ir_vrfy (res);
 374   return res;
 375 }
 376
 377 inline ir_node *
 378 new_r_Mod (ir_graph *irg, ir_node *block,
 379            ir_node *memop, ir_node *op1, ir_node *op2)
 380 {
 381   ir_node *in[3] = {memop, op1, op2};
 382   ir_node *res;
 383   res = new_ir_node (irg, block, op_Mod, mode_T, 2, in);
 384   res = optimize (res);
 385   ir_vrfy (res);
 386   return res;
 387 }
 388
 389 inline ir_node *
 390 new_r_And (ir_graph *irg, ir_node *block,
 391            ir_node *op1, ir_node *op2, ir_mode *mode)
 392 {
 393   ir_node *in[2] = {op1, op2};
 394   ir_node *res;
 395   res = new_ir_node (irg, block, op_And, mode, 2, in);
 396   res = optimize (res);
 397   ir_vrfy (res);
 398   return res;
 399 }
 400
 401 inline ir_node *
 402 new_r_Or (ir_graph *irg, ir_node *block,
 403           ir_node *op1, ir_node *op2, ir_mode *mode)
 404 {
 405   ir_node *in[2] = {op1, op2};
 406   ir_node *res;
 407   res = new_ir_node (irg, block, op_Or, mode, 2, in);
 408   res = optimize (res);
 409   ir_vrfy (res);
 410   return res;
 411 }
 412
 413 inline ir_node *
 414 new_r_Eor (ir_graph *irg, ir_node *block,
 415           ir_node *op1, ir_node *op2, ir_mode *mode)
 416 {
 417   ir_node *in[2] = {op1, op2};
 418   ir_node *res;
 419   res = new_ir_node (irg, block, op_Eor, mode, 2, in);
 420   res = optimize (res);
 421   ir_vrfy (res);
 422   return res;
 423 }
 424
 425 inline ir_node *
 426 new_r_Not    (ir_graph *irg, ir_node *block,
 427               ir_node *op, ir_mode *mode)
 428 {
 429   ir_node *in[1] = {op};
 430   ir_node *res;
 431   res = new_ir_node (irg, block, op_Not, mode, 1, in);
 432   res = optimize (res);
 433   ir_vrfy (res);
 434   return res;
 435 }
 436
 437 inline ir_node *
 438 new_r_Shl (ir_graph *irg, ir_node *block,
 439           ir_node *op, ir_node *k, ir_mode *mode)
 440 {
 441   ir_node *in[2] = {op, k};
 442   ir_node *res;
 443   res = new_ir_node (irg, block, op_Shl, mode, 2, in);
 444   res = optimize (res);
 445   ir_vrfy (res);
 446   return res;
 447 }
 448
 449 inline ir_node *
 450 new_r_Shr (ir_graph *irg, ir_node *block,
 451            ir_node *op, ir_node *k, ir_mode *mode)
 452 {
 453   ir_node *in[2] = {op, k};
 454   ir_node *res;
 455   res = new_ir_node (irg, block, op_Shr, mode, 2, in);
 456   res = optimize (res);
 457   ir_vrfy (res);
 458   return res;
 459 }
 460
 461 inline ir_node *
 462 new_r_Shrs (ir_graph *irg, ir_node *block,
 463            ir_node *op, ir_node *k, ir_mode *mode)
 464 {
 465   ir_node *in[2] = {op, k};
 466   ir_node *res;
 467   res = new_ir_node (irg, block, op_Shrs, mode, 2, in);
 468   res = optimize (res);
 469   ir_vrfy (res);
 470   return res;
 471 }
 472
 473 inline ir_node *
 474 new_r_Rot (ir_graph *irg, ir_node *block,
 475            ir_node *op, ir_node *k, ir_mode *mode)
 476 {
 477   ir_node *in[2] = {op, k};
 478   ir_node *res;
 479   res = new_ir_node (irg, block, op_Rot, mode, 2, in);
 480   res = optimize (res);
 481   ir_vrfy (res);
 482   return res;
 483 }
 484
 485 inline ir_node *
 486 new_r_Abs (ir_graph *irg, ir_node *block,
 487            ir_node *op, ir_mode *mode)
 488 {
 489   ir_node *in[1] = {op};
 490   ir_node *res;
 491   res = new_ir_node (irg, block, op_Abs, mode, 1, in);
 492   res = optimize (res);
 493   ir_vrfy (res);
 494   return res;
 495 }
 496
 497 inline ir_node *
 498 new_r_Cmp (ir_graph *irg, ir_node *block,
 499            ir_node *op1, ir_node *op2)
 500 {
 501   ir_node *in[2] = {op1, op2};
 502   ir_node *res;
 503   res = new_ir_node (irg, block, op_Cmp, mode_T, 2, in);
 504   res = optimize (res);
 505   ir_vrfy (res);
 506   return res;
 507 }
 508
 509 inline ir_node *
 510 new_r_Jmp (ir_graph *irg, ir_node *block)
 511 {
 512   ir_node *in[0] = {};
 513   ir_node *res;
 514   res = new_ir_node (irg, block, op_Jmp, mode_X, 0, in);
 515   res = optimize (res);
 516   ir_vrfy (res);
 517   return res;
 518 }
 519
 520 inline ir_node *
 521 new_r_Cond (ir_graph *irg, ir_node *block, ir_node *c)
 522 {
 523   ir_node *in[1] = {c};
 524   ir_node *res;
 525   res = new_ir_node (irg, block, op_Cond, mode_T, 1, in);
 526   res = optimize (res);
 527   ir_vrfy (res);
 528   return res;
 529 }
 530
 531 ir_node *
 532 new_r_Call (ir_graph *irg, ir_node *block, ir_node *store,
 533             ir_node *callee, int arity, ir_node **in, type_method *type)
 534 {
 535   ir_node **r_in;
 536   ir_node *res;
 537   int r_arity;
 538
 539   r_arity = arity+2;
 540   NEW_ARR_A (ir_node *, r_in, r_arity);
 541   r_in[0] = store;
 542   r_in[1] = callee;
 543   memcpy (&r_in[2], in, sizeof (ir_node *) * arity);
 544
 545   res = new_ir_node (irg, block, op_Call, mode_T, r_arity, r_in);
 546
 547   set_Call_type(res, type);
 548   res = optimize (res);
 549   ir_vrfy (res);
 550   return res;
 551 }
 552
 553 ir_node *
 554 new_r_Return (ir_graph *irg, ir_node *block,
 555               ir_node *store, int arity, ir_node **in)
 556 {
 557   ir_node **r_in;
 558   ir_node *res;
 559   int r_arity;
 560
 561   r_arity = arity+1;
 562
 563   NEW_ARR_A (ir_node *, r_in, r_arity);
 564
 565   r_in[0] = store;
 566
 567   memcpy (&r_in[1], in, sizeof (ir_node *) * arity);
 568
 569   res = new_ir_node (irg, block, op_Return, mode_X, r_arity, r_in);
 570
 571   res = optimize (res);
 572
 573   ir_vrfy (res);
 574   return res;
 575 }
 576
 577 inline ir_node *
 578 new_r_Raise (ir_graph *irg, ir_node *block, ir_node *store, ir_node *obj)
 579 {
 580   ir_node *in[2] = {store, obj};
 581   ir_node *res;
 582   res = new_ir_node (irg, block, op_Raise, mode_X, 2, in);
 583
 584   res = optimize (res);
 585   ir_vrfy (res);
 586   return res;
 587 }
 588
 589 inline ir_node *
 590 new_r_Load (ir_graph *irg, ir_node *block,
 591             ir_node *store, ir_node *adr)
 592 {
 593   ir_node *in[2] = {store, adr};
 594   ir_node *res;
 595   res = new_ir_node (irg, block, op_Load, mode_T, 2, in);
 596
 597   res = optimize (res);
 598   ir_vrfy (res);
 599   return res;
 600 }
 601
 602 inline ir_node *
 603 new_r_Store (ir_graph *irg, ir_node *block,
 604              ir_node *store, ir_node *adr, ir_node *val)
 605 {
 606   ir_node *in[3] = {store, adr, val};
 607   ir_node *res;
 608   res = new_ir_node (irg, block, op_Store, mode_T, 3, in);
 609
 610   res = optimize (res);
 611   ir_vrfy (res);
 612   return res;
 613 }
 614
 615 inline ir_node *
 616 new_r_Alloc (ir_graph *irg, ir_node *block, ir_node *store,
 617             ir_node *size, type *alloc_type, where_alloc where)
 618 {
 619   ir_node *in[2] = {store, size};
 620   ir_node *res;
 621   res = new_ir_node (irg, block, op_Alloc, mode_T, 2, in);
 622
 623   res->attr.a.where = where;
 624   res->attr.a.type = alloc_type;
 625
 626   res = optimize (res);
 627   ir_vrfy (res);
 628   return res;
 629 }
 630
 631 inline ir_node *
 632 new_r_Free (ir_graph *irg, ir_node *block, ir_node *store,
 633             ir_node *ptr, ir_node *size, type *free_type)
 634 {
 635   ir_node *in[3] = {store, ptr, size};
 636   ir_node *res;
 637   res = new_ir_node (irg, block, op_Free, mode_T, 3, in);
 638
 639   res->attr.f = free_type;
 640
 641   res = optimize (res);
 642   ir_vrfy (res);
 643   return res;
 644 }
 645
 646 inline ir_node *
 647 new_r_Sel (ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
 648            int arity, ir_node **in, entity *ent)
 649 {
 650   ir_node **r_in;
 651   ir_node *res;
 652   int r_arity;
 653
 654   r_arity = arity + 2;
 655   NEW_ARR_A (ir_node *, r_in, r_arity);
 656   r_in[0] = store;
 657   r_in[1] = objptr;
 658   memcpy (&r_in[2], in, sizeof (ir_node *) * arity);
 659   res = new_ir_node (irg, block, op_Sel, mode_p, r_arity, r_in);
 660
 661   res->attr.s.ltyp = static_linkage;
 662   res->attr.s.ent = ent;
 663
 664   res = optimize (res);
 665   ir_vrfy (res);
 666   return res;
 667 }
 668
 669 inline ir_node *
 670 new_r_SymConst (ir_graph *irg, ir_node *block, type_or_id *value,
 671                 symconst_kind symkind)
 672 {
 673   ir_node *in[0] = {};
 674   ir_node *res;
 675   res = new_ir_node (irg, block, op_SymConst, mode_I, 0, in);
 676
 677   res->attr.i.num = symkind;
 678   if (symkind == linkage_ptr_info) {
 679     res->attr.i.tori.ptrinfo = (ident *)value;
 680   } else {
 681     assert (   (   (symkind == type_tag)
 682                 || (symkind == size))
 683             && (is_type(value)));
 684     res->attr.i.tori.typ = (type *)value;
 685   }
 686   res = optimize (res);
 687   ir_vrfy (res);
 688   return res;
 689 }
 690
 691 ir_node *
 692 new_r_Sync (ir_graph *irg, ir_node *block, int arity, ir_node **in)
 693 {
 694   ir_node *res;
 695
 696   res = new_ir_node (irg, block, op_Sync, mode_M, arity, in);
 697
 698   res = optimize (res);
 699   ir_vrfy (res);
 700   return res;
 701 }
 702
 703
 704 ir_node *
 705 new_r_Bad (ir_node *block)
 706 {
 707   return current_ir_graph->bad;
 708 }
 709
 710 /***********************/
 711 /** public interfaces  */
 712 /** construction tools */
 713
 714 ir_node *
 715 new_Start (void)
 716 {
 717   ir_node *res;
 718
 719   res = new_ir_node (current_ir_graph, current_ir_graph->current_block,
 720                      op_Start, mode_T, 0, NULL);
 721
 722   res = optimize (res);
 723   ir_vrfy (res);
 724   return res;
 725 }
 726
 727
 728 ir_node *
 729 new_End (void)
 730 {
 731   ir_node *res;
 732
 733   res = new_ir_node (current_ir_graph,  current_ir_graph->current_block,
 734                      op_End, mode_X, -1, NULL);
 735
 736   res = optimize (res);
 737   ir_vrfy (res);
 738   return res;
 739
 740 }
 741
 742 ir_node *
 743 new_Block (void)
 744 {
 745   ir_node *res;
 746
 747   res = new_ir_node (current_ir_graph, NULL, op_Block, mode_R, -1, NULL);
 748   current_ir_graph->current_block = res;
 749   res->attr.block.matured = 0;
 750   set_Block_block_visit(res, 0);
 751
 752   /* forget this optimization. use this only if mature !!!!
 753   res = optimize (res); */
 754   ir_vrfy (res);
 755
 756   /** create a new dynamic array, which stores all parameters in irnodes */
 757   /** using the same obstack as the whole irgraph */
 758   res->attr.block.graph_arr = NEW_ARR_D (ir_node *, current_ir_graph->obst,
 759                                          current_ir_graph->params);
 760
 761   /** initialize the parameter array */
 762   memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->params);
 763
 764   return res;
 765 }
 766
 767
 768 ir_node *
 769 new_Phi (int arity, ir_node **in, ir_mode *mode)
 770 {
 771   return new_r_Phi (current_ir_graph, current_ir_graph->current_block,
 772                     arity, in, mode);
 773 }
 774
 775 ir_node *
 776 new_Const (ir_mode *mode, tarval *con)
 777 {
 778   return new_r_Const (current_ir_graph, current_ir_graph->start_block,
 779                       mode, con);
 780 }
 781
 782 ir_node *
 783 new_Id (ir_node *val, ir_mode *mode)
 784 {
 785   return new_r_Id (current_ir_graph, current_ir_graph->current_block,
 786                    val, mode);
 787 }
 788
 789 ir_node *
 790 new_Proj (ir_node *arg, ir_mode *mode, long proj)
 791 {
 792   return new_r_Proj (current_ir_graph, current_ir_graph->current_block,
 793                      arg, mode, proj);
 794 }
 795
 796 ir_node *
 797 new_Conv (ir_node *op, ir_mode *mode)
 798 {
 799   return new_r_Conv (current_ir_graph, current_ir_graph->current_block,
 800                      op, mode);
 801 }
 802
 803 ir_node *
 804 new_Tuple (int arity, ir_node **in)
 805 {
 806   return new_r_Tuple (current_ir_graph, current_ir_graph->current_block,
 807                       arity, in);
 808 }
 809
 810 ir_node *
 811 new_Add (ir_node *op1, ir_node *op2, ir_mode *mode)
 812 {
 813   return new_r_Add (current_ir_graph, current_ir_graph->current_block,
 814                     op1, op2, mode);
 815 }
 816
 817 ir_node *
 818 new_Sub (ir_node *op1, ir_node *op2, ir_mode *mode)
 819 {
 820   return new_r_Sub (current_ir_graph, current_ir_graph->current_block,
 821                     op1, op2, mode);
 822 }
 823
 824
 825 ir_node *
 826 new_Minus  (ir_node *op,  ir_mode *mode)
 827 {
 828   return new_r_Minus (current_ir_graph, current_ir_graph->current_block,
 829                       op, mode);
 830 }
 831
 832 ir_node *
 833 new_Mul (ir_node *op1, ir_node *op2, ir_mode *mode)
 834 {
 835   return new_r_Mul (current_ir_graph, current_ir_graph->current_block,
 836                     op1, op2, mode);
 837 }
 838
 839 ir_node *
 840 new_Quot (ir_node *memop, ir_node *op1, ir_node *op2)
 841 {
 842   return new_r_Quot (current_ir_graph, current_ir_graph->current_block,
 843                      memop, op1, op2);
 844 }
 845
 846 ir_node *
 847 new_DivMod (ir_node *memop, ir_node *op1, ir_node *op2)
 848 {
 849   return new_r_DivMod (current_ir_graph, current_ir_graph->current_block,
 850                        memop, op1, op2);
 851 }
 852
 853 ir_node *
 854 new_Div (ir_node *memop, ir_node *op1, ir_node *op2)
 855 {
 856   return new_r_Div (current_ir_graph, current_ir_graph->current_block,
 857                     memop, op1, op2);
 858 }
 859
 860 ir_node *
 861 new_Mod (ir_node *memop, ir_node *op1, ir_node *op2)
 862 {
 863   return new_r_Mod (current_ir_graph, current_ir_graph->current_block,
 864                     memop, op1, op2);
 865 }
 866
 867 ir_node *
 868 new_And (ir_node *op1, ir_node *op2, ir_mode *mode)
 869 {
 870   return new_r_And (current_ir_graph, current_ir_graph->current_block,
 871                     op1, op2, mode);
 872 }
 873
 874 ir_node *
 875 new_Or (ir_node *op1, ir_node *op2, ir_mode *mode)
 876 {
 877   return new_r_Or (current_ir_graph, current_ir_graph->current_block,
 878                    op1, op2, mode);
 879 }
 880
 881 ir_node *
 882 new_Eor (ir_node *op1, ir_node *op2, ir_mode *mode)
 883 {
 884   return new_r_Eor (current_ir_graph, current_ir_graph->current_block,
 885                     op1, op2, mode);
 886 }
 887
 888 ir_node *
 889 new_Not (ir_node *op, ir_mode *mode)
 890 {
 891   return new_r_Not (current_ir_graph, current_ir_graph->current_block,
 892                     op, mode);
 893 }
 894
 895 ir_node *
 896 new_Shl (ir_node *op, ir_node *k, ir_mode *mode)
 897 {
 898   return new_r_Shl (current_ir_graph, current_ir_graph->current_block,
 899                     op, k, mode);
 900 }
 901
 902 ir_node *
 903 new_Shr (ir_node *op, ir_node *k, ir_mode *mode)
 904 {
 905   return new_r_Shr (current_ir_graph, current_ir_graph->current_block,
 906                     op, k, mode);
 907 }
 908
 909 ir_node *
 910 new_Shrs (ir_node *op, ir_node *k, ir_mode *mode)
 911 {
 912   return new_r_Shrs (current_ir_graph, current_ir_graph->current_block,
 913                      op, k, mode);
 914 }
 915
 916 ir_node *
 917 new_Rotate (ir_node *op, ir_node *k, ir_mode *mode)
 918 {
 919   return new_r_Rot (current_ir_graph, current_ir_graph->current_block,
 920                      op, k, mode);
 921 }
 922
 923 ir_node *
 924 new_Abs (ir_node *op, ir_mode *mode)
 925 {
 926   return new_r_Abs (current_ir_graph, current_ir_graph->current_block,
 927                     op, mode);
 928 }
 929
 930 ir_node *
 931 new_Cmp (ir_node *op1, ir_node *op2)
 932 {
 933   return new_r_Cmp (current_ir_graph, current_ir_graph->current_block,
 934                     op1, op2);
 935 }
 936
 937 ir_node *
 938 new_Jmp (void)
 939 {
 940   return new_r_Jmp (current_ir_graph, current_ir_graph->current_block);
 941 }
 942
 943 ir_node *
 944 new_Cond (ir_node *c)
 945 {
 946   return new_r_Cond (current_ir_graph, current_ir_graph->current_block, c);
 947 }
 948
 949 ir_node *
 950 new_Call (ir_node *store, ir_node *callee, int arity, ir_node **in,
 951           type_method *type)
 952 {
 953   return new_r_Call (current_ir_graph, current_ir_graph->current_block,
 954                      store, callee, arity, in, type);
 955 }
 956
 957 /* make M parameter in call explicit:
 958 new_Return (ir_node* store, int arity, ir_node **in) */
 959 ir_node *
 960 new_Return (ir_node* store, int arity, ir_node **in)
 961 {
 962   return new_r_Return (current_ir_graph, current_ir_graph->current_block,
 963                        store, arity, in);
 964 }
 965
 966 ir_node *
 967 new_Raise (ir_node *store, ir_node *obj)
 968 {
 969   return new_r_Raise (current_ir_graph, current_ir_graph->current_block,
 970                       store, obj);
 971 }
 972
 973 ir_node *
 974 new_Load (ir_node *store, ir_node *addr)
 975 {
 976   return new_r_Load (current_ir_graph, current_ir_graph->current_block,
 977                      store, addr);
 978 }
 979
 980 ir_node *
 981 new_Store (ir_node *store, ir_node *addr, ir_node *val)
 982 {
 983   return new_r_Store (current_ir_graph, current_ir_graph->current_block,
 984                       store, addr, val);
 985 }
 986
 987 ir_node *
 988 new_Alloc (ir_node *store, ir_node *size, type *alloc_type,
 989            where_alloc where)
 990 {
 991   return new_r_Alloc (current_ir_graph, current_ir_graph->current_block,
 992                       store, size, alloc_type, where);
 993 }
 994
 995 ir_node *
 996 new_Free (ir_node *store, ir_node *ptr, ir_node *size, type *free_type)
 997 {
 998   return new_r_Free (current_ir_graph, current_ir_graph->current_block,
 999                      store, ptr, size, free_type);
1000 }
1001
1002 ir_node *
1003 new_simpleSel (ir_node *store, ir_node *objptr, entity *ent)
1004 /* GL: objptr was called frame before.  Frame was a bad choice for the name
1005    as the operand could as well be a pointer to a dynamic object. */
1006 {
1007   return new_r_Sel (current_ir_graph, current_ir_graph->current_block,
1008                     store, objptr, 0, NULL, ent);
1009 }
1010
1011 ir_node *
1012 new_Sel (ir_node *store, ir_node *objptr, int n_index, ir_node **index, entity *sel)
1013 {
1014   return new_r_Sel (current_ir_graph, current_ir_graph->current_block,
1015                     store, objptr, n_index, index, sel);
1016 }
1017
1018 ir_node *
1019 new_SymConst (type_or_id *value, symconst_kind kind)
1020 {
1021   return new_r_SymConst (current_ir_graph, current_ir_graph->current_block,
1022                          value, kind);
1023 }
1024
1025 ir_node *
1026 new_Sync (int arity, ir_node** in)
1027 {
1028   return new_r_Sync (current_ir_graph, current_ir_graph->current_block,
1029                      arity, in);
1030 }
1031
1032
1033 ir_node *
1034 new_Bad (void)
1035 {
1036   return current_ir_graph->bad;
1037 }
1038
1039 #if 0
1040 /************************/
1041 /* ir block constructor */
1042
1043 /* GL: what's this good for? */
1044
1045 typedef struct ir_block {
1046   char closed;
1047   char matured;
1048   /* -1 = error, 0 = OK */
1049 } ir_block;
1050
1051 ir_block *
1052 new_ir_Block(void)
1053 {
1054   ir_block *res;
1055
1056   res->closed = -1;
1057   res->matured = -1;
1058
1059   return res;
1060 }
1061 #endif
1062
1063 /* initialize */
1064
1065 /* call once for each run of the library */
1066 void
1067 init_cons (void)
1068 {
1069 }