nsz Git - libfirm/blob - ir/be/sparc/sparc_transform.c

   1 /*
   2  * Copyright (C) 1995-2010 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   code selection (transform FIRM into SPARC FIRM)
  23  * @version $Id$
  24  */
  25
  26 #include "config.h"
  27
  28 #include "irnode_t.h"
  29 #include "irgraph_t.h"
  30 #include "irmode_t.h"
  31 #include "irgmod.h"
  32 #include "iredges.h"
  33 #include "irvrfy.h"
  34 #include "ircons.h"
  35 #include "irprintf.h"
  36 #include "dbginfo.h"
  37 #include "iropt_t.h"
  38 #include "debug.h"
  39 #include "error.h"
  40
  41 #include "../benode.h"
  42 #include "../beirg.h"
  43 #include "../beutil.h"
  44 #include "../betranshlp.h"
  45 #include "bearch_sparc_t.h"
  46
  47 #include "sparc_nodes_attr.h"
  48 #include "sparc_transform.h"
  49 #include "sparc_new_nodes.h"
  50 #include "gen_sparc_new_nodes.h"
  51
  52 #include "gen_sparc_regalloc_if.h"
  53
  54 #include <limits.h>
  55
  56 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
  57
  58 static sparc_code_gen_t *env_cg;
  59
  60 static ir_node *gen_SymConst(ir_node *node);
  61
  62
  63 static inline int mode_needs_gp_reg(ir_mode *mode)
  64 {
  65         return mode_is_int(mode) || mode_is_reference(mode);
  66 }
  67
  68 /**
  69  * Create an And that will zero out upper bits.
  70  *
  71  * @param dbgi     debug info
  72  * @param block    the basic block
  73  * @param op       the original node
  74  * @param src_bits  number of lower bits that will remain
  75  */
  76 static ir_node *gen_zero_extension(dbg_info *dbgi, ir_node *block, ir_node *op,
  77                                    int src_bits)
  78 {
  79         if (src_bits == 8) {
  80                 return new_bd_sparc_And_imm(dbgi, block, op, 0xFF);
  81         } else if (src_bits == 16) {
  82                 ir_node *lshift = new_bd_sparc_Sll_imm(dbgi, block, op, 16);
  83                 ir_node *rshift = new_bd_sparc_Slr_imm(dbgi, block, lshift, 16);
  84                 return rshift;
  85         } else {
  86                 panic("zero extension only supported for 8 and 16 bits");
  87         }
  88 }
  89
  90 /**
  91  * Generate code for a sign extension.
  92  */
  93 static ir_node *gen_sign_extension(dbg_info *dbgi, ir_node *block, ir_node *op,
  94                                    int src_bits)
  95 {
  96         int shift_width = 32 - src_bits;
  97         ir_node *lshift_node = new_bd_sparc_Sll_imm(dbgi, block, op, shift_width);
  98         ir_node *rshift_node = new_bd_sparc_Sra_imm(dbgi, block, lshift_node, shift_width);
  99         return rshift_node;
 100 }
 101
 102 /**
 103  * returns true if it is assured, that the upper bits of a node are "clean"
 104  * which means for a 16 or 8 bit value, that the upper bits in the register
 105  * are 0 for unsigned and a copy of the last significant bit for signed
 106  * numbers.
 107  */
 108 static bool upper_bits_clean(ir_node *transformed_node, ir_mode *mode)
 109 {
 110         (void) transformed_node;
 111         (void) mode;
 112         /* TODO */
 113         return false;
 114 }
 115
 116 static ir_node *gen_extension(dbg_info *dbgi, ir_node *block, ir_node *op,
 117                               ir_mode *orig_mode)
 118 {
 119         int bits = get_mode_size_bits(orig_mode);
 120         if (bits == 32)
 121                 return op;
 122
 123         if (mode_is_signed(orig_mode)) {
 124                 return gen_sign_extension(dbgi, block, op, bits);
 125         } else {
 126                 return gen_zero_extension(dbgi, block, op, bits);
 127         }
 128 }
 129
 130
 131 /**
 132  * Creates a possible DAG for a constant.
 133  */
 134 static ir_node *create_const_graph_value(dbg_info *dbgi, ir_node *block,
 135                                 long value)
 136 {
 137         ir_node *result;
 138
 139         // we need to load hi & lo separately
 140         if (value < -4096 || value > 4095) {
 141                 ir_node *hi = new_bd_sparc_HiImm(dbgi, block, (int) value);
 142                 result = new_bd_sparc_LoImm(dbgi, block, hi, value);
 143                 be_dep_on_frame(hi);
 144         } else {
 145                 result = new_bd_sparc_Mov_imm(dbgi, block, (int) value);
 146                 be_dep_on_frame(result);
 147         }
 148
 149         return result;
 150 }
 151
 152
 153 /**
 154  * Create a DAG constructing a given Const.
 155  *
 156  * @param irn  a Firm const
 157  */
 158 static ir_node *create_const_graph(ir_node *irn, ir_node *block)
 159 {
 160         tarval  *tv = get_Const_tarval(irn);
 161         ir_mode *mode = get_tarval_mode(tv);
 162         dbg_info *dbgi = get_irn_dbg_info(irn);
 163         long value;
 164
 165
 166         if (mode_is_reference(mode)) {
 167                 /* SPARC V8 is 32bit, so we can safely convert a reference tarval into Iu */
 168                 assert(get_mode_size_bits(mode) == get_mode_size_bits(mode_Iu));
 169                 tv = tarval_convert_to(tv, mode_Iu);
 170         }
 171
 172         value = get_tarval_long(tv);
 173         return create_const_graph_value(dbgi, block, value);
 174 }
 175
 176 typedef enum {
 177         MATCH_NONE         = 0,
 178         MATCH_COMMUTATIVE  = 1 << 0,
 179         MATCH_SIZE_NEUTRAL = 1 << 1,
 180 } match_flags_t;
 181
 182 typedef ir_node* (*new_binop_reg_func) (dbg_info *dbgi, ir_node *block, ir_node *op1, ir_node *op2);
 183 typedef ir_node* (*new_binop_fp_func) (dbg_info *dbgi, ir_node *block, ir_node *op1, ir_node *op2, ir_mode *mode);
 184 typedef ir_node* (*new_binop_imm_func) (dbg_info *dbgi, ir_node *block, ir_node *op1, int simm13);
 185
 186 /**
 187  * checks if a node's value can be encoded as a immediate
 188  *
 189  */
 190 static bool is_imm_encodeable(const ir_node *node)
 191 {
 192         long val;
 193
 194         //assert(mode_is_float_vector(get_irn_mode(node)));
 195
 196         if (!is_Const(node))
 197                 return false;
 198
 199         val = get_tarval_long(get_Const_tarval(node));
 200
 201         return !(val < -4096 || val > 4095);
 202 }
 203
 204 /**
 205  * helper function for binop operations
 206  *
 207  * @param new_binop_reg_func register generation function ptr
 208  * @param new_binop_imm_func immediate generation function ptr
 209  */
 210 static ir_node *gen_helper_binop(ir_node *node, match_flags_t flags,
 211                                 new_binop_reg_func new_reg, new_binop_imm_func new_imm)
 212 {
 213         ir_node  *block   = be_transform_node(get_nodes_block(node));
 214         ir_node  *op1     = get_binop_left(node);
 215         ir_node  *new_op1;
 216         ir_node  *op2     = get_binop_right(node);
 217         ir_node  *new_op2;
 218         dbg_info *dbgi    = get_irn_dbg_info(node);
 219
 220         if (is_imm_encodeable(op2)) {
 221                 ir_node *new_op1 = be_transform_node(op1);
 222                 return new_imm(dbgi, block, new_op1, get_tarval_long(get_Const_tarval(op2)));
 223         }
 224
 225         new_op2 = be_transform_node(op2);
 226
 227         if ((flags & MATCH_COMMUTATIVE) && is_imm_encodeable(op1)) {
 228                 return new_imm(dbgi, block, new_op2, get_tarval_long(get_Const_tarval(op1)) );
 229         }
 230
 231         new_op1 = be_transform_node(op1);
 232
 233         return new_reg(dbgi, block, new_op1, new_op2);
 234 }
 235
 236 /**
 237  * helper function for FP binop operations
 238  */
 239 static ir_node *gen_helper_binfpop(ir_node *node, new_binop_fp_func new_reg)
 240 {
 241         ir_node  *block   = be_transform_node(get_nodes_block(node));
 242         ir_node  *op1     = get_binop_left(node);
 243         ir_node  *new_op1;
 244         ir_node  *op2     = get_binop_right(node);
 245         ir_node  *new_op2;
 246         dbg_info *dbgi    = get_irn_dbg_info(node);
 247
 248         new_op2 = be_transform_node(op2);
 249         new_op1 = be_transform_node(op1);
 250         return new_reg(dbgi, block, new_op1, new_op2, get_irn_mode(node));
 251 }
 252
 253 /**
 254  * Creates an sparc Add.
 255  *
 256  * @param node   FIRM node
 257  * @return the created sparc Add node
 258  */
 259 static ir_node *gen_Add(ir_node *node)
 260 {
 261         ir_mode  *mode    = get_irn_mode(node);
 262         ir_node  *block   = be_transform_node(get_nodes_block(node));
 263         dbg_info *dbgi    = get_irn_dbg_info(node);
 264
 265         (void) block;
 266         (void) dbgi;
 267
 268         if (mode_is_float(mode))
 269                 panic("FP not implemented yet");
 270
 271         return gen_helper_binop(node, MATCH_COMMUTATIVE | MATCH_SIZE_NEUTRAL, new_bd_sparc_Add_reg, new_bd_sparc_Add_imm);
 272 }
 273
 274
 275 /**
 276  * Creates an sparc Sub.
 277  *
 278  * @param node       FIRM node
 279  * @return the created sparc Sub node
 280  */
 281 static ir_node *gen_Sub(ir_node *node)
 282 {
 283         ir_mode  *mode    = get_irn_mode(node);
 284         ir_node  *block   = be_transform_node(get_nodes_block(node));
 285         dbg_info *dbgi    = get_irn_dbg_info(node);
 286
 287         (void) block;
 288         (void) dbgi;
 289
 290         if (mode_is_float(mode))
 291                 panic("FP not implemented yet");
 292
 293         return gen_helper_binop(node, MATCH_SIZE_NEUTRAL, new_bd_sparc_Sub_reg, new_bd_sparc_Sub_imm);
 294 }
 295
 296
 297 /**
 298  * Transforms a Load.
 299  *
 300  * @param node    the ir Load node
 301  * @return the created sparc Load node
 302  */
 303 static ir_node *gen_Load(ir_node *node)
 304 {
 305         ir_mode  *mode     = get_Load_mode(node);
 306         ir_node  *block    = be_transform_node(get_nodes_block(node));
 307         ir_node  *ptr      = get_Load_ptr(node);
 308         ir_node  *new_ptr  = be_transform_node(ptr);
 309         ir_node  *mem      = get_Load_mem(node);
 310         ir_node  *new_mem  = be_transform_node(mem);
 311         dbg_info *dbgi      = get_irn_dbg_info(node);
 312         ir_node  *new_load = NULL;
 313
 314         if (mode_is_float(mode))
 315                 panic("SPARC: no fp implementation yet");
 316
 317         new_load = new_bd_sparc_Ld(dbgi, block, new_ptr, new_mem, mode, NULL, 0, 0, false);
 318         set_irn_pinned(new_load, get_irn_pinned(node));
 319
 320         return new_load;
 321 }
 322
 323
 324
 325 /**
 326  * Transforms a Store.
 327  *
 328  * @param node    the ir Store node
 329  * @return the created sparc Store node
 330  */
 331 static ir_node *gen_Store(ir_node *node)
 332 {
 333         ir_node  *block    = be_transform_node(get_nodes_block(node));
 334         ir_node  *ptr      = get_Store_ptr(node);
 335         ir_node  *new_ptr  = be_transform_node(ptr);
 336         ir_node  *mem      = get_Store_mem(node);
 337         ir_node  *new_mem  = be_transform_node(mem);
 338         ir_node  *val      = get_Store_value(node);
 339         ir_node  *new_val  = be_transform_node(val);
 340         ir_mode  *mode     = get_irn_mode(val);
 341         dbg_info *dbgi     = get_irn_dbg_info(node);
 342         ir_node *new_store = NULL;
 343
 344         if (mode_is_float(mode))
 345                 panic("SPARC: no fp implementation yet");
 346
 347         new_store = new_bd_sparc_St(dbgi, block, new_ptr, new_val, new_mem, mode, NULL, 0, 0, false);
 348
 349         return new_store;
 350 }
 351
 352 /**
 353  * Creates an sparc Mul.
 354  * returns the lower 32bits of the 64bit multiply result
 355  *
 356  * @return the created sparc Mul node
 357  */
 358 static ir_node *gen_Mul(ir_node *node) {
 359         ir_mode  *mode    = get_irn_mode(node);
 360         dbg_info *dbgi     = get_irn_dbg_info(node);
 361
 362         ir_node *mul;
 363         ir_node *proj_res_low;
 364
 365         if (mode_is_float(mode)) {
 366                 mul = gen_helper_binfpop(node, new_bd_sparc_fMul);
 367                 return mul;
 368         }
 369
 370         assert(mode_is_data(mode));
 371         mul = gen_helper_binop(node, MATCH_COMMUTATIVE | MATCH_SIZE_NEUTRAL, new_bd_sparc_Mul_reg, new_bd_sparc_Mul_imm);
 372         arch_irn_add_flags(mul, arch_irn_flags_modify_flags);
 373
 374         proj_res_low = new_rd_Proj(dbgi, mul, mode_Iu, pn_sparc_Mul_low);
 375         return proj_res_low;
 376 }
 377
 378 /**
 379  * Creates an sparc Mulh.
 380  * Mulh returns the upper 32bits of a mul instruction
 381  *
 382  * @return the created sparc Mulh node
 383  */
 384 static ir_node *gen_Mulh(ir_node *node) {
 385         ir_mode  *mode    = get_irn_mode(node);
 386         dbg_info *dbgi     = get_irn_dbg_info(node);
 387
 388         ir_node *mul;
 389         ir_node *proj_res_hi;
 390
 391         if (mode_is_float(mode))
 392                 panic("FP not supported yet");
 393
 394
 395         assert(mode_is_data(mode));
 396         mul = gen_helper_binop(node, MATCH_COMMUTATIVE | MATCH_SIZE_NEUTRAL, new_bd_sparc_Mulh_reg, new_bd_sparc_Mulh_imm);
 397         //arch_irn_add_flags(mul, arch_irn_flags_modify_flags);
 398         proj_res_hi = new_rd_Proj(dbgi, mul, mode_Iu, pn_sparc_Mulh_low);
 399         return proj_res_hi;
 400 }
 401
 402 /**
 403  * Creates an sparc Div.
 404  *
 405  * @return the created sparc Div node
 406  */
 407 static ir_node *gen_Div(ir_node *node) {
 408
 409         ir_mode  *mode    = get_irn_mode(node);
 410
 411         ir_node *div;
 412
 413         if (mode_is_float(mode))
 414                 panic("FP not supported yet");
 415
 416         //assert(mode_is_data(mode));
 417         div = gen_helper_binop(node, MATCH_SIZE_NEUTRAL, new_bd_sparc_Div_reg, new_bd_sparc_Div_imm);
 418         return div;
 419 }
 420
 421
 422 /**
 423  * transform abs node:
 424  * mov a, b
 425  * sra b, 31, b
 426  * xor a, b
 427  * sub a, b
 428  *
 429  * @return
 430  */
 431 static ir_node *gen_Abs(ir_node *node) {
 432         ir_node  *block   = be_transform_node(get_nodes_block(node));
 433         ir_mode  *mode    = get_irn_mode(node);
 434         dbg_info *dbgi    = get_irn_dbg_info(node);
 435         ir_node   *op     = get_Abs_op(node);
 436
 437         ir_node *mov, *sra, *xor, *sub, *new_op;
 438
 439         if (mode_is_float(mode))
 440                 panic("FP not supported yet");
 441
 442         new_op = be_transform_node(op);
 443
 444         mov = new_bd_sparc_Mov_reg(dbgi, block, new_op);
 445         sra = new_bd_sparc_Sra_imm(dbgi, block, mov, 31);
 446         xor = new_bd_sparc_Xor_reg(dbgi, block, new_op, sra);
 447         sub = new_bd_sparc_Sub_reg(dbgi, block, sra, xor);
 448
 449         return sub;
 450 }
 451
 452 /**
 453  * Transforms a Not node.
 454  *
 455  * @return the created ARM Not node
 456  */
 457 static ir_node *gen_Not(ir_node *node)
 458 {
 459         ir_node  *block   = be_transform_node(get_nodes_block(node));
 460         ir_node  *op      = get_Not_op(node);
 461         ir_node  *new_op  = be_transform_node(op);
 462         dbg_info *dbgi    = get_irn_dbg_info(node);
 463
 464         return new_bd_sparc_Not(dbgi, block, new_op);
 465 }
 466
 467 static ir_node *gen_And(ir_node *node)
 468 {
 469         ir_mode  *mode    = get_irn_mode(node);
 470         ir_node  *block   = be_transform_node(get_nodes_block(node));
 471         dbg_info *dbgi    = get_irn_dbg_info(node);
 472
 473         (void) block;
 474         (void) dbgi;
 475
 476         if (mode_is_float(mode))
 477                 panic("FP not implemented yet");
 478
 479         return gen_helper_binop(node, MATCH_COMMUTATIVE, new_bd_sparc_And_reg, new_bd_sparc_And_imm);
 480 }
 481
 482 static ir_node *gen_Or(ir_node *node)
 483 {
 484         ir_mode  *mode    = get_irn_mode(node);
 485         ir_node  *block   = be_transform_node(get_nodes_block(node));
 486         dbg_info *dbgi    = get_irn_dbg_info(node);
 487
 488         (void) block;
 489         (void) dbgi;
 490
 491         if (mode_is_float(mode))
 492                 panic("FP not implemented yet");
 493
 494         return gen_helper_binop(node, MATCH_COMMUTATIVE, new_bd_sparc_Or_reg, new_bd_sparc_Or_imm);
 495 }
 496
 497 static ir_node *gen_Eor(ir_node *node)
 498 {
 499         ir_mode  *mode    = get_irn_mode(node);
 500         ir_node  *block   = be_transform_node(get_nodes_block(node));
 501         dbg_info *dbgi    = get_irn_dbg_info(node);
 502
 503         (void) block;
 504         (void) dbgi;
 505
 506         if (mode_is_float(mode))
 507                 panic("FP not implemented yet");
 508
 509         return gen_helper_binop(node, MATCH_COMMUTATIVE, new_bd_sparc_Xor_reg, new_bd_sparc_Xor_imm);
 510 }
 511
 512 static ir_node *gen_Shl(ir_node *node)
 513 {
 514         return gen_helper_binop(node, MATCH_SIZE_NEUTRAL, new_bd_sparc_Sll_reg, new_bd_sparc_Sll_imm);
 515 }
 516
 517 static ir_node *gen_Shr(ir_node *node)
 518 {
 519         return gen_helper_binop(node, MATCH_SIZE_NEUTRAL, new_bd_sparc_Slr_reg, new_bd_sparc_Slr_imm);
 520 }
 521
 522 static ir_node *gen_Shrs(ir_node *node)
 523 {
 524         return gen_helper_binop(node, MATCH_SIZE_NEUTRAL, new_bd_sparc_Sra_reg, new_bd_sparc_Sra_imm);
 525 }
 526
 527 /****** TRANSFORM GENERAL BACKEND NODES ********/
 528
 529 /**
 530  * Transforms a Minus node.
 531  *
 532  */
 533 static ir_node *gen_Minus(ir_node *node)
 534 {
 535         ir_node  *block   = be_transform_node(get_nodes_block(node));
 536         ir_node  *op      = get_Minus_op(node);
 537         ir_node  *new_op  = be_transform_node(op);
 538         dbg_info *dbgi    = get_irn_dbg_info(node);
 539         ir_mode  *mode    = get_irn_mode(node);
 540
 541         if (mode_is_float(mode)) {
 542                 panic("FP not implemented yet");
 543         }
 544
 545         assert(mode_is_data(mode));
 546         return new_bd_sparc_Minus(dbgi, block, new_op);
 547 }
 548
 549 static ir_node *make_addr(dbg_info *dbgi, ir_entity *entity)
 550 {
 551         ir_node *block = get_irg_start_block(current_ir_graph);
 552         ir_node *node  = new_bd_sparc_SymConst(dbgi, block, entity);
 553         be_dep_on_frame(node);
 554         return node;
 555 }
 556
 557 /**
 558  * Create an entity for a given (floatingpoint) tarval
 559  */
 560 static ir_entity *create_float_const_entity(tarval *tv)
 561 {
 562         ir_entity        *entity = (ir_entity*) pmap_get(env_cg->constants, tv);
 563         ir_initializer_t *initializer;
 564         ir_mode          *mode;
 565         ir_type          *type;
 566         ir_type          *glob;
 567
 568         if (entity != NULL)
 569                 return entity;
 570
 571         mode   = get_tarval_mode(tv);
 572         type   = get_type_for_mode(mode);
 573         glob   = get_glob_type();
 574         entity = new_entity(glob, id_unique("C%u"), type);
 575         set_entity_visibility(entity, ir_visibility_private);
 576         add_entity_linkage(entity, IR_LINKAGE_CONSTANT);
 577
 578         initializer = create_initializer_tarval(tv);
 579         set_entity_initializer(entity, initializer);
 580
 581         pmap_insert(env_cg->constants, tv, entity);
 582         return entity;
 583 }
 584
 585 /**
 586  * Transforms a Const node.
 587  *
 588  * @param node    the ir Const node
 589  * @return The transformed sparc node.
 590  */
 591 static ir_node *gen_Const(ir_node *node)
 592 {
 593         ir_node *block = be_transform_node(get_nodes_block(node));
 594         ir_mode *mode  = get_irn_mode(node);
 595
 596         if (mode_is_float(mode)) {
 597                 dbg_info  *dbgi   = get_irn_dbg_info(node);
 598                 tarval    *tv     = get_Const_tarval(node);
 599                 ir_entity *entity = create_float_const_entity(tv);
 600                 ir_node   *addr   = make_addr(dbgi, entity);
 601                 ir_node   *mem    = new_NoMem();
 602                 ir_node   *new_op
 603                         = new_bd_sparc_Ldf(dbgi, block, addr, mem, mode, NULL, 0, 0, false);
 604
 605                 ir_node   *proj   = new_Proj(new_op, mode, pn_sparc_Ldf_res);
 606                 return proj;
 607         }
 608
 609         return create_const_graph(node, block);
 610 }
 611
 612 /**
 613  * AddSP
 614  * @param node the ir AddSP node
 615  * @return transformed sparc SAVE node
 616  */
 617 static ir_node *gen_be_AddSP(ir_node *node)
 618 {
 619         ir_node  *block  = be_transform_node(get_nodes_block(node));
 620         ir_node  *sz     = get_irn_n(node, be_pos_AddSP_size);
 621         ir_node  *new_sz = be_transform_node(sz);
 622         ir_node  *sp     = get_irn_n(node, be_pos_AddSP_old_sp);
 623         ir_node  *new_sp = be_transform_node(sp);
 624         dbg_info *dbgi   = get_irn_dbg_info(node);
 625         ir_node  *nomem  = new_NoMem();
 626         ir_node  *new_op;
 627
 628         /* SPARC stack grows in reverse direction */
 629         new_op = new_bd_sparc_SubSP(dbgi, block, new_sp, new_sz, nomem);
 630
 631         return new_op;
 632 }
 633
 634
 635 /**
 636  * SubSP
 637  * @param node the ir SubSP node
 638  * @return transformed sparc SAVE node
 639  */
 640 static ir_node *gen_be_SubSP(ir_node *node)
 641 {
 642         ir_node  *block  = be_transform_node(get_nodes_block(node));
 643         ir_node  *sz     = get_irn_n(node, be_pos_SubSP_size);
 644         ir_node  *new_sz = be_transform_node(sz);
 645         ir_node  *sp     = get_irn_n(node, be_pos_SubSP_old_sp);
 646         ir_node  *new_sp = be_transform_node(sp);
 647         dbg_info *dbgi   = get_irn_dbg_info(node);
 648         ir_node  *nomem  = new_NoMem();
 649         ir_node  *new_op;
 650
 651         /* SPARC stack grows in reverse direction */
 652         new_op = new_bd_sparc_AddSP(dbgi, block, new_sp, new_sz, nomem);
 653         return new_op;
 654 }
 655
 656 /**
 657  * transform FrameAddr
 658  */
 659 static ir_node *gen_be_FrameAddr(ir_node *node)
 660 {
 661         ir_node   *block  = be_transform_node(get_nodes_block(node));
 662         ir_entity *ent    = be_get_frame_entity(node);
 663         ir_node   *fp     = be_get_FrameAddr_frame(node);
 664         ir_node   *new_fp = be_transform_node(fp);
 665         dbg_info  *dbgi   = get_irn_dbg_info(node);
 666         ir_node   *new_node;
 667         new_node = new_bd_sparc_FrameAddr(dbgi, block, new_fp, ent);
 668         return new_node;
 669 }
 670
 671 /**
 672  * Transform a be_Copy.
 673  */
 674 static ir_node *gen_be_Copy(ir_node *node)
 675 {
 676         ir_node *result = be_duplicate_node(node);
 677         ir_mode *mode   = get_irn_mode(result);
 678
 679         if (mode_needs_gp_reg(mode)) {
 680                 set_irn_mode(node, mode_Iu);
 681         }
 682
 683         return result;
 684 }
 685
 686 /**
 687  * Transform a Call
 688  */
 689 static ir_node *gen_be_Call(ir_node *node)
 690 {
 691         ir_node *res = be_duplicate_node(node);
 692         arch_irn_add_flags(res, arch_irn_flags_modify_flags);
 693         return res;
 694 }
 695
 696 /**
 697  * Transforms a Switch.
 698  *
 699  */
 700 static ir_node *gen_SwitchJmp(ir_node *node)
 701 {
 702         ir_node  *block    = be_transform_node(get_nodes_block(node));
 703         ir_node  *selector = get_Cond_selector(node);
 704         dbg_info *dbgi     = get_irn_dbg_info(node);
 705         ir_node *new_op = be_transform_node(selector);
 706         ir_node *const_graph;
 707         ir_node *sub;
 708
 709         ir_node *proj;
 710         const ir_edge_t *edge;
 711         int min = INT_MAX;
 712         int max = INT_MIN;
 713         int translation;
 714         int pn;
 715         int n_projs;
 716
 717         foreach_out_edge(node, edge) {
 718                 proj = get_edge_src_irn(edge);
 719                 assert(is_Proj(proj) && "Only proj allowed at SwitchJmp");
 720
 721                 pn = get_Proj_proj(proj);
 722
 723                 min = pn<min ? pn : min;
 724                 max = pn>max ? pn : max;
 725         }
 726
 727         translation = min;
 728         n_projs = max - translation + 1;
 729
 730         foreach_out_edge(node, edge) {
 731                 proj = get_edge_src_irn(edge);
 732                 assert(is_Proj(proj) && "Only proj allowed at SwitchJmp");
 733
 734                 pn = get_Proj_proj(proj) - translation;
 735                 set_Proj_proj(proj, pn);
 736         }
 737
 738         const_graph = create_const_graph_value(dbgi, block, translation);
 739         sub = new_bd_sparc_Sub_reg(dbgi, block, new_op, const_graph);
 740         return new_bd_sparc_SwitchJmp(dbgi, block, sub, n_projs, get_Cond_default_proj(node) - translation);
 741 }
 742
 743 static bool is_cmp_unsigned(ir_node *b_value)
 744 {
 745         ir_node *pred;
 746         ir_node *op;
 747
 748         if (!is_Proj(b_value))
 749                 panic("can't determine cond signednes");
 750         pred = get_Proj_pred(b_value);
 751         if (!is_Cmp(pred))
 752                 panic("can't determine cond signednes (no cmp)");
 753         op = get_Cmp_left(pred);
 754         return !mode_is_signed(get_irn_mode(op));
 755 }
 756
 757 /**
 758  * Transform Cond nodes
 759  */
 760 static ir_node *gen_Cond(ir_node *node)
 761 {
 762         ir_node  *selector = get_Cond_selector(node);
 763         ir_mode  *mode     = get_irn_mode(selector);
 764         ir_node  *block;
 765         ir_node  *flag_node;
 766         bool      is_unsigned;
 767         pn_Cmp    pnc;
 768         dbg_info *dbgi;
 769
 770         // switch/case jumps
 771         if (mode != mode_b) {
 772                 return gen_SwitchJmp(node);
 773         }
 774
 775         // regular if/else jumps
 776         assert(is_Proj(selector));
 777         assert(is_Cmp(get_Proj_pred(selector)));
 778
 779         block       = be_transform_node(get_nodes_block(node));
 780         dbgi        = get_irn_dbg_info(node);
 781         flag_node   = be_transform_node(get_Proj_pred(selector));
 782         pnc         = get_Proj_proj(selector);
 783         is_unsigned = is_cmp_unsigned(selector);
 784         return new_bd_sparc_BXX(dbgi, block, flag_node, pnc, is_unsigned);
 785 }
 786
 787 /**
 788  * transform Cmp
 789  */
 790 static ir_node *gen_Cmp(ir_node *node)
 791 {
 792         ir_node  *block    = be_transform_node(get_nodes_block(node));
 793         ir_node  *op1      = get_Cmp_left(node);
 794         ir_node  *op2      = get_Cmp_right(node);
 795         ir_mode  *cmp_mode = get_irn_mode(op1);
 796         dbg_info *dbgi     = get_irn_dbg_info(node);
 797         ir_node  *new_op1;
 798         ir_node  *new_op2;
 799
 800         if (mode_is_float(cmp_mode)) {
 801                 panic("FloatCmp not implemented");
 802         }
 803
 804         /*
 805         if (get_mode_size_bits(cmp_mode) != 32) {
 806                 panic("CmpMode != 32bit not supported yet");
 807         }
 808         */
 809
 810         assert(get_irn_mode(op2) == cmp_mode);
 811
 812         /* compare with 0 can be done with Tst */
 813         /*
 814         if (is_Const(op2) && tarval_is_null(get_Const_tarval(op2))) {
 815                 new_op1 = be_transform_node(op1);
 816                 return new_bd_sparc_Tst(dbgi, block, new_op1, false,
 817                                           is_unsigned);
 818         }
 819
 820         if (is_Const(op1) && tarval_is_null(get_Const_tarval(op1))) {
 821                 new_op2 = be_transform_node(op2);
 822                 return new_bd_sparc_Tst(dbgi, block, new_op2, true,
 823                                           is_unsigned);
 824         }
 825         */
 826
 827         /* integer compare */
 828         new_op1 = be_transform_node(op1);
 829         new_op1 = gen_extension(dbgi, block, new_op1, cmp_mode);
 830         new_op2 = be_transform_node(op2);
 831         new_op2 = gen_extension(dbgi, block, new_op2, cmp_mode);
 832         return new_bd_sparc_Cmp_reg(dbgi, block, new_op1, new_op2);
 833 }
 834
 835 /**
 836  * Transforms a SymConst node.
 837  */
 838 static ir_node *gen_SymConst(ir_node *node)
 839 {
 840         ir_entity *entity = get_SymConst_entity(node);
 841         dbg_info  *dbgi   = get_irn_dbg_info(node);
 842
 843         return make_addr(dbgi, entity);
 844 }
 845
 846 /**
 847  * Transforms a Conv node.
 848  *
 849  */
 850 static ir_node *gen_Conv(ir_node *node)
 851 {
 852         ir_node  *block    = be_transform_node(get_nodes_block(node));
 853         ir_node  *op       = get_Conv_op(node);
 854         ir_node  *new_op   = be_transform_node(op);
 855         ir_mode  *src_mode = get_irn_mode(op);
 856         ir_mode  *dst_mode = get_irn_mode(node);
 857         dbg_info *dbg      = get_irn_dbg_info(node);
 858
 859         int src_bits = get_mode_size_bits(src_mode);
 860         int dst_bits = get_mode_size_bits(dst_mode);
 861
 862         if (src_mode == dst_mode)
 863                 return new_op;
 864
 865         if (mode_is_float(src_mode) || mode_is_float(dst_mode)) {
 866                 assert((src_bits <= 64 && dst_bits <= 64) && "quad FP not implemented");
 867
 868                 if (mode_is_float(src_mode)) {
 869                         if (mode_is_float(dst_mode)) {
 870                                 // float -> float conv
 871                                 if (src_bits > dst_bits) {
 872                                         return new_bd_sparc_FsTOd(dbg, block, new_op, dst_mode);
 873                                 } else {
 874                                         return new_bd_sparc_FdTOs(dbg, block, new_op, dst_mode);
 875                                 }
 876                         } else {
 877                                 // float -> int conv
 878                                 switch (dst_bits) {
 879                                         case 32:
 880                                                 return new_bd_sparc_FsTOi(dbg, block, new_op, dst_mode);
 881                                         case 64:
 882                                                 return new_bd_sparc_FdTOi(dbg, block, new_op, dst_mode);
 883                                         default:
 884                                                 panic("quad FP not implemented");
 885                                 }
 886                         }
 887                 } else {
 888                         // int -> float conv
 889                         switch (dst_bits) {
 890                                 case 32:
 891                                         return new_bd_sparc_FiTOs(dbg, block, new_op, src_mode);
 892                                 case 64:
 893                                         return new_bd_sparc_FiTOd(dbg, block, new_op, src_mode);
 894                                 default:
 895                                         panic("quad FP not implemented");
 896                         }
 897                 }
 898         } else { /* complete in gp registers */
 899                 int min_bits;
 900                 ir_mode *min_mode;
 901
 902                 if (src_bits == dst_bits) {
 903                         /* kill unneccessary conv */
 904                         return new_op;
 905                 }
 906
 907                 if (src_bits < dst_bits) {
 908                         min_bits = src_bits;
 909                         min_mode = src_mode;
 910                 } else {
 911                         min_bits = dst_bits;
 912                         min_mode = dst_mode;
 913                 }
 914
 915                 if (upper_bits_clean(new_op, min_mode)) {
 916                         return new_op;
 917                 }
 918
 919                 if (mode_is_signed(min_mode)) {
 920                         return gen_sign_extension(dbg, block, new_op, min_bits);
 921                 } else {
 922                         return gen_zero_extension(dbg, block, new_op, min_bits);
 923                 }
 924         }
 925 }
 926
 927 static ir_node *gen_Unknown(ir_node *node)
 928 {
 929         ir_node  *block     = get_nodes_block(node);
 930         ir_node  *new_block = be_transform_node(block);
 931         dbg_info *dbgi      = get_irn_dbg_info(node);
 932
 933         /* just produce a 0 */
 934         ir_mode *mode = get_irn_mode(node);
 935         if (mode_is_float(mode)) {
 936                 panic("FP not implemented");
 937                 be_dep_on_frame(node);
 938                 return node;
 939         } else if (mode_needs_gp_reg(mode)) {
 940                 return create_const_graph_value(dbgi, new_block, 0);
 941         }
 942
 943         panic("Unexpected Unknown mode");
 944 }
 945
 946 /**
 947  * Transform some Phi nodes
 948  */
 949 static ir_node *gen_Phi(ir_node *node)
 950 {
 951         const arch_register_req_t *req;
 952         ir_node  *block = be_transform_node(get_nodes_block(node));
 953         ir_graph *irg   = current_ir_graph;
 954         dbg_info *dbgi  = get_irn_dbg_info(node);
 955         ir_mode  *mode  = get_irn_mode(node);
 956         ir_node  *phi;
 957
 958         if (mode_needs_gp_reg(mode)) {
 959                 /* we shouldn't have any 64bit stuff around anymore */
 960                 assert(get_mode_size_bits(mode) <= 32);
 961                 /* all integer operations are on 32bit registers now */
 962                 mode = mode_Iu;
 963                 req  = sparc_reg_classes[CLASS_sparc_gp].class_req;
 964         } else {
 965                 req = arch_no_register_req;
 966         }
 967
 968         /* phi nodes allow loops, so we use the old arguments for now
 969          * and fix this later */
 970         phi = new_ir_node(dbgi, irg, block, op_Phi, mode, get_irn_arity(node), get_irn_in(node) + 1);
 971         copy_node_attr(irg, node, phi);
 972         be_duplicate_deps(node, phi);
 973         arch_set_out_register_req(phi, 0, req);
 974         be_enqueue_preds(node);
 975         return phi;
 976 }
 977
 978
 979 /**
 980  * Transform a Proj from a Load.
 981  */
 982 static ir_node *gen_Proj_Load(ir_node *node)
 983 {
 984         ir_node  *load     = get_Proj_pred(node);
 985         ir_node  *new_load = be_transform_node(load);
 986         dbg_info *dbgi     = get_irn_dbg_info(node);
 987         long     proj      = get_Proj_proj(node);
 988
 989         /* renumber the proj */
 990         switch (get_sparc_irn_opcode(new_load)) {
 991                 case iro_sparc_Ld:
 992                         /* handle all gp loads equal: they have the same proj numbers. */
 993                         if (proj == pn_Load_res) {
 994                                 return new_rd_Proj(dbgi, new_load, mode_Iu, pn_sparc_Ld_res);
 995                         } else if (proj == pn_Load_M) {
 996                                 return new_rd_Proj(dbgi, new_load, mode_M, pn_sparc_Ld_M);
 997                         }
 998                         break;
 999                 default:
1000                         panic("Unsupported Proj from Load");
1001         }
1002
1003         return be_duplicate_node(node);
1004 }
1005
1006 /**
1007  * Transform the Projs of a be_AddSP.
1008  */
1009 static ir_node *gen_Proj_be_AddSP(ir_node *node)
1010 {
1011         ir_node  *pred     = get_Proj_pred(node);
1012         ir_node  *new_pred = be_transform_node(pred);
1013         dbg_info *dbgi     = get_irn_dbg_info(node);
1014         long     proj      = get_Proj_proj(node);
1015
1016         if (proj == pn_be_AddSP_sp) {
1017                 ir_node *res = new_rd_Proj(dbgi, new_pred, mode_Iu,
1018                                            pn_sparc_SubSP_stack);
1019                 arch_set_irn_register(res, &sparc_gp_regs[REG_SP]);
1020                 return res;
1021         } else if (proj == pn_be_AddSP_res) {
1022                 return new_rd_Proj(dbgi, new_pred, mode_Iu, pn_sparc_SubSP_stack);
1023         } else if (proj == pn_be_AddSP_M) {
1024                 return new_rd_Proj(dbgi, new_pred, mode_M, pn_sparc_SubSP_M);
1025         }
1026
1027         panic("Unsupported Proj from AddSP");
1028 }
1029
1030 /**
1031  * Transform the Projs of a be_SubSP.
1032  */
1033 static ir_node *gen_Proj_be_SubSP(ir_node *node)
1034 {
1035         ir_node  *pred     = get_Proj_pred(node);
1036         ir_node  *new_pred = be_transform_node(pred);
1037         dbg_info *dbgi     = get_irn_dbg_info(node);
1038         long     proj      = get_Proj_proj(node);
1039
1040         if (proj == pn_be_SubSP_sp) {
1041                 ir_node *res = new_rd_Proj(dbgi, new_pred, mode_Iu,
1042                                            pn_sparc_AddSP_stack);
1043                 arch_set_irn_register(res, &sparc_gp_regs[REG_SP]);
1044                 return res;
1045         } else if (proj == pn_be_SubSP_M) {
1046                 return new_rd_Proj(dbgi,  new_pred, mode_M, pn_sparc_AddSP_M);
1047         }
1048
1049         panic("Unsupported Proj from SubSP");
1050 }
1051
1052 /**
1053  * Transform the Projs from a Cmp.
1054  */
1055 static ir_node *gen_Proj_Cmp(ir_node *node)
1056 {
1057         (void) node;
1058         panic("not implemented");
1059 }
1060
1061 /**
1062  * transform Projs from a Div
1063  */
1064 static ir_node *gen_Proj_Div(ir_node *node)
1065 {
1066         ir_node  *pred     = get_Proj_pred(node);
1067         ir_node  *new_pred = be_transform_node(pred);
1068         dbg_info *dbgi     = get_irn_dbg_info(node);
1069         long     proj      = get_Proj_proj(node);
1070
1071         switch (proj) {
1072         case pn_Div_res:
1073                 if (is_sparc_Div(new_pred)) {
1074                         return new_rd_Proj(dbgi, new_pred, mode_Iu, pn_sparc_Div_res);
1075                 }
1076                 break;
1077         default:
1078                 break;
1079         }
1080         panic("Unsupported Proj from Div");
1081 }
1082
1083
1084 /**
1085  * Transform a Proj node.
1086  */
1087 static ir_node *gen_Proj(ir_node *node)
1088 {
1089         ir_graph *irg  = current_ir_graph;
1090         dbg_info *dbgi = get_irn_dbg_info(node);
1091         ir_node  *pred = get_Proj_pred(node);
1092         long     proj  = get_Proj_proj(node);
1093
1094         (void) irg;
1095         (void) dbgi;
1096
1097         if (is_Store(pred)) {
1098                 if (proj == pn_Store_M) {
1099                         return be_transform_node(pred);
1100                 } else {
1101                         panic("Unsupported Proj from Store");
1102                 }
1103         } else if (is_Load(pred)) {
1104                 return gen_Proj_Load(node);
1105         } else if (be_is_SubSP(pred)) {
1106                 //panic("gen_Proj not implemented for SubSP");
1107                 return gen_Proj_be_SubSP(node);
1108         } else if (be_is_AddSP(pred)) {
1109                 //panic("gen_Proj not implemented for AddSP");
1110                 return gen_Proj_be_AddSP(node);
1111         } else if (is_Cmp(pred)) {
1112                 //panic("gen_Proj not implemented for Cmp");
1113                 return gen_Proj_Cmp(node);
1114         } else if (is_Div(pred)) {
1115                 return gen_Proj_Div(node);
1116         } else if (is_Start(pred)) {
1117         /*
1118                 if (proj == pn_Start_X_initial_exec) {
1119                         ir_node *block = get_nodes_block(pred);
1120                         ir_node *jump;
1121
1122                         // we exchange the ProjX with a jump
1123                         block = be_transform_node(block);
1124                         jump  = new_rd_Jmp(dbgi, block);
1125                         return jump;
1126                 }
1127
1128                 if (node == get_irg_anchor(irg, anchor_tls)) {
1129                         return gen_Proj_tls(node);
1130                 }
1131         */
1132         } else {
1133                 ir_node *new_pred = be_transform_node(pred);
1134                 ir_mode *mode     = get_irn_mode(node);
1135                 if (mode_needs_gp_reg(mode)) {
1136                         ir_node *new_proj = new_r_Proj(new_pred, mode_Iu, get_Proj_proj(node));
1137                         new_proj->node_nr = node->node_nr;
1138                         return new_proj;
1139                 }
1140         }
1141
1142         return be_duplicate_node(node);
1143 }
1144
1145
1146 /**
1147  * transform a Jmp
1148  */
1149 static ir_node *gen_Jmp(ir_node *node)
1150 {
1151         ir_node  *block     = get_nodes_block(node);
1152         ir_node  *new_block = be_transform_node(block);
1153         dbg_info *dbgi      = get_irn_dbg_info(node);
1154
1155         return new_bd_sparc_Ba(dbgi, new_block);
1156 }
1157
1158 /**
1159  * configure transformation callbacks
1160  */
1161 void sparc_register_transformers(void)
1162 {
1163         be_start_transform_setup();
1164
1165         be_set_transform_function(op_Abs,          gen_Abs);
1166         be_set_transform_function(op_Add,          gen_Add);
1167         be_set_transform_function(op_And,          gen_And);
1168         be_set_transform_function(op_be_AddSP,     gen_be_AddSP);
1169         be_set_transform_function(op_be_Call,      gen_be_Call);
1170         be_set_transform_function(op_be_Copy,      gen_be_Copy);
1171         be_set_transform_function(op_be_FrameAddr, gen_be_FrameAddr);
1172         be_set_transform_function(op_be_SubSP,     gen_be_SubSP);
1173         be_set_transform_function(op_Cmp,          gen_Cmp);
1174         be_set_transform_function(op_Cond,         gen_Cond);
1175         be_set_transform_function(op_Const,        gen_Const);
1176         be_set_transform_function(op_Conv,         gen_Conv);
1177         be_set_transform_function(op_Div,          gen_Div);
1178         be_set_transform_function(op_Eor,          gen_Eor);
1179         be_set_transform_function(op_Jmp,          gen_Jmp);
1180         be_set_transform_function(op_Load,         gen_Load);
1181         be_set_transform_function(op_Minus,        gen_Minus);
1182         be_set_transform_function(op_Mul,          gen_Mul);
1183         be_set_transform_function(op_Mulh,         gen_Mulh);
1184         be_set_transform_function(op_Not,          gen_Not);
1185         be_set_transform_function(op_Or,           gen_Or);
1186         be_set_transform_function(op_Phi,          gen_Phi);
1187         be_set_transform_function(op_Proj,         gen_Proj);
1188         be_set_transform_function(op_Shl,          gen_Shl);
1189         be_set_transform_function(op_Shr,          gen_Shr);
1190         be_set_transform_function(op_Shrs,         gen_Shrs);
1191         be_set_transform_function(op_Store,        gen_Store);
1192         be_set_transform_function(op_Sub,          gen_Sub);
1193         be_set_transform_function(op_SymConst,     gen_SymConst);
1194         be_set_transform_function(op_Unknown,      gen_Unknown);
1195
1196         be_set_transform_function(op_sparc_Save,   be_duplicate_node);
1197 }
1198
1199 /**
1200  * Transform a Firm graph into a SPARC graph.
1201  */
1202 void sparc_transform_graph(sparc_code_gen_t *cg)
1203 {
1204         sparc_register_transformers();
1205         env_cg = cg;
1206         be_transform_graph(cg->irg, NULL);
1207 }
1208
1209 void sparc_init_transform(void)
1210 {
1211         FIRM_DBG_REGISTER(dbg, "firm.be.sparc.transform");
1212 }