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