nsz Git - libfirm/blob - ir/be/mips/mips_transform.c

   1 /* The codegenrator (transform FIRM into mips FIRM */
   2 /* $Id$ */
   3
   4 #ifdef HAVE_CONFIG_H
   5 #include "config.h"
   6 #endif
   7
   8 #include <limits.h>
   9
  10 #include "irnode_t.h"
  11 #include "irgraph_t.h"
  12 #include "irmode_t.h"
  13 #include "irgmod.h"
  14 #include "iredges.h"
  15 #include "irvrfy.h"
  16 #include "ircons.h"
  17 #include "dbginfo.h"
  18 #include "iropt_t.h"
  19 #include "debug.h"
  20
  21 #include "../benode_t.h"
  22 #include "../beabi.h"
  23 #include "../besched.h"
  24 #include "../besched_t.h"
  25 #include "bearch_mips_t.h"
  26
  27 #include "mips_nodes_attr.h"
  28 #include "../arch/archop.h"     /* we need this for Min and Max nodes */
  29 #include "mips_transform.h"
  30 #include "mips_new_nodes.h"
  31 #include "mips_map_regs.h"
  32 #include "mips_util.h"
  33 #include "mips_emitter.h"
  34
  35 #include "gen_mips_regalloc_if.h"
  36
  37 /****************************************************************************************************
  38  *                  _        _                        __                           _   _
  39  *                 | |      | |                      / _|                         | | (_)
  40  *  _ __   ___   __| | ___  | |_ _ __ __ _ _ __  ___| |_ ___  _ __ _ __ ___   __ _| |_ _  ___  _ __
  41  * | '_ \ / _ \ / _` |/ _ \ | __| '__/ _` | '_ \/ __|  _/ _ \| '__| '_ ` _ \ / _` | __| |/ _ \| '_ \
  42  * | | | | (_) | (_| |  __/ | |_| | | (_| | | | \__ \ || (_) | |  | | | | | | (_| | |_| | (_) | | | |
  43  * |_| |_|\___/ \__,_|\___|  \__|_|  \__,_|_| |_|___/_| \___/|_|  |_| |_| |_|\__,_|\__|_|\___/|_| |_|
  44  *
  45  ****************************************************************************************************/
  46
  47 #define MIPS_GENBINFUNC(mips_nodetype)                                                                                                                  \
  48         static ir_node* mips_gen_##mips_nodetype(mips_transform_env_t *env, ir_node *op1, ir_node *op2) {\
  49                 ASSERT_NO_FLOAT(env->mode);                                                                                                                             \
  50                 /*assert(get_irn_mode(op1) == get_irn_mode(op2));*/                                                                             \
  51                 /*assert(get_irn_mode(op1) == env->mode);*/                                                                                             \
  52                 assert(get_mode_size_bits(env->mode) == 32);                                                                                    \
  53                 return new_rd_mips_##mips_nodetype(env->dbg, env->irg, env->block, op1, op2, env->mode);\
  54         }
  55
  56 MIPS_GENBINFUNC(add)
  57 MIPS_GENBINFUNC(sub)
  58 MIPS_GENBINFUNC(and)
  59 MIPS_GENBINFUNC(or)
  60 MIPS_GENBINFUNC(xor)
  61 MIPS_GENBINFUNC(sl)
  62 MIPS_GENBINFUNC(sr)
  63 MIPS_GENBINFUNC(sra)
  64
  65 #define MIPS_GENUNFUNC(mips_nodetype)                                                                                                                   \
  66         static ir_node *mips_gen_##mips_nodetype(mips_transform_env_t *env, ir_node *op) {                      \
  67                 ASSERT_NO_FLOAT(env->mode);                                                                                                                             \
  68                 assert(get_irn_mode(op) == env->mode);                                                                                                  \
  69                 assert(get_mode_size_bits(env->mode) == 32);                                                                                    \
  70                 return new_rd_mips_##mips_nodetype(env->dbg, env->irg, env->block, op, env->mode);              \
  71         }
  72
  73 MIPS_GENUNFUNC(not)
  74
  75 static ir_node* mips_get_reg_node(mips_transform_env_t *env, const arch_register_t *reg) {
  76         return be_abi_get_callee_save_irn(env->cg->birg->abi, reg);
  77 }
  78
  79 static ir_node* gen_zero_node(mips_transform_env_t *env, dbg_info *ebg, ir_graph *irg, ir_node *block)
  80 {
  81         ir_node *zero = be_abi_get_callee_save_irn(env->cg->birg->abi, &mips_gp_regs[REG_ZERO]);
  82         // TODO make zero nodes work
  83         //ir_node *unknown = new_rd_mips_zero(dbg, irg, block, mode);
  84
  85         return zero;
  86 }
  87
  88 static ir_node* gen_node_for_Const(mips_transform_env_t *env, dbg_info *dbg, ir_graph *irg, ir_node *block, ir_node *constant)
  89 {
  90         tarval* tv = get_Const_tarval(constant);
  91         ir_node *lui;
  92         ir_node *lli;
  93         mips_attr_t *attr;
  94         ir_mode* mode = get_irn_mode(constant);
  95         unsigned long val, lower, upper;
  96
  97         val = get_tarval_long(tv);
  98         if(val == 0)
  99                 return gen_zero_node(env, dbg, irg, block);
 100
 101         lower = val & 0xffff;
 102         upper = (val >> 16) & 0xffff;
 103         if(upper == 0) {
 104                 ir_node *zero = gen_zero_node(env, dbg, irg, block);
 105                 ir_node *lli = new_rd_mips_lli(dbg, irg, block, zero, mode);
 106                 attr = get_mips_attr(lli);
 107                 attr->tv = new_tarval_from_long(val, mode);
 108
 109                 return lli;
 110         }
 111
 112         lui = new_rd_mips_lui(dbg, irg, block, mode);
 113         attr = get_mips_attr(lui);
 114         attr->tv = new_tarval_from_long(val, mode);
 115
 116         if(lower == 0)
 117                 return lui;
 118
 119         lli = new_rd_mips_lli(dbg, irg, block, lui, mode);
 120         attr = get_mips_attr(lli);
 121         attr->tv = new_tarval_from_long(val, mode);
 122
 123         return lli;
 124 }
 125
 126 static ir_node* exchange_node_for_Const(mips_transform_env_t *env, ir_node* pred, int n) {
 127         ir_node *node = env->irn;
 128         dbg_info *dbg = get_irn_dbg_info(pred);
 129         ir_graph *irg = get_irn_irg(node);
 130         ir_node *block;
 131
 132         if(get_irn_opcode(node) == iro_Phi) {
 133                 ir_node *phipred = get_nodes_block(node);
 134                 block = get_Block_cfgpred_block(phipred, n);
 135         } else {
 136                 block = get_nodes_block(node);
 137         }
 138
 139         return gen_node_for_Const(env, dbg, irg, block, pred);
 140 }
 141
 142 static ir_node* gen_node_for_SymConst(mips_transform_env_t *env, ir_node* pred, int n) {
 143         ir_node *result;
 144         symconst_kind kind;
 145         mips_attr_t *attr;
 146         ir_node *node = env->irn;
 147         dbg_info *dbg = get_irn_dbg_info(pred);
 148         ir_graph *irg = get_irn_irg(node);
 149         ir_mode* mode = get_irn_mode(pred);
 150         ir_node *block;
 151
 152         if (is_Phi(node)) {
 153                 ir_node *phipred = get_nodes_block(node);
 154                 block = get_Block_cfgpred_block(phipred, n);
 155         } else {
 156                 block = get_nodes_block(node);
 157         }
 158
 159         kind = get_SymConst_kind(pred);
 160         if(kind == symconst_addr_ent) {
 161                 result = new_rd_mips_la(dbg, irg, block, mode);
 162                 attr = get_mips_attr(result);
 163                 attr->symconst_id = get_entity_ld_ident(get_SymConst_entity(pred));
 164                 return result;
 165         } else if(kind == symconst_addr_name) {
 166                 result = new_rd_mips_la(dbg, irg, block, mode);
 167                 attr = get_mips_attr(result);
 168                 attr->symconst_id = get_SymConst_name(pred);
 169                 return result;
 170         }
 171
 172         // TODO
 173         assert(0);
 174         return NULL;
 175 }
 176
 177 /**
 178  * Generates a mips node for a firm Load node
 179  */
 180 static ir_node *gen_node_for_Load(mips_transform_env_t *env) {
 181         ir_node *node = env->irn;
 182         ir_node *result = NULL;
 183         ir_mode *mode;
 184         ir_node *load_ptr;
 185         mips_attr_t *attr;
 186
 187         ASSERT_NO_FLOAT(get_irn_mode(node));
 188
 189         mode = get_Load_mode(node);
 190         assert(mode->vector_elem == 1);
 191         assert(mode->sort == irms_int_number || mode->sort == irms_reference);
 192
 193         load_ptr = get_Load_ptr(node);
 194         assert(get_mode_sort(mode) == irms_reference || get_mode_sort(mode) == irms_int_number);
 195         result = new_rd_mips_load_r(env->dbg, env->irg, env->block,
 196                         get_Load_mem(node), load_ptr, get_irn_mode(node));
 197
 198         attr = get_mips_attr(result);
 199         attr->tv = new_tarval_from_long(0, mode_Iu);
 200         attr->modes.load_store_mode = mode;
 201
 202         return result;
 203 }
 204
 205 /**
 206  * Generates a mips node for a firm Store node
 207  */
 208 static ir_node *gen_node_for_Store(mips_transform_env_t *env) {
 209         ir_node *node = env->irn;
 210         ir_node *result = NULL;
 211         ir_mode *mode;
 212         mips_attr_t *attr;
 213         ir_node *store_ptr;
 214
 215         ASSERT_NO_FLOAT(env->mode);
 216
 217         store_ptr = get_Store_ptr(node);
 218         mode = get_irn_mode(store_ptr);
 219         assert(mode->vector_elem == 1);
 220         assert(mode->sort == irms_int_number || mode->sort == irms_reference);
 221
 222         if(get_irn_opcode(store_ptr) == iro_SymConst) {
 223                 result = new_rd_mips_store_i(env->dbg, env->irg, env->block, get_Store_mem(node),
 224                         get_Store_ptr(node), get_Store_value(node), env->mode);
 225         } else {
 226                 result = new_rd_mips_store_r(env->dbg, env->irg, env->block, get_Store_mem(node),
 227                         get_Store_ptr(node), get_Store_value(node), env->mode);
 228         }
 229         attr = get_mips_attr(result);
 230         attr->tv = new_tarval_from_long(0, mode_Iu);
 231         attr->modes.load_store_mode = mode;
 232
 233         return result;
 234 }
 235
 236 static ir_node *gen_node_for_div_Proj(mips_transform_env_t *env) {
 237         ir_node *proj = env->irn;
 238         ir_node *new_proj;
 239         ir_node *pred = get_irn_n(proj, 0);
 240         mips_attr_t *attr;
 241         long n;
 242
 243         n = get_Proj_proj(proj);
 244
 245         // set the div mode to the DivMod node
 246         attr = get_mips_attr(pred);
 247         assert(attr->modes.original_mode == NULL || attr->modes.original_mode == env->mode);
 248         attr->modes.original_mode = env->mode;
 249
 250         // we have to construct a new proj here, to avoid circular refs that
 251         // happen when we reuse the old one
 252         new_proj = new_ir_node(env->dbg, env->irg, env->block, op_Proj, mode_ANY, 1, &pred);
 253         set_Proj_proj(new_proj, n);
 254
 255         if(n == pn_DivMod_res_div) {
 256                 return new_rd_mips_mflo(env->dbg, env->irg, env->block, new_proj, env->mode);
 257         } else if(n == pn_DivMod_res_mod) {
 258                 return new_rd_mips_mfhi(env->dbg, env->irg, env->block, new_proj, env->mode);
 259         }
 260
 261         return proj;
 262 }
 263
 264 static ir_node *make_jmp_or_fallthrough(mips_transform_env_t *env)
 265 {
 266         const ir_edge_t *edge;
 267         ir_node *node = env->irn;
 268         ir_node *next_block;
 269         int our_block_sched_nr = mips_get_block_sched_nr(get_nodes_block(node));
 270
 271         edge = get_irn_out_edge_first(node);
 272         next_block = get_edge_src_irn(edge);
 273
 274         if(mips_get_sched_block(env->cg, our_block_sched_nr + 1) == next_block) {
 275                 return new_rd_mips_fallthrough(env->dbg, env->irg, env->block, mode_X);
 276         }
 277
 278         return new_rd_mips_b(env->dbg, env->irg, env->block, mode_X);
 279 }
 280
 281 static ir_node *gen_node_for_Cond_Proj(mips_transform_env_t *env, ir_node* node, int true_false)
 282 {
 283         // we can't use get_Cond_selector here because the selector is already
 284         // replaced by a mips_ compare node
 285         ir_node *proj = get_Cond_selector(node);
 286         ir_node *original_cmp = get_irn_n(proj, 0);
 287         ir_node *cmp;
 288         ir_node *condjmp;
 289         ir_node *op1, *op2;
 290         dbg_info *dbg = env->dbg;
 291         ir_graph *irg = env->irg;
 292         ir_node *block = env->block;
 293         long n;
 294
 295         n = get_Proj_proj(proj);
 296         assert(n < 8 && "Only ordered comps supported");
 297
 298         assert(get_irn_opcode(original_cmp) == iro_Cmp);
 299         op1 = get_Cmp_left(original_cmp);
 300         op2 = get_Cmp_right(original_cmp);
 301
 302         switch(n) {
 303         case pn_Cmp_False:
 304                 if(true_false)
 305                         return NULL;
 306
 307                 return make_jmp_or_fallthrough(env);
 308
 309         case pn_Cmp_Eq:
 310                 if(!true_false)
 311                         return make_jmp_or_fallthrough(env);
 312
 313                 condjmp = new_rd_mips_beq(dbg, irg, block, op1, op2, mode_T);
 314                 return new_rd_Proj(dbg, irg, block, condjmp, mode_X, 1);
 315
 316         case pn_Cmp_Lt:
 317                 if(!true_false)
 318                         return make_jmp_or_fallthrough(env);
 319
 320                 cmp = new_rd_mips_slt(dbg, irg, block, op1, op2, get_irn_mode(op1));
 321                 condjmp = new_rd_mips_bgtz(dbg, irg, block, cmp, mode_T);
 322                 return new_rd_Proj(dbg, irg, block, condjmp, mode_X, 1);
 323
 324         case pn_Cmp_Le:
 325                 if(!true_false)
 326                         return make_jmp_or_fallthrough(env);
 327
 328                 cmp = new_rd_mips_slt(dbg, irg, block, op2, op1, get_irn_mode(op1));
 329                 condjmp = new_rd_mips_blez(dbg, irg, block, cmp, mode_T);
 330                 return new_rd_Proj(dbg, irg, block, condjmp, mode_X, 1);
 331
 332         case pn_Cmp_Gt:
 333                 if(!true_false)
 334                         return make_jmp_or_fallthrough(env);
 335
 336                 cmp = new_rd_mips_slt(dbg, irg, block, op2, op1, get_irn_mode(op1));
 337                 condjmp = new_rd_mips_bgtz(dbg, irg, block, cmp, mode_T);
 338                 return new_rd_Proj(dbg, irg, block, condjmp, mode_X, 1);
 339
 340         case pn_Cmp_Ge:
 341                 if(!true_false)
 342                         return make_jmp_or_fallthrough(env);
 343
 344                 cmp = new_rd_mips_slt(dbg, irg, block, op1, op2, get_irn_mode(op1));
 345                 condjmp = new_rd_mips_blez(dbg, irg, block, cmp, mode_T);
 346                 return new_rd_Proj(dbg, irg, block, condjmp, mode_X, 1);
 347
 348         case pn_Cmp_Lg:
 349                 if(!true_false)
 350                         return make_jmp_or_fallthrough(env);
 351
 352                 condjmp = new_rd_mips_bne(dbg, irg, block, op1, op2, mode_T);
 353                 return new_rd_Proj(dbg, irg, block, condjmp, mode_X, 1);
 354
 355         case pn_Cmp_Leg:
 356                 if(!true_false)
 357                         return NULL;
 358
 359                 return make_jmp_or_fallthrough(env);
 360
 361         default:
 362                 assert(0);
 363         }
 364
 365         return NULL;
 366 }
 367
 368 static ir_node *gen_node_for_Proj(mips_transform_env_t *env)
 369 {
 370         ir_node *proj = env->irn;
 371         long n;
 372         ir_node *predecessor = get_Proj_pred(proj);
 373
 374         // all DivMods, Div, Mod should be replaced by now
 375         assert(get_irn_opcode(predecessor) != iro_DivMod);
 376         assert(get_irn_opcode(predecessor) != iro_Div);
 377         assert(get_irn_opcode(predecessor) != iro_Mod);
 378
 379         if(is_mips_div(predecessor))
 380                 return gen_node_for_div_Proj(env);
 381
 382         if(get_irn_opcode(predecessor) == iro_Cond) {
 383                 ir_node *selector = get_Cond_selector(predecessor);
 384                 ir_mode *mode = get_irn_mode(selector);
 385                 n = get_Proj_proj(proj);
 386
 387                 if(get_mode_sort(mode) == irms_internal_boolean) {
 388                         assert(n == pn_Cond_true || n == pn_Cond_false);
 389                         return gen_node_for_Cond_Proj(env, predecessor, n == pn_Cond_true);
 390                 }
 391         }
 392
 393         return proj;
 394 }
 395
 396 static ir_node *gen_node_for_Cond(mips_transform_env_t *env)
 397 {
 398         ir_node *selector = get_Cond_selector(env->irn);
 399         ir_mode *selector_mode = get_irn_mode(selector);
 400         ir_node *node = env->irn;
 401         dbg_info *dbg = env->dbg;
 402         ir_graph *irg = env->irg;
 403         ir_node *block = env->block;
 404         ir_node *sub, *sltu, *minval_const, *max_const, *switchjmp;
 405         ir_node *defaultproj, *defaultproj_succ;
 406         ir_node *beq, *sl;
 407         long pn, minval, maxval, defaultprojn;
 408         const ir_edge_t *edge;
 409         ir_node *zero, *two_const, *add, *la, *load, *proj;
 410         ir_mode *unsigned_mode;
 411         mips_attr_t *attr;
 412
 413         // mode_b conds are handled by gen_node_for_Proj
 414         if(get_mode_sort(selector_mode) != irms_int_number)
 415                 return env->irn;
 416
 417         assert(get_mode_size_bits(selector_mode) == 32);
 418
 419         defaultprojn = get_Cond_defaultProj(node);
 420
 421         // go over all projs to find min-&maxval of the switch
 422         minval = INT_MAX;
 423         maxval = INT_MIN;
 424         foreach_out_edge(node, edge) {
 425                 ir_node* proj = get_edge_src_irn(edge);
 426                 assert(is_Proj(proj) && "Only proj allowed at SwitchJmp");
 427
 428                 pn = get_Proj_proj(proj);
 429                 if(pn == defaultprojn) {
 430                         defaultproj = proj;
 431                         continue;
 432                 }
 433
 434                 if(pn < minval)
 435                         minval = pn;
 436                 if(pn > maxval)
 437                         maxval = pn;
 438         }
 439         assert(defaultproj != NULL);
 440
 441         // subtract minval from the switch value
 442
 443         if(minval != 0) {
 444                 minval_const = new_rd_Const(dbg, irg, block, selector_mode, new_tarval_from_long(minval, selector_mode));
 445                 minval_const = gen_node_for_Const(env, dbg, irg, block, minval_const);
 446                 sub = new_rd_mips_sub(dbg, irg, block, selector, minval_const, selector_mode);
 447         } else {
 448                 sub = selector;
 449         }
 450
 451         // compare if we're above maxval-minval or below zero.
 452         // we can do this with 1 compare because we use unsigned mode
 453         unsigned_mode = new_ir_mode(get_mode_name(selector_mode),
 454                         get_mode_sort(selector_mode), get_mode_size_bits(selector_mode),
 455                         0, get_mode_arithmetic(selector_mode), get_mode_modulo_shift(selector_mode));
 456
 457         max_const = new_rd_Const(dbg, irg, block, unsigned_mode, new_tarval_from_long(maxval - minval + 1, unsigned_mode));
 458         max_const = gen_node_for_Const(env, dbg, irg, block, max_const);
 459         sltu = new_rd_mips_slt(dbg, irg, block, sub, max_const, unsigned_mode);
 460
 461         zero = gen_zero_node(env, dbg, irg, block);
 462         beq = new_rd_mips_beq(dbg, irg, block, sltu, zero, mode_T);
 463
 464         // attach defaultproj to beq now
 465         set_irn_n(defaultproj, 0, beq);
 466         set_Proj_proj(defaultproj, 1);
 467
 468         two_const = new_rd_Const(dbg, irg, block, unsigned_mode, new_tarval_from_long(2, unsigned_mode));
 469         two_const = gen_node_for_Const(env, dbg, irg, block, two_const);
 470         sl = new_rd_mips_sl(dbg, irg, block, sub, two_const, unsigned_mode);
 471
 472         la = new_rd_mips_la(dbg, irg, block, mode_Iu);
 473         add = new_rd_mips_add(dbg, irg, block, sl, la, mode_Iu);
 474         load = new_rd_mips_load_r(dbg, irg, block, new_rd_NoMem(irg), add, mode_T);
 475         attr = get_mips_attr(load);
 476         attr->modes.load_store_mode = mode_Iu;
 477         attr->tv = new_tarval_from_long(0, mode_Iu);
 478
 479         proj = new_rd_Proj(dbg, irg, block, load, mode_Iu, pn_Load_res);
 480
 481         switchjmp = new_rd_mips_SwitchJump(dbg, irg, block, proj, mode_T);
 482         attr = get_mips_attr(switchjmp);
 483         attr->switch_default_pn = defaultprojn;
 484
 485         edge = get_irn_out_edge_first(defaultproj);
 486         defaultproj_succ = get_edge_src_irn(edge);
 487         attr->symconst_id = new_id_from_str(mips_get_block_label(defaultproj_succ));
 488
 489         attr = get_mips_attr(la);
 490         attr->symconst_id = new_id_from_str(mips_get_jumptbl_label(switchjmp));
 491
 492         return switchjmp;
 493 }
 494
 495 static ir_node *create_conv_store_load(mips_transform_env_t *env, ir_mode* srcmode, ir_mode* dstmode) {
 496         ir_node *nomem, *store, *mem_proj, *value_proj, *load;
 497         entity *mem_entity;
 498         ir_node *node = env->irn;
 499         ir_node *pred = get_Conv_op(node);
 500         ir_node *sp;
 501         // TODO HACK make this global...
 502         ident* id;
 503         ir_type *i32type;
 504         ir_type *ptr_i32type;
 505         mips_attr_t* attr;
 506
 507         id = new_id_from_str("__conv0");
 508         i32type = new_type_primitive(new_id_from_str("ptr32"), mode_Iu);
 509         ptr_i32type = new_d_type_pointer(id, i32type, mode_P, env->dbg);
 510         mem_entity = new_d_entity(get_irg_frame_type(env->irg), id, ptr_i32type, env->dbg);
 511
 512         sp = mips_get_reg_node(env, &mips_gp_regs[REG_SP]);
 513         nomem = new_ir_node(env->dbg, env->irg, env->block, op_NoMem, mode_M, 0, NULL);
 514
 515         store = new_rd_mips_store_r(env->dbg, env->irg, env->block, nomem, sp, pred, mode_T);
 516         attr = get_mips_attr(store);
 517         attr->tv = new_tarval_from_long(0, mode_Iu);
 518         attr->modes.load_store_mode = srcmode;
 519         attr->stack_entity = mem_entity;
 520
 521         mem_proj = new_ir_node(env->dbg, env->irg, env->block, op_Proj, mode_M, 1, &store);
 522         set_Proj_proj(mem_proj, pn_Store_M);
 523
 524         load = new_rd_mips_load_r(env->dbg, env->irg, env->block, mem_proj, sp, mode_T);
 525         attr = get_mips_attr(load);
 526         attr->tv = new_tarval_from_long(0, mode_Iu);
 527         attr->modes.load_store_mode = dstmode;
 528         attr->stack_entity = mem_entity;
 529
 530         value_proj = new_ir_node(env->dbg, env->irg, env->block, op_Proj, env->mode, 1, &load);
 531         set_Proj_proj(value_proj, pn_Load_res);
 532
 533         return value_proj;
 534 }
 535
 536 static ir_node *create_conv_and(mips_transform_env_t *env, long immediate) {
 537         ir_node *node = env->irn;
 538         ir_node *pred;
 539         ir_node *result;
 540         mips_attr_t *attr;
 541
 542         pred = get_Conv_op(node);
 543         result = new_rd_mips_andi(env->dbg, env->irg, env->block, pred, node->mode);
 544         attr = get_mips_attr(result);
 545         attr->tv = new_tarval_from_long(immediate, mode_Iu);
 546
 547         return result;
 548 }
 549
 550 static ir_node *gen_node_for_Conv(mips_transform_env_t *env) {
 551         ir_node *node = env->irn;
 552         ir_node *pred;
 553         ir_mode *srcmode;
 554         ir_mode *destmode;
 555         int dst_size, src_size;
 556
 557         pred = get_Conv_op(node);
 558         srcmode = get_irn_mode(pred);
 559         destmode = get_irn_mode(node);
 560
 561         dst_size = get_mode_size_bits(destmode);
 562         src_size = get_mode_size_bits(srcmode);
 563
 564         if(srcmode->size >= destmode->size) {
 565                 assert(srcmode->size > destmode->size || srcmode->sign != destmode->sign);
 566                 return new_rd_mips_reinterpret_conv(env->dbg, env->irg, env->block, pred, node->mode);
 567         }
 568         if(srcmode->sign) {
 569                 if(srcmode->size == 8) {
 570                         return create_conv_store_load(env, mode_Bs, mode_Bs);
 571                 } else if(srcmode->size == 16) {
 572                         return create_conv_store_load(env, mode_Hs, mode_Hs);
 573                 }
 574         } else {
 575                 if(src_size == 8) {
 576                         return create_conv_and(env, 0xff);
 577                 } else if(src_size == 16) {
 578                         return create_conv_and(env, 0xffff);
 579                 }
 580         }
 581
 582         assert(0);
 583         return NULL;
 584 }
 585
 586 static ir_node *gen_node_mips_div(mips_transform_env_t *env, ir_node* op1, ir_node* op2, long p_div, long p_mod,
 587                                                                   long p_m, long p_x)
 588 {
 589         ir_node *node = env->irn;
 590         ir_node *div;
 591         const ir_edge_t *edge;
 592
 593         div = new_rd_mips_div(env->dbg, env->irg, env->block, op1, op2, mode_T);
 594
 595         // Adjust div projs
 596         foreach_out_edge(node, edge) {
 597                 ir_node *proj = get_edge_src_irn(edge);
 598                 long n = get_Proj_proj(proj);
 599                 assert(is_Proj(proj) && "non-Proj from Mod node");
 600                 if (n == p_div) {
 601                         set_Proj_proj(proj, pn_DivMod_res_div);
 602                 } else if (n == p_mod) {
 603                         set_Proj_proj(proj, pn_DivMod_res_mod);
 604                 } else if(n == p_m) {
 605                         set_Proj_proj(proj, pn_DivMod_M);
 606                 } else if(n == p_x) {
 607                         set_Proj_proj(proj, pn_DivMod_X_except);
 608                 } else {
 609                         assert(!"invalid proj");
 610                 }
 611         }
 612
 613         return div;
 614 }
 615
 616 static ir_node *gen_node_for_DivMod(mips_transform_env_t *env) {
 617         ir_node *node = env->irn;
 618
 619         return gen_node_mips_div(env, get_DivMod_left(node), get_DivMod_right(node), pn_DivMod_res_div,
 620                                                          pn_DivMod_res_mod, pn_DivMod_M, pn_DivMod_X_except);
 621 }
 622
 623 static ir_node *gen_node_for_Div(mips_transform_env_t *env) {
 624         ir_node *node = env->irn;
 625
 626         return gen_node_mips_div(env, get_Div_left(node), get_Div_right(node), pn_Div_res, -1,
 627                                                          pn_Div_M, pn_Div_X_except);
 628 }
 629
 630 static ir_node *gen_node_for_Mod(mips_transform_env_t *env) {
 631         ir_node *node = env->irn;
 632
 633         return gen_node_mips_div(env, get_Mod_left(node), get_Mod_right(node), -1, pn_Mod_res,
 634                                                          pn_Mod_M, pn_Mod_X_except);
 635 }
 636
 637 static ir_node *gen_node_for_Mul(mips_transform_env_t *env) {
 638         ir_node *node = env->irn;
 639         ir_node *mul;
 640         ir_node *mflo;
 641         ir_node *op1, *op2;
 642
 643         op1 = get_Mul_left(node);
 644         op2 = get_Mul_right(node);
 645
 646         assert(get_mode_size_bits(env->mode) == 32);
 647         assert(get_mode_size_bits(get_irn_mode(op1)) == get_mode_size_bits(env->mode));
 648         assert(get_mode_size_bits(get_irn_mode(op2)) == get_mode_size_bits(env->mode));
 649
 650         mul = new_rd_mips_mult(env->dbg, env->irg, env->block, get_Mul_left(node), get_Mul_right(node), env->mode);
 651         mflo = new_rd_mips_mflo(env->dbg, env->irg, env->block, mul, env->mode);
 652
 653         return mflo;
 654 }
 655
 656 static ir_node *gen_node_for_IJmp(mips_transform_env_t *env) {
 657         ir_node *node = env->irn;
 658
 659         return new_rd_mips_j(env->dbg, env->irg, env->block, get_IJmp_target(node), node->mode);
 660 }
 661
 662 static ir_node *gen_node_for_Jmp(mips_transform_env_t *env) {
 663         return make_jmp_or_fallthrough(env);
 664 }
 665
 666 static ir_node *gen_node_for_Abs(mips_transform_env_t *env) {
 667         ir_node *node = env->irn;
 668         ir_node *sra, *add, *xor;
 669         mips_attr_t *attr;
 670
 671         // TODO for other bit sizes...
 672         assert(get_mode_size_bits(env->mode) == 32);
 673         sra = new_rd_mips_srai(env->dbg, env->irg, env->block, get_Abs_op(node), node->mode);
 674         attr = get_mips_attr(sra);
 675         attr->tv = new_tarval_from_long(31, mode_Iu);
 676         add = new_rd_mips_add(env->dbg, env->irg, env->block, get_Abs_op(node), sra, node->mode);
 677         xor = new_rd_mips_xor(env->dbg, env->irg, env->block, sra, add, node->mode);
 678
 679         return xor;
 680 }
 681
 682 static ir_node *gen_node_for_Rot(mips_transform_env_t *env) {
 683         ir_node *node = env->irn;
 684         ir_node *subu, *srlv, *sllv, *or;
 685
 686         subu = new_rd_mips_subuzero(env->dbg, env->irg, env->block, get_Rot_right(node), env->mode);
 687         srlv = new_rd_mips_srlv(env->dbg, env->irg, env->block, get_Rot_left(node), subu, env->mode);
 688         sllv = new_rd_mips_sllv(env->dbg, env->irg, env->block, get_Rot_left(node), get_Rot_right(node), env->mode);
 689         or = new_rd_mips_or(env->dbg, env->irg, env->block, sllv, srlv, env->mode);
 690
 691         return or;
 692 }
 693
 694 static ir_node *gen_node_for_Unknown(mips_transform_env_t *env)
 695 {
 696         return gen_zero_node(env, env->dbg, env->irg, env->block);
 697 }
 698
 699 /*
 700  * lower a copyB into standard Firm assembler :-)
 701  */
 702 ir_node *gen_code_for_CopyB(ir_node *block, ir_node *node) {
 703         ir_node *cnt, *sub;
 704         ir_node *dst = get_CopyB_dst(node);
 705         ir_node *src = get_CopyB_src(node);
 706         ir_type *type = get_CopyB_type(node);
 707         ir_node *mem = get_CopyB_mem(node);
 708         ir_node *mm[4];
 709         ir_node *result = NULL;
 710         int size = get_type_size_bytes(type);
 711         dbg_info *dbg = get_irn_dbg_info(node);
 712         ir_graph *irg = get_irn_irg(block);
 713         mips_attr_t *attr;
 714         int i, n;
 715
 716         if (size > 16) {
 717                 ir_node     *phi, *projT, *projF, *cmp, *proj, *cond, *jmp, *in[2];
 718                 ir_node     *new_bl, *src_phi, *dst_phi, *mem_phi, *add;
 719                 ir_mode     *p_mode = get_irn_mode(src);
 720                 ir_node     *ld[4];
 721
 722                 /* build the control loop */
 723                 in[0] = in[1] = new_r_Unknown(irg, mode_X);
 724
 725                 new_bl = new_r_Block(irg, 2, in);
 726
 727                 in[0] = cnt = new_Const_long(mode_Is, (size >> 4));
 728         in[1] = new_r_Unknown(irg, mode_Is);
 729                 phi   = new_r_Phi(irg, new_bl, 2, in, mode_Is);
 730
 731                 sub = new_rd_Sub(dbg, irg, new_bl, phi, new_Const_long(mode_Is, -1), mode_Is);
 732                 set_Phi_pred(phi, 1, sub);
 733
 734                 cmp = new_rd_Cmp(dbg, irg, new_bl, sub, new_Const_long(mode_Is, 0));
 735                 proj = new_r_Proj(irg, new_bl, cmp, mode_b, pn_Cmp_Lg);
 736                 cond = new_rd_Cond(dbg, irg, new_bl, proj);
 737
 738                 projT = new_r_Proj(irg, new_bl, cond, mode_X, pn_Cond_true);
 739                 projF = new_r_Proj(irg, new_bl, cond, mode_X, pn_Cond_false);
 740
 741                 jmp = get_Block_cfgpred(block, 0);
 742                 set_Block_cfgpred(block, 0, projF);
 743
 744                 set_Block_cfgpred(new_bl, 0, jmp);
 745                 set_Block_cfgpred(new_bl, 1, projT);
 746
 747                 size &= 0xF;
 748
 749                 /* build the copy */
 750                 in[0]   = src;
 751         in[1]   = new_r_Unknown(irg, p_mode);
 752                 src_phi = new_r_Phi(irg, new_bl, 2, in, p_mode);
 753
 754                 in[0]   = dst;
 755                 dst_phi = new_r_Phi(irg, new_bl, 2, in, p_mode);
 756
 757                 add = new_rd_Add(dbg, irg, new_bl, src_phi, new_Const_long(mode_Is, 16), p_mode);
 758                 set_Phi_pred(src_phi, 1, add);
 759                 add = new_rd_Add(dbg, irg, new_bl, dst_phi, new_Const_long(mode_Is, 16), p_mode);
 760                 set_Phi_pred(dst_phi, 1, add);
 761
 762                 in[0]   = mem;
 763         in[1]   = new_r_Unknown(irg, mode_M);
 764                 mem_phi = new_r_Phi(irg, new_bl, 2, in, mode_M);
 765
 766                 src = src_phi;
 767                 dst = dst_phi;
 768
 769                 /* create 4 parallel loads */
 770                 for (i = 0; i < 4; ++i) {
 771                         ir_node *load;
 772
 773                         load = new_rd_mips_load_r(dbg, irg, new_bl, mem_phi, src, mode_T);
 774                         attr = get_mips_attr(load);
 775                         attr->modes.load_store_mode = mode_Iu;
 776                         attr->tv = new_tarval_from_long(i * 4, mode_Iu);
 777
 778                         ld[i] = new_rd_Proj(dbg, irg, new_bl, load, mode_Iu, pn_Load_res);
 779                 }
 780
 781                 /* create 4 parallel stores */
 782                 for (i = 0; i < 4; ++i) {
 783                         ir_node *store;
 784
 785                         store = new_rd_mips_store_r(dbg, irg, new_bl, mem_phi, dst, ld[i], mode_T);
 786                         attr = get_mips_attr(store);
 787                         attr->modes.load_store_mode = mode_Iu;
 788                         attr->tv = new_tarval_from_long(i * 4, mode_Iu);
 789
 790                         mm[i] = new_rd_Proj(dbg, irg, new_bl, store, mode_M, pn_Store_M);
 791                 }
 792                 mem = new_r_Sync(irg, new_bl, 4, mm);
 793                 result = mem;
 794                 set_Phi_pred(mem_phi, 1, mem);
 795         }
 796
 797         // output store/loads manually
 798         n = 0;
 799         for(i = size; i > 0; ) {
 800                 ir_mode *mode;
 801                 ir_node *load, *store, *projv;
 802                 int offset = size - i;
 803                 if(i >= 4) {
 804                         mode = mode_Iu;
 805                         i -= 4;
 806                 } else if(i >= 2) {
 807                         mode = mode_Hu;
 808                         i -= 2;
 809                 } else {
 810                         mode = mode_Bu;
 811                         i -= 1;
 812                 }
 813
 814                 load = new_rd_mips_load_r(dbg, irg, block, mem, src, mode_T);
 815                 attr = get_mips_attr(load);
 816                 attr->modes.load_store_mode = mode;
 817                 attr->tv = new_tarval_from_long(offset, mode_Iu);
 818
 819                 projv = new_rd_Proj(dbg, irg, block, load, mode, pn_Load_res);
 820
 821                 store = new_rd_mips_store_r(dbg, irg, block, mem, dst, projv, mode_T);
 822                 attr = get_mips_attr(store);
 823                 attr->modes.load_store_mode = mode;
 824                 attr->tv = new_tarval_from_long(offset, mode_Iu);
 825
 826                 mm[n] = new_rd_Proj(dbg, irg, block, store, mode_M, pn_Store_M);
 827                 n++;
 828         }
 829
 830         if(n > 0) {
 831                 result = new_r_Sync(irg, block, n, mm);
 832         } else if(n == 1) {
 833                 result = mm[0];
 834         }
 835
 836         return result;
 837 }
 838
 839 static void mips_fix_CopyB_Proj(mips_transform_env_t* env) {
 840         ir_node *node = env->irn;
 841         long n = get_Proj_proj(node);
 842
 843         if(n == pn_CopyB_M_except) {
 844                 assert(0);
 845         } else if(n == pn_CopyB_M_regular) {
 846                 set_Proj_proj(node, pn_Store_M);
 847         } else if(n == pn_CopyB_M_except) {
 848                 set_Proj_proj(node, pn_Store_X_except);
 849         }
 850 }
 851
 852 static void mips_transform_Spill(mips_transform_env_t* env) {
 853         ir_node *node = env->irn;
 854         ir_node *sched_point = NULL;
 855         ir_node *store, *proj;
 856         ir_node *nomem = new_rd_NoMem(env->irg);
 857         ir_node *ptr   = get_irn_n(node, 0);
 858         ir_node *val   = get_irn_n(node, 1);
 859         entity  *ent   = be_get_frame_entity(node);
 860         mips_attr_t *attr;
 861
 862         if(sched_is_scheduled(node)) {
 863                 sched_point = sched_prev(node);
 864         }
 865
 866         store = new_rd_mips_store_r(env->dbg, env->irg, env->block, nomem, ptr, val, mode_T);
 867         attr = get_mips_attr(store);
 868         attr->stack_entity = ent;
 869         attr->modes.load_store_mode = get_irn_mode(val);
 870
 871         proj = new_rd_Proj(env->dbg, env->irg, env->block, store, mode_M, pn_Store_M);
 872
 873         if (sched_point) {
 874                 sched_add_after(sched_point, store);
 875                 sched_add_after(store, proj);
 876
 877                 sched_remove(node);
 878         }
 879
 880         exchange(node, proj);
 881 }
 882
 883 static void mips_transform_Reload(mips_transform_env_t* env) {
 884         ir_node *node = env->irn;
 885         ir_node *sched_point = NULL;
 886         ir_node *load, *proj;
 887         ir_node *ptr   = get_irn_n(node, 0);
 888         ir_node *mem   = get_irn_n(node, 1);
 889         ir_mode *mode  = get_irn_mode(node);
 890         entity  *ent   = be_get_frame_entity(node);
 891         const arch_register_t* reg;
 892         mips_attr_t *attr;
 893
 894         if(sched_is_scheduled(node)) {
 895                 sched_point = sched_prev(node);
 896         }
 897
 898         load = new_rd_mips_load_r(env->dbg, env->irg, env->block, mem, ptr, mode_T);
 899         attr = get_mips_attr(load);
 900         attr->stack_entity = ent;
 901         attr->modes.load_store_mode = mode;
 902
 903         proj = new_rd_Proj(env->dbg, env->irg, env->block, load, mode, pn_Load_res);
 904
 905         if (sched_point) {
 906                 sched_add_after(sched_point, load);
 907                 sched_add_after(load, proj);
 908
 909                 sched_remove(node);
 910         }
 911
 912         /* copy the register from the old node to the new Load */
 913         reg = arch_get_irn_register(env->cg->arch_env, node);
 914         arch_set_irn_register(env->cg->arch_env, proj, reg);
 915
 916         exchange(node, proj);
 917 }
 918
 919 static ir_node *gen_node_for_StackParam(mips_transform_env_t *env)
 920 {
 921         ir_node *node = env->irn;
 922         ir_node *sp = get_irn_n(node, 0);
 923         ir_node *load;
 924         ir_node *nomem = new_rd_NoMem(env->irg);
 925         ir_node *proj;
 926         mips_attr_t *attr;
 927
 928         load = new_rd_mips_load_r(env->dbg, env->irg, env->block, nomem, sp, mode_T);
 929         attr = get_mips_attr(load);
 930         attr->stack_entity = be_get_frame_entity(node);
 931         attr->modes.load_store_mode = env->mode;
 932
 933         proj = new_rd_Proj(env->dbg, env->irg, env->block, load, env->mode, pn_Load_res);
 934
 935         return proj;
 936 }
 937
 938 static ir_node *gen_node_for_AddSP(mips_transform_env_t *env)
 939 {
 940         ir_node *node = env->irn;
 941         ir_node *op1, *op2;
 942         ir_node *add;
 943         const arch_register_t *reg;
 944
 945         op1 = get_irn_n(node, 0);
 946         op2 = get_irn_n(node, 1);
 947
 948         add = new_rd_mips_add(env->dbg, env->irg, env->block, op1, op2, mode_Iu);
 949
 950         /* copy the register requirements from the old node to the new node */
 951         reg = arch_get_irn_register(env->cg->arch_env, node);
 952         arch_set_irn_register(env->cg->arch_env, add, reg);
 953
 954         return add;
 955 }
 956
 957 /*********************************************************
 958  *                  _             _      _
 959  *                 (_)           | |    (_)
 960  *  _ __ ___   __ _ _ _ __     __| |_ __ ___   _____ _ __
 961  * | '_ ` _ \ / _` | | '_ \   / _` | '__| \ \ / / _ \ '__|
 962  * | | | | | | (_| | | | | | | (_| | |  | |\ V /  __/ |
 963  * |_| |_| |_|\__,_|_|_| |_|  \__,_|_|  |_| \_/ \___|_|
 964  *
 965  *********************************************************/
 966
 967
 968 /**
 969  * Transforms the given firm node (and maybe some other related nodes)
 970  * into one or more assembler nodes.
 971  *
 972  * @param node    the firm node
 973  * @param env     the debug module
 974  */
 975 void mips_transform_node(ir_node *node, void *env) {
 976         mips_code_gen_t *cgenv = (mips_code_gen_t *)env;
 977         opcode  code               = get_irn_opcode(node);
 978         ir_node *asm_node          = node;
 979         mips_transform_env_t tenv;
 980
 981         if (is_Block(node))
 982                 return;
 983
 984         tenv.block    = get_nodes_block(node);
 985         tenv.dbg      = get_irn_dbg_info(node);
 986         tenv.irg      = current_ir_graph;
 987         tenv.irn      = node;
 988         DEBUG_ONLY(tenv.mod      = cgenv->mod;)
 989         tenv.mode     = get_irn_mode(node);
 990         tenv.cg           = cgenv;
 991
 992 #define UNOP(firm_opcode, mips_nodetype)        case iro_##firm_opcode: asm_node = mips_gen_##mips_nodetype(&tenv, get_##firm_opcode##_op(node)); break
 993 #define BINOP(firm_opcode, mips_nodetype)       case iro_##firm_opcode: asm_node = mips_gen_##mips_nodetype(&tenv, get_##firm_opcode##_left(node), get_##firm_opcode##_right(node)); break
 994 #define IGN(a)         case iro_##a: break
 995 #define BAD(a)         case iro_##a: goto bad
 996
 997         DBG((tenv.mod, LEVEL_1, "check %+F ... ", node));
 998
 999         switch (code) {
1000                 BINOP(Add, add);
1001                 BINOP(Sub, sub);
1002                 BINOP(And, and);
1003                 BINOP(Or, or);
1004                 BINOP(Eor, xor);
1005                 UNOP(Not, not);
1006                 BINOP(Shl, sl);
1007                 BINOP(Shr, sr);
1008                 BINOP(Shrs, sra);
1009
1010         case iro_Abs:
1011                 asm_node = gen_node_for_Abs(&tenv);
1012                 break;
1013
1014         case iro_Rot:
1015                 asm_node = gen_node_for_Rot(&tenv);
1016                 break;
1017
1018         case iro_Div:
1019                 asm_node = gen_node_for_Div(&tenv);
1020                 break;
1021
1022         case iro_Mod:
1023                 asm_node = gen_node_for_Mod(&tenv);
1024                 break;
1025
1026         case iro_Load:
1027                 asm_node = gen_node_for_Load(&tenv);
1028                 break;
1029
1030         case iro_Store:
1031                 asm_node = gen_node_for_Store(&tenv);
1032                 break;
1033
1034         case iro_Proj:
1035                 asm_node = gen_node_for_Proj(&tenv);
1036                 break;
1037
1038         case iro_Conv:
1039                 asm_node = gen_node_for_Conv(&tenv);
1040                 break;
1041
1042         case iro_DivMod:
1043                 asm_node = gen_node_for_DivMod(&tenv);
1044                 break;
1045
1046         case iro_Mul:
1047                 asm_node = gen_node_for_Mul(&tenv);
1048                 break;
1049
1050         case iro_Jmp:
1051                 asm_node = gen_node_for_Jmp(&tenv);
1052                 break;
1053
1054         case iro_IJmp:
1055                 asm_node = gen_node_for_IJmp(&tenv);
1056                 break;
1057
1058         case iro_Unknown:
1059                 asm_node = gen_node_for_Unknown(&tenv);
1060                 break;
1061
1062         case iro_Cond:
1063                 asm_node = gen_node_for_Cond(&tenv);
1064                 break;
1065
1066                 /* TODO: implement these nodes */
1067                 BAD(Mux);
1068
1069                 /* You probably don't need to handle the following nodes */
1070
1071                 // call is handled in the emit phase
1072                 IGN(Call);
1073                 // Cmp is handled together with Cond
1074                 IGN(Cmp);
1075                 IGN(Alloc);
1076
1077                 IGN(Block);
1078                 IGN(Start);
1079                 IGN(End);
1080                 IGN(NoMem);
1081                 IGN(Phi);
1082                 IGN(Break);
1083                 IGN(Sync);
1084
1085                 IGN(Const);
1086                 IGN(SymConst);
1087
1088                 BAD(Raise);
1089                 BAD(Sel);
1090                 BAD(InstOf);
1091                 BAD(Cast);
1092                 BAD(Free);
1093                 BAD(Tuple);
1094                 BAD(Id);
1095                 BAD(Bad);
1096                 BAD(Confirm);
1097                 BAD(Filter);
1098                 BAD(CallBegin);
1099                 BAD(EndReg);
1100                 BAD(EndExcept);
1101
1102                 default:
1103                         if(be_is_StackParam(node)) {
1104                                 asm_node = gen_node_for_StackParam(&tenv);
1105                         } else if(be_is_AddSP(node)) {
1106                                 asm_node = gen_node_for_AddSP(&tenv);
1107                         }
1108                         break;
1109
1110 bad:
1111                 fprintf(stderr, "Not implemented: %s\n", get_irn_opname(node));
1112                 assert(0);
1113         }
1114
1115         if (asm_node != node) {
1116                 exchange(node, asm_node);
1117                 DB((tenv.mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node));
1118         } else {
1119                 DB((tenv.mod, LEVEL_1, "ignored\n"));
1120         }
1121 }
1122
1123 void mips_pre_transform_node(ir_node *node, void *env) {
1124         mips_code_gen_t *cgenv = (mips_code_gen_t *)env;
1125         int i;
1126
1127         mips_transform_env_t tenv;
1128
1129         if (is_Block(node))
1130                 return;
1131
1132         tenv.block    = get_nodes_block(node);
1133         tenv.dbg      = get_irn_dbg_info(node);
1134         tenv.irg      = current_ir_graph;
1135         tenv.irn      = node;
1136         DEBUG_ONLY(tenv.mod      = cgenv->mod;)
1137         tenv.mode     = get_irn_mode(node);
1138         tenv.cg           = cgenv;
1139
1140         if(is_Proj(node)) {
1141                 ir_node* pred = get_Proj_pred(node);
1142
1143                 if(get_irn_opcode(pred) == iro_CopyB) {
1144                         mips_fix_CopyB_Proj(&tenv);
1145                 }
1146         }
1147
1148         for(i = 0; i < get_irn_arity(node); ++i) {
1149                 ir_node* pred = get_irn_n(node, i);
1150
1151                 if (is_Const(pred)) {
1152                         ir_node* constnode = exchange_node_for_Const(&tenv, pred, i);
1153                         set_irn_n(node, i, constnode);
1154                 } else if (get_irn_op(pred) == op_SymConst) {
1155                         ir_node* constnode = gen_node_for_SymConst(&tenv, pred, i);
1156                         set_irn_n(node, i, constnode);
1157                 }
1158         }
1159 }
1160
1161 /**
1162  * Calls the transform functions for Spill and Reload.
1163  */
1164 void mips_after_ra_walker(ir_node *node, void *env) {
1165         mips_code_gen_t *cg = env;
1166         mips_transform_env_t tenv;
1167
1168         if (is_Block(node))
1169                 return;
1170
1171         tenv.block = get_nodes_block(node);
1172         tenv.dbg   = get_irn_dbg_info(node);
1173         tenv.irg   = current_ir_graph;
1174         tenv.irn   = node;
1175         DEBUG_ONLY(tenv.mod   = cg->mod;)
1176         tenv.mode  = get_irn_mode(node);
1177         tenv.cg    = cg;
1178
1179         /* be_is_StackParam(node) || */
1180         if (be_is_Reload(node)) {
1181                 mips_transform_Reload(&tenv);
1182         } else if (be_is_Spill(node)) {
1183                 mips_transform_Spill(&tenv);
1184         }
1185 }