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

   1 /*
   2  * Copyright (C) 1995-2008 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   The codegenrator (transform FIRM into mips FIRM
  23  * @author  Matthias Braun, Mehdi
  24  * @version $Id$
  25  */
  26 #ifdef HAVE_CONFIG_H
  27 #include "config.h"
  28 #endif
  29
  30 #include <limits.h>
  31
  32 #include "irnode_t.h"
  33 #include "irgraph_t.h"
  34 #include "irmode_t.h"
  35 #include "irgmod.h"
  36 #include "iredges.h"
  37 #include "irvrfy.h"
  38 #include "ircons.h"
  39 #include "irprintf.h"
  40 #include "irop.h"
  41 #include "iropt_t.h"
  42 #include "debug.h"
  43 #include "error.h"
  44
  45 #include "../benode_t.h"
  46 #include "../beabi.h"
  47 #include "../besched.h"
  48 #include "../besched_t.h"
  49 #include "../beirg_t.h"
  50 #include "../betranshlp.h"
  51 #include "bearch_mips_t.h"
  52
  53 #include "mips_nodes_attr.h"
  54 #include "archop.h"
  55 #include "mips_transform.h"
  56 #include "mips_new_nodes.h"
  57 #include "mips_map_regs.h"
  58 #include "mips_util.h"
  59 #include "mips_emitter.h"
  60
  61 #include "gen_mips_regalloc_if.h"
  62
  63 /** hold the current code generator during transformation */
  64 static mips_code_gen_t *env_cg = NULL;
  65
  66 /****************************************************************************************************
  67  *                  _        _                        __                           _   _
  68  *                 | |      | |                      / _|                         | | (_)
  69  *  _ __   ___   __| | ___  | |_ _ __ __ _ _ __  ___| |_ ___  _ __ _ __ ___   __ _| |_ _  ___  _ __
  70  * | '_ \ / _ \ / _` |/ _ \ | __| '__/ _` | '_ \/ __|  _/ _ \| '__| '_ ` _ \ / _` | __| |/ _ \| '_ \
  71  * | | | | (_) | (_| |  __/ | |_| | | (_| | | | \__ \ || (_) | |  | | | | | | (_| | |_| | (_) | | | |
  72  * |_| |_|\___/ \__,_|\___|  \__|_|  \__,_|_| |_|___/_| \___/|_|  |_| |_| |_|\__,_|\__|_|\___/|_| |_|
  73  *
  74  ****************************************************************************************************/
  75
  76 typedef ir_node *construct_binop_func(dbg_info *db, ir_graph *irg,
  77         ir_node *block, ir_node *left, ir_node *right);
  78
  79 static INLINE int mode_needs_gp_reg(ir_mode *mode) {
  80         return mode_is_int(mode) || mode_is_reference(mode);
  81 }
  82
  83 ir_node *mips_create_Immediate(long val)
  84 {
  85         ir_graph *irg   = current_ir_graph;
  86         ir_node  *block = get_irg_start_block(irg);
  87         const arch_register_t **slots;
  88         ir_node  *res;
  89
  90         assert(val >=  -32768 && val <= 32767);
  91         res      = new_rd_mips_Immediate(NULL, irg, block, MIPS_IMM_CONST, NULL,
  92                                          val);
  93         slots    = get_mips_slots(res);
  94         slots[0] = &mips_gp_regs[REG_GP_NOREG];
  95
  96         return res;
  97 }
  98
  99 ir_node* mips_create_zero(void)
 100 {
 101         ir_graph *irg   = current_ir_graph;
 102         ir_node  *block = get_irg_start_block(irg);
 103         ir_node  *zero  = new_rd_mips_zero(NULL, irg, block);
 104         const arch_register_t **slots = get_mips_slots(zero);
 105
 106         slots[0] = &mips_gp_regs[REG_ZERO];
 107
 108         return zero;
 109 }
 110
 111 static ir_node *try_create_Immediate(ir_node *node)
 112 {
 113         tarval   *tv;
 114         long      val;
 115         ir_mode  *mode;
 116
 117         if(!is_Const(node))
 118                 return NULL;
 119
 120         mode = get_irn_mode(node);
 121         if(!mode_needs_gp_reg(mode))
 122                 return NULL;
 123
 124         tv = get_Const_tarval(node);
 125         if(tarval_is_long(tv)) {
 126                 val = get_tarval_long(tv);
 127         } else {
 128                 ir_fprintf(stderr, "Optimisation Warning: tarval %+F is not a long?\n",
 129                            node);
 130                 return NULL;
 131         }
 132
 133         if(val < -32768 || val > 32767)
 134                 return NULL;
 135
 136         return mips_create_Immediate(val);
 137 }
 138
 139 static void create_binop_operands(ir_node **new_left, ir_node **new_right,
 140                                   ir_node *left, ir_node *right,
 141                                   int is_commutative)
 142 {
 143         *new_right = try_create_Immediate(right);
 144         if(*new_right != NULL) {
 145                 *new_left = be_transform_node(left);
 146                 return;
 147         }
 148         if(is_commutative) {
 149                 *new_right = try_create_Immediate(left);
 150                 if(*new_right != NULL) {
 151                         *new_left = be_transform_node(right);
 152                         return;
 153                 }
 154         }
 155
 156         *new_left  = be_transform_node(left);
 157         *new_right = be_transform_node(right);
 158 }
 159
 160 static ir_node *gen_binop(ir_node *node, ir_node *left, ir_node *right,
 161                           construct_binop_func func, int supports_immediate)
 162 {
 163         ir_graph *irg   = current_ir_graph;
 164         dbg_info *dbgi  = get_irn_dbg_info(node);
 165         ir_node  *block = be_transform_node(get_nodes_block(node));
 166         ir_node  *res;
 167         ir_node  *new_left, *new_right;
 168
 169         assert(mode_needs_gp_reg(get_irn_mode(node)));
 170
 171         if(supports_immediate) {
 172                 int is_commutative = is_op_commutative(get_irn_op(node));
 173                 create_binop_operands(&new_left, &new_right, left, right,
 174                                       is_commutative);
 175         } else {
 176                 new_left  = be_transform_node(left);
 177                 new_right = be_transform_node(right);
 178         }
 179
 180         res = func(dbgi, irg, block, new_left, new_right);
 181
 182         return res;
 183 }
 184
 185 static ir_node *gen_Add(ir_node *node)
 186 {
 187         /* TODO: match add(symconst, const) */
 188         return gen_binop(node, get_Add_left(node), get_Add_right(node),
 189                          new_rd_mips_addu, 1);
 190 }
 191
 192 static ir_node *gen_Sub(ir_node *node)
 193 {
 194         return gen_binop(node, get_Sub_left(node), get_Sub_right(node),
 195                          new_rd_mips_addu, 0);
 196 }
 197
 198 static ir_node *gen_And(ir_node *node)
 199 {
 200         return gen_binop(node, get_Add_left(node), get_Add_right(node),
 201                          new_rd_mips_and, 1);
 202 }
 203
 204 static ir_node *gen_Or(ir_node *node)
 205 {
 206         return gen_binop(node, get_Add_left(node), get_Add_right(node),
 207                          new_rd_mips_or, 1);
 208 }
 209
 210 static ir_node *gen_Eor(ir_node *node)
 211 {
 212         return gen_binop(node, get_Add_left(node), get_Add_right(node),
 213                          new_rd_mips_xor, 1);
 214 }
 215
 216 static ir_node *gen_Shl(ir_node *node)
 217 {
 218         return gen_binop(node, get_Add_left(node), get_Add_right(node),
 219                          new_rd_mips_sll, 1);
 220 }
 221
 222 static ir_node *gen_Shr(ir_node *node)
 223 {
 224         return gen_binop(node, get_Add_left(node), get_Add_right(node),
 225                          new_rd_mips_srl, 1);
 226 }
 227
 228 static ir_node *gen_Shrs(ir_node *node)
 229 {
 230         return gen_binop(node, get_Add_left(node), get_Add_right(node),
 231                          new_rd_mips_sra, 1);
 232 }
 233
 234 static ir_node *gen_Not(ir_node *node)
 235 {
 236         ir_graph *irg   = current_ir_graph;
 237         dbg_info *dbgi  = get_irn_dbg_info(node);
 238         ir_node  *block = be_transform_node(get_nodes_block(node));
 239         ir_node  *op    = get_Not_op(node);
 240         ir_node  *new_op;
 241         ir_node  *res;
 242         ir_node  *one;
 243
 244         /* we can transform not->or to nor */
 245         if(is_Or(op)) {
 246                 return gen_binop(op, get_Or_left(op), get_Or_right(op),
 247                                  new_rd_mips_nor, 1);
 248         }
 249
 250         /* construct (op < 1) */
 251         one    = mips_create_Immediate(1);
 252         new_op = be_transform_node(op);
 253         res    = new_rd_mips_sltu(dbgi, irg, block, new_op, one);
 254
 255         return res;
 256 }
 257
 258 static ir_node *gen_Minus(ir_node *node)
 259 {
 260         ir_graph *irg    = current_ir_graph;
 261         dbg_info *dbgi   = get_irn_dbg_info(node);
 262         ir_node  *block  = be_transform_node(get_nodes_block(node));
 263         ir_node  *op     = get_Minus_op(node);
 264         ir_node  *new_op = be_transform_node(op);
 265         ir_node  *res;
 266         ir_node  *zero;
 267
 268         /* construct (0 - op) */
 269         zero = mips_create_zero();
 270         res  = new_rd_mips_subu(dbgi, irg, block, zero, new_op);
 271
 272         return res;
 273 }
 274
 275 static ir_node *gen_Abs(ir_node *node)
 276 {
 277         ir_graph *irg    = current_ir_graph;
 278         dbg_info *dbgi   = get_irn_dbg_info(node);
 279         ir_node  *block  = be_transform_node(get_nodes_block(node));
 280         ir_node  *op     = get_Abs_op(node);
 281         ir_node  *new_op = be_transform_node(op);
 282         ir_node  *sra_const, *sra, *add, *xor;
 283
 284         /* TODO: support other bit sizes... */
 285         assert(get_mode_size_bits(get_irn_mode(node)) == 32);
 286         sra_const = mips_create_Immediate(31);
 287         sra       = new_rd_mips_sra(dbgi, irg, block, new_op, sra_const);
 288         add       = new_rd_mips_addu(dbgi, irg, block, new_op, sra);
 289         xor       = new_rd_mips_xor(dbgi, irg, block, sra, add);
 290
 291         return xor;
 292 }
 293
 294 static ir_node* gen_Const(ir_node *node)
 295 {
 296         ir_graph *irg   = current_ir_graph;
 297         dbg_info *dbgi  = get_irn_dbg_info(node);
 298         ir_node  *block = be_transform_node(get_nodes_block(node));
 299         tarval   *tv    = get_Const_tarval(node);
 300         ir_node  *upper_node;
 301         ir_node  *lower_node;
 302         ir_node  *or_const;
 303         unsigned long val, lower, upper;
 304
 305         if(tarval_is_long(tv)) {
 306                 val = get_tarval_long(tv);
 307         } else {
 308                 panic("Can't get value of tarval %+F", node);
 309         }
 310
 311         val = get_tarval_long(tv);
 312
 313         lower = val & 0xffff;
 314         upper = (val >> 16) & 0xffff;
 315         if(upper == 0) {
 316                 upper_node = mips_create_zero();
 317         } else {
 318                 upper_node = new_rd_mips_lui(dbgi, irg, block, MIPS_IMM_CONST, NULL,
 319                                              upper);
 320         }
 321
 322         if(lower == 0)
 323                 return upper_node;
 324
 325         or_const   = mips_create_Immediate(lower);
 326         lower_node = new_rd_mips_or(dbgi, irg, block, upper_node, or_const);
 327
 328         return lower_node;
 329 }
 330
 331 static ir_node* gen_SymConst(ir_node *node)
 332 {
 333         ir_graph *irg   = current_ir_graph;
 334         dbg_info *dbgi  = get_irn_dbg_info(node);
 335         ir_node  *block = be_transform_node(get_nodes_block(node));
 336         ir_entity *entity;
 337         ir_node *lui, *or_const, *or;
 338
 339         if(get_SymConst_kind(node) != symconst_addr_ent) {
 340                 panic("Only address entity symconsts supported in mips backend");
 341         }
 342
 343         entity = get_SymConst_entity(node);
 344
 345         lui            = new_rd_mips_lui(dbgi, irg, block, MIPS_IMM_SYMCONST_HI,
 346                                          entity, 0);
 347         or_const       = new_rd_mips_Immediate(dbgi, irg, block,
 348                                                MIPS_IMM_SYMCONST_LO, entity, 0);
 349         or             = new_rd_mips_or(dbgi, irg, block, lui, or_const);
 350
 351         return or;
 352 }
 353
 354 typedef ir_node* (*gen_load_func) (dbg_info *dbg, ir_graph *irg,
 355                                    ir_node *block, ir_node *ptr, ir_node *mem,
 356                                    ir_entity *entity, long offset);
 357
 358 /**
 359  * Generates a mips node for a firm Load node
 360  */
 361 static ir_node *gen_Load(ir_node *node)
 362 {
 363         ir_graph *irg     = current_ir_graph;
 364         dbg_info *dbgi    = get_irn_dbg_info(node);
 365         ir_node  *block   = be_transform_node(get_nodes_block(node));
 366         ir_node  *mem     = get_Load_mem(node);
 367         ir_node  *new_mem = be_transform_node(mem);
 368         ir_node  *ptr     = get_Load_ptr(node);
 369         ir_node  *new_ptr = be_transform_node(ptr);
 370         ir_mode  *mode    = get_Load_mode(node);
 371         int       sign    = get_mode_sign(mode);
 372         ir_node  *res;
 373         gen_load_func func;
 374
 375         ASSERT_NO_FLOAT(mode);
 376         assert(mode_needs_gp_reg(mode));
 377
 378         /* TODO: make use of offset in ptrs */
 379
 380         switch(get_mode_size_bits(mode)) {
 381         case 32:
 382                 func = new_rd_mips_lw;
 383                 break;
 384         case 16:
 385                 func = sign ? new_rd_mips_lh : new_rd_mips_lhu;
 386                 break;
 387         case 8:
 388                 func = sign ? new_rd_mips_lb : new_rd_mips_lbu;
 389                 break;
 390         default:
 391                 panic("mips backend only support 32, 16, 8 bit loads");
 392         }
 393
 394         res = func(dbgi, irg, block, new_ptr, new_mem, NULL, 0);
 395         set_irn_pinned(res, get_irn_pinned(node));
 396
 397         return res;
 398 }
 399
 400 typedef ir_node* (*gen_store_func) (dbg_info *dbg, ir_graph *irg,
 401                                     ir_node *block, ir_node *ptr, ir_node *val,
 402                                     ir_node *mem, ir_entity *ent, long offset);
 403
 404 /**
 405  * Generates a mips node for a firm Store node
 406  */
 407 static ir_node *gen_Store(ir_node *node)
 408 {
 409         ir_graph    *irg     = current_ir_graph;
 410         dbg_info    *dbgi    = get_irn_dbg_info(node);
 411         ir_node     *block   = be_transform_node(get_nodes_block(node));
 412         ir_node     *mem     = get_Store_mem(node);
 413         ir_node     *new_mem = be_transform_node(mem);
 414         ir_node     *ptr     = get_Store_ptr(node);
 415         ir_node     *new_ptr = be_transform_node(ptr);
 416         ir_node     *val     = get_Store_value(node);
 417         ir_node     *new_val = be_transform_node(val);
 418         ir_mode     *mode    = get_irn_mode(val);
 419         gen_store_func func;
 420         ir_node     *res;
 421
 422         assert(mode_needs_gp_reg(mode));
 423
 424         switch(get_mode_size_bits(mode)) {
 425         case 32:
 426                 func = new_rd_mips_sw;
 427                 break;
 428         case 16:
 429                 func = new_rd_mips_sh;
 430                 break;
 431         case 8:
 432                 func = new_rd_mips_sb;
 433                 break;
 434         default:
 435                 panic("store only supported for 32, 16, 8 bit values in mips backend");
 436         }
 437
 438         res = func(dbgi, irg, block, new_ptr, new_val, new_mem, NULL, 0);
 439         set_irn_pinned(res, get_irn_pinned(node));
 440
 441         return res;
 442 }
 443
 444 static ir_node *gen_Proj_DivMod(ir_node *node)
 445 {
 446         ir_graph *irg     = current_ir_graph;
 447         dbg_info *dbgi    = get_irn_dbg_info(node);
 448         ir_node  *block   = be_transform_node(get_nodes_block(node));
 449         ir_node  *divmod  = get_Proj_pred(node);
 450         ir_node  *new_div = be_transform_node(divmod);
 451         long      pn      = get_Proj_proj(node);
 452         ir_node  *proj;
 453
 454         assert(is_mips_div(new_div) || is_mips_divu(new_div));
 455
 456         switch(get_irn_opcode(divmod)) {
 457         case iro_Div:
 458                 switch(pn) {
 459                 case pn_Div_M:
 460                         return new_rd_Proj(dbgi, irg, block, new_div, mode_M,
 461                                            pn_mips_div_M);
 462                 case pn_Div_res:
 463                         proj = new_rd_Proj(dbgi, irg, block, new_div, mode_M,
 464                                            pn_mips_div_lohi);
 465                         return new_rd_mips_mflo(dbgi, irg, block, proj);
 466                 default:
 467                         break;
 468                 }
 469         case iro_Mod:
 470                 switch(pn) {
 471                 case pn_Mod_M:
 472                         return new_rd_Proj(dbgi, irg, block, new_div, mode_M,
 473                                            pn_mips_div_M);
 474                 case pn_Mod_res:
 475                         proj = new_rd_Proj(dbgi, irg, block, new_div, mode_M,
 476                                            pn_mips_div_lohi);
 477                         return new_rd_mips_mfhi(dbgi, irg, block, proj);
 478                 default:
 479                         break;
 480                 }
 481
 482         case iro_DivMod:
 483                 switch(pn) {
 484                 case pn_Div_M:
 485                         return new_rd_Proj(dbgi, irg, block, new_div, mode_M,
 486                                            pn_mips_div_M);
 487                 case pn_DivMod_res_div:
 488                         proj = new_rd_Proj(dbgi, irg, block, new_div, mode_M,
 489                                            pn_mips_div_lohi);
 490                         return new_rd_mips_mflo(dbgi, irg, block, proj);
 491                 case pn_DivMod_res_mod:
 492                         proj = new_rd_Proj(dbgi, irg, block, new_div, mode_M,
 493                                            pn_mips_div_lohi);
 494                         return new_rd_mips_mfhi(dbgi, irg, block, proj);
 495                 default:
 496                         break;
 497                 }
 498         default:
 499                 break;
 500         }
 501
 502         panic("invalid proj attached to %+F", divmod);
 503 }
 504
 505 static ir_node *gen_Proj_Start(ir_node *node)
 506 {
 507         ir_graph *irg   = current_ir_graph;
 508         dbg_info *dbgi  = get_irn_dbg_info(node);
 509         ir_node  *block = be_transform_node(get_nodes_block(node));
 510         long      pn    = get_Proj_proj(node);
 511
 512         if(pn == pn_Start_X_initial_exec) {
 513                 /* we exchange the projx with a jump */
 514                 ir_node *jump = new_rd_Jmp(dbgi, irg, block);
 515                 return jump;
 516         }
 517         if(node == get_irg_anchor(irg, anchor_tls)) {
 518                 /* TODO... */
 519                 return be_duplicate_node(node);
 520         }
 521         return be_duplicate_node(node);
 522 }
 523
 524 static ir_node *gen_Proj(ir_node *node)
 525 {
 526         ir_graph *irg  = current_ir_graph;
 527         dbg_info *dbgi = get_irn_dbg_info(node);
 528         ir_node  *pred = get_Proj_pred(node);
 529
 530         switch(get_irn_opcode(pred)) {
 531         case iro_Load:
 532                 break;
 533         case iro_Store:
 534                 break;
 535         case iro_Div:
 536         case iro_Mod:
 537         case iro_DivMod:
 538                 return gen_Proj_DivMod(node);
 539
 540         case iro_Start:
 541                 return gen_Proj_Start(node);
 542
 543         default:
 544                 assert(get_irn_mode(node) != mode_T);
 545                 if(mode_needs_gp_reg(get_irn_mode(node))) {
 546                         ir_node *new_pred = be_transform_node(pred);
 547                         ir_node *block    = be_transform_node(get_nodes_block(node));
 548                         long     pn       = get_Proj_proj(node);
 549
 550                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu, pn);
 551                 }
 552                 break;
 553         }
 554
 555         return be_duplicate_node(node);
 556 }
 557
 558 static ir_node *gen_Phi(ir_node *node)
 559 {
 560         ir_graph *irg   = current_ir_graph;
 561         dbg_info *dbgi  = get_irn_dbg_info(node);
 562         ir_node  *block = be_transform_node(get_nodes_block(node));
 563         ir_mode  *mode  = get_irn_mode(node);
 564         ir_node  *phi;
 565
 566         if(mode_needs_gp_reg(mode)) {
 567                 assert(get_mode_size_bits(mode) <= 32);
 568                 mode = mode_Iu;
 569         }
 570
 571         /* phi nodes allow loops, so we use the old arguments for now
 572          * and fix this later */
 573         phi = new_ir_node(dbgi, irg, block, op_Phi, mode, get_irn_arity(node),
 574                           get_irn_in(node) + 1);
 575         copy_node_attr(node, phi);
 576         be_duplicate_deps(node, phi);
 577
 578         be_set_transformed_node(node, phi);
 579         be_enqueue_preds(node);
 580
 581         return phi;
 582 }
 583
 584 #if 0
 585 static
 586 ir_node *gen_node_for_SwitchCond(mips_transform_env_t *env)
 587 {
 588         ir_node *selector = get_Cond_selector(env->irn);
 589         ir_mode *selector_mode = get_irn_mode(selector);
 590         ir_node *node = env->irn;
 591         dbg_info *dbg = env->dbg;
 592         ir_graph *irg = env->irg;
 593         ir_node *block = env->block;
 594         ir_node *sub, *sltu, *minval_const, *max_const, *switchjmp;
 595         ir_node *defaultproj, *defaultproj_succ;
 596         ir_node *beq, *sl;
 597         long pn, minval, maxval, defaultprojn;
 598         const ir_edge_t *edge;
 599         ir_node *zero, *two_const, *add, *la, *load, *proj;
 600         ir_mode *unsigned_mode;
 601         mips_attr_t *attr;
 602
 603         // mode_b conds are handled by gen_node_for_Proj
 604         if(get_mode_sort(selector_mode) != irms_int_number)
 605                 return env->irn;
 606
 607         assert(get_mode_size_bits(selector_mode) == 32);
 608
 609         defaultproj = NULL;
 610         defaultprojn = get_Cond_defaultProj(node);
 611
 612         // go over all projs to find min-&maxval of the switch
 613         minval = INT_MAX;
 614         maxval = INT_MIN;
 615         foreach_out_edge(node, edge) {
 616                 ir_node* proj = get_edge_src_irn(edge);
 617                 assert(is_Proj(proj) && "Only proj allowed at SwitchJmp");
 618
 619                 pn = get_Proj_proj(proj);
 620                 if(pn == defaultprojn) {
 621                         defaultproj = proj;
 622                         continue;
 623                 }
 624
 625                 if(pn < minval)
 626                         minval = pn;
 627                 if(pn > maxval)
 628                         maxval = pn;
 629         }
 630         assert(defaultproj != NULL);
 631
 632         // subtract minval from the switch value
 633
 634         if(minval != 0) {
 635                 minval_const = new_rd_Const(dbg, irg, block, selector_mode, new_tarval_from_long(minval, selector_mode));
 636                 minval_const = gen_node_for_Const(env, dbg, irg, block, minval_const);
 637                 sub = new_rd_mips_sub(dbg, irg, block, selector, minval_const);
 638         } else {
 639                 sub = selector;
 640         }
 641
 642         // compare if we're above maxval-minval or below zero.
 643         // we can do this with 1 compare because we use unsigned mode
 644         unsigned_mode = new_ir_mode(get_mode_name(selector_mode),
 645                         get_mode_sort(selector_mode), get_mode_size_bits(selector_mode),
 646                         0, get_mode_arithmetic(selector_mode), get_mode_modulo_shift(selector_mode));
 647
 648         max_const = new_rd_Const(dbg, irg, block, unsigned_mode, new_tarval_from_long(maxval - minval + 1, unsigned_mode));
 649         max_const = gen_node_for_Const(env, dbg, irg, block, max_const);
 650         sltu = new_rd_mips_slt(dbg, irg, block, sub, max_const);
 651
 652         zero = gen_zero_node(env, dbg, irg, block);
 653         beq = new_rd_mips_beq(dbg, irg, block, sltu, zero, mode_T);
 654
 655         // attach defaultproj to beq now
 656         set_irn_n(defaultproj, 0, beq);
 657         set_Proj_proj(defaultproj, 1);
 658
 659         two_const = new_rd_Const(dbg, irg, block, unsigned_mode, new_tarval_from_long(2, unsigned_mode));
 660         two_const = gen_node_for_Const(env, dbg, irg, block, two_const);
 661         sl = new_rd_mips_sl(dbg, irg, block, sub, two_const);
 662
 663         la = new_rd_mips_la(dbg, irg, block);
 664         add = new_rd_mips_addu(dbg, irg, block, sl, la);
 665         load = new_rd_mips_load_r(dbg, irg, block, new_rd_NoMem(irg), add, mode_T);
 666         attr = get_mips_attr(load);
 667         attr->modes.load_store_mode = mode_Iu;
 668         attr->tv = new_tarval_from_long(0, mode_Iu);
 669
 670         proj = new_rd_Proj(dbg, irg, block, load, mode_Iu, pn_Load_res);
 671
 672         switchjmp = new_rd_mips_SwitchJump(dbg, irg, block, proj, mode_T);
 673         attr = get_mips_attr(switchjmp);
 674         attr->switch_default_pn = defaultprojn;
 675
 676         edge = get_irn_out_edge_first(defaultproj);
 677         defaultproj_succ = get_edge_src_irn(edge);
 678         attr->symconst_id = new_id_from_str(mips_get_block_label(defaultproj_succ));
 679
 680         attr = get_mips_attr(la);
 681         attr->symconst_id = new_id_from_str(mips_get_jumptbl_label(switchjmp));
 682
 683         return switchjmp;
 684 }
 685 #endif
 686
 687 static ir_node *gen_Cond(ir_node *node)
 688 {
 689         ir_graph *irg       = current_ir_graph;
 690         dbg_info *dbgi      = get_irn_dbg_info(node);
 691         ir_node  *block     = get_nodes_block(node);
 692         ir_node  *sel_proj  = get_Cond_selector(node);
 693         ir_node  *cmp       = get_Proj_pred(sel_proj);
 694         ir_node  *left      = get_Cmp_left(cmp);
 695         ir_node  *new_left  = be_transform_node(left);
 696         ir_node  *right     = get_Cmp_right(cmp);
 697         ir_node  *new_right = be_transform_node(right);
 698         long      pnc       = get_Proj_proj(sel_proj);
 699         ir_node  *res;
 700         ir_node  *slt;
 701         ir_node  *zero;
 702
 703         /* TODO: use blez & co. when possible */
 704
 705         switch(pnc) {
 706         case pn_Cmp_False:
 707         case pn_Cmp_True:
 708         case pn_Cmp_Leg:
 709                 panic("mips backend can't handle unoptimized constant Cond");
 710
 711         case pn_Cmp_Eq:
 712                 res = new_rd_mips_beq(dbgi, irg, block, new_left, new_right);
 713                 break;
 714
 715         case pn_Cmp_Lt:
 716                 zero = mips_create_zero();
 717                 slt  = new_rd_mips_slt(dbgi, irg, block, new_left, new_right);
 718                 res  = new_rd_mips_bne(dbgi, irg, block, slt, zero);
 719                 break;
 720
 721         case pn_Cmp_Le:
 722                 zero = mips_create_zero();
 723                 slt  = new_rd_mips_slt(dbgi, irg, block, new_right, new_left);
 724                 res  = new_rd_mips_beq(dbgi, irg, block, slt, zero);
 725                 break;
 726
 727         case pn_Cmp_Gt:
 728                 zero = mips_create_zero();
 729                 slt  = new_rd_mips_slt(dbgi, irg, block, new_right, new_left);
 730                 res  = new_rd_mips_bne(dbgi, irg, block, slt, zero);
 731                 break;
 732
 733         case pn_Cmp_Ge:
 734                 zero = mips_create_zero();
 735                 slt  = new_rd_mips_slt(dbgi, irg, block, new_right, new_left);
 736                 res  = new_rd_mips_bne(dbgi, irg, block, slt, zero);
 737                 break;
 738
 739         case pn_Cmp_Lg:
 740                 res = new_rd_mips_bne(dbgi, irg, block, new_left, new_right);
 741                 break;
 742
 743         default:
 744                 panic("mips backend doesn't handle unordered compares yet");
 745         }
 746
 747         return res;
 748 }
 749
 750 static ir_node *gen_Conv(ir_node *node)
 751 {
 752         ir_graph *irg      = current_ir_graph;
 753         dbg_info *dbgi     = get_irn_dbg_info(node);
 754         ir_node  *block    = be_transform_node(get_nodes_block(node));
 755         ir_node  *op       = get_Conv_op(node);
 756         ir_node  *new_op   = be_transform_node(op);
 757         ir_mode  *src_mode = get_irn_mode(op);
 758         ir_mode  *dst_mode = get_irn_mode(node);
 759         int       src_size = get_mode_size_bits(src_mode);
 760         int       dst_size = get_mode_size_bits(dst_mode);
 761         ir_node  *res;
 762
 763         assert(mode_needs_gp_reg(src_mode));
 764         assert(mode_needs_gp_reg(dst_mode));
 765
 766         /* we only need to do something on upconvs */
 767         if(src_size >= dst_size) {
 768                 /* unnecessary conv */
 769                 return new_op;
 770         }
 771
 772         if(mode_is_signed(src_mode)) {
 773                 if(src_size == 8) {
 774                         res = new_rd_mips_seb(dbgi, irg, block, new_op);
 775                 } else if(src_size == 16) {
 776                         res = new_rd_mips_seh(dbgi, irg, block, new_op);
 777                 } else {
 778                         panic("invalid conv %+F", node);
 779                 }
 780         } else {
 781                 ir_node *and_const;
 782
 783                 if(src_size == 8) {
 784                         and_const = mips_create_Immediate(0xff);
 785                 } else if(src_size == 16) {
 786                         and_const = mips_create_Immediate(0xffff);
 787                 } else {
 788                         panic("invalid conv %+F", node);
 789                 }
 790                 res = new_rd_mips_and(dbgi, irg, block, new_op, and_const);
 791         }
 792
 793         return res;
 794 }
 795
 796 static ir_node *create_div(ir_node *node, ir_node *left, ir_node *right,
 797                            ir_mode *mode)
 798 {
 799         ir_graph *irg       = current_ir_graph;
 800         dbg_info *dbgi      = get_irn_dbg_info(node);
 801         ir_node  *block     = be_transform_node(get_nodes_block(node));
 802         ir_node  *new_left  = be_transform_node(left);
 803         ir_node  *new_right = be_transform_node(right);
 804         ir_node  *res;
 805
 806         if(mode_is_signed(mode)) {
 807                 res = new_rd_mips_div(dbgi, irg, block, new_left, new_right);
 808         } else {
 809                 res = new_rd_mips_divu(dbgi, irg, block, new_left, new_right);
 810         }
 811
 812         set_irn_pinned(res, get_irn_pinned(node));
 813
 814         return res;
 815 }
 816
 817 static ir_node *gen_DivMod(ir_node *node)
 818 {
 819         return create_div(node, get_DivMod_left(node), get_DivMod_right(node),
 820                           get_DivMod_resmode(node));
 821 }
 822
 823 static ir_node *gen_Div(ir_node *node)
 824 {
 825         return create_div(node, get_Div_left(node), get_Div_right(node),
 826                           get_Div_resmode(node));
 827 }
 828
 829 static ir_node *gen_Mod(ir_node *node)
 830 {
 831         return create_div(node, get_Mod_left(node), get_Mod_right(node),
 832                           get_Mod_resmode(node));
 833 }
 834
 835 #if 0
 836 static ir_node *gen_node_for_Mul(mips_transform_env_t *env) {
 837         ir_node *node = env->irn;
 838         ir_node *mul;
 839         ir_node *mflo;
 840         ir_node *op1, *op2;
 841         ir_mode *mode = get_irn_mode(node);
 842
 843         op1 = get_Mul_left(node);
 844         op2 = get_Mul_right(node);
 845
 846         assert(get_mode_size_bits(env->mode) == 32);
 847         assert(get_mode_size_bits(get_irn_mode(op1)) == get_mode_size_bits(env->mode));
 848         assert(get_mode_size_bits(get_irn_mode(op2)) == get_mode_size_bits(env->mode));
 849
 850         if(mode_is_signed(mode)) {
 851                 mul = new_rd_mips_mult(env->dbg, env->irg, env->block, get_Mul_left(node), get_Mul_right(node));
 852         } else {
 853                 mul = new_rd_mips_multu(env->dbg, env->irg, env->block, get_Mul_left(node), get_Mul_right(node));
 854         }
 855         mflo = new_rd_mips_mflo(env->dbg, env->irg, env->block, mul);
 856
 857         return mflo;
 858 }
 859
 860 static
 861 ir_node *gen_node_for_IJmp(mips_transform_env_t *env) {
 862         ir_graph *irg    = env->irg;
 863         ir_node  *node   = env->irn;
 864         dbg_info *dbg    = get_irn_dbg_info(node);
 865         ir_node  *block  = get_nodes_block(node);
 866         ir_node  *target = get_IJmp_target(node);
 867
 868         return new_rd_mips_jr(dbg, irg, block, target);
 869 }
 870
 871 static
 872 ir_node *gen_node_for_Rot(mips_transform_env_t *env) {
 873         ir_node *node = env->irn;
 874         ir_node *subu, *srlv, *sllv, *or;
 875
 876         subu = new_rd_mips_subuzero(env->dbg, env->irg, env->block, get_Rot_right(node));
 877         srlv = new_rd_mips_srlv(env->dbg, env->irg, env->block, get_Rot_left(node), subu);
 878         sllv = new_rd_mips_sllv(env->dbg, env->irg, env->block, get_Rot_left(node), get_Rot_right(node));
 879         or = new_rd_mips_or(env->dbg, env->irg, env->block, sllv, srlv);
 880
 881         return or;
 882 }
 883 #endif
 884
 885 static ir_node *gen_Unknown(ir_node *node)
 886 {
 887         (void) node;
 888         assert(mode_needs_gp_reg(get_irn_mode(node)));
 889         return mips_create_zero();
 890 }
 891
 892 #if 0
 893 /*
 894  * lower a copyB into standard Firm assembler :-)
 895  */
 896 ir_node *gen_code_for_CopyB(ir_node *block, ir_node *node) {
 897         ir_node *cnt, *sub;
 898         ir_node *dst = get_CopyB_dst(node);
 899         ir_node *src = get_CopyB_src(node);
 900         ir_type *type = get_CopyB_type(node);
 901         ir_node *mem = get_CopyB_mem(node);
 902         ir_node *mm[4];
 903         ir_node *result = NULL;
 904         int size = get_type_size_bytes(type);
 905         dbg_info *dbg = get_irn_dbg_info(node);
 906         ir_graph *irg = get_irn_irg(block);
 907         mips_attr_t *attr;
 908         int i, n;
 909
 910         if (size > 16) {
 911                 ir_node     *phi, *projT, *projF, *cmp, *proj, *cond, *jmp, *in[2];
 912                 ir_node     *new_bl, *src_phi, *dst_phi, *mem_phi, *add;
 913                 ir_mode     *p_mode = get_irn_mode(src);
 914                 ir_node     *ld[4];
 915
 916                 /* build the control loop */
 917                 in[0] = in[1] = new_r_Unknown(irg, mode_X);
 918
 919                 new_bl = new_r_Block(irg, 2, in);
 920
 921                 in[0] = cnt = new_Const_long(mode_Is, (size >> 4));
 922         in[1] = new_r_Unknown(irg, mode_Is);
 923                 phi   = new_r_Phi(irg, new_bl, 2, in, mode_Is);
 924
 925                 sub = new_rd_Sub(dbg, irg, new_bl, phi, new_Const_long(mode_Is, -1), mode_Is);
 926                 set_Phi_pred(phi, 1, sub);
 927
 928                 cmp = new_rd_Cmp(dbg, irg, new_bl, sub, new_Const_long(mode_Is, 0));
 929                 proj = new_r_Proj(irg, new_bl, cmp, mode_b, pn_Cmp_Lg);
 930                 cond = new_rd_Cond(dbg, irg, new_bl, proj);
 931
 932                 projT = new_r_Proj(irg, new_bl, cond, mode_X, pn_Cond_true);
 933                 projF = new_r_Proj(irg, new_bl, cond, mode_X, pn_Cond_false);
 934
 935                 jmp = get_Block_cfgpred(block, 0);
 936                 set_Block_cfgpred(block, 0, projF);
 937
 938                 set_Block_cfgpred(new_bl, 0, jmp);
 939                 set_Block_cfgpred(new_bl, 1, projT);
 940
 941                 size &= 0xF;
 942
 943                 /* build the copy */
 944                 in[0]   = src;
 945         in[1]   = new_r_Unknown(irg, p_mode);
 946                 src_phi = new_r_Phi(irg, new_bl, 2, in, p_mode);
 947
 948                 in[0]   = dst;
 949                 dst_phi = new_r_Phi(irg, new_bl, 2, in, p_mode);
 950
 951                 add = new_rd_Add(dbg, irg, new_bl, src_phi, new_Const_long(mode_Is, 16), p_mode);
 952                 set_Phi_pred(src_phi, 1, add);
 953                 add = new_rd_Add(dbg, irg, new_bl, dst_phi, new_Const_long(mode_Is, 16), p_mode);
 954                 set_Phi_pred(dst_phi, 1, add);
 955
 956                 in[0]   = mem;
 957         in[1]   = new_r_Unknown(irg, mode_M);
 958                 mem_phi = new_r_Phi(irg, new_bl, 2, in, mode_M);
 959
 960                 src = src_phi;
 961                 dst = dst_phi;
 962
 963                 /* create 4 parallel loads */
 964                 for (i = 0; i < 4; ++i) {
 965                         ir_node *load;
 966
 967                         load = new_rd_mips_load_r(dbg, irg, new_bl, mem_phi, src, mode_T);
 968                         attr = get_mips_attr(load);
 969                         attr->modes.load_store_mode = mode_Iu;
 970                         attr->tv = new_tarval_from_long(i * 4, mode_Iu);
 971
 972                         ld[i] = new_rd_Proj(dbg, irg, new_bl, load, mode_Iu, pn_Load_res);
 973                 }
 974
 975                 /* create 4 parallel stores */
 976                 for (i = 0; i < 4; ++i) {
 977                         ir_node *store;
 978
 979                         store = new_rd_mips_store_r(dbg, irg, new_bl, mem_phi, dst, ld[i], mode_T);
 980                         attr = get_mips_attr(store);
 981                         attr->modes.load_store_mode = mode_Iu;
 982                         attr->tv = new_tarval_from_long(i * 4, mode_Iu);
 983
 984                         mm[i] = new_rd_Proj(dbg, irg, new_bl, store, mode_M, pn_Store_M);
 985                 }
 986                 mem = new_r_Sync(irg, new_bl, 4, mm);
 987                 result = mem;
 988                 set_Phi_pred(mem_phi, 1, mem);
 989         }
 990
 991         // output store/loads manually
 992         n = 0;
 993         for(i = size; i > 0; ) {
 994                 ir_mode *mode;
 995                 ir_node *load, *store, *projv;
 996                 int offset = size - i;
 997                 if(i >= 4) {
 998                         mode = mode_Iu;
 999                         i -= 4;
1000                 } else if(i >= 2) {
1001                         mode = mode_Hu;
1002                         i -= 2;
1003                 } else {
1004                         mode = mode_Bu;
1005                         i -= 1;
1006                 }
1007
1008                 load = new_rd_mips_load_r(dbg, irg, block, mem, src, mode_T);
1009                 attr = get_mips_attr(load);
1010                 attr->modes.load_store_mode = mode;
1011                 attr->tv = new_tarval_from_long(offset, mode_Iu);
1012
1013                 projv = new_rd_Proj(dbg, irg, block, load, mode, pn_Load_res);
1014
1015                 store = new_rd_mips_store_r(dbg, irg, block, mem, dst, projv, mode_T);
1016                 attr = get_mips_attr(store);
1017                 attr->modes.load_store_mode = mode;
1018                 attr->tv = new_tarval_from_long(offset, mode_Iu);
1019
1020                 mm[n] = new_rd_Proj(dbg, irg, block, store, mode_M, pn_Store_M);
1021                 n++;
1022         }
1023
1024         if(n > 0) {
1025                 result = new_r_Sync(irg, block, n, mm);
1026         } else if(n == 1) {
1027                 result = mm[0];
1028         }
1029
1030         return result;
1031 }
1032
1033 static void mips_fix_CopyB_Proj(mips_transform_env_t* env) {
1034         ir_node *node = env->irn;
1035         long n = get_Proj_proj(node);
1036
1037         if(n == pn_CopyB_M_except) {
1038                 assert(0);
1039         } else if(n == pn_CopyB_M_regular) {
1040                 set_Proj_proj(node, pn_Store_M);
1041         } else if(n == pn_CopyB_M_except) {
1042                 set_Proj_proj(node, pn_Store_X_except);
1043         }
1044 }
1045 #endif
1046
1047 static void mips_transform_Spill(mips_transform_env_t* env) {
1048         ir_node   *node = env->irn;
1049         ir_node   *sched_point = NULL;
1050         ir_node   *store;
1051         ir_node   *nomem = new_rd_NoMem(env->irg);
1052         ir_node   *ptr   = get_irn_n(node, 0);
1053         ir_node   *val   = get_irn_n(node, 1);
1054         ir_entity *ent   = be_get_frame_entity(node);
1055
1056         if(sched_is_scheduled(node)) {
1057                 sched_point = sched_prev(node);
1058         }
1059
1060         store = new_rd_mips_sw(env->dbg, env->irg, env->block, ptr, val, nomem,
1061                                ent, 0);
1062
1063         if (sched_point) {
1064                 sched_add_after(sched_point, store);
1065                 sched_remove(node);
1066         }
1067
1068         exchange(node, store);
1069 }
1070
1071 static void mips_transform_Reload(mips_transform_env_t* env) {
1072         ir_node   *node = env->irn;
1073         ir_node   *sched_point = NULL;
1074         ir_node   *load, *proj;
1075         ir_node   *ptr   = get_irn_n(node, 0);
1076         ir_node   *mem   = get_irn_n(node, 1);
1077         ir_entity *ent   = be_get_frame_entity(node);
1078         const arch_register_t* reg;
1079
1080         if(sched_is_scheduled(node)) {
1081                 sched_point = sched_prev(node);
1082         }
1083
1084         load = new_rd_mips_lw(env->dbg, env->irg, env->block, ptr, mem, ent, 0);
1085
1086         proj = new_rd_Proj(env->dbg, env->irg, env->block, load, mode_Iu, pn_mips_lw_res);
1087
1088         if (sched_point) {
1089                 sched_add_after(sched_point, load);
1090
1091                 sched_remove(node);
1092         }
1093
1094         /* copy the register from the old node to the new Load */
1095         reg = arch_get_irn_register(env->cg->arch_env, node);
1096         arch_set_irn_register(env->cg->arch_env, proj, reg);
1097
1098         exchange(node, proj);
1099 }
1100
1101 #if 0
1102 static ir_node *gen_AddSP(ir_node *node)
1103 {
1104         ir_node *node = env->irn;
1105         ir_node *op1, *op2;
1106         ir_node *add;
1107         const arch_register_t *reg;
1108
1109         op1 = get_irn_n(node, 0);
1110         op2 = get_irn_n(node, 1);
1111
1112         add = new_rd_mips_addu(env->dbg, env->irg, env->block, op1, op2);
1113
1114         /* copy the register requirements from the old node to the new node */
1115         reg = arch_get_irn_register(env->cg->arch_env, node);
1116         arch_set_irn_register(env->cg->arch_env, add, reg);
1117
1118         return add;
1119 }
1120 #endif
1121
1122 /*********************************************************
1123  *                  _             _      _
1124  *                 (_)           | |    (_)
1125  *  _ __ ___   __ _ _ _ __     __| |_ __ ___   _____ _ __
1126  * | '_ ` _ \ / _` | | '_ \   / _` | '__| \ \ / / _ \ '__|
1127  * | | | | | | (_| | | | | | | (_| | |  | |\ V /  __/ |
1128  * |_| |_| |_|\__,_|_|_| |_|  \__,_|_|  |_| \_/ \___|_|
1129  *
1130  *********************************************************/
1131
1132 static ir_node *gen_Bad(ir_node *node)
1133 {
1134         panic("Unexpected node %+F found in mips transform phase.", node);
1135         return NULL;
1136 }
1137
1138 static void register_transformers(void)
1139 {
1140         clear_irp_opcodes_generic_func();
1141
1142         op_Add->ops.generic      = (op_func) gen_Add;
1143         op_Sub->ops.generic      = (op_func) gen_Sub;
1144         op_And->ops.generic      = (op_func) gen_And;
1145         op_Or->ops.generic       = (op_func) gen_Or;
1146         op_Eor->ops.generic      = (op_func) gen_Eor;
1147         op_Shl->ops.generic      = (op_func) gen_Shl;
1148         op_Shr->ops.generic      = (op_func) gen_Shr;
1149         op_Shrs->ops.generic     = (op_func) gen_Shrs;
1150         op_Not->ops.generic      = (op_func) gen_Not;
1151         op_Minus->ops.generic    = (op_func) gen_Minus;
1152         op_Div->ops.generic      = (op_func) gen_Div;
1153         op_Mod->ops.generic      = (op_func) gen_Mod;
1154         op_DivMod->ops.generic   = (op_func) gen_DivMod;
1155         op_Abs->ops.generic      = (op_func) gen_Abs;
1156         op_Load->ops.generic     = (op_func) gen_Load;
1157         op_Store->ops.generic    = (op_func) gen_Store;
1158         op_Cond->ops.generic     = (op_func) gen_Cond;
1159         op_Conv->ops.generic     = (op_func) gen_Conv;
1160         op_Const->ops.generic    = (op_func) gen_Const;
1161         op_SymConst->ops.generic = (op_func) gen_SymConst;
1162         op_Unknown->ops.generic  = (op_func) gen_Unknown;
1163         op_Proj->ops.generic     = (op_func) gen_Proj;
1164         op_Phi->ops.generic      = (op_func) gen_Phi;
1165
1166         op_Raise->ops.generic     = (op_func) gen_Bad;
1167         op_Sel->ops.generic       = (op_func) gen_Bad;
1168         op_InstOf->ops.generic    = (op_func) gen_Bad;
1169         op_Cast->ops.generic      = (op_func) gen_Bad;
1170         op_Free->ops.generic      = (op_func) gen_Bad;
1171         op_Tuple->ops.generic     = (op_func) gen_Bad;
1172         op_Id->ops.generic        = (op_func) gen_Bad;
1173         op_Confirm->ops.generic   = (op_func) gen_Bad;
1174         op_Filter->ops.generic    = (op_func) gen_Bad;
1175         op_CallBegin->ops.generic = (op_func) gen_Bad;
1176         op_EndReg->ops.generic    = (op_func) gen_Bad;
1177         op_EndExcept->ops.generic = (op_func) gen_Bad;
1178 }
1179
1180 void mips_transform_graph(mips_code_gen_t *cg)
1181 {
1182         env_cg = cg;
1183         register_transformers();
1184         be_transform_graph(cg->birg, NULL, cg);
1185 }
1186
1187 /**
1188  * Calls the transform functions for Spill and Reload.
1189  */
1190 void mips_after_ra_walker(ir_node *node, void *env) {
1191         mips_code_gen_t *cg = env;
1192         mips_transform_env_t tenv;
1193
1194         if (is_Block(node))
1195                 return;
1196
1197         tenv.block = get_nodes_block(node);
1198         tenv.dbg   = get_irn_dbg_info(node);
1199         tenv.irg   = current_ir_graph;
1200         tenv.irn   = node;
1201         tenv.mode  = get_irn_mode(node);
1202         tenv.cg    = cg;
1203
1204         if (be_is_Reload(node)) {
1205                 mips_transform_Reload(&tenv);
1206         } else if (be_is_Spill(node)) {
1207                 mips_transform_Spill(&tenv);
1208         }
1209 }