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