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         ir_graph *irg;
 645         be_node_attr_t *attr;
 646
 647         in[n_be_AddSP_old_sp] = old_sp;
 648         in[n_be_AddSP_size]   = sz;
 649
 650         irg = get_Block_irg(bl);
 651         irn = new_ir_node(NULL, irg, bl, op_be_AddSP, mode_T, n_be_AddSP_last, in);
 652         init_node_attr(irn, n_be_AddSP_last, pn_be_AddSP_last);
 653         attr = (be_node_attr_t*) get_irn_generic_attr(irn);
 654         attr->exc.pin_state = op_pin_state_pinned;
 655
 656         /* Set output constraint to stack register. */
 657         be_set_constr_single_reg_in(irn, n_be_AddSP_old_sp, sp,
 658                                     arch_register_req_type_none);
 659         be_node_set_reg_class_in(irn, n_be_AddSP_size, arch_register_get_class(sp));
 660         be_set_constr_single_reg_out(irn, pn_be_AddSP_sp, sp,
 661                                      arch_register_req_type_produces_sp);
 662
 663         return irn;
 664 }
 665
 666 ir_node *be_new_SubSP(const arch_register_t *sp, ir_node *bl, ir_node *old_sp, ir_node *sz)
 667 {
 668         ir_node *irn;
 669         ir_node *in[n_be_SubSP_last];
 670         ir_graph *irg;
 671         be_node_attr_t *attr;
 672
 673         in[n_be_SubSP_old_sp] = old_sp;
 674         in[n_be_SubSP_size]   = sz;
 675
 676         irg = get_Block_irg(bl);
 677         irn = new_ir_node(NULL, irg, bl, op_be_SubSP, mode_T, n_be_SubSP_last, in);
 678         init_node_attr(irn, n_be_SubSP_last, pn_be_SubSP_last);
 679         attr = (be_node_attr_t*) get_irn_generic_attr(irn);
 680         attr->exc.pin_state = op_pin_state_pinned;
 681
 682         /* Set output constraint to stack register. */
 683         be_set_constr_single_reg_in(irn, n_be_SubSP_old_sp, sp,
 684                                     arch_register_req_type_none);
 685         be_node_set_reg_class_in(irn, n_be_SubSP_size, arch_register_get_class(sp));
 686         be_set_constr_single_reg_out(irn, pn_be_SubSP_sp, sp, arch_register_req_type_produces_sp);
 687
 688         return irn;
 689 }
 690
 691 ir_node *be_new_Start(dbg_info *dbgi, ir_node *bl, int n_outs)
 692 {
 693         ir_node *res;
 694         int i;
 695         ir_graph *irg = get_Block_irg(bl);
 696         be_node_attr_t *attr;
 697
 698         res = new_ir_node(dbgi, irg, bl, op_be_Start, mode_T, 0, NULL);
 699         init_node_attr(res, 0, -1);
 700         attr = (be_node_attr_t*) get_irn_generic_attr(res);
 701         attr->exc.pin_state = op_pin_state_pinned;
 702         for (i = 0; i < n_outs; ++i) {
 703                 add_register_req_out(res);
 704         }
 705
 706         return res;
 707 }
 708
 709 ir_node *be_new_FrameAddr(const arch_register_class_t *cls_frame, ir_node *bl, ir_node *frame, ir_entity *ent)
 710 {
 711         be_frame_attr_t *a;
 712         ir_node *irn;
 713         ir_node *in[1];
 714         ir_graph *irg = get_Block_irg(bl);
 715
 716         in[0]  = frame;
 717         irn    = new_ir_node(NULL, irg, bl, op_be_FrameAddr, get_irn_mode(frame), 1, in);
 718         init_node_attr(irn, 1, 1);
 719         a                     = (be_frame_attr_t*)get_irn_generic_attr(irn);
 720         a->ent                = ent;
 721         a->offset             = 0;
 722         a->base.exc.pin_state = op_pin_state_floats;
 723         be_node_set_reg_class_in(irn, 0, cls_frame);
 724         be_node_set_reg_class_out(irn, 0, cls_frame);
 725
 726         return optimize_node(irn);
 727 }
 728
 729 ir_node *be_get_FrameAddr_frame(const ir_node *node)
 730 {
 731         assert(be_is_FrameAddr(node));
 732         return get_irn_n(node, n_be_FrameAddr_ptr);
 733 }
 734
 735 ir_entity *be_get_FrameAddr_entity(const ir_node *node)
 736 {
 737         const be_frame_attr_t *attr = (const be_frame_attr_t*)get_irn_generic_attr_const(node);
 738         return attr->ent;
 739 }
 740
 741 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)
 742 {
 743         ir_node  *irn;
 744         ir_node **in = ALLOCAN(ir_node*, n + 1);
 745         ir_graph *irg = get_Block_irg(bl);
 746         be_node_attr_t *attr;
 747
 748         in[0] = src;
 749         memcpy(&in[1], in_keep, n * sizeof(in[0]));
 750         irn   = new_ir_node(NULL, irg, bl, op_be_CopyKeep, mode, n + 1, in);
 751         init_node_attr(irn, n + 1, 1);
 752         attr = (be_node_attr_t*) get_irn_generic_attr(irn);
 753         attr->exc.pin_state = op_pin_state_floats;
 754         be_node_set_reg_class_in(irn, 0, cls);
 755         be_node_set_reg_class_out(irn, 0, cls);
 756
 757         return irn;
 758 }
 759
 760 ir_node *be_new_CopyKeep_single(const arch_register_class_t *cls, ir_node *bl, ir_node *src, ir_node *keep, ir_mode *mode)
 761 {
 762         return be_new_CopyKeep(cls, bl, src, 1, &keep, mode);
 763 }
 764
 765 ir_node *be_get_CopyKeep_op(const ir_node *cpy)
 766 {
 767         return get_irn_n(cpy, n_be_CopyKeep_op);
 768 }
 769
 770 void be_set_CopyKeep_op(ir_node *cpy, ir_node *op)
 771 {
 772         set_irn_n(cpy, n_be_CopyKeep_op, op);
 773 }
 774
 775 static bool be_has_frame_entity(const ir_node *irn)
 776 {
 777         switch (get_irn_opcode(irn)) {
 778         case beo_Spill:
 779         case beo_Reload:
 780         case beo_FrameAddr:
 781                 return true;
 782         default:
 783                 return false;
 784         }
 785 }
 786
 787 ir_entity *be_get_frame_entity(const ir_node *irn)
 788 {
 789         if (be_has_frame_entity(irn)) {
 790                 const be_frame_attr_t *a = (const be_frame_attr_t*)get_irn_generic_attr_const(irn);
 791                 return a->ent;
 792         }
 793         return NULL;
 794 }
 795
 796 int be_get_frame_offset(const ir_node *irn)
 797 {
 798         assert(is_be_node(irn));
 799         if (be_has_frame_entity(irn)) {
 800                 const be_frame_attr_t *a = (const be_frame_attr_t*)get_irn_generic_attr_const(irn);
 801                 return a->offset;
 802         }
 803         return 0;
 804 }
 805
 806 void be_set_MemPerm_in_entity(const ir_node *irn, int n, ir_entity *ent)
 807 {
 808         const be_memperm_attr_t *attr = (const be_memperm_attr_t*)get_irn_generic_attr_const(irn);
 809
 810         assert(be_is_MemPerm(irn));
 811         assert(n < be_get_MemPerm_entity_arity(irn));
 812
 813         attr->in_entities[n] = ent;
 814 }
 815
 816 ir_entity* be_get_MemPerm_in_entity(const ir_node* irn, int n)
 817 {
 818         const be_memperm_attr_t *attr = (const be_memperm_attr_t*)get_irn_generic_attr_const(irn);
 819
 820         assert(be_is_MemPerm(irn));
 821         assert(n < be_get_MemPerm_entity_arity(irn));
 822
 823         return attr->in_entities[n];
 824 }
 825
 826 void be_set_MemPerm_out_entity(const ir_node *irn, int n, ir_entity *ent)
 827 {
 828         const be_memperm_attr_t *attr = (const be_memperm_attr_t*)get_irn_generic_attr_const(irn);
 829
 830         assert(be_is_MemPerm(irn));
 831         assert(n < be_get_MemPerm_entity_arity(irn));
 832
 833         attr->out_entities[n] = ent;
 834 }
 835
 836 ir_entity* be_get_MemPerm_out_entity(const ir_node* irn, int n)
 837 {
 838         const be_memperm_attr_t *attr = (const be_memperm_attr_t*)get_irn_generic_attr_const(irn);
 839
 840         assert(be_is_MemPerm(irn));
 841         assert(n < be_get_MemPerm_entity_arity(irn));
 842
 843         return attr->out_entities[n];
 844 }
 845
 846 int be_get_MemPerm_entity_arity(const ir_node *irn)
 847 {
 848         return get_irn_arity(irn) - 1;
 849 }
 850
 851 const arch_register_req_t *be_create_reg_req(struct obstack *obst,
 852                 const arch_register_t *reg, arch_register_req_type_t additional_types)
 853 {
 854         arch_register_req_t         *req = OALLOC(obst, arch_register_req_t);
 855         const arch_register_class_t *cls = arch_register_get_class(reg);
 856         unsigned                    *limited_bitset;
 857
 858         limited_bitset = rbitset_obstack_alloc(obst, arch_register_class_n_regs(cls));
 859         rbitset_set(limited_bitset, arch_register_get_index(reg));
 860
 861         req->type    = arch_register_req_type_limited | additional_types;
 862         req->cls     = cls;
 863         req->limited = limited_bitset;
 864         req->width   = 1;
 865         return req;
 866 }
 867
 868 void be_set_constr_single_reg_in(ir_node *node, int pos,
 869                 const arch_register_t *reg, arch_register_req_type_t additional_types)
 870 {
 871         const arch_register_req_t *req;
 872
 873         if (additional_types == 0) {
 874                 req = reg->single_req;
 875         } else {
 876                 ir_graph       *irg  = get_irn_irg(node);
 877                 struct obstack *obst = be_get_be_obst(irg);
 878                 req = be_create_reg_req(obst, reg, additional_types);
 879         }
 880         be_set_constr_in(node, pos, req);
 881 }
 882
 883 void be_set_constr_single_reg_out(ir_node *node, int pos,
 884                 const arch_register_t *reg, arch_register_req_type_t additional_types)
 885 {
 886         ir_graph                  *irg  = get_irn_irg(node);
 887         be_irg_t                  *birg = be_birg_from_irg(irg);
 888         const arch_register_req_t *req;
 889
 890         /* if we have an ignore register, add ignore flag and just assign it */
 891         if (!rbitset_is_set(birg->allocatable_regs, reg->global_index)) {
 892                 additional_types |= arch_register_req_type_ignore;
 893         }
 894
 895         if (additional_types == 0) {
 896                 req = reg->single_req;
 897         } else {
 898                 struct obstack *obst = be_get_be_obst(irg);
 899                 req = be_create_reg_req(obst, reg, additional_types);
 900         }
 901
 902         arch_irn_set_register(node, pos, reg);
 903         be_set_constr_out(node, pos, req);
 904 }
 905
 906 void be_node_set_reg_class_in(ir_node *irn, int pos,
 907                               const arch_register_class_t *cls)
 908 {
 909         be_set_constr_in(irn, pos, cls->class_req);
 910 }
 911
 912 void be_node_set_reg_class_out(ir_node *irn, int pos,
 913                                const arch_register_class_t *cls)
 914 {
 915         be_set_constr_out(irn, pos, cls->class_req);
 916 }
 917
 918 ir_node *be_get_IncSP_pred(ir_node *irn)
 919 {
 920         assert(be_is_IncSP(irn));
 921         return get_irn_n(irn, 0);
 922 }
 923
 924 void be_set_IncSP_pred(ir_node *incsp, ir_node *pred)
 925 {
 926         assert(be_is_IncSP(incsp));
 927         set_irn_n(incsp, 0, pred);
 928 }
 929
 930 void be_set_IncSP_offset(ir_node *irn, int offset)
 931 {
 932         be_incsp_attr_t *a = (be_incsp_attr_t*)get_irn_generic_attr(irn);
 933         assert(be_is_IncSP(irn));
 934         a->offset = offset;
 935 }
 936
 937 int be_get_IncSP_offset(const ir_node *irn)
 938 {
 939         const be_incsp_attr_t *a = (const be_incsp_attr_t*)get_irn_generic_attr_const(irn);
 940         assert(be_is_IncSP(irn));
 941         return a->offset;
 942 }
 943
 944 int be_get_IncSP_align(const ir_node *irn)
 945 {
 946         const be_incsp_attr_t *a = (const be_incsp_attr_t*)get_irn_generic_attr_const(irn);
 947         assert(be_is_IncSP(irn));
 948         return a->align;
 949 }
 950
 951 ir_node *be_spill(ir_node *block, ir_node *irn)
 952 {
 953         ir_graph                    *irg       = get_Block_irg(block);
 954         ir_node                     *frame     = get_irg_frame(irg);
 955         const arch_register_class_t *cls       = arch_get_irn_reg_class_out(irn);
 956         const arch_register_class_t *cls_frame = arch_get_irn_reg_class_out(frame);
 957         ir_node                     *spill;
 958
 959         spill = be_new_Spill(cls, cls_frame, block, frame, irn);
 960         return spill;
 961 }
 962
 963 ir_node *be_reload(const arch_register_class_t *cls, ir_node *insert, ir_mode *mode, ir_node *spill)
 964 {
 965         ir_node  *reload;
 966         ir_node  *bl    = is_Block(insert) ? insert : get_nodes_block(insert);
 967         ir_graph *irg   = get_Block_irg(bl);
 968         ir_node  *frame = get_irg_frame(irg);
 969         const arch_register_class_t *cls_frame = arch_get_irn_reg_class_out(frame);
 970
 971         assert(be_is_Spill(spill) || (is_Phi(spill) && get_irn_mode(spill) == mode_M));
 972
 973         reload = be_new_Reload(cls, cls_frame, bl, frame, spill, mode);
 974
 975         if (is_Block(insert)) {
 976                 do {
 977                         insert = sched_prev(insert);
 978                 } while (is_cfop(insert));
 979                 sched_add_after(insert, reload);
 980         } else {
 981                 sched_add_before(insert, reload);
 982         }
 983
 984         return reload;
 985 }
 986
 987
 988 static arch_irn_class_t be_node_classify(const ir_node *irn)
 989 {
 990         switch (get_irn_opcode(irn)) {
 991                 case beo_Spill:  return arch_irn_class_spill;
 992                 case beo_Reload: return arch_irn_class_reload;
 993                 case beo_Perm:   return arch_irn_class_perm;
 994                 case beo_Copy:   return arch_irn_class_copy;
 995                 default:         return arch_irn_class_none;
 996         }
 997 }
 998
 999 static ir_entity *be_node_get_frame_entity(const ir_node *irn)
