nsz Git - libfirm/blob - ir/be/arm/arm_transform.c

   1 /* The codegenerator (transform FIRM into arm FIRM */
   2 /* $Id$ */
   3
   4 #ifdef HAVE_CONFIG_H
   5 #include "config.h"
   6 #endif
   7
   8 #include "irnode_t.h"
   9 #include "irgraph_t.h"
  10 #include "irmode_t.h"
  11 #include "irgmod.h"
  12 #include "iredges.h"
  13 #include "irvrfy.h"
  14 #include "ircons.h"
  15 #include "irprintf.h"
  16 #include "dbginfo.h"
  17 #include "iropt_t.h"
  18 #include "debug.h"
  19
  20 #include "../benode_t.h"
  21 #include "bearch_arm_t.h"
  22
  23 #include "arm_nodes_attr.h"
  24 #include "../arch/archop.h"     /* we need this for Min and Max nodes */
  25 #include "arm_transform.h"
  26 #include "arm_new_nodes.h"
  27 #include "arm_map_regs.h"
  28
  29 #include "gen_arm_regalloc_if.h"
  30
  31 #include <limits.h>
  32
  33
  34 extern ir_op *get_op_Mulh(void);
  35
  36
  37
  38 /****************************************************************************************************
  39  *                  _        _                        __                           _   _
  40  *                 | |      | |                      / _|                         | | (_)
  41  *  _ __   ___   __| | ___  | |_ _ __ __ _ _ __  ___| |_ ___  _ __ _ __ ___   __ _| |_ _  ___  _ __
  42  * | '_ \ / _ \ / _` |/ _ \ | __| '__/ _` | '_ \/ __|  _/ _ \| '__| '_ ` _ \ / _` | __| |/ _ \| '_ \
  43  * | | | | (_) | (_| |  __/ | |_| | | (_| | | | \__ \ || (_) | |  | | | | | | (_| | |_| | (_) | | | |
  44  * |_| |_|\___/ \__,_|\___|  \__|_|  \__,_|_| |_|___/_| \___/|_|  |_| |_| |_|\__,_|\__|_|\___/|_| |_|
  45  *
  46  ****************************************************************************************************/
  47
  48 typedef struct vals_ {
  49         int ops;
  50         unsigned char values[4];
  51         unsigned char shifts[4];
  52 } vals;
  53
  54 /** Execute ROL. */
  55 static unsigned do_rol(unsigned v, unsigned rol) {
  56         return (v << rol) | (v >> (32 - rol));
  57 }
  58
  59 /**
  60  * construct 8bit values und rot amounts for a value
  61  */
  62 static void gen_vals_from_word(unsigned int value, vals *result)
  63 {
  64         int initial = 0;
  65
  66         memset(result, 0, sizeof(*result));
  67
  68         /* special case: we prefer shift amount 0 */
  69         if (value < 0x100) {
  70                 result->values[0] = value;
  71                 result->ops       = 1;
  72                 return;
  73         }
  74
  75         while (value != 0) {
  76                 if (value & 0xFF) {
  77                         unsigned v = do_rol(value, 8) & 0xFFFFFF;
  78                         int shf = 0;
  79                         for (;;) {
  80                                 if ((v & 3) != 0)
  81                                         break;
  82                                 shf += 2;
  83                                 v >>= 2;
  84                         }
  85                         v  &= 0xFF;
  86                         shf = (initial + shf - 8) & 0x1F;
  87                         result->values[result->ops] = v;
  88                         result->shifts[result->ops] = shf;
  89                         ++result->ops;
  90
  91                         value ^= do_rol(v, shf) >> initial;
  92                 }
  93                 else {
  94                         value >>= 8;
  95                         initial += 8;
  96                 }
  97         }
  98 }
  99
 100 /**
 101  * Creates a arm_Const node.
 102  */
 103 static ir_node *create_const_node(ir_node *irn, ir_node *block, long value) {
 104         tarval *tv = new_tarval_from_long(value, mode_Iu);
 105         dbg_info *dbg = get_irn_dbg_info(irn);
 106         return new_rd_arm_Mov_i(dbg, current_ir_graph, block, get_irn_mode(irn), tv);
 107 }
 108
 109 /**
 110  * Creates a arm_Const_Neg node.
 111  */
 112 static ir_node *create_const_neg_node(ir_node *irn, ir_node *block, long value) {
 113         tarval *tv = new_tarval_from_long(value, mode_Iu);
 114         dbg_info *dbg = get_irn_dbg_info(irn);
 115         return new_rd_arm_Mvn_i(dbg, current_ir_graph, block, get_irn_mode(irn), tv);
 116 }
 117
 118 #define NEW_BINOP_NODE(opname, env, op1, op2) new_rd_arm_##opname(env->dbg, current_ir_graph, env->block, op1, op2, env->mode)
 119
 120 /**
 121  * Encodes an immediate with shifter operand
 122  */
 123 static unsigned int arm_encode_imm_w_shift(unsigned int shift, unsigned int immediate) {
 124         return immediate | ((shift>>1)<<8);
 125 }
 126
 127 /**
 128  * Decode an immediate with shifter operand
 129  */
 130 unsigned int arm_decode_imm_w_shift(tarval *tv) {
 131         unsigned l = get_tarval_long(tv);
 132         unsigned rol = (l & ~0xFF) >> 7;
 133
 134         return do_rol(l & 0xFF, rol);
 135 }
 136
 137 /**
 138  * Creates a possible DAG for an constant.
 139  */
 140 static ir_node *create_const_graph_value(ir_node *irn, ir_node *block, unsigned int value) {
 141         ir_node *result;
 142         int negate = 0;
 143         vals v, vn;
 144         int cnt;
 145         ir_mode *mode = get_irn_mode(irn);
 146         dbg_info *dbg = get_irn_dbg_info(irn);
 147
 148         gen_vals_from_word(value, &v);
 149         gen_vals_from_word(~value, &vn);
 150
 151         if (vn.ops < v.ops) {
 152                 /* remove bits */
 153                 result = create_const_neg_node(irn, block, arm_encode_imm_w_shift(vn.shifts[0], vn.values[0]));
 154
 155                 for (cnt = 1; cnt < vn.ops; ++cnt) {
 156                         tarval *tv = new_tarval_from_long(arm_encode_imm_w_shift(vn.shifts[cnt], vn.values[cnt]), mode_Iu);
 157                         ir_node *bic_i_node = new_rd_arm_Bic_i(dbg, current_ir_graph, block, result, mode, tv);
 158                         result = bic_i_node;
 159                 }
 160         }
 161         else {
 162                 /* add bits */
 163                 result = create_const_node(irn, block, arm_encode_imm_w_shift(v.shifts[0], v.values[0]));
 164
 165                 for (cnt = 1; cnt < v.ops; ++cnt) {
 166                         tarval *tv = new_tarval_from_long(arm_encode_imm_w_shift(v.shifts[cnt], v.values[cnt]), mode_Iu);
 167                         ir_node *orr_i_node = new_rd_arm_Or_i(dbg, current_ir_graph, block, result, mode, tv);
 168                         result = orr_i_node;
 169                 }
 170         }
 171         return result;
 172 }
 173
 174 /**
 175  * Create a DAG constructing a given Const.
 176  *
 177  * @param irn  a Firm const
 178  */
 179 static ir_node *create_const_graph(ir_node *irn, ir_node *block) {
 180         int value = get_tarval_long(get_Const_tarval(irn));
 181         return create_const_graph_value(irn, block, value);
 182 }
 183
 184
 185 /**
 186  * Creates code for a Firm Const node.
 187  */
 188 static ir_node *gen_Const(ir_node *irn, arm_code_gen_t *cg) {
 189         ir_graph *irg = current_ir_graph;
 190         ir_node *block = get_nodes_block(irn);
 191         ir_mode *mode = get_irn_mode(irn);
 192         dbg_info *dbg = get_irn_dbg_info(irn);
 193
 194         if (mode_is_float(mode)) {
 195                 if (USE_FPA(cg->isa))
 196                         return new_rd_arm_fpaConst(dbg, irg, block, mode, get_Const_tarval(irn));
 197                 else if (USE_VFP(cg->isa))
 198                         assert(mode != mode_E && "IEEE Extended FP not supported");
 199                 assert(0 && "NYI");
 200         }
 201         else if (mode_is_reference(mode))
 202                 return irn;
 203         return create_const_graph(irn, block);
 204 }
 205
 206 static ir_node *gen_mask(ir_node *irn, ir_node *op, int result_bits) {
 207         ir_node *block = get_nodes_block(irn);
 208         unsigned mask_bits = (1 << result_bits) - 1;
 209         ir_node *mask_node = create_const_graph_value(irn, block, mask_bits);
 210         dbg_info *dbg = get_irn_dbg_info(irn);
 211         return new_rd_arm_And(dbg, current_ir_graph, block, op, mask_node, get_irn_mode(irn), ARM_SHF_NONE, NULL);
 212 }
 213
 214 static ir_node *gen_sign_extension(ir_node *irn, ir_node *op, int result_bits) {
 215         ir_node *block = get_nodes_block(irn);
 216         int shift_width = 32 - result_bits;
 217         ir_graph *irg = current_ir_graph;
 218         ir_node *shift_const_node = create_const_graph_value(irn, block, shift_width);
 219         dbg_info *dbg = get_irn_dbg_info(irn);
 220         ir_node *lshift_node = new_rd_arm_Shl(dbg, irg, block, op, shift_const_node, get_irn_mode(op));
 221         ir_node *rshift_node = new_rd_arm_Shrs(dbg, irg, block, lshift_node, shift_const_node, get_irn_mode(irn));
 222         return rshift_node;
 223 }
 224
 225 /**
 226  * Transforms a Conv node.
 227  *
 228  * @param env   The transformation environment
 229  * @return the created arm Conv node
 230  */
 231 static ir_node *gen_Conv(ir_node *irn, arm_code_gen_t *cg) {
 232         ir_graph *irg = current_ir_graph;
 233         ir_node *block   = get_nodes_block(irn);
 234         ir_node *op      = get_Conv_op(irn);
 235         ir_mode *in_mode = get_irn_mode(op);
 236         ir_mode *out_mode = get_irn_mode(irn);
 237         dbg_info *dbg    = get_irn_dbg_info(irn);
 238
 239         if (in_mode == out_mode)
 240                 return op;
 241
 242         if (mode_is_float(in_mode) || mode_is_float(out_mode)) {
 243                 cg->have_fp = 1;
 244
 245                 if (USE_FPA(cg->isa)) {
 246                         if (mode_is_float(in_mode)) {
 247                                 if (mode_is_float(out_mode)) {
 248                                         /* from float to float */
 249                                         return new_rd_arm_fpaMov(dbg, irg, block, op, out_mode);
 250                                 }
 251                                 else {
 252                                         /* from float to int */
 253                                         return new_rd_arm_fpaFix(dbg, irg, block, op, out_mode);
 254                                 }
 255                         }
 256                         else {
 257                                 /* from int to float */
 258                                 return new_rd_arm_fpaFlt(dbg, irg, block, op, out_mode);
 259                         }
 260                 }
 261                 assert(0 && "NYI");
 262         }
 263         else { /* complete in gp registers */
 264                 int in_bits  = get_mode_size_bits(in_mode);
 265                 int out_bits = get_mode_size_bits(out_mode);
 266                 int in_sign  = get_mode_sign(in_mode);
 267                 int out_sign = get_mode_sign(out_mode);
 268
 269                 // 32 -> 32
 270                         // NOPpen
 271                 if (in_bits == out_bits && in_bits == 32)
 272                         return op;
 273
 274                 // 16 -> 16
 275                         // unsigned -> unsigned
 276                                 // NOP
 277                         // unsigned -> signed
 278                                 // sign extension (31:16)=(15)
 279                         // signed -> unsigned
 280                                 // maskieren (31:16)=0
 281                         // signed -> signed
 282                                 // NOP
 283                 if (in_bits == out_bits && out_bits < 32) {
 284                         if (in_sign && !out_sign) {
 285                                 return gen_mask(irn, op, out_bits);
 286                         } else {
 287                                 return gen_sign_extension(irn, op, out_bits);
 288                         }
 289                 }
 290
 291                 // 16 -> 32
 292                         // unsigned -> unsigned
 293                                 // NOP
 294                         // unsigned -> signed
 295                                 // NOP
 296                         // signed -> unsigned
 297                                 // sign extension (31:16)=(15)
 298                         // signed -> signed
 299                                 // sign extension (31:16)=(15)
 300                 if (in_bits < out_bits) {
 301                         if (in_sign) {
 302                                 return gen_sign_extension(irn, op, out_bits);
 303                         } else {
 304                                 return op;
 305                         }
 306                 }
 307
 308                 // 32 -> 16
 309                         // unsigned -> unsigned
 310                                 // maskieren (31:16)=0
 311                         // unsigned -> signed
 312                                 // maskieren (31:16)=0
 313                         // signed -> unsigned
 314                                 // maskieren (31:16)=0
 315                         // signed -> signed
 316                                 // sign extension (erledigt auch maskieren) (31:16)=(15)
 317                 if (in_bits > out_bits) {
 318                         if (in_sign && out_sign) {
 319                                 return gen_sign_extension(irn, op, out_bits);
 320                         } else {
 321                                 return gen_mask(irn, op, out_bits);
 322                         }
 323                 }
 324                 assert(0 && "recheck integer conversion logic!");
 325                 return irn;
 326         }
 327         return NULL;
 328 }
 329
 330 /**
 331  * Return true if an operand is a shifter operand
 332  */
 333 static int is_shifter_operand(ir_node *n, arm_shift_modifier *pmod) {
 334         arm_shift_modifier mod = ARM_SHF_NONE;
 335
 336         if (is_arm_Mov(n))
 337                 mod = get_arm_shift_modifier(n);
 338
 339         *pmod = mod;
 340         if (mod != ARM_SHF_NONE) {
 341                 long v = get_tarval_long(get_arm_value(n));
 342                 if (v < 32)
 343                         return (int)v;
 344         }
 345         return 0;
 346 }
 347
 348 /**
 349  * Creates an arm Add.
 350  *
 351  * @param env   The transformation environment
 352  * @return the created arm Add node
 353  */
 354 static ir_node *gen_Add(ir_node *irn, arm_code_gen_t *cg) {
 355         ir_node *block = get_nodes_block(irn);
 356         ir_node *op1 = get_Add_left(irn);
 357         ir_node *op2 = get_Add_right(irn);
 358         ir_mode *mode = get_irn_mode(irn);
 359         ir_graph *irg = current_ir_graph;
 360         ir_node *op3;
 361         int v;
 362         arm_shift_modifier mod;
 363         dbg_info *dbg = get_irn_dbg_info(irn);
 364
 365         if (mode_is_float(mode)) {
 366                 cg->have_fp = 1;
 367                 if (USE_FPA(cg->isa))
 368                         return new_rd_arm_fpaAdd(dbg, irg, block, op1, op2, mode);
 369                 else if (USE_VFP(cg->isa)) {
 370                         assert(mode != mode_E && "IEEE Extended FP not supported");
 371                 }
 372                 assert(0 && "NYI");
 373         }
 374         if (mode_is_numP(mode)) {
 375                 if (is_arm_Mov_i(op1))
 376                         return new_rd_arm_Add_i(dbg, irg, block, op2, mode, get_arm_value(op1));
 377                 if (is_arm_Mov_i(op2))
 378                         return new_rd_arm_Add_i(dbg, irg, block, op1, mode, get_arm_value(op2));
 379
 380                 /* check for MLA */
 381                 if (is_arm_Mul(op1) && get_irn_n_edges(op1) == 1) {
 382                         op3 = op2;
 383                         op2 = get_irn_n(op1, 1);
 384                         op1 = get_irn_n(op1, 0);
 385
 386                         return new_rd_arm_Mla(dbg, irg, block, op1, op2, op3, mode);
 387                 }
 388                 if (is_arm_Mul(op2) && get_irn_n_edges(op2) == 1) {
 389                         op3 = op1;
 390                         op1 = get_irn_n(op2, 0);
 391                         op2 = get_irn_n(op2, 1);
 392
 393                         return new_rd_arm_Mla(dbg, irg, block, op1, op2, op3, mode);
 394                 }
 395
 396                 /* is the first a shifter */
 397                 v = is_shifter_operand(op1, &mod);
 398                 if (v) {
 399                         op1 = get_irn_n(op1, 0);
 400                         return new_rd_arm_Add(dbg, irg, block, op2, op1, mode, mod, new_tarval_from_long(v, mode_Iu));
 401                 }
 402                 /* is the second a shifter */
 403                 v = is_shifter_operand(op2, &mod);
 404                 if (v) {
 405                         op2 = get_irn_n(op2, 0);
 406                         return new_rd_arm_Add(dbg, irg, block, op1, op2, mode, mod, new_tarval_from_long(v, mode_Iu));
 407                 }
 408
 409                 /* normal ADD */
 410                 return new_rd_arm_Add(dbg, irg, block, op1, op2, mode, ARM_SHF_NONE, NULL);
 411         }
 412
 413         assert(0 && "unknown mode for add");
 414         return NULL;
 415 }
 416
 417 /**
 418  * Creates an arm Mul.
 419  *
 420  * @param env   The transformation environment
 421  * @return the created arm Mul node
 422  */
 423 static ir_node *gen_Mul(ir_node *irn, arm_code_gen_t *cg) {
 424         ir_node *block = get_nodes_block(irn);
 425         ir_node *op1 = get_Mul_left(irn);
 426         ir_node *op2 = get_Mul_right(irn);
 427         ir_mode *mode = get_irn_mode(irn);
 428         ir_graph *irg = current_ir_graph;
 429         dbg_info *dbg = get_irn_dbg_info(irn);
 430
 431         if (mode_is_float(mode)) {
 432                 cg->have_fp = 1;
 433                 if (USE_FPA(cg->isa))
 434                         return new_rd_arm_fpaMul(dbg, irg, block, op1, op2, mode);
 435                 else if (USE_VFP(cg->isa)) {
 436                         assert(mode != mode_E && "IEEE Extended FP not supported");
 437                 }
 438                 assert(0 && "NYI");
 439         }
 440         return new_rd_arm_Mul(dbg, irg, block, op1, op2, mode);
 441 }
 442
 443 /**
 444  * Creates an arm floating point Div.
 445  *
 446  * @param env   The transformation environment
 447  * @return the created arm fDiv node
 448  */
 449 static ir_node *gen_Quot(ir_node *irn, arm_code_gen_t *cg) {
 450         ir_node *block = get_nodes_block(irn);
 451         ir_node *op1 = get_Quot_left(irn);
 452         ir_node *op2 = get_Quot_right(irn);
 453         ir_mode *mode = get_irn_mode(irn);
 454         dbg_info *dbg = get_irn_dbg_info(irn);
 455
 456         assert(mode != mode_E && "IEEE Extended FP not supported");
 457
 458         cg->have_fp = 1;
 459         if (USE_FPA(cg->isa))
 460                 return new_rd_arm_fpaDiv(dbg, current_ir_graph, block, op1, op2, mode);
 461         else if (USE_VFP(cg->isa)) {
 462                 assert(mode != mode_E && "IEEE Extended FP not supported");
 463         }
 464         assert(0 && "NYI");
 465
 466         return NULL;
 467 }
 468
 469 #define GEN_INT_OP(op) \
 470 static ir_node *gen_ ## op(ir_node *irn, arm_code_gen_t *cg) { \
 471         ir_graph *irg = current_ir_graph; \
 472         ir_node *block = get_nodes_block(irn); \
 473         ir_node *op1 = get_ ## op ## _left(irn); \
 474         ir_node *op2 = get_ ## op ## _right(irn); \
 475         int v; \
 476         arm_shift_modifier mod; \
 477         ir_mode *mode = get_irn_mode(irn); \
 478         dbg_info *dbg = get_irn_dbg_info(irn); \
 479  \
 480         if (is_arm_Mov_i(op1)) \
 481                 return new_rd_arm_ ## op ## _i(dbg, irg, block, op2, mode, get_arm_value(op1)); \
 482         if (is_arm_Mov_i(op2)) \
 483                 return new_rd_arm_ ## op ## _i(dbg, irg, block, op1, mode, get_arm_value(op2)); \
 484         /* is the first a shifter */ \
 485         v = is_shifter_operand(op1, &mod); \
 486         if (v) { \
 487                 op1 = get_irn_n(op1, 0); \
 488                 return new_rd_arm_ ## op(dbg, irg, block, op2, op1, mode, mod, new_tarval_from_long(v, mode_Iu)); \
 489         } \
 490         /* is the second a shifter */ \
 491         v = is_shifter_operand(op2, &mod); \
 492         if (v) { \
 493                 op2 = get_irn_n(op2, 0); \
 494                 return new_rd_arm_ ## op(dbg, irg, block, op1, op2, mode, mod, new_tarval_from_long(v, mode_Iu)); \
 495         } \
 496         /* Normal op */ \
 497         return new_rd_arm_ ## op(dbg, irg, block, op1, op2, mode, ARM_SHF_NONE, NULL); \
 498 }
 499
 500
 501 /**
 502  * Creates an arm And.
 503  *
 504  * @param env   The transformation environment
 505  * @return the created arm And node
 506  */
 507 static ir_node *gen_And(ir_node *irn, arm_code_gen_t *cg);
 508 GEN_INT_OP(And)
 509
 510 /**
 511  * Creates an arm Orr.
 512  *
 513  * @param env   The transformation environment
 514  * @return the created arm Or node
 515  */
 516 static ir_node *gen_Or(ir_node *irn, arm_code_gen_t *cg);
 517 GEN_INT_OP(Or)
 518
 519 /**
 520  * Creates an arm Eor.
 521  *
 522  * @param env   The transformation environment
 523  * @return the created arm Eor node
 524  */
 525 static ir_node *gen_Eor(ir_node *irn, arm_code_gen_t *cg);
 526 GEN_INT_OP(Eor)
 527
 528 /**
 529  * Creates an arm Sub.
 530  *
 531  * @param env   The transformation environment
 532  * @return the created arm Sub node
 533  */
 534 static ir_node *gen_Sub(ir_node *irn, arm_code_gen_t *cg) {
 535         ir_node *block = get_nodes_block(irn);
 536         ir_node *op1 = get_Sub_left(irn);
 537         ir_node *op2 = get_Sub_right(irn);
 538         int v;
 539         arm_shift_modifier mod;
 540         ir_mode *mode = get_irn_mode(irn);
 541         ir_graph *irg = current_ir_graph;
 542         dbg_info *dbg = get_irn_dbg_info(irn);
 543
 544         if (mode_is_float(mode)) {
 545                 cg->have_fp = 1;
 546                 if (USE_FPA(cg->isa))
 547                         return new_rd_arm_fpaSub(dbg, irg, block, op1, op2, mode);
 548                 else if (USE_VFP(cg->isa)) {
 549                         assert(mode != mode_E && "IEEE Extended FP not supported");
 550                 }
 551                 assert(0 && "NYI");
 552         }
 553         if (mode_is_numP(mode)) {
 554                 if (is_arm_Mov_i(op1))
 555                         return new_rd_arm_Rsb_i(dbg, irg, block, op2, mode, get_arm_value(op1));
 556                 if (is_arm_Mov_i(op2))
 557                         return new_rd_arm_Sub_i(dbg, irg, block, op1, mode, get_arm_value(op2));
 558
 559                 /* is the first a shifter */
 560                 v = is_shifter_operand(op1, &mod);
 561                 if (v) {
 562                         op1 = get_irn_n(op1, 0);
 563                         return new_rd_arm_Rsb(dbg, irg, block, op2, op1, mode, mod, new_tarval_from_long(v, mode_Iu));
 564                 }
 565                 /* is the second a shifter */
 566                 v = is_shifter_operand(op2, &mod);
 567                 if (v) {
 568                         op2 = get_irn_n(op2, 0);
 569                         return new_rd_arm_Sub(dbg, irg, block, op1, op2, mode, mod, new_tarval_from_long(v, mode_Iu));
 570                 }
 571                 /* normal sub */
 572                 return new_rd_arm_Sub(dbg, irg, block, op1, op2, mode, ARM_SHF_NONE, NULL);
 573         }
 574         assert(0 && "unknown mode for sub");
 575         return NULL;
 576 }
 577
 578 /**
 579  * Creates an arm Shl.
 580  *
 581  * @param env   The transformation environment
 582  * @return the created arm Shl node
 583  */
 584 static ir_node *gen_Shl(ir_node *irn, arm_code_gen_t *cg) {
 585         ir_node *result;
 586         ir_node *block = get_nodes_block(irn);
 587         ir_node *op1 = get_Shl_left(irn);
 588         ir_node *op2 = get_Shl_right(irn);
 589         ir_mode *mode = get_irn_mode(irn);
 590         ir_graph *irg = current_ir_graph;
 591         dbg_info *dbg = get_irn_dbg_info(irn);
 592
 593         if (is_arm_Mov_i(op2)) {
 594                 result = new_rd_arm_Mov(dbg, irg, block, op1, mode, ARM_SHF_LSL, get_arm_value(op2));
 595         } else {
 596                 result = new_rd_arm_Shl(dbg, irg, block, op1, op2, mode);
 597         }
 598         return result;
 599 }
 600
 601 /**
 602  * Creates an arm Shr.
 603  *
 604  * @param env   The transformation environment
 605  * @return the created arm Shr node
 606  */
 607 static ir_node *gen_Shr(ir_node *irn, arm_code_gen_t *cg) {
 608         ir_node *result;
 609         ir_node *block = get_nodes_block(irn);
 610         ir_node *op1 = get_Shr_left(irn);
 611         ir_node *op2 = get_Shr_right(irn);
 612         ir_mode *mode = get_irn_mode(irn);
 613         ir_graph *irg = current_ir_graph;
 614         dbg_info *dbg = get_irn_dbg_info(irn);
 615
 616         if (is_arm_Mov_i(op2)) {
 617                 result = new_rd_arm_Mov(dbg, irg, block, op1, mode, ARM_SHF_LSR, get_arm_value(op2));
 618         } else {
 619                 result = new_rd_arm_Shr(dbg, irg, block, op1, op2, mode);
 620         }
 621         return result;
 622 }
 623
 624 /**
 625  * Creates an arm Shrs.
 626  *
 627  * @param env   The transformation environment
 628  * @return the created arm Shrs node
 629  */
 630 static ir_node *gen_Shrs(ir_node *irn, arm_code_gen_t *cg) {
 631         ir_node *result;
 632         ir_node *block = get_nodes_block(irn);
 633         ir_node *op1 = get_Shrs_left(irn);
 634         ir_node *op2 = get_Shrs_right(irn);
 635         ir_mode *mode = get_irn_mode(irn);
 636         dbg_info *dbg = get_irn_dbg_info(irn);
 637
 638         if (is_arm_Mov_i(op2)) {
 639                 result = new_rd_arm_Mov(dbg, current_ir_graph, block, op1, mode, ARM_SHF_ASR, get_arm_value(op2));
 640         } else {
 641                 result = new_rd_arm_Shrs(dbg, current_ir_graph, block, op1, op2, mode);
 642         }
 643         return result;
 644 }
 645
 646 /**
 647  * Transforms a Not node.
 648  *
 649  * @param env   The transformation environment
 650  * @return the created arm Not node
 651  */
 652 static ir_node *gen_Not(ir_node *irn, arm_code_gen_t *cg) {
 653         ir_node *block = get_nodes_block(irn);
 654         ir_node *op = get_Not_op(irn);
 655         int v;
 656         arm_shift_modifier mod = ARM_SHF_NONE;
 657         tarval  *tv = NULL;
 658         dbg_info *dbg = get_irn_dbg_info(irn);
 659
 660         v = is_shifter_operand(op, &mod);
 661         if (v) {
 662                 op = get_irn_n(op, 0);
 663                 tv = new_tarval_from_long(v, mode_Iu);
 664         }
 665         return new_rd_arm_Mvn(dbg, current_ir_graph, block, op, get_irn_mode(irn), mod, tv);
 666 }
 667
 668 /**
 669  * Transforms an Abs node.
 670  *
 671  * @param env   The transformation environment
 672  * @return the created arm Abs node
 673  */
 674 static ir_node *gen_Abs(ir_node *irn, arm_code_gen_t *cg) {
 675         ir_node *block = get_nodes_block(irn);
 676         ir_node *op = get_Abs_op(irn);
 677         ir_mode *mode = get_irn_mode(irn);
 678         dbg_info *dbg = get_irn_dbg_info(irn);
 679
 680         if (mode_is_float(mode)) {
 681                 cg->have_fp = 1;
 682                 if (USE_FPA(cg->isa))
 683                         return new_rd_arm_fpaAbs(dbg, current_ir_graph, block, op, mode);
 684                 else if (USE_VFP(cg->isa)) {
 685                         assert(mode != mode_E && "IEEE Extended FP not supported");
 686                 }
 687                 assert(0 && "NYI");
 688         }
 689         return new_rd_arm_Abs(dbg, current_ir_graph, block, op, mode);
 690 }
 691
 692 /**
 693  * Transforms a Minus node.
 694  *
 695  * @param env   The transformation environment
 696  * @return the created arm Minus node
 697  */
 698 static ir_node *gen_Minus(ir_node *irn, arm_code_gen_t *cg) {
 699         ir_node *block = get_nodes_block(irn);
 700         ir_node *op = get_Minus_op(irn);
 701         ir_mode *mode = get_irn_mode(irn);
 702         ir_graph *irg = current_ir_graph;
 703         dbg_info *dbg = get_irn_dbg_info(irn);
 704
 705         if (mode_is_float(mode)) {
 706                 cg->have_fp = 1;
 707                 if (USE_FPA(cg->isa))
 708                         return new_rd_arm_fpaMnv(dbg, irg, block, op, mode);
 709                 else if (USE_VFP(cg->isa)) {
 710                         assert(mode != mode_E && "IEEE Extended FP not supported");
 711                 }
 712                 assert(0 && "NYI");
 713         }
 714         return new_rd_arm_Rsb_i(dbg, irg, block, op, mode, get_mode_null(mode));
 715 }
 716
 717 /**
 718  * Transforms a Load.
 719  *
 720  * @param mod     the debug module
 721  * @param block   the block the new node should belong to
 722  * @param node    the ir Load node
 723  * @param mode    node mode
 724  * @return the created arm Load node
 725  */
 726 static ir_node *gen_Load(ir_node *irn, arm_code_gen_t *cg) {
 727         ir_node *block = get_nodes_block(irn);
 728         ir_mode *mode = get_Load_mode(irn);
 729         ir_graph *irg = current_ir_graph;
 730         dbg_info *dbg = get_irn_dbg_info(irn);
 731
 732         if (mode_is_float(mode)) {
 733                 cg->have_fp = 1;
 734                 if (USE_FPA(cg->isa))
 735                         return new_rd_arm_fpaLdf(dbg, irg, block, get_Load_ptr(irn), get_Load_mem(irn),
 736                                 get_Load_mode(irn));
 737                 else if (USE_VFP(cg->isa)) {
 738                         assert(mode != mode_E && "IEEE Extended FP not supported");
 739                 }
 740                 assert(0 && "NYI");
 741         }
 742         if (mode == mode_Bu) {
 743                 return new_rd_arm_Loadb(dbg, irg, block, get_Load_ptr(irn), get_Load_mem(irn));
 744         }
 745         if (mode == mode_Bs) {
 746                 return new_rd_arm_Loadbs(dbg, irg, block, get_Load_ptr(irn), get_Load_mem(irn));
 747         }
 748         if (mode == mode_Hu) {
 749                 return new_rd_arm_Loadh(dbg, irg, block, get_Load_ptr(irn), get_Load_mem(irn));
 750         }
 751         if (mode == mode_Hs) {
 752                 return new_rd_arm_Loadhs(dbg, irg, block, get_Load_ptr(irn), get_Load_mem(irn));
 753         }
 754         if (mode_is_reference(mode)) {
 755                 return new_rd_arm_Load(dbg, irg, block, get_Load_ptr(irn), get_Load_mem(irn));
 756         }
 757         return new_rd_arm_Load(dbg, irg, block, get_Load_ptr(irn), get_Load_mem(irn));
 758 }
 759
 760 /**
 761  * Transforms a Store.
 762  *
 763  * @param mod     the debug module
 764  * @param block   the block the new node should belong to
 765  * @param node    the ir Store node
 766  * @param mode    node mode
 767  * @return the created arm Store node
 768  */
 769 static ir_node *gen_Store(ir_node *irn, arm_code_gen_t *cg) {
 770         ir_node *block = get_nodes_block(irn);
 771         ir_mode *mode = get_irn_mode(get_Store_value(irn));
 772         ir_graph *irg = current_ir_graph;
 773         dbg_info *dbg = get_irn_dbg_info(irn);
 774
 775         assert(mode != mode_E && "IEEE Extended FP not supported");
 776         if (mode_is_float(mode)) {
 777                 cg->have_fp = 1;
 778                 if (USE_FPA(cg->isa))
 779                         return new_rd_arm_fpaStf(dbg, irg, block, get_Store_ptr(irn), get_Store_value(irn),
 780                                 get_Store_mem(irn), get_irn_mode(get_Store_value(irn)));
 781                 else if (USE_VFP(cg->isa)) {
 782                         assert(mode != mode_E && "IEEE Extended FP not supported");
 783                 }
 784                 assert(0 && "NYI");
 785         }
 786         if (mode == mode_Bu) {
 787                 return new_rd_arm_Storeb(dbg, irg, block, get_Store_ptr(irn), get_Store_value(irn), get_Store_mem(irn));
 788         }
 789         if (mode == mode_Bs) {
 790                 return new_rd_arm_Storebs(dbg, irg, block, get_Store_ptr(irn), get_Store_value(irn), get_Store_mem(irn));
 791         }
 792         if (mode == mode_Hu) {
 793                 return new_rd_arm_Storeh(dbg, irg, block, get_Store_ptr(irn), get_Store_value(irn), get_Store_mem(irn));
 794         }
 795         if (mode == mode_Hs) {
 796                 return new_rd_arm_Storehs(dbg, irg, block, get_Store_ptr(irn), get_Store_value(irn), get_Store_mem(irn));
 797         }
 798         return new_rd_arm_Store(dbg, irg, block, get_Store_ptr(irn), get_Store_value(irn), get_Store_mem(irn));
 799 }
 800
 801
 802 static ir_node *gen_Cond(ir_node *irn, arm_code_gen_t *cg) {
 803         ir_node *result   = NULL;
 804         ir_node *selector = get_Cond_selector(irn);
 805         ir_node *block    = get_nodes_block(irn);
 806         ir_graph *irg     = current_ir_graph;
 807         dbg_info *dbg     = get_irn_dbg_info(irn);
 808
 809         if ( get_irn_mode(selector) == mode_b ) {
 810                 //CondJmp
 811                 ir_node *proj_node = get_Cond_selector(irn);
 812                 ir_node *cmp_node = get_Proj_pred(proj_node);
 813                 ir_node *op1 = get_Cmp_left(cmp_node);
 814                 ir_node *op2 = get_Cmp_right(cmp_node);
 815                 result = new_rd_arm_CondJmp(dbg, irg, block, op1, op2, mode_T);
 816                 set_arm_proj_num(result, get_Proj_proj(proj_node));
 817         } else {
 818                 //SwitchJmp
 819                 ir_node *op = get_irn_n(irn, 0);
 820                 ir_node *const_graph;
 821                 ir_node *sub;
 822                 ir_node *const_node;
 823
 824                 ir_node *proj;
 825                 const ir_edge_t *edge;
 826                 int min = INT_MAX;
 827                 int max = INT_MIN;
 828                 int translation;
 829                 int norm_max;
 830                 int norm_min;
 831                 int pn;
 832                 int n_projs;
 833                 ir_node **projs;
 834
 835                 foreach_out_edge(irn, edge) {
 836                         proj = get_edge_src_irn(edge);
 837                         assert(is_Proj(proj) && "Only proj allowed at SwitchJmp");
 838
 839                         pn = get_Proj_proj(proj);
 840
 841                         min = pn<min ? pn : min;
 842                         max = pn>max ? pn : max;
 843                 }
 844                 translation = min;
 845                 norm_max = max - translation;
 846                 norm_min = min - translation;
 847
 848                 n_projs = norm_max + 1;
 849                 projs = xcalloc(n_projs , sizeof(ir_node*));
 850
 851
 852                 foreach_out_edge(irn, edge) {
 853                         proj = get_edge_src_irn(edge);
 854                         assert(is_Proj(proj) && "Only proj allowed at SwitchJmp");
 855
 856                         pn = get_Proj_proj(proj) - translation;
 857                         set_Proj_proj(proj, pn);
 858                 }
 859
 860
 861                 const_node = new_rd_Const(dbg, irg, block, mode_Iu, new_tarval_from_long(translation, mode_Iu));
 862                 const_graph = gen_Const(const_node, cg);
 863                 sub = new_rd_arm_Sub(dbg, irg, block, op, const_graph, get_irn_mode(op), ARM_SHF_NONE, NULL);
 864                 result = new_rd_arm_SwitchJmp(dbg, irg, block, sub, mode_T);
 865                 set_arm_n_projs(result, n_projs);
 866                 set_arm_default_proj_num(result, get_Cond_defaultProj(irn)-translation);
 867         }
 868         return result;
 869 }
 870
 871 /**
 872  * Returns the name of a SymConst.
 873  * @param symc  the SymConst
 874  * @return name of the SymConst
 875  */
 876 const char *get_sc_name(ir_node *symc) {
 877         if (get_irn_opcode(symc) != iro_SymConst)
 878                 return "NONE";
 879
 880         switch (get_SymConst_kind(symc)) {
 881                 case symconst_addr_name:
 882                         return get_id_str(get_SymConst_name(symc));
 883
 884                 case symconst_addr_ent:
 885                         return get_entity_ld_name(get_SymConst_entity(symc));
 886
 887                 default:
 888                         assert(0 && "Unsupported SymConst");
 889         }
 890
 891         return NULL;
 892 }
 893
 894 static ir_node *gen_SymConst(ir_node *irn, arm_code_gen_t *cg) {
 895         ir_node *block = get_nodes_block(irn);
 896         ir_mode *mode = get_irn_mode(irn);
 897         dbg_info *dbg = get_irn_dbg_info(irn);
 898         return new_rd_arm_SymConst(dbg, current_ir_graph, block, mode, get_sc_name(irn));
 899 }
 900
 901
 902
 903 /**
 904  * Transforms a CopyB node.
 905  *
 906  * @param env   The transformation environment
 907  * @return The transformed node.
 908  */
 909 static ir_node *gen_CopyB(ir_node *irn, arm_code_gen_t *cg) {
 910         ir_node  *res   = NULL;
 911         dbg_info *dbg   = get_irn_dbg_info(irn);
 912         ir_mode  *mode  = get_irn_mode(irn);
 913         ir_node  *src   = get_CopyB_src(irn);
 914         ir_node  *dst   = get_CopyB_dst(irn);
 915         ir_node  *mem   = get_CopyB_mem(irn);
 916         ir_node  *block = get_nodes_block(irn);
 917         int       size  = get_type_size_bytes(get_CopyB_type(irn));
 918         ir_graph *irg   = current_ir_graph;
 919         ir_node *src_copy;
 920         ir_node *dst_copy;
 921
 922         src_copy = be_new_Copy(&arm_reg_classes[CLASS_arm_gp], irg, block, src);
 923         dst_copy = be_new_Copy(&arm_reg_classes[CLASS_arm_gp], irg, block, dst);
 924
 925         res = new_rd_arm_CopyB( dbg, irg, block, dst_copy, src_copy, new_rd_arm_EmptyReg(dbg, irg, block, mode_Iu), new_rd_arm_EmptyReg(dbg, irg, block, mode_Iu), new_rd_arm_EmptyReg(dbg, irg, block, mode_Iu), mem, mode);
 926         set_arm_value(res, new_tarval_from_long(size, mode_Iu));
 927
 928         return res;
 929 }
 930
 931
 932
 933
 934
 935 /********************************************
 936  *  _                          _
 937  * | |                        | |
 938  * | |__   ___ _ __   ___   __| | ___  ___
 939  * | '_ \ / _ \ '_ \ / _ \ / _` |/ _ \/ __|
 940  * | |_) |  __/ | | | (_) | (_| |  __/\__ \
 941  * |_.__/ \___|_| |_|\___/ \__,_|\___||___/
 942  *
 943  ********************************************/
 944
 945 /**
 946  * Return an expanding stack offset.
 947  * Note that function is called in the transform phase
 948  * where the stack offsets are still relative regarding
 949  * the first (frame allocating) IncSP.
 950  * However this is exactly what we want because frame
 951  * access must be done relative the the fist IncSP ...
 952  */
 953 static int get_sp_expand_offset(ir_node *inc_sp) {
 954         unsigned offset    = be_get_IncSP_offset(inc_sp);
 955         be_stack_dir_t dir = be_get_IncSP_direction(inc_sp);
 956
 957         if (offset == BE_STACK_FRAME_SIZE)
 958                 return 0;
 959         return dir == be_stack_dir_expand ? (int)offset : -(int)offset;
 960 }
 961
 962 static ir_node *gen_StackParam(ir_node *irn, arm_code_gen_t *cg) {
 963 #if 0
 964         ir_node *new_op = NULL;
 965         ir_node *block  = get_nodes_block(irn);
 966         ir_node *noreg  = ia32_new_NoReg_gp(env->cg);
 967         ir_node *mem    = new_rd_NoMem(env->irg);
 968         ir_node *ptr    = get_irn_n(irn, 0);
 969         entity  *ent    = be_get_frame_entity(irn);
 970         ir_mode *mode   = env->mode;
 971
 972 //      /* If the StackParam has only one user ->     */
 973 //      /* put it in the Block where the user resides */
 974 //      if (get_irn_n_edges(node) == 1) {
 975 //              env->block = get_nodes_block(get_edge_src_irn(get_irn_out_edge_first(node)));
 976 //      }
 977
 978         if (mode_is_float(mode)) {
 979                 if (USE_SSE2(env->cg))
 980                         new_op = new_rd_ia32_fLoad(env->dbg, env->irg, block, ptr, noreg, mem, mode_T);
 981                 else {
 982                         env->cg->used_x87 = 1;
 983                         new_op = new_rd_ia32_vfld(env->dbg, env->irg, block, ptr, noreg, mem, mode_T);
 984                 }
 985         }
 986         else {
 987                 new_op = new_rd_ia32_Load(env->dbg, env->irg, block, ptr, noreg, mem, mode_T);
 988         }
 989
 990         set_ia32_frame_ent(new_op, ent);
 991         set_ia32_use_frame(new_op);
 992
 993         set_ia32_am_support(new_op, ia32_am_Source);
 994         set_ia32_op_type(new_op, ia32_AddrModeS);
 995         set_ia32_am_flavour(new_op, ia32_B);
 996         set_ia32_ls_mode(new_op, mode);
 997
 998         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, env->irn));
 999
