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