1000 {
1001         return be_get_frame_entity(irn);
1002 }
1003
1004 void be_node_set_frame_entity(ir_node *irn, ir_entity *ent)
1005 {
1006         be_frame_attr_t *a;
1007
1008         assert(be_has_frame_entity(irn));
1009
1010         a = (be_frame_attr_t*)get_irn_generic_attr(irn);
1011         a->ent = ent;
1012 }
1013
1014 static void be_node_set_frame_offset(ir_node *irn, int offset)
1015 {
1016         be_frame_attr_t *a;
1017
1018         if (!be_has_frame_entity(irn))
1019                 return;
1020
1021         a = (be_frame_attr_t*)get_irn_generic_attr(irn);
1022         a->offset = offset;
1023 }
1024
1025 static int be_node_get_sp_bias(const ir_node *irn)
1026 {
1027         if (be_is_IncSP(irn))
1028                 return be_get_IncSP_offset(irn);
1029         if (be_is_Call(irn))
1030                 return -(int)be_Call_get_pop(irn);
1031
1032         return 0;
1033 }
1034
1035
1036
1037 /* for be nodes */
1038 static const arch_irn_ops_t be_node_irn_ops = {
1039         be_node_classify,
1040         be_node_get_frame_entity,
1041         be_node_set_frame_offset,
1042         be_node_get_sp_bias,
1043         NULL,    /* get_inverse             */
1044         NULL,    /* get_op_estimated_cost   */
1045         NULL,    /* possible_memory_operand */
1046         NULL,    /* perform_memory_operand  */
1047 };
1048
1049 static int get_start_reg_index(ir_graph *irg, const arch_register_t *reg)
1050 {
1051         ir_node *start  = get_irg_start(irg);
1052         unsigned n_outs = arch_irn_get_n_outs(start);
1053         int      i;
1054
1055         /* do a naive linear search... */
1056         for (i = 0; i < (int)n_outs; ++i) {
1057                 const arch_register_req_t *out_req
1058                         = arch_get_out_register_req(start, i);
1059                 if (! (out_req->type & arch_register_req_type_limited))
1060                         continue;
1061                 if (out_req->cls != arch_register_get_class(reg))
1062                         continue;
1063                 if (!rbitset_is_set(out_req->limited, reg->index))
1064                         continue;
1065                 return i;
1066         }
1067         panic("Tried querying undefined register '%s' at Start", reg->name);
1068 }
1069
1070 ir_node *be_get_initial_reg_value(ir_graph *irg, const arch_register_t *reg)
1071 {
1072         int      i     = get_start_reg_index(irg, reg);
1073         ir_node *start = get_irg_start(irg);
1074         ir_mode *mode  = arch_register_class_mode(arch_register_get_class(reg));
1075         const ir_edge_t *edge;
1076
1077         foreach_out_edge(start, edge) {
1078                 ir_node *proj = get_edge_src_irn(edge);
1079                 if (!is_Proj(proj)) // maybe End/Anchor
1080                         continue;
1081                 if (get_Proj_proj(proj) == i) {
1082                         return proj;
1083                 }
1084         }
1085         return new_r_Proj(start, mode, i);
1086 }
1087
1088 int be_find_return_reg_input(ir_node *ret, const arch_register_t *reg)
1089 {
1090         int arity = get_irn_arity(ret);
1091         int i;
1092         /* do a naive linear search... */
1093         for (i = 0; i < arity; ++i) {
1094                 const arch_register_req_t *req = arch_get_in_register_req(ret, i);
1095                 if (! (req->type & arch_register_req_type_limited))
1096                         continue;
1097                 if (req->cls != arch_register_get_class(reg))
1098                         continue;
1099                 if (!rbitset_is_set(req->limited, reg->index))
1100                         continue;
1101                 return i;
1102         }
1103         panic("Tried querying undefined register '%s' at Return", reg->name);
1104 }
1105
1106 static arch_irn_class_t dummy_classify(const ir_node *node)
1107 {
1108         (void) node;
1109         return arch_irn_class_none;
1110 }
1111
1112 static ir_entity* dummy_get_frame_entity(const ir_node *node)
1113 {
1114         (void) node;
1115         return NULL;
1116 }
1117
1118 static void dummy_set_frame_offset(ir_node *node, int bias)
1119 {
1120         (void) node;
1121         (void) bias;
1122         panic("dummy_set_frame_offset() should not be called");
1123 }
1124
1125 static int dummy_get_sp_bias(const ir_node *node)
1126 {
1127         (void) node;
1128         return 0;
1129 }
1130
1131 /* for "middleend" nodes */
1132 static const arch_irn_ops_t dummy_be_irn_ops = {
1133         dummy_classify,
1134         dummy_get_frame_entity,
1135         dummy_set_frame_offset,
1136         dummy_get_sp_bias,
1137         NULL,      /* get_inverse           */
1138         NULL,      /* get_op_estimated_cost */
1139         NULL,      /* possible_memory_operand */
1140         NULL,      /* perform_memory_operand */
1141 };
1142
1143
1144
1145 ir_node *be_new_Phi(ir_node *block, int n_ins, ir_node **ins, ir_mode *mode,
1146                     const arch_register_class_t *cls)
1147 {
1148         const arch_register_req_t *req;
1149         ir_graph       *irg  = get_irn_irg(block);
1150         struct obstack *obst = be_get_be_obst(irg);
1151         backend_info_t *info;
1152         int             i;
1153
1154         ir_node *phi = new_r_Phi(block, n_ins, ins, mode);
1155         info = be_get_info(phi);
1156         info->out_infos = NEW_ARR_D(reg_out_info_t, obst, 1);
1157         memset(info->out_infos, 0, 1 * sizeof(info->out_infos[0]));
1158         info->in_reqs = OALLOCN(obst, const arch_register_req_t*, n_ins);
1159
1160         if (cls == NULL) {
1161                 req = arch_no_register_req;
1162         } else {
1163                 req = cls->class_req;
1164         }
1165         info->out_infos[0].req = req;
1166         for (i = 0; i < n_ins; ++i) {
1167                 info->in_reqs[i] = req;
1168         }
1169
1170         return phi;
1171 }
1172
1173 void be_set_phi_reg_req(ir_node *node, const arch_register_req_t *req)
1174 {
1175         int arity = get_irn_arity(node);
1176         int i;
1177
1178         backend_info_t *info = be_get_info(node);
1179         info->out_infos[0].req = req;
1180         for (i = 0; i < arity; ++i) {
1181                 info->in_reqs[i] = req;
1182         }
1183
1184         assert(mode_is_datab(get_irn_mode(node)));
1185 }
1186
1187 void be_dump_phi_reg_reqs(FILE *F, ir_node *node, dump_reason_t reason)
1188 {
1189         switch (reason) {
1190         case dump_node_opcode_txt:
1191                 fputs(get_op_name(get_irn_op(node)), F);
1192                 break;
1193         case dump_node_mode_txt:
1194                 fprintf(F, "%s", get_mode_name(get_irn_mode(node)));
1195                 break;
1196         case dump_node_nodeattr_txt:
1197                 break;
1198         case dump_node_info_txt:
1199         {
1200                 backend_info_t *info = be_get_info(node);
1201                 if (info != NULL && info->out_infos[0].req != NULL) {
1202                         arch_dump_reqs_and_registers(F, node);
1203                 }
1204                 break;
1205         }
1206
1207         default:
1208                 break;
1209         }
1210 }
1211
1212 static const arch_irn_ops_t phi_irn_ops = {
1213         dummy_classify,
1214         dummy_get_frame_entity,
1215         dummy_set_frame_offset,
1216         dummy_get_sp_bias,
1217         NULL,    /* get_inverse             */
1218         NULL,    /* get_op_estimated_cost   */
1219         NULL,    /* possible_memory_operand */
1220         NULL,    /* perform_memory_operand  */
1221 };
1222
1223
1224
1225 /**
1226  * ir_op-Operation: dump a be node to file
1227  */
1228 static void dump_node(FILE *f, ir_node *irn, dump_reason_t reason)
1229 {
1230         assert(is_be_node(irn));
1231
1232         switch (reason) {
1233                 case dump_node_opcode_txt:
1234                         fputs(get_op_name(get_irn_op(irn)), f);
1235                         break;
1236                 case dump_node_mode_txt:
1237                         if (be_is_Copy(irn) || be_is_CopyKeep(irn)) {
1238                                 fprintf(f, "%s", get_mode_name(get_irn_mode(irn)));
1239                         }
1240                         break;
1241                 case dump_node_nodeattr_txt:
1242                         if (be_is_Call(irn)) {
1243                                 const be_call_attr_t *a = (const be_call_attr_t*)get_irn_generic_attr_const(irn);
1244                                 if (a->ent)
1245                                         fprintf(f, " [%s] ", get_entity_name(a->ent));
1246                         }
1247                         if (be_is_IncSP(irn)) {
1248                                 const be_incsp_attr_t *attr = (const be_incsp_attr_t*)get_irn_generic_attr_const(irn);
1249                                 fprintf(f, " [%d] ", attr->offset);
1250                         }
1251                         break;
1252                 case dump_node_info_txt:
1253                         arch_dump_reqs_and_registers(f, irn);
1254
1255                         if (be_has_frame_entity(irn)) {
1256                                 const be_frame_attr_t *a = (const be_frame_attr_t*)get_irn_generic_attr_const(irn);
1257                                 if (a->ent) {
1258                                         unsigned size = get_type_size_bytes(get_entity_type(a->ent));
1259                                         ir_fprintf(f, "frame entity: %+F, offset 0x%x (%d), size 0x%x (%d) bytes\n",
1260                                           a->ent, a->offset, a->offset, size, size);
1261                                 }
1262
1263                         }
1264
1265                         switch (get_irn_opcode(irn)) {
1266                         case beo_IncSP: {
1267                                 const be_incsp_attr_t *a = (const be_incsp_attr_t*)get_irn_generic_attr_const(irn);
1268                                 fprintf(f, "align: %d\n", a->align);
1269                                 fprintf(f, "offset: %d\n", a->offset);
1270                                 break;
1271                         }
1272                         case beo_Call: {
1273                                 const be_call_attr_t *a = (const be_call_attr_t*)get_irn_generic_attr_const(irn);
1274
1275                                 if (a->ent)
1276                                         fprintf(f, "\ncalling: %s\n", get_entity_name(a->ent));
1277                                 break;
1278                         }
1279                         case beo_MemPerm: {
1280                                 int i;
1281                                 for (i = 0; i < be_get_MemPerm_entity_arity(irn); ++i) {
1282                                         ir_entity *in, *out;
1283                                         in = be_get_MemPerm_in_entity(irn, i);
1284                                         out = be_get_MemPerm_out_entity(irn, i);
1285                                         if (in) {
1286                                                 fprintf(f, "\nin[%d]: %s\n", i, get_entity_name(in));
1287                                         }
1288                                         if (out) {
1289                                                 fprintf(f, "\nout[%d]: %s\n", i, get_entity_name(out));
1290                                         }
1291                                 }
1292                                 break;
1293                         }
1294
1295                         default:
1296                                 break;
1297                         }
1298         }
1299 }
1300
1301 /**
1302  * ir_op-Operation:
1303  * Copies the backend specific attributes from old node to new node.
1304  */
1305 static void copy_attr(ir_graph *irg, const ir_node *old_node, ir_node *new_node)
1306 {
1307         const void     *old_attr = get_irn_generic_attr_const(old_node);
1308         void           *new_attr = get_irn_generic_attr(new_node);
1309         struct obstack *obst     = be_get_be_obst(irg);
1310         backend_info_t *old_info = be_get_info(old_node);
1311         backend_info_t *new_info = be_get_info(new_node);
1312
1313         assert(is_be_node(old_node));
1314         assert(is_be_node(new_node));
1315
1316         memcpy(new_attr, old_attr, get_op_attr_size(get_irn_op(old_node)));
1317
1318         new_info->flags = old_info->flags;
1319         if (old_info->out_infos != NULL) {
1320                 size_t n_outs = ARR_LEN(old_info->out_infos);
1321                 /* need dyanmic out infos? */
1322                 if (be_is_Perm(new_node)) {
1323                         new_info->out_infos = NEW_ARR_F(reg_out_info_t, n_outs);
1324                 } else {
1325                         new_info->out_infos = NEW_ARR_D(reg_out_info_t, obst, n_outs);
1326                 }
1327                 memcpy(new_info->out_infos, old_info->out_infos,
1328                            n_outs * sizeof(new_info->out_infos[0]));
1329         } else {
1330                 new_info->out_infos = NULL;
1331         }
1332
1333         /* input infos */
1334         if (old_info->in_reqs != NULL) {
1335                 unsigned n_ins = get_irn_arity(old_node);
1336                 /* need dynamic in infos? */
1337                 if (get_irn_op(old_node)->opar == oparity_dynamic) {
1338                         new_info->in_reqs = NEW_ARR_F(const arch_register_req_t*, n_ins);
1339                 } else {
1340                         new_info->in_reqs = OALLOCN(obst,const arch_register_req_t*, n_ins);
1341                 }
1342                 memcpy(new_info->in_reqs, old_info->in_reqs,
1343                        n_ins * sizeof(new_info->in_reqs[0]));
1344         } else {
1345                 new_info->in_reqs = NULL;
1346         }
1347 }
1348
1349 static const ir_op_ops be_node_op_ops = {
1350         firm_default_hash,
1351         NULL,
1352         NULL,
1353         NULL,
1354         NULL,
1355         NULL,
1356         NULL,
1357         NULL,
1358         NULL,
1359         copy_attr,
1360         NULL,
1361         NULL,
1362         NULL,
1363         NULL,
1364         dump_node,
1365         NULL,
1366         &be_node_irn_ops
1367 };
1368
1369 int is_be_node(const ir_node *irn)
1370 {
1371         return get_op_ops(get_irn_op(irn))->be_ops == &be_node_irn_ops;
1372 }
1373
1374 void be_init_op(void)
1375 {
1376         unsigned opc;
1377
1378         /* Acquire all needed opcodes. */
1379         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);
1380         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);
1381         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);
1382         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);
1383         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);
1384         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);
1385         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);
1386         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);
1387         ir_op_set_fragile_indices(op_be_Call, n_be_Call_mem, pn_be_Call_X_regular, pn_be_Call_X_except);
1388         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);
1389         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);
1390         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);
1391         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);
1392         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);
1393         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);
1394
1395         op_be_Spill->ops.node_cmp_attr     = FrameAddr_cmp_attr;
1396         op_be_Reload->ops.node_cmp_attr    = FrameAddr_cmp_attr;
1397         op_be_Perm->ops.node_cmp_attr      = be_nodes_equal;
1398         op_be_MemPerm->ops.node_cmp_attr   = be_nodes_equal;
1399         op_be_Copy->ops.node_cmp_attr      = be_nodes_equal;
1400         op_be_Keep->ops.node_cmp_attr      = be_nodes_equal;
1401         op_be_CopyKeep->ops.node_cmp_attr  = be_nodes_equal;
1402         op_be_Call->ops.node_cmp_attr      = Call_cmp_attr;
1403         op_be_Return->ops.node_cmp_attr    = Return_cmp_attr;
1404         op_be_AddSP->ops.node_cmp_attr     = be_nodes_equal;
1405         op_be_SubSP->ops.node_cmp_attr     = be_nodes_equal;
1406         op_be_IncSP->ops.node_cmp_attr     = IncSP_cmp_attr;
1407         op_be_Start->ops.node_cmp_attr     = be_nodes_equal;
1408         op_be_FrameAddr->ops.node_cmp_attr = FrameAddr_cmp_attr;
1409
1410         /* attach out dummy_ops to middle end nodes */
1411         for (opc = iro_First; opc <= iro_Last; ++opc) {
1412                 ir_op *op = get_irp_opcode(opc);
1413                 assert(op->ops.be_ops == NULL);
1414                 op->ops.be_ops = &dummy_be_irn_ops;
1415         }
1416
1417         op_Phi->ops.be_ops = &phi_irn_ops;
1418 }