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 /* irnode constructor                                             */
  20 /* create a new irnode in irg, with an op, mode, arity and        */
  21 /* some incoming irnodes                                          */
  22 /* this constructor is used in every specified irnode constructor */
  23 inline ir_node *
  24 new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
  25              int arity, ir_node **in)
  26 {
  27   ir_node *res;
  28   int node_size = offsetof (ir_node, attr) +  op->attr_size;
  29
  30   res = (ir_node *) obstack_alloc (irg->obst, node_size);
  31
  32   res->kind = k_ir_node;
  33   res->op = op;
  34   res->mode = mode;
  35   res->visit = 0;
  36   res->link = NULL;
  37   if (arity < 0) {
  38     res->in = NEW_ARR_F (ir_node *, 1);
  39   } else {
  40     res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
  41     memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
  42   }
  43   res->in[0] = block;
  44   return res;
  45 }
  46
  47
  48
  49
  50 /*********************************************** */
  51 /** privat interfaces, for professional use only */
  52
  53 /* Creates a Phi node with 0 predecessors */
  54 inline ir_node *
  55 new_r_Phi0 (ir_graph *irg, ir_node *block, ir_mode *mode)
  56 {
  57   ir_node *res;
  58
  59   res = new_ir_node (irg, block, op_Phi, mode, 0, NULL);
  60
  61   /* GL I'm not sure whether we should optimize this guy. *
  62      res = optimize (res); ??? */
  63   ir_vrfy (res);
  64   return res;
  65 }
  66
  67 /* Creates a Phi node with all predecessors.  Calling this constructor
  68    is only allowed if the corresponding block is mature.  */
  69 ir_node *
  70 new_r_Phi (ir_graph *irg, ir_node *block, int arity, ir_node **in, ir_mode *mode)
  71 {
  72   ir_node *res;
  73
  74   assert( get_Block_matured(block) );
  75   assert( get_irn_arity(block) == arity );
  76
  77   res = new_ir_node (irg, block, op_Phi, mode, arity, in);
  78
  79   res = optimize (res);
  80   ir_vrfy (res);
  81   return res;
  82 }
  83
  84 /* This is a stack used for allocating and deallocating nodes in
  85    new_r_Phi_in.  The original implementation used the obstack
  86    to model this stack, now it is explicit.  This reduces side effects.
  87 */
  88 #if USE_EXPICIT_PHI_IN_STACK
  89 Phi_in_stack *
  90 new_Phi_in_stack() {
  91   Phi_in_stack *res;
  92
  93   res = (Phi_in_stack *) malloc ( sizeof (Phi_in_stack));
  94
  95   res->stack = NEW_ARR_F (ir_node *, 1);
  96   res->pos = 0;
  97
  98   return res;
  99 }
 100
 101
 102 void free_to_Phi_in_stack(ir_node *phi) {
 103   assert(get_irn_opcode(phi) == iro_Phi);
 104
 105   if (ARR_LEN(current_ir_graph->Phi_in_stack->stack) ==
 106       current_ir_graph->Phi_in_stack->pos)
 107     ARR_APP1 (ir_node *, current_ir_graph->Phi_in_stack->stack, phi);
 108   else
 109     current_ir_graph->Phi_in_stack->stack[current_ir_graph->Phi_in_stack->pos] = phi;
 110
 111   (current_ir_graph->Phi_in_stack->pos)++;
 112 }
 113
 114 ir_node *
 115 alloc_or_pop_from_Phi_in_stack(ir_graph *irg, ir_node *block, ir_mode *mode,
 116              int arity, ir_node **in) {
 117   ir_node *res;
 118   ir_node **stack = current_ir_graph->Phi_in_stack->stack;
 119   int pos = current_ir_graph->Phi_in_stack->pos;
 120
 121
 122   if (pos == 0) {
 123     /* We need to allocate a new node */
 124     res = new_ir_node (irg, block, op_Phi, mode, arity, in);
 125   } else {
 126     /* reuse the old node and initialize it again. */
 127     res = stack[pos-1];
 128
 129     assert (res->kind == k_ir_node);
 130     assert (res->op == op_Phi);
 131     res->mode = mode;
 132     res->visit = 0;
 133     res->link = NULL;
 134     assert (arity >= 0);
 135     /* ???!!! How to free the old in array??  */
 136     res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
 137     res->in[0] = block;
 138     memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
 139
 140     (current_ir_graph->Phi_in_stack->pos)--;
 141   }
 142   return res;
 143 }
 144 #endif
 145
 146
 147
 148 /* Creates a Phi node with a given, fixed array **in of predecessors.
 149    If the Phi node is unnecessary, as the same value reaches the block
 150    through all control flow paths, it is eliminated and the value
 151    returned directly.  This constructor is only intended for use in
 152    the automatic Phi node generation triggered by get_value or mature.
 153    The implementation is quite tricky and depends on the fact, that
 154    the nodes are allocated on a stack:
 155    The in array contains predecessors and NULLs.  The NULLs appear,
 156    if get_r_value_internal, that computed the predecessors, reached
 157    the same block on two paths.  In this case the same value reaches
 158    this block on both paths, there is no definition in between.  We need
 159    not allocate a Phi where these path's merge, but we have to communicate
 160    this fact to the caller.  This happens by returning a pointer to the
 161    node the caller _will_ allocate.  (Yes, we predict the address. We can
 162    do so because the nodes are allocated on the obstack.)  The caller then
 163    finds a pointer to itself and, when this routine is called again,
 164    eliminates itself.
 165    */
 166 inline ir_node *
 167 new_r_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
 168               ir_node **in, int ins)
 169 {
 170   int i;
 171   ir_node *res, *known;
 172
 173   /* allocate a new node on the obstack.
 174      This can return a node to which some of the pointers in the in-array
 175      already point.
 176      Attention: the constructor copies the in array, i.e., the later changes
 177      to the array in this routine do not affect the constructed node!  If
 178      the in array contains NULLs, there will be missing predecessors in the
 179      returned node.
 180      Is this a possible internal state of the Phi node generation? */
 181 #if USE_EXPICIT_PHI_IN_STACK
 182   res = known = alloc_or_pop_from_Phi_in_stack(irg, block, mode, ins, in);
 183 #else
 184   res = known = new_ir_node (irg, block, op_Phi, mode, ins, in);
 185 #endif
 186   /* The in-array can contain NULLs.  These were returned by get_r_value_internal
 187      if it reached the same block/definition on a second path.
 188      The NULLs are replaced by the node itself to simplify the test in the
 189      next loop. */
 190   for (i=0;  i < ins;  ++i)
 191     if (in[i] == NULL) in[i] = res;
 192
 193   /* This loop checks whether the Phi has more than one predecessor.
 194      If so, it is a real Phi node and we break the loop.  Else the
 195      Phi node merges the same definition on several paths and therefore
 196      is not needed. */
 197   for (i=0;  i < ins;  ++i)
 198   {
 199     if (in[i]==res || in[i]==known) continue;
 200
 201     if (known==res)
 202       known = in[i];
 203     else
 204       break;
 205   }
 206
 207   /* i==ins: there is at most one predecessor, we don't need a phi node. */
 208   if (i==ins) {
 209 #if USE_EXPICIT_PHI_IN_STACK
 210     free_to_Phi_in_stack(res);
 211 #else
 212     obstack_free (current_ir_graph->obst, res);
 213 #endif
 214     res = known;
 215   } else {
 216     res = optimize (res);
 217     ir_vrfy (res);
 218   }
 219
 220   /* return the pointer to the Phi node.  This node might be deallocated! */
 221   return res;
 222 }
 223
 224 ir_node *
 225 new_r_Const (ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con)
 226 {
 227   ir_node *res;
 228   res = new_ir_node (irg, block, op_Const, mode, 0, NULL);
 229   res->attr.con = con;
 230   res = optimize (res);
 231   ir_vrfy (res);
 232
 233 #if 0
 234   res = local_optimize_newby (res);
 235 # endif
 236
 237   return res;
 238 }
 239
 240 ir_node *
 241 new_r_Id (ir_graph *irg, ir_node *block, ir_node *val, ir_mode *mode)
 242 {
 243   ir_node *in[1] = {val};
 244   ir_node *res;
 245   res = new_ir_node (irg, block, op_Id, mode, 1, in);
 246   res = optimize (res);
 247   ir_vrfy (res);
 248   return res;
 249 }
 250
 251 ir_node *
 252 new_r_Proj (ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode, long proj)
 253 {
 254   ir_node *in[1] = {arg};
 255   ir_node *res;
 256   res = new_ir_node (irg, block, op_Proj, mode, 1, in);
 257   res->attr.proj = proj;
 258   res = optimize (res);
 259   ir_vrfy (res);
 260   return res;
 261
 262 }
 263
 264 ir_node *
 265 new_r_Conv (ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode)
 266 {
 267   ir_node *in[1] = {op};
 268   ir_node *res;
 269   res = new_ir_node (irg, block, op_Conv, mode, 1, in);
 270   res = optimize (res);
 271   ir_vrfy (res);
 272   return res;
 273
 274 }
 275
 276 ir_node *
 277 new_r_Tuple (ir_graph *irg, ir_node *block, int arity, ir_node **in)
 278 {
 279   ir_node *res;
 280
 281   res = new_ir_node (irg, block, op_Tuple, mode_T, arity, in);
 282   res = optimize (res);
 283   ir_vrfy (res);
 284   return res;
 285 }
 286
 287 inline ir_node *
 288 new_r_Add (ir_graph *irg, ir_node *block,
 289            ir_node *op1, ir_node *op2, ir_mode *mode)
 290 {
 291   ir_node *in[2] = {op1, op2};
 292   ir_node *res;
 293   res = new_ir_node (irg, block, op_Add, mode, 2, in);
 294   res = optimize (res);
 295   ir_vrfy (res);
 296   return res;
 297 }
 298
 299 inline ir_node *
 300 new_r_Sub (ir_graph *irg, ir_node *block,
 301            ir_node *op1, ir_node *op2, ir_mode *mode)
 302 {
 303   ir_node *in[2] = {op1, op2};
 304   ir_node *res;
 305   res = new_ir_node (irg, block, op_Sub, mode, 2, in);
 306   res = optimize (res);
 307   ir_vrfy (res);
 308   return res;
 309 }
 310
 311 inline ir_node *
 312 new_r_Minus (ir_graph *irg, ir_node *block,
 313              ir_node *op,  ir_mode *mode)
 314 {
 315   ir_node *in[1] = {op};
 316   ir_node *res;
 317   res = new_ir_node (irg, block, op_Minus, mode, 1, in);
 318   res = optimize (res);
 319   ir_vrfy (res);
 320   return res;
 321 }
 322
 323 inline ir_node *
 324 new_r_Mul (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_Mul, mode, 2, in);
 330   res = optimize (res);
 331   ir_vrfy (res);
 332   return res;
 333 }
 334
 335 inline ir_node *
 336 new_r_Quot (ir_graph *irg, ir_node *block,
 337             ir_node *memop, ir_node *op1, ir_node *op2)
 338 {
 339   ir_node *in[3] = {memop, op1, op2};
 340   ir_node *res;
 341   res = new_ir_node (irg, block, op_Quot, mode_T, 2, in);
 342   res = optimize (res);
 343   ir_vrfy (res);
 344   return res;
 345 }
 346
 347 inline ir_node *
 348 new_r_DivMod (ir_graph *irg, ir_node *block,
 349               ir_node *memop, ir_node *op1, ir_node *op2)
 350 {
 351   ir_node *in[3] = {memop, op1, op2};
 352   ir_node *res;
 353   res = new_ir_node (irg, block, op_DivMod, mode_T, 2, in);
 354   res = optimize (res);
 355   ir_vrfy (res);
 356   return res;
 357 }
 358
 359 inline ir_node *
 360 new_r_Div (ir_graph *irg, ir_node *block,
 361            ir_node *memop, ir_node *op1, ir_node *op2)
 362 {
 363   ir_node *in[3] = {memop, op1, op2};
 364   ir_node *res;
 365   res = new_ir_node (irg, block, op_Div, mode_T, 2, in);
 366   res = optimize (res);
 367   ir_vrfy (res);
 368   return res;
 369 }
 370
 371 inline ir_node *
 372 new_r_Mod (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_Mod, mode_T, 2, in);
 378   res = optimize (res);
 379   ir_vrfy (res);
 380   return res;
 381 }
 382
 383 inline ir_node *
 384 new_r_And (ir_graph *irg, ir_node *block,
 385            ir_node *op1, ir_node *op2, ir_mode *mode)
 386 {
 387   ir_node *in[2] = {op1, op2};
 388   ir_node *res;
 389   res = new_ir_node (irg, block, op_And, mode, 2, in);
 390   res = optimize (res);
 391   ir_vrfy (res);
 392   return res;
 393 }
 394
 395 inline ir_node *
 396 new_r_Or (ir_graph *irg, ir_node *block,
 397           ir_node *op1, ir_node *op2, ir_mode *mode)
 398 {
 399   ir_node *in[2] = {op1, op2};
 400   ir_node *res;
 401   res = new_ir_node (irg, block, op_Or, mode, 2, in);
 402   res = optimize (res);
 403   ir_vrfy (res);
 404   return res;
 405 }
 406
 407 inline ir_node *
 408 new_r_Eor (ir_graph *irg, ir_node *block,
 409           ir_node *op1, ir_node *op2, ir_mode *mode)
 410 {
 411   ir_node *in[2] = {op1, op2};
 412   ir_node *res;
 413   res = new_ir_node (irg, block, op_Eor, mode, 2, in);
 414   res = optimize (res);
 415   ir_vrfy (res);
 416   return res;
 417 }
 418
 419 inline ir_node *
 420 new_r_Not    (ir_graph *irg, ir_node *block,
 421               ir_node *op, ir_mode *mode)
 422 {
 423   ir_node *in[1] = {op};
 424   ir_node *res;
 425   res = new_ir_node (irg, block, op_Not, mode, 1, in);
 426   res = optimize (res);
 427   ir_vrfy (res);
 428   return res;
 429 }
 430
 431 inline ir_node *
 432 new_r_Shl (ir_graph *irg, ir_node *block,
 433           ir_node *op, ir_node *k, ir_mode *mode)
 434 {
 435   ir_node *in[2] = {op, k};
 436   ir_node *res;
 437   res = new_ir_node (irg, block, op_Shl, mode, 2, in);
 438   res = optimize (res);
 439   ir_vrfy (res);
 440   return res;
 441 }
 442
 443 inline ir_node *
 444 new_r_Shr (ir_graph *irg, ir_node *block,
 445            ir_node *op, ir_node *k, ir_mode *mode)
 446 {
 447   ir_node *in[2] = {op, k};
 448   ir_node *res;
 449   res = new_ir_node (irg, block, op_Shr, mode, 2, in);
 450   res = optimize (res);
 451   ir_vrfy (res);
 452   return res;
 453 }
 454
 455 inline ir_node *
 456 new_r_Shrs (ir_graph *irg, ir_node *block,
 457            ir_node *op, ir_node *k, ir_mode *mode)
 458 {
 459   ir_node *in[2] = {op, k};
 460   ir_node *res;
 461   res = new_ir_node (irg, block, op_Shrs, mode, 2, in);
 462   res = optimize (res);
 463   ir_vrfy (res);
 464   return res;
 465 }
 466
 467 inline ir_node *
 468 new_r_Rot (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_Rot, mode, 2, in);
 474   res = optimize (res);
 475   ir_vrfy (res);
 476   return res;
 477 }
 478
 479 inline ir_node *
 480 new_r_Abs (ir_graph *irg, ir_node *block,
 481            ir_node *op, ir_mode *mode)
 482 {
 483   ir_node *in[1] = {op};
 484   ir_node *res;
 485   res = new_ir_node (irg, block, op_Abs, mode, 1, in);
 486   res = optimize (res);
 487   ir_vrfy (res);
 488   return res;
 489 }
 490
 491 inline ir_node *
 492 new_r_Cmp (ir_graph *irg, ir_node *block,
 493            ir_node *op1, ir_node *op2)
 494 {
 495   ir_node *in[2] = {op1, op2};
 496   ir_node *res;
 497   res = new_ir_node (irg, block, op_Cmp, mode_T, 2, in);
 498   res = optimize (res);
 499   ir_vrfy (res);
 500   return res;
 501 }
 502
 503 inline ir_node *
 504 new_r_Jmp (ir_graph *irg, ir_node *block)
 505 {
 506   ir_node *in[0] = {};
 507   ir_node *res;
 508   res = new_ir_node (irg, block, op_Jmp, mode_X, 0, in);
 509   res = optimize (res);
 510   ir_vrfy (res);
 511   return res;
 512 }
 513
 514 inline ir_node *
 515 new_r_Cond (ir_graph *irg, ir_node *block, ir_node *c)
 516 {
 517   ir_node *in[1] = {c};
 518   ir_node *res;
 519   res = new_ir_node (irg, block, op_Cond, mode_T, 1, in);
 520   res = optimize (res);
 521   ir_vrfy (res);
 522   return res;
 523 }
 524
 525 ir_node *
 526 new_r_Call (ir_graph *irg, ir_node *block, ir_node *store,
 527             ir_node *callee, int arity, ir_node **in, type_method *type)
 528 {
 529   ir_node **r_in;
 530   ir_node *res;
 531   int r_arity;
 532
 533   r_arity = arity+2;
 534   NEW_ARR_A (ir_node *, r_in, r_arity);
 535   r_in[0] = store;
 536   r_in[1] = callee;
 537   memcpy (&r_in[2], in, sizeof (ir_node *) * arity);
 538
 539   res = new_ir_node (irg, block, op_Call, mode_T, r_arity, r_in);
 540
 541   set_Call_type(res, type);
 542   res = optimize (res);
 543   ir_vrfy (res);
 544   return res;
 545 }
 546
 547 ir_node *
 548 new_r_Return (ir_graph *irg, ir_node *block,
 549               ir_node *store, int arity, ir_node **in)
 550 {
 551   ir_node **r_in;
 552   ir_node *res;
 553   int r_arity;
 554
 555   r_arity = arity+1;
 556
 557   NEW_ARR_A (ir_node *, r_in, r_arity);
 558
 559   r_in[0] = store;
 560
 561   memcpy (&r_in[1], in, sizeof (ir_node *) * arity);
 562
 563   res = new_ir_node (irg, block, op_Return, mode_X, r_arity, r_in);
 564
 565   res = optimize (res);
 566
 567   ir_vrfy (res);
 568   return res;
 569 }
 570
 571 inline ir_node *
 572 new_r_Raise (ir_graph *irg, ir_node *block, ir_node *store, ir_node *obj)
 573 {
 574   ir_node *in[2] = {store, obj};
 575   ir_node *res;
 576   res = new_ir_node (irg, block, op_Raise, mode_X, 2, in);
 577
 578   res = optimize (res);
 579   ir_vrfy (res);
 580   return res;
 581 }
 582
 583 inline ir_node *
 584 new_r_Load (ir_graph *irg, ir_node *block,
 585             ir_node *store, ir_node *adr)
 586 {
 587   ir_node *in[2] = {store, adr};
 588   ir_node *res;
 589   res = new_ir_node (irg, block, op_Load, mode_T, 2, in);
 590
 591   res = optimize (res);
 592   ir_vrfy (res);
 593   return res;
 594 }
 595
 596 inline ir_node *
 597 new_r_Store (ir_graph *irg, ir_node *block,
 598              ir_node *store, ir_node *adr, ir_node *val)
 599 {
 600   ir_node *in[3] = {store, adr, val};
 601   ir_node *res;
 602   res = new_ir_node (irg, block, op_Store, mode_T, 3, in);
 603
 604   res = optimize (res);
 605   ir_vrfy (res);
 606   return res;
 607 }
 608
 609 inline ir_node *
 610 new_r_Alloc (ir_graph *irg, ir_node *block, ir_node *store,
 611             ir_node *size, type *alloc_type, where_alloc where)
 612 {
 613   ir_node *in[2] = {store, size};
 614   ir_node *res;
 615   res = new_ir_node (irg, block, op_Alloc, mode_T, 2, in);
 616
 617   res->attr.a.where = where;
 618   res->attr.a.type = alloc_type;
 619
 620   res = optimize (res);
 621   ir_vrfy (res);
 622   return res;
 623 }
 624
 625 inline ir_node *
 626 new_r_Free (ir_graph *irg, ir_node *block, ir_node *store,
 627             ir_node *ptr, ir_node *size, type *free_type)
 628 {
 629   ir_node *in[3] = {store, ptr, size};
 630   ir_node *res;
 631   res = new_ir_node (irg, block, op_Free, mode_T, 3, in);
 632
 633   res->attr.f = free_type;
 634
 635   res = optimize (res);
 636   ir_vrfy (res);
 637   return res;
 638 }
 639
 640 inline ir_node *
 641 new_r_Sel (ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
 642            int arity, ir_node **in, entity *ent)
 643 {
 644   ir_node **r_in;
 645   ir_node *res;
 646   int r_arity;
 647
 648   r_arity = arity + 2;
 649   NEW_ARR_A (ir_node *, r_in, r_arity);
 650   r_in[0] = store;
 651   r_in[1] = objptr;
 652   memcpy (&r_in[2], in, sizeof (ir_node *) * arity);
 653   res = new_ir_node (irg, block, op_Sel, mode_p, r_arity, r_in);
 654
 655   res->attr.s.ltyp = static_linkage;
 656   res->attr.s.ent = ent;
 657
 658   res = optimize (res);
 659   ir_vrfy (res);
 660   return res;
 661 }
 662
 663 inline ir_node *
 664 new_r_SymConst (ir_graph *irg, ir_node *block, type_or_id *value,
 665                 symconst_kind symkind)
 666 {
 667   ir_node *in[0] = {};
 668   ir_node *res;
 669   res = new_ir_node (irg, block, op_SymConst, mode_I, 0, in);
 670
 671   res->attr.i.num = symkind;
 672   if (symkind == linkage_ptr_info) {
 673     res->attr.i.tori.ptrinfo = (ident *)value;
 674   } else {
 675     assert (   (   (symkind == type_tag)
 676                 || (symkind == size))
 677             && (is_type(value)));
 678     res->attr.i.tori.typ = (type *)value;
 679   }
 680   res = optimize (res);
 681   ir_vrfy (res);
 682   return res;
 683 }
 684
 685 ir_node *
 686 new_r_Sync (ir_graph *irg, ir_node *block, int arity, ir_node **in)
 687 {
 688   ir_node *res;
 689
 690   res = new_ir_node (irg, block, op_Sync, mode_M, arity, in);
 691
 692   res = optimize (res);
 693   ir_vrfy (res);
 694   return res;
 695 }
 696
 697
 698 ir_node *
 699 new_r_Bad (ir_node *block)
 700 {
 701   return current_ir_graph->bad;
 702 }
 703
 704 /***********************/
 705 /** public interfaces  */
 706 /** construction tools */
 707
 708 ir_node *
 709 new_Start (void)
 710 {
 711   ir_node *res;
 712
 713   res = new_ir_node (current_ir_graph, current_ir_graph->current_block,
 714                      op_Start, mode_T, 0, NULL);
 715
 716   res = optimize (res);
 717   ir_vrfy (res);
 718   return res;
 719 }
 720
 721
 722 ir_node *
 723 new_End (void)
 724 {
 725   ir_node *res;
 726
 727   res = new_ir_node (current_ir_graph,  current_ir_graph->current_block,
 728                      op_End, mode_X, -1, NULL);
 729
 730   res = optimize (res);
 731   ir_vrfy (res);
 732   return res;
 733
 734 }
 735
 736 ir_node *
 737 new_Block (void)
 738 {
 739   ir_node *res;
 740
 741   res = new_ir_node (current_ir_graph, NULL, op_Block, mode_R, -1, NULL);
 742   current_ir_graph->current_block = res;
 743   res->attr.block.matured = 0;
 744   set_Block_block_visit(res, 0);
 745
 746   // res = optimize (res); /* GL: only optimize if mature!!!! */
 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 }