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