1000         return new_rd_Proj(env->dbg, env->irg, block, new_op, mode, 0);
1001 #endif
1002 }
1003
1004 /**
1005  * Transforms a FrameAddr into an ia32 Add.
1006  */
1007 static ir_node *gen_be_FrameAddr(ir_node *irn, arm_code_gen_t *cg) {
1008         ir_node *block  = get_nodes_block(irn);
1009         entity  *ent    = be_get_frame_entity(irn);
1010         int     offset  = get_entity_offset_bytes(ent);
1011         ir_node *op     = get_irn_n(irn, 0);
1012         ir_node *cnst;
1013         ir_mode *mode   = get_irn_mode(irn);
1014         dbg_info *dbg   = get_irn_dbg_info(irn);
1015
1016         if (be_is_IncSP(op)) {
1017                 /* BEWARE: we get an offset which is absolute from an offset that
1018                    is relative. Both must be merged */
1019                 offset += get_sp_expand_offset(op);
1020         }
1021         cnst = create_const_graph_value(irn, block, (unsigned)offset);
1022         if (is_arm_Mov_i(cnst))
1023                 return new_rd_arm_Add_i(dbg, current_ir_graph, block, op, mode, get_arm_value(cnst));
1024         return new_rd_arm_Add(dbg, current_ir_graph, block, op, cnst, mode, ARM_SHF_NONE, NULL);
1025 }
1026
1027 /**
1028  * Transforms a FrameLoad into an ia32 Load.
1029  */
1030 static ir_node *gen_FrameLoad(ir_node *irn, arm_code_gen_t *cg) {
1031 #if 0
1032         ir_node *new_op = NULL;
1033         ir_node *noreg  = ia32_new_NoReg_gp(env->cg);
1034         ir_node *mem    = get_irn_n(irn, 0);
1035         ir_node *ptr    = get_irn_n(irn, 1);
1036         entity  *ent    = be_get_frame_entity(irn);
1037         ir_mode *mode   = get_type_mode(get_entity_type(ent));
1038
1039         if (mode_is_float(mode)) {
1040                 if (USE_SSE2(env->cg))
1041                         new_op = new_rd_ia32_fLoad(env->dbg, current_ir_graph, env->block, ptr, noreg, mem, mode_T);
1042                 else {
1043                         env->cg->used_x87 = 1;
1044                         new_op = new_rd_ia32_vfld(env->dbg, current_ir_graph, env->block, ptr, noreg, mem, mode_T);
1045                 }
1046         }
1047         else {
1048                 new_op = new_rd_ia32_Load(env->dbg, current_ir_graph, env->block, ptr, noreg, mem, mode_T);
1049         }
1050
1051         set_ia32_frame_ent(new_op, ent);
1052         set_ia32_use_frame(new_op);
1053
1054         set_ia32_am_support(new_op, ia32_am_Source);
1055         set_ia32_op_type(new_op, ia32_AddrModeS);
1056         set_ia32_am_flavour(new_op, ia32_B);
1057         set_ia32_ls_mode(new_op, mode);
1058
1059         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, env->irn));
1060
1061         return new_op;
1062 #endif
1063 }
1064
1065
1066 /**
1067  * Transforms a FrameStore into an ia32 Store.
1068  */
1069 static ir_node *gen_FrameStore(ir_node *irn, arm_code_gen_t *cg) {
1070 #if 0
1071         ir_node *new_op = NULL;
1072         ir_node *noreg  = ia32_new_NoReg_gp(env->cg);
1073         ir_node *mem    = get_irn_n(irn, 0);
1074         ir_node *ptr    = get_irn_n(irn, 1);
1075         ir_node *val    = get_irn_n(irn, 2);
1076         entity  *ent    = be_get_frame_entity(irn);
1077         ir_mode *mode   = get_irn_mode(val);
1078
1079         if (mode_is_float(mode)) {
1080                 if (USE_SSE2(env->cg))
1081                         new_op = new_rd_ia32_fStore(env->dbg, env->irg, env->block, ptr, noreg, val, mem, mode_T);
1082                 else {
1083                         env->cg->used_x87 = 1;
1084                         new_op = new_rd_ia32_vfst(env->dbg, env->irg, env->block, ptr, noreg, val, mem, mode_T);
1085                 }
1086         }
1087         else if (get_mode_size_bits(mode) == 8) {
1088                 new_op = new_rd_ia32_Store8Bit(env->dbg, env->irg, env->block, ptr, noreg, val, mem, mode_T);
1089         }
1090         else {
1091                 new_op = new_rd_ia32_Store(env->dbg, env->irg, env->block, ptr, noreg, val, mem, mode_T);
1092         }
1093
1094         set_ia32_frame_ent(new_op, ent);
1095         set_ia32_use_frame(new_op);
1096
1097         set_ia32_am_support(new_op, ia32_am_Dest);
1098         set_ia32_op_type(new_op, ia32_AddrModeD);
1099         set_ia32_am_flavour(new_op, ia32_B);
1100         set_ia32_ls_mode(new_op, mode);
1101
1102         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, env->irn));
1103
1104         return new_op;
1105 #endif
1106 }
1107
1108
1109 // static ir_node *gen_be_Copy(ir_node *irn, arm_code_gen_t *cg) {
1110 //      return new_rd_arm_Copy(env->dbg, env->irg, env->block, op, env->mode);
1111 // }
1112
1113 /*********************************************************
1114  *                  _             _      _
1115  *                 (_)           | |    (_)
1116  *  _ __ ___   __ _ _ _ __     __| |_ __ ___   _____ _ __
1117  * | '_ ` _ \ / _` | | '_ \   / _` | '__| \ \ / / _ \ '__|
1118  * | | | | | | (_| | | | | | | (_| | |  | |\ V /  __/ |
1119  * |_| |_| |_|\__,_|_|_| |_|  \__,_|_|  |_| \_/ \___|_|
1120  *
1121  *********************************************************/
1122
1123 /**
1124  * move constants out of the start block
1125  */
1126 void arm_move_consts(ir_node *node, void *env) {
1127         arm_code_gen_t *cgenv = (arm_code_gen_t *)env;
1128         int i;
1129
1130         if (is_Block(node))
1131                 return;
1132
1133         if (is_Phi(node)) {
1134                 for (i = get_irn_arity(node) - 1; i >= 0; --i) {
1135                         ir_node *pred = get_irn_n(node,i);
1136                         opcode pred_code = get_irn_opcode(pred);
1137                         if (pred_code == iro_Const) {
1138                                 ir_node *const_graph;
1139                                 const_graph = create_const_graph(pred, get_nodes_block(get_irn_n(get_nodes_block(node),i)));
1140                                 set_irn_n(node, i, const_graph);
1141                         }
1142                         else if (pred_code == iro_SymConst) {
1143                                 /* FIXME: in general, SymConst always require a load, so it
1144                                    might be better to place them into the first real block
1145                                    and let the spiller rematerialize them. */
1146                                 const char *str = get_sc_name(pred);
1147                                 ir_node *symconst_node;
1148                                 symconst_node = new_rd_arm_SymConst(get_irn_dbg_info(pred),
1149                                         current_ir_graph, get_nodes_block(get_irn_n(get_nodes_block(node),i)),
1150                                         get_irn_mode(pred), str);
1151                                 set_irn_n(node, i, symconst_node);
1152                         }
1153                 }
1154                 return;
1155         }
1156         for (i = 0; i < get_irn_arity(node); i++) {
1157                 ir_node *pred = get_irn_n(node,i);
1158                 opcode pred_code = get_irn_opcode(pred);
1159                 if (pred_code == iro_Const) {
1160                         ir_node *const_graph;
1161                         const_graph = create_const_graph(pred, get_nodes_block(node));
1162                         set_irn_n(node, i, const_graph);
1163                 } else if (pred_code == iro_SymConst) {
1164                         const char *str = get_sc_name(pred);
1165                         ir_node *symconst_node;
1166                         symconst_node = new_rd_arm_SymConst(get_irn_dbg_info(pred),
1167                                 current_ir_graph, get_nodes_block(node),
1168                                 get_irn_mode(pred), str);
1169                         set_irn_n(node, i, symconst_node);
1170                 }
1171         }
1172 }
1173
1174
1175 /************************************************************************/
1176 /* move symbolic constants out of startblock                            */
1177 /************************************************************************/
1178 void arm_move_symconsts(ir_node *node, void *env) {
1179         int i;
1180
1181         if (is_Block(node))
1182                 return;
1183
1184         for (i = 0; i < get_irn_arity(node); i++) {
1185                 ir_node *pred      = get_irn_n(node,i);
1186                 opcode   pred_code = get_irn_opcode(pred);
1187
1188                 if (pred_code == iro_SymConst) {
1189                         const char *str = get_sc_name(pred);
1190                         ir_node    *symconst_node;
1191
1192                         symconst_node = new_rd_arm_SymConst(get_irn_dbg_info(pred),
1193                                 current_ir_graph, get_nodes_block(node), get_irn_mode(pred), str);
1194                         set_irn_n(node, i, symconst_node);
1195                 }
1196         }
1197 }
1198
1199 /**
1200  * the BAD transformer.
1201  */
1202 static ir_node *bad_transform(ir_node *irn, arm_code_gen_t *cg) {
1203         ir_fprintf(stderr, "Not implemented: %+F\n", irn);
1204         assert(0);
1205         return NULL;
1206 }
1207
1208 /**
1209  * Enters all transform functions into the generic pointer
1210  */
1211 void arm_register_transformers(void) {
1212         ir_op *op_Max, *op_Min, *op_Mulh;
1213
1214         /* first clear the generic function pointer for all ops */
1215         clear_irp_opcodes_generic_func();
1216
1217 #define FIRM_OP(a)     op_##a->ops.generic = (op_func)gen_##a
1218 #define BAD(a)         op_##a->ops.generic = (op_func)bad_transform
1219 #define IGN(a)
1220
1221         FIRM_OP(Add);  // done
1222         FIRM_OP(Mul);  // done
1223         FIRM_OP(Quot); // done
1224         FIRM_OP(And);  // done
1225         FIRM_OP(Or);   // done
1226         FIRM_OP(Eor);  // done
1227
1228         FIRM_OP(Sub);  // done
1229         FIRM_OP(Shl);  // done
1230         FIRM_OP(Shr);  // done
1231         FIRM_OP(Shrs); // done
1232
1233         FIRM_OP(Minus); // done
1234         FIRM_OP(Not);   // done
1235         FIRM_OP(Abs);   // done
1236
1237         FIRM_OP(CopyB); // done
1238         FIRM_OP(Const); // TODO: floating point consts
1239         FIRM_OP(Conv); // TODO: floating point conversions
1240
1241         FIRM_OP(Load);   // done
1242         FIRM_OP(Store);  // done
1243
1244         FIRM_OP(SymConst);
1245         FIRM_OP(Cond);    // integer done
1246
1247         /* TODO: implement these nodes */
1248
1249         IGN(Div);    // intrinsic lowering
1250         IGN(Mod);    // intrinsic lowering
1251         IGN(DivMod); // TODO: implement DivMod
1252
1253         IGN(Mux);
1254         IGN(Unknown);
1255         IGN(Cmp);     // done, implemented in cond
1256
1257         /* You probably don't need to handle the following nodes */
1258
1259         IGN(Call);
1260         IGN(Proj);
1261         IGN(Alloc);
1262
1263         IGN(Block);
1264         IGN(Start);
1265         IGN(End);
1266         IGN(NoMem);
1267         IGN(Phi);
1268         IGN(IJmp);
1269         IGN(Jmp);     // emitter done
1270         IGN(Break);
1271         IGN(Sync);
1272
1273         BAD(Raise);
1274         BAD(Sel);
1275         BAD(InstOf);
1276         BAD(Cast);
1277         BAD(Free);
1278         BAD(Tuple);
1279         BAD(Id);
1280         BAD(Bad);
1281         BAD(Confirm);
1282         BAD(Filter);
1283         BAD(CallBegin);
1284         BAD(EndReg);
1285         BAD(EndExcept);
1286
1287         FIRM_OP(be_FrameAddr);
1288
1289         op_Max = get_op_Max();
1290         if (op_Max)
1291                 BAD(Max);
1292         op_Min = get_op_Min();
1293         if (op_Min)
1294                 BAD(Min);
1295         op_Mulh = get_op_Mulh();
1296         if (op_Mulh)
1297                 BAD(Mulh);
1298
1299 #undef IGN
1300 #undef FIRM_OP
1301 #undef BAD
1302 }
1303
1304 typedef ir_node *(transform_func)(ir_node *irn, arm_code_gen_t *cg);
1305
1306 /**
1307  * Transforms the given firm node (and maybe some other related nodes)
1308  * into one or more assembler nodes.
1309  *
1310  * @param node    the firm node
1311  * @param env     the debug module
1312  */
1313 void arm_transform_node(ir_node *node, void *env) {
1314         arm_code_gen_t *cg = (arm_code_gen_t *)env;
1315         ir_op *op          = get_irn_op(node);
1316         ir_node *asm_node  = NULL;
1317
1318         if (op == op_Block)
1319                 return;
1320
1321         DBG((cg->mod, LEVEL_1, "check %+F ... ", node));
1322
1323         if (op->ops.generic) {
1324                 transform_func *transform = (transform_func *)op->ops.generic;
1325
1326                 asm_node = (*transform)(node, cg);
1327         }
1328
1329         if (asm_node) {
1330                 exchange(node, asm_node);
1331                 DB((cg->mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node));
1332         }
1333         else {
1334                 DB((cg->mod, LEVEL_1, "ignored\n"));
1335         }
1336 }