nsz Git - libfirm/blob - ir/be/benode.c

   1 /*
   2  * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   6  * This file may be distributed and/or modified under the terms of the
   7  * GNU General Public License version 2 as published by the Free Software
   8  * Foundation and appearing in the file LICENSE.GPL included in the
   9  * packaging of this file.
  10  *
  11  * Licensees holding valid libFirm Professional Edition licenses may use
  12  * this file in accordance with the libFirm Commercial License.
  13  * Agreement provided with the Software.
  14  *
  15  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief       Backend node support for generic backend nodes.
  23  * @author      Sebastian Hack
  24  * @date        17.05.2005
  25  *
  26  * Backend node support for generic backend nodes.
  27  * This file provides Perm, Copy, Spill and Reload nodes.
  28  */
  29 #include "config.h"
  30
  31 #include <stdlib.h>
  32
  33 #include "obst.h"
  34 #include "set.h"
  35 #include "pmap.h"
  36 #include "util.h"
  37 #include "debug.h"
  38 #include "fourcc.h"
  39 #include "bitfiddle.h"
  40 #include "raw_bitset.h"
  41 #include "error.h"
  42 #include "array_t.h"
  43
  44 #include "irop_t.h"
  45 #include "irmode_t.h"
  46 #include "irnode_t.h"
  47 #include "ircons_t.h"
  48 #include "irprintf.h"
  49 #include "irgwalk.h"
  50 #include "iropt_t.h"
  51 #include "irbackedge_t.h"
  52 #include "irverify_t.h"
  53
  54 #include "be_t.h"
  55 #include "belive_t.h"
  56 #include "besched.h"
  57 #include "benode.h"
  58 #include "bearch.h"
  59
  60 #include "beirgmod.h"
  61
  62 typedef struct be_node_attr_t {
  63         except_attr  exc;
  64 } be_node_attr_t;
  65
  66 /** The be_Return nodes attribute type. */
  67 typedef struct {
  68         be_node_attr_t base;
  69         int            num_ret_vals; /**< number of return values */
  70         unsigned       pop;          /**< number of bytes that should be popped */
  71         int            emit_pop;     /**< if set, emit pop bytes, even if pop = 0 */
  72 } be_return_attr_t;
  73
  74 /** The be_IncSP attribute type. */
  75 typedef struct {
  76         be_node_attr_t base;
  77         int            offset;    /**< The offset by which the stack shall be
  78                                        expanded/shrinked. */
  79         int            align;     /**< whether stack should be aligned after the
  80                                        IncSP */
  81 } be_incsp_attr_t;
  82
  83 /** The be_Frame attribute type. */
  84 typedef struct {
  85         be_node_attr_t  base;
  86         ir_entity      *ent;
  87         int             offset;
  88 } be_frame_attr_t;
  89
  90 /** The be_Call attribute type. */
  91 typedef struct {
  92         be_node_attr_t  base;
  93         ir_entity      *ent;        /**< called entity if this is a static call. */
  94         unsigned        pop;
  95         ir_type        *call_tp;    /**< call type, copied from the original Call */
  96 } be_call_attr_t;
  97
  98 typedef struct {
  99         be_node_attr_t base;
 100         ir_entity    **in_entities;
 101         ir_entity    **out_entities;
 102 } be_memperm_attr_t;
 103
 104 ir_op *op_be_Spill;
 105 ir_op *op_be_Reload;
 106 ir_op *op_be_Perm;
 107 ir_op *op_be_MemPerm;
 108 ir_op *op_be_Copy;
 109 ir_op *op_be_Keep;
 110 ir_op *op_be_CopyKeep;
 111 ir_op *op_be_Call;
 112 ir_op *op_be_Return;
 113 ir_op *op_be_IncSP;
 114 ir_op *op_be_AddSP;
 115 ir_op *op_be_SubSP;
 116 ir_op *op_be_Start;
 117 ir_op *op_be_FrameAddr;
 118
 119 /**
 120  * Compare the attributes of two be_FrameAddr nodes.
 121  *
 122  * @return zero if both nodes have identically attributes
 123  */
 124 static int FrameAddr_cmp_attr(const ir_node *a, const ir_node *b)
 125 {
 126         const be_frame_attr_t *a_attr = (const be_frame_attr_t*)get_irn_generic_attr_const(a);
 127         const be_frame_attr_t *b_attr = (const be_frame_attr_t*)get_irn_generic_attr_const(b);
 128
 129         if (a_attr->ent != b_attr->ent || a_attr->offset != b_attr->offset)
 130                 return 1;
 131
 132         return be_nodes_equal(a, b);
 133 }
 134
 135 /**
 136  * Compare the attributes of two be_Return nodes.
 137  *
 138  * @return zero if both nodes have identically attributes
 139  */
 140 static int Return_cmp_attr(const ir_node *a, const ir_node *b)
 141 {
 142         const be_return_attr_t *a_attr = (const be_return_attr_t*)get_irn_generic_attr_const(a);
 143         const be_return_attr_t *b_attr = (const be_return_attr_t*)get_irn_generic_attr_const(b);
 144
 145         if (a_attr->num_ret_vals != b_attr->num_ret_vals)
 146                 return 1;
 147         if (a_attr->pop != b_attr->pop)
 148                 return 1;
 149         if (a_attr->emit_pop != b_attr->emit_pop)
 150                 return 1;
 151
 152         return be_nodes_equal(a, b);
 153 }
 154
 155 /**
 156  * Compare the attributes of two be_IncSP nodes.
 157  *
 158  * @return zero if both nodes have identically attributes
 159  */
 160 static int IncSP_cmp_attr(const ir_node *a, const ir_node *b)
 161 {
 162         const be_incsp_attr_t *a_attr = (const be_incsp_attr_t*)get_irn_generic_attr_const(a);
 163         const be_incsp_attr_t *b_attr = (const be_incsp_attr_t*)get_irn_generic_attr_const(b);
 164
 165         if (a_attr->offset != b_attr->offset)
 166                 return 1;
 167
 168         return be_nodes_equal(a, b);
 169 }
 170
 171 /**
 172  * Compare the attributes of two be_Call nodes.
 173  *
 174  * @return zero if both nodes have identically attributes
 175  */
 176 static int Call_cmp_attr(const ir_node *a, const ir_node *b)
 177 {
 178         const be_call_attr_t *a_attr = (const be_call_attr_t*)get_irn_generic_attr_const(a);
 179         const be_call_attr_t *b_attr = (const be_call_attr_t*)get_irn_generic_attr_const(b);
 180
 181         if (a_attr->ent != b_attr->ent ||
 182                 a_attr->call_tp != b_attr->call_tp)
 183                 return 1;
 184
 185         return be_nodes_equal(a, b);
 186 }
 187
 188 static arch_register_req_t *allocate_reg_req(const ir_node *node)
 189 {
 190         ir_graph       *irg  = get_irn_irg(node);
 191         struct obstack *obst = be_get_be_obst(irg);
 192
 193         arch_register_req_t *req = OALLOCZ(obst, arch_register_req_t);
 194         return req;
 195 }
 196
 197 void be_set_constr_in(ir_node *node, int pos, const arch_register_req_t *req)
 198 {
 199         backend_info_t *info = be_get_info(node);
 200         assert(pos < get_irn_arity(node));
 201         info->in_reqs[pos] = req;
 202 }
 203
 204 void be_set_constr_out(ir_node *node, int pos, const arch_register_req_t *req)
 205 {
 206         backend_info_t *info = be_get_info(node);
 207         info->out_infos[pos].req = req;
 208 }
 209
 210 /**
 211  * Initializes the generic attribute of all be nodes and return it.
 212  */
 213 static void init_node_attr(ir_node *node, int n_inputs, int n_outputs)
 214 {
 215         ir_graph       *irg  = get_irn_irg(node);
 216         struct obstack *obst = be_get_be_obst(irg);
 217         backend_info_t *info = be_get_info(node);
 218         const arch_register_req_t **in_reqs;
 219
 220         if (n_inputs >= 0) {
 221                 int i;
 222                 assert(n_inputs == get_irn_arity(node));
 223                 in_reqs = OALLOCN(obst, const arch_register_req_t*, n_inputs);
 224                 for (i = 0; i < n_inputs; ++i) {
 225                         in_reqs[i] = arch_no_register_req;
 226                 }
 227         } else {
 228                 in_reqs = NEW_ARR_F(const arch_register_req_t*, 0);
 229         }
 230         info->in_reqs = in_reqs;
 231
 232         if (n_outputs >= 0) {
 233                 int i;
 234                 info->out_infos = NEW_ARR_D(reg_out_info_t, obst, n_outputs);
 235                 memset(info->out_infos, 0, n_outputs * sizeof(info->out_infos[0]));
 236                 for (i = 0; i < n_outputs; ++i) {
 237                         info->out_infos[i].req = arch_no_register_req;
 238                 }
 239         } else {
 240                 info->out_infos = NEW_ARR_F(reg_out_info_t, 0);
 241         }
 242 }
 243
 244 static void add_register_req_in(ir_node *node)
 245 {
 246         backend_info_t *info = be_get_info(node);
 247         ARR_APP1(const arch_register_req_t*, info->in_reqs, arch_no_register_req);
 248 }
 249
 250 ir_node *be_new_Spill(const arch_register_class_t *cls,
 251                 const arch_register_class_t *cls_frame, ir_node *bl,
 252                 ir_node *frame, ir_node *to_spill)
 253 {
 254         be_frame_attr_t *a;
 255         ir_node         *in[2];
 256         ir_node         *res;
 257         ir_graph        *irg = get_Block_irg(bl);
 258
 259         in[0]     = frame;
 260         in[1]     = to_spill;
 261         res       = new_ir_node(NULL, irg, bl, op_be_Spill, mode_M, 2, in);
 262         init_node_attr(res, 2, 1);
 263         a         = (be_frame_attr_t*) get_irn_generic_attr(res);
 264         a->ent    = NULL;
 265         a->offset = 0;
 266         a->base.exc.pin_state = op_pin_state_pinned;
 267
 268         be_node_set_reg_class_in(res, n_be_Spill_frame, cls_frame);
 269         be_node_set_reg_class_in(res, n_be_Spill_val, cls);
 270         arch_set_irn_register_req_out(res, 0, arch_no_register_req);
 271
 272         return res;
 273 }
 274
 275 ir_node *be_new_Reload(const arch_register_class_t *cls,
 276                 const arch_register_class_t *cls_frame, ir_node *block,
 277                 ir_node *frame, ir_node *mem, ir_mode *mode)
 278 {
 279         ir_node  *in[2];
 280         ir_node  *res;
 281         ir_graph *irg = get_Block_irg(block);
 282         be_frame_attr_t *a;
 283
 284         in[0] = frame;
 285         in[1] = mem;
 286         res   = new_ir_node(NULL, irg, block, op_be_Reload, mode, 2, in);
 287
 288         init_node_attr(res, 2, 1);
 289         be_node_set_reg_class_out(res, 0, cls);
 290
 291         be_node_set_reg_class_in(res, n_be_Reload_frame, cls_frame);
 292         arch_set_irn_flags(res, arch_irn_flags_rematerializable);
 293
 294         a         = (be_frame_attr_t*) get_irn_generic_attr(res);
 295         a->ent    = NULL;
 296         a->offset = 0;
 297         a->base.exc.pin_state = op_pin_state_pinned;
 298
 299         return res;
 300 }
 301
 302 ir_node *be_get_Reload_mem(const ir_node *irn)
 303 {
 304         assert(be_is_Reload(irn));
 305         return get_irn_n(irn, n_be_Reload_mem);
 306 }
 307
 308 ir_node *be_get_Reload_frame(const ir_node *irn)
 309 {
 310         assert(be_is_Reload(irn));
 311         return get_irn_n(irn, n_be_Reload_frame);
 312 }
 313
 314 ir_node *be_get_Spill_val(const ir_node *irn)
 315 {
 316         assert(be_is_Spill(irn));
 317         return get_irn_n(irn, n_be_Spill_val);
 318 }
 319
 320 ir_node *be_get_Spill_frame(const ir_node *irn)
 321 {
 322         assert(be_is_Spill(irn));
 323         return get_irn_n(irn, n_be_Spill_frame);
 324 }
 325
 326 ir_node *be_new_Perm(const arch_register_class_t *cls, ir_node *block,
 327                      int n, ir_node *in[])
 328 {
 329         int            i;
 330         ir_graph       *irg = get_Block_irg(block);
 331         be_node_attr_t *attr;
 332
 333         ir_node *irn = new_ir_node(NULL, irg, block, op_be_Perm, mode_T, n, in);
 334         init_node_attr(irn, n, n);
 335         attr                = (be_node_attr_t*) get_irn_generic_attr(irn);
 336         attr->exc.pin_state = op_pin_state_pinned;
 337         for (i = 0; i < n; ++i) {
 338                 const ir_node             *input = in[i];
 339                 const arch_register_req_t *req   = arch_get_irn_register_req(input);
 340                 if (req->width == 1) {
 341                         be_set_constr_in(irn, i, cls->class_req);
 342                         be_set_constr_out(irn, i, cls->class_req);
 343                 } else {
 344                         arch_register_req_t *new_req = allocate_reg_req(irn);
 345                         new_req->cls   = cls;
 346                         new_req->type  = (req->type & arch_register_req_type_aligned);
 347                         new_req->width = req->width;
 348                         be_set_constr_in(irn, i, new_req);
 349                         be_set_constr_out(irn, i, new_req);
 350                 }
 351         }
 352
 353         return irn;
 354 }
 355
 356 void be_Perm_reduce(ir_node *perm, int new_size, int *map)
 357 {
 358         int             arity      = get_irn_arity(perm);
 359         const arch_register_req_t **old_in_reqs
 360                 = ALLOCAN(const arch_register_req_t*, arity);
 361         reg_out_info_t  *old_infos = ALLOCAN(reg_out_info_t, arity);
 362         backend_info_t  *info      = be_get_info(perm);
 363         ir_node        **new_in;
 364         int              i;
 365
 366         assert(be_is_Perm(perm));
 367         assert(new_size <= arity);
 368
 369         new_in = ALLOCAN(ir_node*, new_size);
 370
 371         /* save the old register data */
 372         memcpy(old_in_reqs, info->in_reqs, arity * sizeof(old_in_reqs[0]));
 373         memcpy(old_infos, info->out_infos, arity * sizeof(old_infos[0]));
 374
 375         /* compose the new in array and set the new register data directly */
 376         for (i = 0; i < new_size; ++i) {
 377                 int idx = map[i];
 378                 new_in[i]          = get_irn_n(perm, idx);
 379                 info->in_reqs[i]   = old_in_reqs[idx];
 380                 info->out_infos[i] = old_infos[idx];
 381         }
 382
 383         set_irn_in(perm, new_size, new_in);
 384 }
 385
 386 ir_node *be_new_MemPerm(ir_node *block, int n, ir_node *in[])
 387 {
 388         ir_graph                     *irg       = get_Block_irg(block);
 389         const arch_env_t             *arch_env  = be_get_irg_arch_env(irg);
 390         ir_node                      *frame     = get_irg_frame(irg);
 391         const arch_register_t        *sp        = arch_env->sp;
 392         ir_node                      *irn;
 393         be_memperm_attr_t            *attr;
 394         ir_node                     **real_in;
 395
 396         real_in = ALLOCAN(ir_node*, n + 1);
 397         real_in[0] = frame;
 398         memcpy(&real_in[1], in, n * sizeof(real_in[0]));
 399
 400         irn = new_ir_node(NULL, irg, block, op_be_MemPerm, mode_T, n+1, real_in);
 401
 402         init_node_attr(irn, n + 1, n);
 403         be_node_set_reg_class_in(irn, 0, sp->reg_class);
 404
 405         attr               = (be_memperm_attr_t*)get_irn_generic_attr(irn);
 406         attr->in_entities  = OALLOCNZ(irg->obst, ir_entity*, n);
 407         attr->out_entities = OALLOCNZ(irg->obst, ir_entity*, n);
 408
 409         return irn;
 410 }
 411
 412 ir_node *be_new_Copy(ir_node *bl, ir_node *op)
 413 {
 414         ir_node *in[1];
 415         ir_node *res;
 416         arch_register_req_t *req;
 417         be_node_attr_t *attr;
 418         ir_graph *irg = get_Block_irg(bl);
 419         const arch_register_req_t   *in_req = arch_get_irn_register_req(op);
 420         const arch_register_class_t *cls    = in_req->cls;
 421
 422         in[0] = op;
 423         res   = new_ir_node(NULL, irg, bl, op_be_Copy, get_irn_mode(op), 1, in);
 424         init_node_attr(res, 1, 1);
 425         attr = (be_node_attr_t*) get_irn_generic_attr(res);
 426         attr->exc.pin_state = op_pin_state_floats;
 427         be_node_set_reg_class_in(res, 0, cls);
 428         be_node_set_reg_class_out(res, 0, cls);
 429
 430         req = allocate_reg_req(res);
 431         req->cls        = cls;
 432         req->type       = arch_register_req_type_should_be_same
 433                 | (in_req->type & arch_register_req_type_aligned);
 434         req->other_same = 1U << 0;
 435         req->width      = in_req->width;
 436         be_set_constr_out(res, 0, req);
 437
 438         return res;
 439 }
 440
 441 ir_node *be_get_Copy_op(const ir_node *cpy)
 442 {
 443         return get_irn_n(cpy, n_be_Copy_op);
 444 }
 445
 446 void be_set_Copy_op(ir_node *cpy, ir_node *op)
 447 {
 448         set_irn_n(cpy, n_be_Copy_op, op);
 449 }
 450
 451 ir_node *be_new_Keep(ir_node *block, int n, ir_node *in[])
 452 {
 453         int i;
 454         ir_node *res;
 455         ir_graph *irg = get_Block_irg(block);
 456         be_node_attr_t *attr;
 457
 458         res = new_ir_node(NULL, irg, block, op_be_Keep, mode_ANY, -1, NULL);
 459         init_node_attr(res, -1, 1);
 460         attr = (be_node_attr_t*) get_irn_generic_attr(res);
 461         attr->exc.pin_state = op_pin_state_pinned;
 462
 463         for (i = 0; i < n; ++i) {
 464                 add_irn_n(res, in[i]);
 465                 add_register_req_in(res);
 466         }
 467         keep_alive(res);
 468
 469         return res;
 470 }
 471
 472 void be_Keep_add_node(ir_node *keep, const arch_register_class_t *cls, ir_node *node)
 473 {
 474         int n;
 475
 476         assert(be_is_Keep(keep));
 477         n = add_irn_n(keep, node);
 478         add_register_req_in(keep);
 479         be_node_set_reg_class_in(keep, n, cls);
 480 }
 481
 482 ir_node *be_new_Call(dbg_info *dbg, ir_graph *irg, ir_node *bl, ir_node *mem,
 483                 const arch_register_req_t *sp_req, ir_node *sp,
 484                 const arch_register_req_t *ptr_req, ir_node *ptr,
 485                 int n_outs, int n, ir_node *in[], ir_type *call_tp)
 486 {
 487         be_call_attr_t *a;
 488         int real_n = n_be_Call_first_arg + n;
 489         ir_node *irn;
 490         ir_node **real_in;
 491
 492         NEW_ARR_A(ir_node *, real_in, real_n);
 493         real_in[n_be_Call_mem] = mem;
 494         real_in[n_be_Call_sp]  = sp;
 495         real_in[n_be_Call_ptr] = ptr;
 496         memcpy(&real_in[n_be_Call_first_arg], in, n * sizeof(in[0]));
 497
 498         irn = new_ir_node(dbg, irg, bl, op_be_Call, mode_T, real_n, real_in);
 499         init_node_attr(irn, real_n, n_outs);
 500         a                     = (be_call_attr_t*)get_irn_generic_attr(irn);
 501         a->ent                = NULL;
 502         a->call_tp            = call_tp;
 503         a->pop                = 0;
 504         a->base.exc.pin_state = op_pin_state_pinned;
 505         be_set_constr_in(irn, n_be_Call_sp, sp_req);
 506         be_set_constr_in(irn, n_be_Call_ptr, ptr_req);
 507         return irn;
 508 }
 509
 510 ir_entity *be_Call_get_entity(const ir_node *call)
 511 {
 512         const be_call_attr_t *a = (const be_call_attr_t*)get_irn_generic_attr_const(call);
 513         assert(be_is_Call(call));
 514         return a->ent;
 515 }
 516
 517 void be_Call_set_entity(ir_node *call, ir_entity *ent)
 518 {
 519         be_call_attr_t *a = (be_call_attr_t*)get_irn_generic_attr(call);
 520         assert(be_is_Call(call));
 521         a->ent = ent;
 522 }
 523
 524 ir_type *be_Call_get_type(ir_node *call)
 525 {
 526         const be_call_attr_t *a = (const be_call_attr_t*)get_irn_generic_attr_const(call);
 527         assert(be_is_Call(call));
 528         return a->call_tp;
 529 }
 530
 531 void be_Call_set_type(ir_node *call, ir_type *call_tp)
 532 {
 533         be_call_attr_t *a = (be_call_attr_t*)get_irn_generic_attr(call);
 534         assert(be_is_Call(call));
 535         a->call_tp = call_tp;
 536 }
 537
 538 void be_Call_set_pop(ir_node *call, unsigned pop)
 539 {
 540         be_call_attr_t *a = (be_call_attr_t*)get_irn_generic_attr(call);
 541         a->pop = pop;
 542 }
 543
 544 unsigned be_Call_get_pop(const ir_node *call)
 545 {
 546         const be_call_attr_t *a = (const be_call_attr_t*)get_irn_generic_attr_const(call);
 547         return a->pop;
 548 }
 549
 550 ir_node *be_new_Return(dbg_info *dbg, ir_graph *irg, ir_node *block, int n_res,
 551                        unsigned pop, int n, ir_node *in[])
 552 {
 553         be_return_attr_t *a;
 554         ir_node *res;
 555
 556         res = new_ir_node(dbg, irg, block, op_be_Return, mode_X, n, in);
 557         init_node_attr(res, n, 1);
 558         be_set_constr_out(res, 0, arch_no_register_req);
 559
 560         a = (be_return_attr_t*)get_irn_generic_attr(res);
 561         a->num_ret_vals       = n_res;
 562         a->pop                = pop;
 563         a->emit_pop           = 0;
 564         a->base.exc.pin_state = op_pin_state_pinned;
 565
 566         return res;
 567 }
 568
 569 int be_Return_get_n_rets(const ir_node *ret)
 570 {
 571         const be_return_attr_t *a = (const be_return_attr_t*)get_irn_generic_attr_const(ret);
 572         return a->num_ret_vals;
 573 }
 574
 575 unsigned be_Return_get_pop(const ir_node *ret)
 576 {
 577         const be_return_attr_t *a = (const be_return_attr_t*)get_irn_generic_attr_const(ret);
 578         return a->pop;
 579 }
 580
 581 int be_Return_get_emit_pop(const ir_node *ret)
 582 {
 583         const be_return_attr_t *a = (const be_return_attr_t*)get_irn_generic_attr_const(ret);
 584         return a->emit_pop;
 585 }
 586
 587 void be_Return_set_emit_pop(ir_node *ret, int emit_pop)
 588 {
 589         be_return_attr_t *a = (be_return_attr_t*)get_irn_generic_attr(ret);
 590         a->emit_pop = emit_pop;
 591 }
 592
 593 ir_node *be_new_IncSP(const arch_register_t *sp, ir_node *bl,
 594                       ir_node *old_sp, int offset, int align)
 595 {
 596         be_incsp_attr_t *a;
 597         ir_node *irn;
 598         ir_node *in[1];
 599         ir_graph *irg = get_Block_irg(bl);
 600
 601         in[0]     = old_sp;
 602         irn       = new_ir_node(NULL, irg, bl, op_be_IncSP, sp->reg_class->mode,
 603                                 ARRAY_SIZE(in), in);
 604         init_node_attr(irn, 1, 1);
 605         a                     = (be_incsp_attr_t*)get_irn_generic_attr(irn);
 606         a->offset             = offset;
 607         a->align              = align;
 608         a->base.exc.pin_state = op_pin_state_pinned;
 609
 610         /* Set output constraint to stack register. */
 611         be_node_set_reg_class_in(irn, 0, sp->reg_class);
 612         be_set_constr_single_reg_out(irn, 0, sp, arch_register_req_type_produces_sp);
 613
 614         return irn;
 615 }
 616
 617 ir_node *be_new_AddSP(const arch_register_t *sp, ir_node *bl, ir_node *old_sp,
 618                 ir_node *sz)
 619 {
 620         ir_node *irn;
 621         ir_node *in[n_be_AddSP_last];
 622         ir_graph *irg;
 623         be_node_attr_t *attr;
 624
 625         in[n_be_AddSP_old_sp] = old_sp;
 626         in[n_be_AddSP_size]   = sz;
 627
 628         irg = get_Block_irg(bl);
 629         irn = new_ir_node(NULL, irg, bl, op_be_AddSP, mode_T, n_be_AddSP_last, in);
 630         init_node_attr(irn, n_be_AddSP_last, pn_be_AddSP_last);
 631         attr = (be_node_attr_t*) get_irn_generic_attr(irn);
 632         attr->exc.pin_state = op_pin_state_pinned;
 633
 634         /* Set output constraint to stack register. */
 635         be_set_constr_single_reg_in(irn, n_be_AddSP_old_sp, sp,
 636                                     arch_register_req_type_none);
 637         be_node_set_reg_class_in(irn, n_be_AddSP_size, sp->reg_class);
 638         be_set_constr_single_reg_out(irn, pn_be_AddSP_sp, sp,
 639                                      arch_register_req_type_produces_sp);
 640
 641         return irn;
 642 }
 643
 644 ir_node *be_new_SubSP(const arch_register_t *sp, ir_node *bl, ir_node *old_sp, ir_node *sz)
 645 {
 646         ir_node *irn;
 647         ir_node *in[n_be_SubSP_last];
 648         ir_graph *irg;
 649         be_node_attr_t *attr;
 650
 651         in[n_be_SubSP_old_sp] = old_sp;
 652         in[n_be_SubSP_size]   = sz;
 653
 654         irg = get_Block_irg(bl);
 655         irn = new_ir_node(NULL, irg, bl, op_be_SubSP, mode_T, n_be_SubSP_last, in);
 656         init_node_attr(irn, n_be_SubSP_last, pn_be_SubSP_last);
 657         attr = (be_node_attr_t*) get_irn_generic_attr(irn);
 658         attr->exc.pin_state = op_pin_state_pinned;
 659
 660         /* Set output constraint to stack register. */
 661         be_set_constr_single_reg_in(irn, n_be_SubSP_old_sp, sp,
 662                                     arch_register_req_type_none);
 663         be_node_set_reg_class_in(irn, n_be_SubSP_size, sp->reg_class);
 664         be_set_constr_single_reg_out(irn, pn_be_SubSP_sp, sp, arch_register_req_type_produces_sp);
 665
 666         return irn;
 667 }
 668
 669 ir_node *be_new_Start(dbg_info *dbgi, ir_node *bl, int n_outs)
 670 {
 671         ir_node *res;
 672         ir_graph *irg = get_Block_irg(bl);
 673         be_node_attr_t *attr;
 674
 675         res = new_ir_node(dbgi, irg, bl, op_be_Start, mode_T, 0, NULL);
 676         init_node_attr(res, 0, n_outs);
 677         attr = (be_node_attr_t*) get_irn_generic_attr(res);
 678         attr->exc.pin_state = op_pin_state_pinned;
 679
 680         return res;
 681 }
 682
 683 ir_node *be_new_FrameAddr(const arch_register_class_t *cls_frame, ir_node *bl, ir_node *frame, ir_entity *ent)
 684 {
 685         be_frame_attr_t *a;
 686         ir_node *irn;
 687         ir_node *in[1];
 688         ir_graph *irg = get_Block_irg(bl);
 689
 690         in[0]  = frame;
 691         irn    = new_ir_node(NULL, irg, bl, op_be_FrameAddr, get_irn_mode(frame), 1, in);
 692         init_node_attr(irn, 1, 1);
 693         a                     = (be_frame_attr_t*)get_irn_generic_attr(irn);
 694         a->ent                = ent;
 695         a->offset             = 0;
 696         a->base.exc.pin_state = op_pin_state_floats;
 697         be_node_set_reg_class_in(irn, 0, cls_frame);
 698         be_node_set_reg_class_out(irn, 0, cls_frame);
 699
 700         return optimize_node(irn);
 701 }
 702
 703 ir_node *be_get_FrameAddr_frame(const ir_node *node)
 704 {
 705         assert(be_is_FrameAddr(node));
 706         return get_irn_n(node, n_be_FrameAddr_ptr);
 707 }
 708
 709 ir_entity *be_get_FrameAddr_entity(const ir_node *node)
 710 {
 711         const be_frame_attr_t *attr = (const be_frame_attr_t*)get_irn_generic_attr_const(node);
 712         return attr->ent;
 713 }
 714
 715 ir_node *be_new_CopyKeep(ir_node *bl, ir_node *src, int n, ir_node *in_keep[])
 716 {
 717         ir_node  *irn;
 718         ir_node **in = ALLOCAN(ir_node*, n + 1);
 719         ir_graph *irg = get_Block_irg(bl);
 720         const arch_register_req_t   *req  = arch_get_irn_register_req(src);
 721         const arch_register_class_t *cls  = req->cls;
 722         ir_mode                     *mode = get_irn_mode(src);
 723         be_node_attr_t *attr;
 724
 725         in[0] = src;
 726         memcpy(&in[1], in_keep, n * sizeof(in[0]));
 727         irn   = new_ir_node(NULL, irg, bl, op_be_CopyKeep, mode, n + 1, in);
 728         init_node_attr(irn, n + 1, 1);
 729         attr = (be_node_attr_t*) get_irn_generic_attr(irn);
 730         attr->exc.pin_state = op_pin_state_floats;
 731         be_node_set_reg_class_in(irn, 0, cls);
 732         be_node_set_reg_class_out(irn, 0, cls);
 733
 734         return irn;
 735 }
 736
 737 ir_node *be_new_CopyKeep_single(ir_node *bl, ir_node *src, ir_node *keep)
 738 {
 739         return be_new_CopyKeep(bl, src, 1, &keep);
 740 }
 741
 742 ir_node *be_get_CopyKeep_op(const ir_node *cpy)
 743 {
 744         return get_irn_n(cpy, n_be_CopyKeep_op);
 745 }
 746
 747 void be_set_CopyKeep_op(ir_node *cpy, ir_node *op)
 748 {
 749         set_irn_n(cpy, n_be_CopyKeep_op, op);
 750 }
 751
 752 static bool be_has_frame_entity(const ir_node *irn)
 753 {
 754         switch (get_irn_opcode(irn)) {
 755         case beo_Spill:
 756         case beo_Reload:
 757         case beo_FrameAddr:
 758                 return true;
 759         default:
 760                 return false;
 761         }
 762 }
 763
 764 ir_entity *be_get_frame_entity(const ir_node *irn)
 765 {
 766         if (be_has_frame_entity(irn)) {
 767                 const be_frame_attr_t *a = (const be_frame_attr_t*)get_irn_generic_attr_const(irn);
 768                 return a->ent;
 769         }
 770         return NULL;
 771 }
 772
 773 int be_get_frame_offset(const ir_node *irn)
 774 {
 775         assert(is_be_node(irn));
 776         if (be_has_frame_entity(irn)) {
 777                 const be_frame_attr_t *a = (const be_frame_attr_t*)get_irn_generic_attr_const(irn);
 778                 return a->offset;
 779         }
 780         return 0;
 781 }
 782
 783 void be_set_MemPerm_in_entity(const ir_node *irn, int n, ir_entity *ent)
 784 {
 785         const be_memperm_attr_t *attr = (const be_memperm_attr_t*)get_irn_generic_attr_const(irn);
 786
 787         assert(be_is_MemPerm(irn));
 788         assert(n < be_get_MemPerm_entity_arity(irn));
 789
 790         attr->in_entities[n] = ent;
 791 }
 792
 793 ir_entity* be_get_MemPerm_in_entity(const ir_node* irn, int n)
 794 {
 795         const be_memperm_attr_t *attr = (const be_memperm_attr_t*)get_irn_generic_attr_const(irn);
 796
 797         assert(be_is_MemPerm(irn));
 798         assert(n < be_get_MemPerm_entity_arity(irn));
 799
 800         return attr->in_entities[n];
 801 }
 802
 803 void be_set_MemPerm_out_entity(const ir_node *irn, int n, ir_entity *ent)
 804 {
 805         const be_memperm_attr_t *attr = (const be_memperm_attr_t*)get_irn_generic_attr_const(irn);
 806
 807         assert(be_is_MemPerm(irn));
 808         assert(n < be_get_MemPerm_entity_arity(irn));
 809
 810         attr->out_entities[n] = ent;
 811 }
 812
 813 ir_entity* be_get_MemPerm_out_entity(const ir_node* irn, int n)
 814 {
 815         const be_memperm_attr_t *attr = (const be_memperm_attr_t*)get_irn_generic_attr_const(irn);
 816
 817         assert(be_is_MemPerm(irn));
 818         assert(n < be_get_MemPerm_entity_arity(irn));
 819
 820         return attr->out_entities[n];
 821 }
 822
 823 int be_get_MemPerm_entity_arity(const ir_node *irn)
 824 {
 825         return get_irn_arity(irn) - 1;
 826 }
 827
 828 const arch_register_req_t *be_create_reg_req(struct obstack *obst,
 829                 const arch_register_t *reg, arch_register_req_type_t additional_types)
 830 {
 831         arch_register_req_t         *req = OALLOC(obst, arch_register_req_t);
 832         const arch_register_class_t *cls = arch_register_get_class(reg);
 833         unsigned                    *limited_bitset;
 834
 835         limited_bitset = rbitset_obstack_alloc(obst, arch_register_class_n_regs(cls));
 836         rbitset_set(limited_bitset, arch_register_get_index(reg));
 837
 838         req->type    = arch_register_req_type_limited | additional_types;
 839         req->cls     = cls;
 840         req->limited = limited_bitset;
 841         req->width   = 1;
 842         return req;
 843 }
 844
 845 void be_set_constr_single_reg_in(ir_node *node, int pos,
 846                 const arch_register_t *reg, arch_register_req_type_t additional_types)
 847 {
 848         const arch_register_req_t *req;
 849
 850         if (additional_types == 0) {
 851                 req = reg->single_req;
 852         } else {
 853                 ir_graph       *irg  = get_irn_irg(node);
 854                 struct obstack *obst = be_get_be_obst(irg);
 855                 req = be_create_reg_req(obst, reg, additional_types);
 856         }
 857         be_set_constr_in(node, pos, req);
 858 }
 859
 860 void be_set_constr_single_reg_out(ir_node *node, int pos,
 861                 const arch_register_t *reg, arch_register_req_type_t additional_types)
 862 {
 863         ir_graph                  *irg  = get_irn_irg(node);
 864         be_irg_t                  *birg = be_birg_from_irg(irg);
 865         const arch_register_req_t *req;
 866
 867         /* if we have an ignore register, add ignore flag and just assign it */
 868         if (!rbitset_is_set(birg->allocatable_regs, reg->global_index)) {
 869                 additional_types |= arch_register_req_type_ignore;
 870         }
 871
 872         if (additional_types == 0) {
 873                 req = reg->single_req;
 874         } else {
 875                 struct obstack *obst = be_get_be_obst(irg);
 876                 req = be_create_reg_req(obst, reg, additional_types);
 877         }
 878
 879         arch_set_irn_register_out(node, pos, reg);
 880         be_set_constr_out(node, pos, req);
 881 }
 882
 883 void be_node_set_reg_class_in(ir_node *irn, int pos,
 884                               const arch_register_class_t *cls)
 885 {
 886         be_set_constr_in(irn, pos, cls->class_req);
 887 }
 888
 889 void be_node_set_reg_class_out(ir_node *irn, int pos,
 890                                const arch_register_class_t *cls)
 891 {
 892         be_set_constr_out(irn, pos, cls->class_req);
 893 }
 894
 895 ir_node *be_get_IncSP_pred(ir_node *irn)
 896 {
 897         assert(be_is_IncSP(irn));
 898         return get_irn_n(irn, 0);
 899 }
 900
 901 void be_set_IncSP_pred(ir_node *incsp, ir_node *pred)
 902 {
 903         assert(be_is_IncSP(incsp));
 904         set_irn_n(incsp, 0, pred);
 905 }
 906
 907 void be_set_IncSP_offset(ir_node *irn, int offset)
 908 {
 909         be_incsp_attr_t *a = (be_incsp_attr_t*)get_irn_generic_attr(irn);
 910         assert(be_is_IncSP(irn));
 911         a->offset = offset;
 912 }
 913
 914 int be_get_IncSP_offset(const ir_node *irn)
 915 {
 916         const be_incsp_attr_t *a = (const be_incsp_attr_t*)get_irn_generic_attr_const(irn);
 917         assert(be_is_IncSP(irn));
 918         return a->offset;
 919 }
 920
 921 int be_get_IncSP_align(const ir_node *irn)
 922 {
 923         const be_incsp_attr_t *a = (const be_incsp_attr_t*)get_irn_generic_attr_const(irn);
 924         assert(be_is_IncSP(irn));
 925         return a->align;
 926 }
 927
 928 static ir_entity *be_node_get_frame_entity(const ir_node *irn)
 929 {
 930         return be_get_frame_entity(irn);
 931 }
 932
 933 void be_node_set_frame_entity(ir_node *irn, ir_entity *ent)
 934 {
 935         be_frame_attr_t *a;
 936
 937         assert(be_has_frame_entity(irn));
 938
 939         a = (be_frame_attr_t*)get_irn_generic_attr(irn);
 940         a->ent = ent;
 941 }
 942
 943 static void be_node_set_frame_offset(ir_node *irn, int offset)
 944 {
 945         be_frame_attr_t *a;
 946
 947         if (!be_has_frame_entity(irn))
 948                 return;
 949
 950         a = (be_frame_attr_t*)get_irn_generic_attr(irn);
 951         a->offset = offset;
 952 }
 953
 954 static int be_node_get_sp_bias(const ir_node *irn)
 955 {
 956         if (be_is_IncSP(irn))
 957                 return be_get_IncSP_offset(irn);
 958         if (be_is_Call(irn))
 959                 return -(int)be_Call_get_pop(irn);
 960
 961         return 0;
 962 }
 963
 964
 965
 966 /* for be nodes */
 967 static const arch_irn_ops_t be_node_irn_ops = {
 968         be_node_get_frame_entity,
 969         be_node_set_frame_offset,
 970         be_node_get_sp_bias,
 971         NULL,    /* get_inverse             */
 972         NULL,    /* get_op_estimated_cost   */
 973         NULL,    /* possible_memory_operand */
 974         NULL,    /* perform_memory_operand  */
 975 };
 976
 977 static int get_start_reg_index(ir_graph *irg, const arch_register_t *reg)
 978 {
 979         ir_node *start  = get_irg_start(irg);
 980         unsigned n_outs = arch_get_irn_n_outs(start);
 981         int      i;
 982
 983         /* do a naive linear search... */
 984         for (i = 0; i < (int)n_outs; ++i) {
 985                 const arch_register_req_t *out_req
 986                         = arch_get_irn_register_req_out(start, i);
 987                 if (! (out_req->type & arch_register_req_type_limited))
 988                         continue;
 989                 if (out_req->cls != arch_register_get_class(reg))
 990                         continue;
 991                 if (!rbitset_is_set(out_req->limited, reg->index))
 992                         continue;
 993                 return i;
 994         }
 995         panic("Tried querying undefined register '%s' at Start", reg->name);
 996 }
 997
 998 ir_node *be_get_initial_reg_value(ir_graph *irg, const arch_register_t *reg)
 999 {
1000         int      i     = get_start_reg_index(irg, reg);
1001         ir_node *start = get_irg_start(irg);
1002         ir_mode *mode  = arch_register_class_mode(arch_register_get_class(reg));
1003
1004         foreach_out_edge(start, edge) {
1005                 ir_node *proj = get_edge_src_irn(edge);
1006                 if (!is_Proj(proj)) // maybe End/Anchor
1007                         continue;
1008                 if (get_Proj_proj(proj) == i) {
1009                         return proj;
1010                 }
1011         }
1012         return new_r_Proj(start, mode, i);
1013 }
1014
1015 int be_find_return_reg_input(ir_node *ret, const arch_register_t *reg)
1016 {
1017         int arity = get_irn_arity(ret);
1018         int i;
1019         /* do a naive linear search... */
1020         for (i = 0; i < arity; ++i) {
1021                 const arch_register_req_t *req = arch_get_irn_register_req_in(ret, i);
1022                 if (! (req->type & arch_register_req_type_limited))
1023                         continue;
1024                 if (req->cls != arch_register_get_class(reg))
1025                         continue;
1026                 if (!rbitset_is_set(req->limited, reg->index))
1027                         continue;
1028                 return i;
1029         }
1030         panic("Tried querying undefined register '%s' at Return", reg->name);
1031 }
1032
1033 static ir_entity* dummy_get_frame_entity(const ir_node *node)
1034 {
1035         (void) node;
1036         return NULL;
1037 }
1038
1039 static void dummy_set_frame_offset(ir_node *node, int bias)
1040 {
1041         (void) node;
1042         (void) bias;
1043         panic("should not be called");
1044 }
1045
1046 static int dummy_get_sp_bias(const ir_node *node)
1047 {
1048         (void) node;
1049         return 0;
1050 }
1051
1052 /* for "middleend" nodes */
1053 static const arch_irn_ops_t dummy_be_irn_ops = {
1054         dummy_get_frame_entity,
1055         dummy_set_frame_offset,
1056         dummy_get_sp_bias,
1057         NULL,      /* get_inverse           */
1058         NULL,      /* get_op_estimated_cost */
1059         NULL,      /* possible_memory_operand */
1060         NULL,      /* perform_memory_operand */
1061 };
1062
1063
1064
1065 ir_node *be_new_Phi(ir_node *block, int n_ins, ir_node **ins, ir_mode *mode,
1066                     const arch_register_req_t *req)
1067 {
1068         ir_graph       *irg  = get_irn_irg(block);
1069         struct obstack *obst = be_get_be_obst(irg);
1070         backend_info_t *info;
1071         int             i;
1072
1073         ir_node *phi = new_ir_node(NULL, irg, block, op_Phi, mode, n_ins, ins);
1074         phi->attr.phi.u.backedge = new_backedge_arr(irg->obst, n_ins);
1075         info = be_get_info(phi);
1076         info->out_infos = NEW_ARR_D(reg_out_info_t, obst, 1);
1077         memset(info->out_infos, 0, 1 * sizeof(info->out_infos[0]));
1078         info->in_reqs = OALLOCN(obst, const arch_register_req_t*, n_ins);
1079
1080         info->out_infos[0].req = req;
1081         for (i = 0; i < n_ins; ++i) {
1082                 info->in_reqs[i] = req;
1083         }
1084         irn_verify_irg(phi, irg);
1085         phi = optimize_node(phi);
1086         return phi;
1087 }
1088
1089 void be_set_phi_reg_req(ir_node *node, const arch_register_req_t *req)
1090 {
1091         int arity = get_irn_arity(node);
1092         int i;
1093
1094         backend_info_t *info = be_get_info(node);
1095         info->out_infos[0].req = req;
1096         for (i = 0; i < arity; ++i) {
1097                 info->in_reqs[i] = req;
1098         }
1099
1100         assert(mode_is_datab(get_irn_mode(node)));
1101 }
1102
1103 void be_dump_phi_reg_reqs(FILE *F, const ir_node *node, dump_reason_t reason)
1104 {
1105         switch (reason) {
1106         case dump_node_opcode_txt:
1107                 fputs(get_op_name(get_irn_op(node)), F);
1108                 break;
1109         case dump_node_mode_txt:
1110                 fprintf(F, "%s", get_mode_name(get_irn_mode(node)));
1111                 break;
1112         case dump_node_nodeattr_txt:
1113                 break;
1114         case dump_node_info_txt:
1115         {
1116                 backend_info_t *info = be_get_info(node);
1117                 if (info != NULL && info->out_infos[0].req != NULL) {
1118                         arch_dump_reqs_and_registers(F, node);
1119                 }
1120                 break;
1121         }
1122
1123         default:
1124                 break;
1125         }
1126 }
1127
1128 static const arch_irn_ops_t phi_irn_ops = {
1129         dummy_get_frame_entity,
1130         dummy_set_frame_offset,
1131         dummy_get_sp_bias,
1132         NULL,    /* get_inverse             */
1133         NULL,    /* get_op_estimated_cost   */
1134         NULL,    /* possible_memory_operand */
1135         NULL,    /* perform_memory_operand  */
1136 };
1137
1138
1139
1140 /**
1141  * ir_op-Operation: dump a be node to file
1142  */
1143 static void dump_node(FILE *f, const ir_node *irn, dump_reason_t reason)
1144 {
1145         assert(is_be_node(irn));
1146
1147         switch (reason) {
1148                 case dump_node_opcode_txt:
1149                         fputs(get_op_name(get_irn_op(irn)), f);
1150                         break;
1151                 case dump_node_mode_txt:
1152                         if (be_is_Copy(irn) || be_is_CopyKeep(irn)) {
1153                                 fprintf(f, "%s", get_mode_name(get_irn_mode(irn)));
1154                         }
1155                         break;
1156                 case dump_node_nodeattr_txt:
1157                         if (be_is_Call(irn)) {
1158                                 const be_call_attr_t *a = (const be_call_attr_t*)get_irn_generic_attr_const(irn);
1159                                 if (a->ent)
1160                                         fprintf(f, " [%s] ", get_entity_name(a->ent));
1161                         }
1162                         if (be_is_IncSP(irn)) {
1163                                 const be_incsp_attr_t *attr = (const be_incsp_attr_t*)get_irn_generic_attr_const(irn);
1164                                 fprintf(f, " [%d] ", attr->offset);
1165                         }
1166                         break;
1167                 case dump_node_info_txt:
1168                         arch_dump_reqs_and_registers(f, irn);
1169
1170                         if (be_has_frame_entity(irn)) {
1171                                 const be_frame_attr_t *a = (const be_frame_attr_t*)get_irn_generic_attr_const(irn);
1172                                 if (a->ent) {
1173                                         unsigned size = get_type_size_bytes(get_entity_type(a->ent));
1174                                         ir_fprintf(f, "frame entity: %+F, offset 0x%x (%d), size 0x%x (%d) bytes\n",
1175                                           a->ent, a->offset, a->offset, size, size);
1176                                 }
1177
1178                         }
1179
1180                         switch (get_irn_opcode(irn)) {
1181                         case beo_IncSP: {
1182                                 const be_incsp_attr_t *a = (const be_incsp_attr_t*)get_irn_generic_attr_const(irn);
1183                                 fprintf(f, "align: %d\n", a->align);
1184                                 fprintf(f, "offset: %d\n", a->offset);
1185                                 break;
1186                         }
1187                         case beo_Call: {
1188                                 const be_call_attr_t *a = (const be_call_attr_t*)get_irn_generic_attr_const(irn);
1189
1190                                 if (a->ent)
1191                                         fprintf(f, "\ncalling: %s\n", get_entity_name(a->ent));
1192                                 break;
1193                         }
1194                         case beo_MemPerm: {
1195                                 int i;
1196                                 for (i = 0; i < be_get_MemPerm_entity_arity(irn); ++i) {
1197                                         ir_entity *in, *out;
1198                                         in = be_get_MemPerm_in_entity(irn, i);
1199                                         out = be_get_MemPerm_out_entity(irn, i);
1200                                         if (in) {
1201                                                 fprintf(f, "\nin[%d]: %s\n", i, get_entity_name(in));
1202                                         }
1203                                         if (out) {
1204                                                 fprintf(f, "\nout[%d]: %s\n", i, get_entity_name(out));
1205                                         }
1206                                 }
1207                                 break;
1208                         }
1209
1210                         default:
1211                                 break;
1212                         }
1213         }
1214 }
1215
1216 /**
1217  * ir_op-Operation:
1218  * Copies the backend specific attributes from old node to new node.
1219  */
1220 static void copy_attr(ir_graph *irg, const ir_node *old_node, ir_node *new_node)
1221 {
1222         const void     *old_attr = get_irn_generic_attr_const(old_node);
1223         void           *new_attr = get_irn_generic_attr(new_node);
1224         struct obstack *obst     = be_get_be_obst(irg);
1225         backend_info_t *old_info = be_get_info(old_node);
1226         backend_info_t *new_info = be_get_info(new_node);
1227
1228         assert(is_be_node(old_node));
1229         assert(is_be_node(new_node));
1230
1231         memcpy(new_attr, old_attr, get_op_attr_size(get_irn_op(old_node)));
1232
1233         new_info->flags = old_info->flags;
1234         if (old_info->out_infos != NULL) {
1235                 size_t n_outs = ARR_LEN(old_info->out_infos);
1236                 /* need dyanmic out infos? */
1237                 if (be_is_Perm(new_node)) {
1238                         new_info->out_infos = NEW_ARR_F(reg_out_info_t, n_outs);
1239                 } else {
1240                         new_info->out_infos = NEW_ARR_D(reg_out_info_t, obst, n_outs);
1241                 }
1242                 memcpy(new_info->out_infos, old_info->out_infos,
1243                            n_outs * sizeof(new_info->out_infos[0]));
1244         } else {
1245                 new_info->out_infos = NULL;
1246         }
1247
1248         /* input infos */
1249         if (old_info->in_reqs != NULL) {
1250                 unsigned n_ins = get_irn_arity(old_node);
1251                 /* need dynamic in infos? */
1252                 if (get_irn_op(old_node)->opar == oparity_dynamic) {
1253                         new_info->in_reqs = NEW_ARR_F(const arch_register_req_t*, n_ins);
1254                 } else {
1255                         new_info->in_reqs = OALLOCN(obst,const arch_register_req_t*, n_ins);
1256                 }
1257                 memcpy(new_info->in_reqs, old_info->in_reqs,
1258                        n_ins * sizeof(new_info->in_reqs[0]));
1259         } else {
1260                 new_info->in_reqs = NULL;
1261         }
1262 }
1263
1264 int is_be_node(const ir_node *irn)
1265 {
1266         return get_op_ops(get_irn_op(irn))->be_ops == &be_node_irn_ops;
1267 }
1268
1269 static ir_op *new_be_op(unsigned code, const char *name, op_pin_state p,
1270                         irop_flags flags, op_arity opar, size_t attr_size)
1271 {
1272         ir_op *res = new_ir_op(code, name, p, flags, opar, 0, attr_size);
1273         res->ops.dump_node = dump_node;
1274         res->ops.copy_attr = copy_attr;
1275         res->ops.be_ops    = &be_node_irn_ops;
1276         return res;
1277 }
1278
1279 void be_init_op(void)
1280 {
1281         unsigned opc;
1282
1283         assert(op_be_Spill == NULL);
1284
1285         /* Acquire all needed opcodes. */
1286         op_be_Spill     = new_be_op(beo_Spill,     "be_Spill",     op_pin_state_exc_pinned, irop_flag_none,                          oparity_unary,    sizeof(be_frame_attr_t));
1287         op_be_Reload    = new_be_op(beo_Reload,    "be_Reload",    op_pin_state_exc_pinned, irop_flag_none,                          oparity_zero,     sizeof(be_frame_attr_t));
1288         op_be_Perm      = new_be_op(beo_Perm,      "be_Perm",      op_pin_state_exc_pinned, irop_flag_none,                          oparity_variable, sizeof(be_node_attr_t));
1289         op_be_MemPerm   = new_be_op(beo_MemPerm,   "be_MemPerm",   op_pin_state_exc_pinned, irop_flag_none,                          oparity_variable, sizeof(be_memperm_attr_t));
1290         op_be_Copy      = new_be_op(beo_Copy,      "be_Copy",      op_pin_state_exc_pinned, irop_flag_none,                          oparity_unary,    sizeof(be_node_attr_t));
1291         op_be_Keep      = new_be_op(beo_Keep,      "be_Keep",      op_pin_state_exc_pinned, irop_flag_keep,                          oparity_dynamic,  sizeof(be_node_attr_t));
1292         op_be_CopyKeep  = new_be_op(beo_CopyKeep,  "be_CopyKeep",  op_pin_state_exc_pinned, irop_flag_keep,                          oparity_variable, sizeof(be_node_attr_t));
1293         op_be_Call      = new_be_op(beo_Call,      "be_Call",      op_pin_state_exc_pinned, irop_flag_fragile|irop_flag_uses_memory, oparity_variable, sizeof(be_call_attr_t));
1294         ir_op_set_memory_index(op_be_Call, n_be_Call_mem);
1295         ir_op_set_fragile_indices(op_be_Call, pn_be_Call_X_regular, pn_be_Call_X_except);
1296         op_be_Return    = new_be_op(beo_Return,    "be_Return",    op_pin_state_exc_pinned, irop_flag_cfopcode,                      oparity_variable, sizeof(be_return_attr_t));
1297         op_be_AddSP     = new_be_op(beo_AddSP,     "be_AddSP",     op_pin_state_exc_pinned, irop_flag_none,                          oparity_unary,    sizeof(be_node_attr_t));
1298         op_be_SubSP     = new_be_op(beo_SubSP,     "be_SubSP",     op_pin_state_exc_pinned, irop_flag_none,                          oparity_unary,    sizeof(be_node_attr_t));
1299         op_be_IncSP     = new_be_op(beo_IncSP,     "be_IncSP",     op_pin_state_exc_pinned, irop_flag_none,                          oparity_unary,    sizeof(be_incsp_attr_t));
1300         op_be_Start     = new_be_op(beo_Start,     "be_Start",     op_pin_state_exc_pinned, irop_flag_none,                          oparity_zero,     sizeof(be_node_attr_t));
1301         op_be_FrameAddr = new_be_op(beo_FrameAddr, "be_FrameAddr", op_pin_state_exc_pinned, irop_flag_none,                          oparity_unary,    sizeof(be_frame_attr_t));
1302
1303         op_be_Spill->ops.node_cmp_attr     = FrameAddr_cmp_attr;
1304         op_be_Reload->ops.node_cmp_attr    = FrameAddr_cmp_attr;
1305         op_be_Perm->ops.node_cmp_attr      = be_nodes_equal;
1306         op_be_MemPerm->ops.node_cmp_attr   = be_nodes_equal;
1307         op_be_Copy->ops.node_cmp_attr      = be_nodes_equal;
1308         op_be_Keep->ops.node_cmp_attr      = be_nodes_equal;
1309         op_be_CopyKeep->ops.node_cmp_attr  = be_nodes_equal;
1310         op_be_Call->ops.node_cmp_attr      = Call_cmp_attr;
1311         op_be_Return->ops.node_cmp_attr    = Return_cmp_attr;
1312         op_be_AddSP->ops.node_cmp_attr     = be_nodes_equal;
1313         op_be_SubSP->ops.node_cmp_attr     = be_nodes_equal;
1314         op_be_IncSP->ops.node_cmp_attr     = IncSP_cmp_attr;
1315         op_be_Start->ops.node_cmp_attr     = be_nodes_equal;
1316         op_be_FrameAddr->ops.node_cmp_attr = FrameAddr_cmp_attr;
1317
1318         /* attach out dummy_ops to middle end nodes */
1319         for (opc = iro_First; opc <= iro_Last; ++opc) {
1320                 ir_op *op = ir_get_opcode(opc);
1321                 assert(op->ops.be_ops == NULL);
1322                 op->ops.be_ops = &dummy_be_irn_ops;
1323         }
1324
1325         op_Phi->ops.be_ops = &phi_irn_ops;
1326 }
1327
1328 void be_finish_op(void)
1329 {
1330         free_ir_op(op_be_Spill);     op_be_Spill     = NULL;
1331         free_ir_op(op_be_Reload);    op_be_Reload    = NULL;
1332         free_ir_op(op_be_Perm);      op_be_Perm      = NULL;
1333         free_ir_op(op_be_MemPerm);   op_be_MemPerm   = NULL;
1334         free_ir_op(op_be_Copy);      op_be_Copy      = NULL;
1335         free_ir_op(op_be_Keep);      op_be_Keep      = NULL;
1336         free_ir_op(op_be_CopyKeep);  op_be_CopyKeep  = NULL;
1337         free_ir_op(op_be_Call);      op_be_Call      = NULL;
1338         free_ir_op(op_be_Return);    op_be_Return    = NULL;
1339         free_ir_op(op_be_IncSP);     op_be_IncSP     = NULL;
1340         free_ir_op(op_be_AddSP);     op_be_AddSP     = NULL;
1341         free_ir_op(op_be_SubSP);     op_be_SubSP     = NULL;
1342         free_ir_op(op_be_Start);     op_be_Start     = NULL;
1343         free_ir_op(op_be_FrameAddr); op_be_FrameAddr = NULL;
1344 }