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

   1 /*
   2  * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   6  * This file may be distributed and/or modified under the terms of the
   7  * GNU General Public License version 2 as published by the Free Software
   8  * Foundation and appearing in the file LICENSE.GPL included in the
   9  * packaging of this file.
  10  *
  11  * Licensees holding valid libFirm Professional Edition licenses may use
  12  * this file in accordance with the libFirm Commercial License.
  13  * Agreement provided with the Software.
  14  *
  15  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief   arm emitter
  23  * @author  Oliver Richter, Tobias Gneist, Michael Beck
  24  * @version $Id$
  25  */
  26 #define SILENCER
  27
  28 #ifdef HAVE_CONFIG_H
  29 #include "config.h"
  30 #endif
  31
  32 #include <limits.h>
  33
  34 #include "xmalloc.h"
  35 #include "tv.h"
  36 #include "iredges.h"
  37 #include "debug.h"
  38 #include "irgwalk.h"
  39 #include "irtools.h"
  40 #include "irprintf.h"
  41 #include "irop_t.h"
  42 #include "irprog_t.h"
  43 #include "irargs_t.h"
  44 #include "error.h"
  45 #include "raw_bitset.h"
  46 #include "dbginfo.h"
  47
  48 #include "../besched.h"
  49 #include "../beblocksched.h"
  50 #include "../beirg_t.h"
  51 #include "../begnuas.h"
  52 #include "../be_dbgout.h"
  53
  54 #include "arm_emitter.h"
  55 #include "arm_optimize.h"
  56 #include "gen_arm_emitter.h"
  57 #include "arm_nodes_attr.h"
  58 #include "arm_new_nodes.h"
  59 #include "arm_map_regs.h"
  60 #include "gen_arm_regalloc_if.h"
  61
  62 #include "../benode_t.h"
  63
  64 #define BLOCK_PREFIX ".L"
  65
  66 #define SNPRINTF_BUF_LEN 128
  67
  68 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
  69
  70 static const arm_code_gen_t *cg;
  71 static const arm_isa_t      *isa;
  72 static set                  *sym_or_tv;
  73
  74 /**
  75  * Returns the register at in position pos.
  76  */
  77 static const arch_register_t *get_in_reg(const ir_node *irn, int pos) {
  78         ir_node                *op;
  79         const arch_register_t  *reg = NULL;
  80
  81         assert(get_irn_arity(irn) > pos && "Invalid IN position");
  82
  83         /* The out register of the operator at position pos is the
  84            in register we need. */
  85         op = get_irn_n(irn, pos);
  86
  87         reg = arch_get_irn_register(op);
  88
  89         assert(reg && "no in register found");
  90
  91         /* in case of a joker register: just return a valid register */
  92         if (arch_register_type_is(reg, joker)) {
  93                 const arch_register_req_t *req = arch_get_register_req(irn, pos);
  94
  95                 if (arch_register_req_is(req, limited)) {
  96                         /* in case of limited requirements: get the first allowed register */
  97                         unsigned idx = rbitset_next(req->limited, 0, 1);
  98                         reg = arch_register_for_index(req->cls, idx);
  99                 } else {
 100                         /* otherwise get first register in class */
 101                         reg = arch_register_for_index(req->cls, 0);
 102                 }
 103         }
 104         return reg;
 105 }
 106
 107
 108 /**
 109  * Returns the register at out position pos.
 110  */
 111 static const arch_register_t *get_out_reg(const ir_node *node, int pos)
 112 {
 113     ir_node                *proj;
 114     const arch_register_t  *reg = NULL;
 115
 116     /* 1st case: irn is not of mode_T, so it has only                 */
 117     /*           one OUT register -> good                             */
 118     /* 2nd case: irn is of mode_T -> collect all Projs and ask the    */
 119     /*           Proj with the corresponding projnum for the register */
 120
 121     if (get_irn_mode(node) != mode_T) {
 122         reg = arch_get_irn_register(node);
 123     } else if (is_arm_irn(node)) {
 124         reg = get_arm_out_reg(node, pos);
 125     } else {
 126         const ir_edge_t *edge;
 127
 128         foreach_out_edge(node, edge) {
 129             proj = get_edge_src_irn(edge);
 130             assert(is_Proj(proj) && "non-Proj from mode_T node");
 131             if (get_Proj_proj(proj) == pos) {
 132                 reg = arch_get_irn_register(proj);
 133                 break;
 134             }
 135         }
 136     }
 137
 138     assert(reg && "no out register found");
 139     return reg;
 140 }
 141
 142 /*************************************************************
 143  *             _       _    __   _          _
 144  *            (_)     | |  / _| | |        | |
 145  *  _ __  _ __ _ _ __ | |_| |_  | |__   ___| |_ __   ___ _ __
 146  * | '_ \| '__| | '_ \| __|  _| | '_ \ / _ \ | '_ \ / _ \ '__|
 147  * | |_) | |  | | | | | |_| |   | | | |  __/ | |_) |  __/ |
 148  * | .__/|_|  |_|_| |_|\__|_|   |_| |_|\___|_| .__/ \___|_|
 149  * | |                                       | |
 150  * |_|                                       |_|
 151  *************************************************************/
 152
 153 /**
 154  * Emit the name of the source register at given input position.
 155  */
 156 void arm_emit_source_register(const ir_node *node, int pos) {
 157         const arch_register_t *reg = get_in_reg(node, pos);
 158         be_emit_string(arch_register_get_name(reg));
 159 }
 160
 161 /**
 162  * Emit the name of the destination register at given output position.
 163  */
 164 void arm_emit_dest_register(const ir_node *node, int pos) {
 165         const arch_register_t *reg = get_out_reg(node, pos);
 166         be_emit_string(arch_register_get_name(reg));
 167 }
 168
 169 /**
 170  * Emit a node's offset.
 171  */
 172 void arm_emit_offset(const ir_node *node) {
 173         int offset = 0;
 174         ir_opcode opc = get_irn_opcode(node);
 175
 176         if (opc == beo_Reload || opc == beo_Spill) {
 177                 ir_entity *ent = be_get_frame_entity(node);
 178                 offset = get_entity_offset(ent);
 179         } else {
 180                 assert(!"unimplemented arm_emit_offset for this node type");
 181                 panic("unimplemented arm_emit_offset for this node type");
 182         }
 183         be_emit_irprintf("%d", offset);
 184 }
 185
 186 /**
 187  * Emit the arm fpa instruction suffix depending on the mode.
 188  */
 189 static void arm_emit_fpa_postfix(const ir_mode *mode) {
 190         int bits = get_mode_size_bits(mode);
 191         char c = 'e';
 192
 193         if (bits == 32)
 194                 c = 's';
 195         else if (bits == 64)
 196                 c = 'd';
 197         be_emit_char(c);
 198 }
 199
 200 /**
 201  * Emit the instruction suffix depending on the mode.
 202  */
 203 void arm_emit_mode(const ir_node *node) {
 204         ir_mode *mode;
 205
 206         if (is_arm_irn(node)) {
 207                 const arm_attr_t *attr = get_arm_attr_const(node);
 208                 mode = attr->op_mode ? attr->op_mode : get_irn_mode(node);
 209         } else {
 210                 mode = get_irn_mode(node);
 211         }
 212         arm_emit_fpa_postfix(mode);
 213 }
 214
 215 /**
 216  * Emit a const or SymConst value.
 217  */
 218 void arm_emit_immediate(const ir_node *node) {
 219         const arm_attr_t *attr = get_arm_attr_const(node);
 220
 221         if (ARM_GET_SHF_MOD(attr) == ARM_SHF_IMM) {
 222                 be_emit_irprintf("#0x%X", arm_decode_imm_w_shift(get_arm_imm_value(node)));
 223         } else if (ARM_GET_FPA_IMM(attr)) {
 224                 be_emit_irprintf("#%s", arm_get_fpa_imm_name(get_arm_imm_value(node)));
 225         } else if (is_arm_SymConst(node))
 226                 be_emit_ident(get_arm_symconst_id(node));
 227         else {
 228                 assert(!"not a Constant");
 229         }
 230 }
 231
 232 /**
 233  * Returns the tarval or offset of an arm node as a string.
 234  */
 235 void arm_emit_shift(const ir_node *node) {
 236         arm_shift_modifier mod;
 237
 238         mod = get_arm_shift_modifier(node);
 239         if (ARM_HAS_SHIFT(mod)) {
 240                 int v = get_arm_imm_value(node);
 241
 242                 be_emit_irprintf(", %s #%d", arm_shf_mod_name(mod), v);
 243         }
 244 }
 245
 246 /** An entry in the sym_or_tv set. */
 247 typedef struct sym_or_tv_t {
 248         union {
 249                 ident  *id;          /**< An ident. */
 250                 tarval *tv;          /**< A tarval. */
 251                 const void *generic; /**< For generic compare. */
 252         } u;
 253         unsigned label;      /**< the associated label. */
 254         char is_ident;       /**< Non-zero if an ident is stored. */
 255 } sym_or_tv_t;
 256
 257 /**
 258  * Returns a unique label. This number will not be used a second time.
 259  */
 260 static unsigned get_unique_label(void) {
 261         static unsigned id = 0;
 262         return ++id;
 263 }
 264
 265 /**
 266  * Emit a SymConst.
 267  */
 268 static void emit_arm_SymConst(const ir_node *irn) {
 269         sym_or_tv_t key, *entry;
 270         unsigned label;
 271
 272         key.u.id     = get_arm_symconst_id(irn);
 273         key.is_ident = 1;
 274         key.label    = 0;
 275         entry = (sym_or_tv_t *)set_insert(sym_or_tv, &key, sizeof(key), HASH_PTR(key.u.generic));
 276         if (entry->label == 0) {
 277                 /* allocate a label */
 278                 entry->label = get_unique_label();
 279         }
 280         label = entry->label;
 281
 282         /* load the symbol indirect */
 283         be_emit_cstring("\tldr ");
 284         arm_emit_dest_register(irn, 0);
 285         be_emit_irprintf(", .L%u", label);
 286         be_emit_finish_line_gas(irn);
 287 }
 288
 289 /**
 290  * Emit a floating point fpa constant.
 291  */
 292 static void emit_arm_fpaConst(const ir_node *irn) {
 293         sym_or_tv_t key, *entry;
 294         unsigned label;
 295         ir_mode *mode;
 296
 297         key.u.tv     = get_fpaConst_value(irn);
 298         key.is_ident = 0;
 299         key.label    = 0;
 300         entry = (sym_or_tv_t *)set_insert(sym_or_tv, &key, sizeof(key), HASH_PTR(key.u.generic));
 301         if (entry->label == 0) {
 302                 /* allocate a label */
 303                 entry->label = get_unique_label();
 304         }
 305         label = entry->label;
 306
 307         /* load the tarval indirect */
 308         mode = get_irn_mode(irn);
 309         be_emit_cstring("\tldf");
 310         arm_emit_fpa_postfix(mode);
 311         be_emit_char(' ');
 312
 313         arm_emit_dest_register(irn, 0);
 314         be_emit_irprintf(", .L%u", label);
 315         be_emit_finish_line_gas(irn);
 316 }
 317
 318 /**
 319  * Returns the next block in a block schedule.
 320  */
 321 static ir_node *sched_next_block(const ir_node *block) {
 322     return get_irn_link(block);
 323 }
 324
 325 /**
 326  * Returns the target block for a control flow node.
 327  */
 328 static ir_node *get_cfop_target_block(const ir_node *irn) {
 329         return get_irn_link(irn);
 330 }
 331
 332 /**
 333  * Emits a block label for the given block.
 334  */
 335 static void arm_emit_block_name(const ir_node *block) {
 336         if (has_Block_label(block)) {
 337                 be_emit_string(be_gas_block_label_prefix());
 338                 be_emit_irprintf("%lu", get_Block_label(block));
 339         } else {
 340                 be_emit_cstring(BLOCK_PREFIX);
 341                 be_emit_irprintf("%d", get_irn_node_nr(block));
 342         }
 343 }
 344
 345 /**
 346  * Emit the target label for a control flow node.
 347  */
 348 static void arm_emit_cfop_target(const ir_node *irn) {
 349         ir_node *block = get_cfop_target_block(irn);
 350
 351         arm_emit_block_name(block);
 352 }
 353
 354 /**
 355  * Emit a Compare with conditional branch.
 356  */
 357 static void emit_arm_CmpBra(const ir_node *irn) {
 358         const ir_edge_t *edge;
 359         const ir_node *proj_true  = NULL;
 360         const ir_node *proj_false = NULL;
 361         const ir_node *block;
 362         const ir_node *next_block;
 363         ir_node *op1 = get_irn_n(irn, 0);
 364         ir_mode *opmode = get_irn_mode(op1);
 365         const char *suffix;
 366         int proj_num = get_arm_CondJmp_proj_num(irn);
 367
 368         foreach_out_edge(irn, edge) {
 369                 ir_node *proj = get_edge_src_irn(edge);
 370                 long nr = get_Proj_proj(proj);
 371                 if (nr == pn_Cond_true) {
 372                         proj_true = proj;
 373                 } else {
 374                         proj_false = proj;
 375                 }
 376         }
 377
 378         /* for now, the code works for scheduled and non-schedules blocks */
 379         block = get_nodes_block(irn);
 380
 381         /* we have a block schedule */
 382         next_block = sched_next_block(block);
 383
 384         if (proj_num == pn_Cmp_False) {
 385                 /* always false: should not happen */
 386                 be_emit_cstring("\tb ");
 387                 arm_emit_cfop_target(proj_false);
 388                 be_emit_finish_line_gas(proj_false);
 389         } else if (proj_num == pn_Cmp_True) {
 390                 /* always true: should not happen */
 391                 be_emit_cstring("\tb ");
 392                 arm_emit_cfop_target(proj_true);
 393                 be_emit_finish_line_gas(proj_true);
 394         } else {
 395                 if (mode_is_float(opmode)) {
 396                         suffix = "ICHWILLIMPLEMENTIERTWERDEN";
 397
 398                         be_emit_cstring("\tfcmp ");
 399                         arm_emit_source_register(irn, 0);
 400                         be_emit_cstring(", ");
 401                         arm_emit_source_register(irn, 1);
 402                         be_emit_finish_line_gas(irn);
 403
 404                         be_emit_cstring("\tfmstat");
 405                         be_emit_pad_comment();
 406                         be_emit_cstring("/* FCSPR -> CPSR */");
 407                         be_emit_finish_line_gas(NULL);
 408                 } else {
 409                         if (get_cfop_target_block(proj_true) == next_block) {
 410                                 /* exchange both proj's so the second one can be omitted */
 411                                 const ir_node *t = proj_true;
 412
 413                                 proj_true  = proj_false;
 414                                 proj_false = t;
 415                                 proj_num   = get_negated_pnc(proj_num, mode_Iu);
 416                         }
 417                         switch (proj_num) {
 418                                 case pn_Cmp_Eq:  suffix = "eq"; break;
 419                                 case pn_Cmp_Lt:  suffix = "lt"; break;
 420                                 case pn_Cmp_Le:  suffix = "le"; break;
 421                                 case pn_Cmp_Gt:  suffix = "gt"; break;
 422                                 case pn_Cmp_Ge:  suffix = "ge"; break;
 423                                 case pn_Cmp_Lg:  suffix = "ne"; break;
 424                                 case pn_Cmp_Leg: suffix = "al"; break;
 425                                 default: assert(!"Cmp unsupported"); suffix = "al";
 426                         }
 427                         be_emit_cstring("\tcmp ");
 428                         arm_emit_source_register(irn, 0);
 429                         be_emit_cstring(", ");
 430                         arm_emit_source_register(irn, 1);
 431                         be_emit_finish_line_gas(irn);
 432                 }
 433
 434                 /* emit the true proj */
 435                 be_emit_irprintf("\tb%s ", suffix);
 436                 arm_emit_cfop_target(proj_true);
 437                 be_emit_finish_line_gas(proj_true);
 438
 439                 if (get_cfop_target_block(proj_false) == next_block) {
 440                         be_emit_cstring("\t/* fallthrough to ");
 441                         arm_emit_cfop_target(proj_false);
 442                         be_emit_cstring(" */");
 443                         be_emit_finish_line_gas(proj_false);
 444                 } else {
 445                         be_emit_cstring("b ");
 446                         arm_emit_cfop_target(proj_false);
 447                         be_emit_finish_line_gas(proj_false);
 448                 }
 449         }
 450 }
 451
 452
 453 /**
 454  * Emit a Tst with conditional branch.
 455  */
 456 static void emit_arm_TstBra(const ir_node *irn)
 457 {
 458         const ir_edge_t *edge;
 459         const ir_node *proj_true  = NULL;
 460         const ir_node *proj_false = NULL;
 461         const ir_node *block;
 462         const ir_node *next_block;
 463         const char *suffix;
 464         int proj_num = get_arm_CondJmp_proj_num(irn);
 465
 466         foreach_out_edge(irn, edge) {
 467                 ir_node *proj = get_edge_src_irn(edge);
 468                 long nr = get_Proj_proj(proj);
 469                 if (nr == pn_Cond_true) {
 470                         proj_true = proj;
 471                 } else {
 472                         proj_false = proj;
 473                 }
 474         }
 475
 476         /* for now, the code works for scheduled and non-schedules blocks */
 477         block = get_nodes_block(irn);
 478
 479         /* we have a block schedule */
 480         next_block = sched_next_block(block);
 481
 482         assert(proj_num != pn_Cmp_False);
 483         assert(proj_num != pn_Cmp_True);
 484
 485         if (get_cfop_target_block(proj_true) == next_block) {
 486                 /* exchange both proj's so the second one can be omitted */
 487                 const ir_node *t = proj_true;
 488
 489                 proj_true  = proj_false;
 490                 proj_false = t;
 491                 proj_num   = get_negated_pnc(proj_num, mode_Iu);
 492         }
 493         switch (proj_num) {
 494                 case pn_Cmp_Eq:  suffix = "eq"; break;
 495                 case pn_Cmp_Lt:  suffix = "lt"; break;
 496                 case pn_Cmp_Le:  suffix = "le"; break;
 497                 case pn_Cmp_Gt:  suffix = "gt"; break;
 498                 case pn_Cmp_Ge:  suffix = "ge"; break;
 499                 case pn_Cmp_Lg:  suffix = "ne"; break;
 500                 case pn_Cmp_Leg: suffix = "al"; break;
 501                 default: assert(!"Cmp unsupported"); suffix = "al";
 502         }
 503         be_emit_cstring("\ttst ");
 504         arm_emit_source_register(irn, 0);
 505         be_emit_cstring(", ");
 506         arm_emit_source_register(irn, 1);
 507         be_emit_finish_line_gas(irn);
 508
 509         /* emit the true proj */
 510         be_emit_irprintf("\tb%s ", suffix);
 511         arm_emit_cfop_target(proj_true);
 512         be_emit_finish_line_gas(proj_true);
 513
 514         if (get_cfop_target_block(proj_false) == next_block) {
 515                 be_emit_cstring("\t/* fallthrough to ");
 516                 arm_emit_cfop_target(proj_false);
 517                 be_emit_cstring(" */");
 518                 be_emit_finish_line_gas(proj_false);
 519         } else {
 520                 be_emit_cstring("b ");
 521                 arm_emit_cfop_target(proj_false);
 522                 be_emit_finish_line_gas(proj_false);
 523         }
 524 }
 525
 526 /**
 527  * Emit a Compare with conditional branch.
 528  */
 529 static void emit_arm_fpaCmfBra(const ir_node *irn) {
 530         (void) irn;
 531 }
 532
 533 /**
 534  * Emit a Compare with conditional branch.
 535  */
 536 static void emit_arm_fpaCmfeBra(const ir_node *irn) {
 537         (void) irn;
 538 }
 539
 540 /** Sort register in ascending order. */
 541 static int reg_cmp(const void *a, const void *b) {
 542         const arch_register_t * const *ra = a;
 543         const arch_register_t * const *rb = b;
 544
 545         return *ra < *rb ? -1 : (*ra != *rb);
 546 }
 547
 548 /**
 549  * Create the CopyB instruction sequence.
 550  */
 551 static void emit_arm_CopyB(const ir_node *irn) {
 552         unsigned size = (unsigned)get_arm_imm_value(irn);
 553
 554         const char *tgt = arch_register_get_name(get_in_reg(irn, 0));
 555         const char *src = arch_register_get_name(get_in_reg(irn, 1));
 556         const char *t0, *t1, *t2, *t3;
 557
 558         const arch_register_t *tmpregs[4];
 559
 560         /* collect the temporary registers and sort them, we need ascending order */
 561         tmpregs[0] = get_in_reg(irn, 2);
 562         tmpregs[1] = get_in_reg(irn, 3);
 563         tmpregs[2] = get_in_reg(irn, 4);
 564         tmpregs[3] = &arm_gp_regs[REG_R12];
 565
 566         /* Note: R12 is always the last register because the RA did not assign higher ones */
 567         qsort((void *)tmpregs, 3, sizeof(tmpregs[0]), reg_cmp);
 568
 569         /* need ascending order */
 570         t0 = arch_register_get_name(tmpregs[0]);
 571         t1 = arch_register_get_name(tmpregs[1]);
 572         t2 = arch_register_get_name(tmpregs[2]);
 573         t3 = arch_register_get_name(tmpregs[3]);
 574
 575         be_emit_cstring("/* MemCopy (");
 576         be_emit_string(src);
 577         be_emit_cstring(")->(");
 578         arm_emit_source_register(irn, 0);
 579         be_emit_irprintf(" [%u bytes], Uses ", size);
 580         be_emit_string(t0);
 581         be_emit_cstring(", ");
 582         be_emit_string(t1);
 583         be_emit_cstring(", ");
 584         be_emit_string(t2);
 585         be_emit_cstring(", and ");
 586         be_emit_string(t3);
 587         be_emit_cstring("*/");
 588         be_emit_finish_line_gas(NULL);
 589
 590         assert(size > 0 && "CopyB needs size > 0" );
 591
 592         if (size & 3) {
 593                 assert(!"strange hack enabled: copy more bytes than needed!");
 594                 size += 4;
 595         }
 596
 597         size >>= 2;
 598         switch (size & 3) {
 599         case 0:
 600                 break;
 601         case 1:
 602                 be_emit_cstring("\tldr ");
 603                 be_emit_string(t3);
 604                 be_emit_cstring(", [");
 605                 be_emit_string(src);
 606                 be_emit_cstring(", #0]");
 607                 be_emit_finish_line_gas(NULL);
 608
 609                 be_emit_cstring("\tstr ");
 610                 be_emit_string(t3);
 611                 be_emit_cstring(", [");
 612                 be_emit_string(tgt);
 613                 be_emit_cstring(", #0]");
 614                 be_emit_finish_line_gas(irn);
 615                 break;
 616         case 2:
 617                 be_emit_cstring("\tldmia ");
 618                 be_emit_string(src);
 619                 be_emit_cstring("!, {");
 620                 be_emit_string(t0);
 621                 be_emit_cstring(", ");
 622                 be_emit_string(t1);
 623                 be_emit_char('}');
 624                 be_emit_finish_line_gas(NULL);
 625
 626                 be_emit_cstring("\tstmia ");
 627                 be_emit_string(tgt);
 628                 be_emit_cstring("!, {");
 629                 be_emit_string(t0);
 630                 be_emit_cstring(", ");
 631                 be_emit_string(t1);
 632                 be_emit_char('}');
 633                 be_emit_finish_line_gas(irn);
 634                 break;
 635         case 3:
 636                 be_emit_cstring("\tldmia ");
 637                 be_emit_string(src);
 638                 be_emit_cstring("!, {");
 639                 be_emit_string(t0);
 640                 be_emit_cstring(", ");
 641                 be_emit_string(t1);
 642                 be_emit_cstring(", ");
 643                 be_emit_string(t2);
 644                 be_emit_char('}');
 645                 be_emit_finish_line_gas(NULL);
 646
 647                 be_emit_cstring("\tstmia ");
 648                 be_emit_string(tgt);
 649                 be_emit_cstring("!, {");
 650                 be_emit_string(t0);
 651                 be_emit_cstring(", ");
 652                 be_emit_string(t1);
 653                 be_emit_cstring(", ");
 654                 be_emit_string(t2);
 655                 be_emit_char('}');
 656                 be_emit_finish_line_gas(irn);
 657                 break;
 658         }
 659         size >>= 2;
 660         while (size) {
 661                 be_emit_cstring("\tldmia ");
 662                 be_emit_string(src);
 663                 be_emit_cstring("!, {");
 664                 be_emit_string(t0);
 665                 be_emit_cstring(", ");
 666                 be_emit_string(t1);
 667                 be_emit_cstring(", ");
 668                 be_emit_string(t2);
 669                 be_emit_cstring(", ");
 670                 be_emit_string(t3);
 671                 be_emit_char('}');
 672                 be_emit_finish_line_gas(NULL);
 673
 674                 be_emit_cstring("\tstmia ");
 675                 be_emit_string(tgt);
 676                 be_emit_cstring("!, {");
 677                 be_emit_string(t0);
 678                 be_emit_cstring(", ");
 679                 be_emit_string(t1);
 680                 be_emit_cstring(", ");
 681                 be_emit_string(t2);
 682                 be_emit_cstring(", ");
 683                 be_emit_string(t3);
 684                 be_emit_char('}');
 685                 be_emit_finish_line_gas(irn);
 686                 --size;
 687         }
 688 }
 689
 690 static void emit_arm_SwitchJmp(const ir_node *irn) {
 691         const ir_edge_t    *edge;
 692         ir_node            *proj;
 693         int i;
 694         ir_node **projs;
 695         int n_projs;
 696         int block_nr;
 697         ir_node *default_proj = NULL;
 698
 699         block_nr = get_irn_node_nr(irn);
 700         n_projs = get_arm_SwitchJmp_n_projs(irn);
 701
 702         projs = XMALLOCNZ(ir_node*, n_projs);
 703
 704         foreach_out_edge(irn, edge) {
 705                 proj = get_edge_src_irn(edge);
 706                 assert(is_Proj(proj) && "Only proj allowed at SwitchJmp");
 707
 708                 if (get_Proj_proj(proj) == get_arm_SwitchJmp_default_proj_num(irn))
 709                         default_proj = proj;
 710
 711                 projs[get_Proj_proj(proj)] = proj;
 712         }
 713         assert(default_proj != NULL && "SwitchJmp should have a Default Proj");
 714
 715         /*
 716            CMP %1S, n_projs - 1
 717            BHI default
 718         */
 719
 720         be_emit_cstring("\tcmp ");
 721         arm_emit_source_register(irn, 0);
 722         be_emit_irprintf(", #%u", n_projs - 1);
 723         be_emit_finish_line_gas(irn);
 724
 725         be_emit_cstring("\tbhi ");
 726         arm_emit_cfop_target(default_proj);
 727         be_emit_finish_line_gas(default_proj);
 728
 729         /*
 730            LDR %r12, .TABLE_X_START
 731            ADD %r12, %r12, [%1S, LSL #2]
 732            LDR %r15, %r12
 733          */
 734
 735         be_emit_irprintf("\tldr %%r12, TABLE_%d_START", block_nr);
 736         be_emit_finish_line_gas(NULL);
 737
 738         be_emit_irprintf("\tadd %%r12, %%r12, ");
 739         arm_emit_source_register(irn, 0);
 740         be_emit_cstring(", LSL #2");
 741         be_emit_finish_line_gas(NULL);
 742
 743         be_emit_cstring("\tldr %r15, [%r12, #0]");
 744         be_emit_finish_line_gas(NULL);
 745
 746         be_emit_irprintf("TABLE_%d_START:\n\t.word\tTABLE_%d", block_nr, block_nr);
 747         be_emit_finish_line_gas(NULL);
 748         be_emit_irprintf("\t.align 2");
 749         be_emit_finish_line_gas(NULL);
 750         be_emit_irprintf("TABLE_%d:", block_nr);
 751         be_emit_finish_line_gas(NULL);
 752
 753         for (i = 0; i < n_projs; ++i) {
 754                 proj = projs[i];
 755                 if (proj == NULL) {
 756                         proj = projs[get_arm_SwitchJmp_default_proj_num(irn)];
 757                 }
 758                 be_emit_cstring("\t.word\t");
 759                 arm_emit_cfop_target(proj);
 760                 be_emit_finish_line_gas(proj);
 761         }
 762         be_emit_irprintf("\t.align 2\n");
 763         be_emit_finish_line_gas(NULL);
 764         xfree(projs);
 765 }
 766
 767 /************************************************************************/
 768 /* emit_be                                                              */
 769 /************************************************************************/
 770
 771 static void emit_be_Call(const ir_node *irn) {
 772         ir_entity *ent = be_Call_get_entity(irn);
 773
 774         be_emit_cstring("\tbl ");
 775         if (ent) {
 776                 set_entity_backend_marked(ent, 1);
 777                 be_emit_ident(get_entity_ld_ident(ent));
 778         } else {
 779                 arm_emit_source_register(irn, be_pos_Call_ptr);
 780         }
 781         be_emit_finish_line_gas(irn);
 782 }
 783
 784 /** Emit an IncSP node */
 785 static void emit_be_IncSP(const ir_node *irn) {
 786         int offs = -be_get_IncSP_offset(irn);
 787
 788         if (offs != 0) {
 789                 if (offs < 0) {
 790                         be_emit_cstring("\tsub ");
 791                         offs = -offs;
 792                 } else {
 793                         be_emit_cstring("\tadd ");
 794                 }
 795                 arm_emit_dest_register(irn, 0);
 796                 be_emit_cstring(", ");
 797                 arm_emit_source_register(irn, 0);
 798                 be_emit_irprintf(", #0x%X", offs);
 799         } else {
 800                 /* omitted IncSP(0) */
 801                 return;
 802         }
 803         be_emit_finish_line_gas(irn);
 804 }
 805
 806 static void emit_be_Copy(const ir_node *irn) {
 807         ir_mode *mode = get_irn_mode(irn);
 808
 809         if (get_in_reg(irn, 0) == get_out_reg(irn, 0)) {
 810                 /* omitted Copy */
 811                 return;
 812         }
 813
 814         if (mode_is_float(mode)) {
 815                 if (USE_FPA(isa)) {
 816                         be_emit_cstring("\tmvf");
 817                         arm_emit_mode(irn);
 818                         be_emit_char(' ');
 819                         arm_emit_dest_register(irn, 0);
 820                         be_emit_cstring(", ");
 821                         arm_emit_source_register(irn, 0);
 822                         be_emit_finish_line_gas(irn);
 823                 } else {
 824                         assert(0 && "move not supported for this mode");
 825                         panic("emit_be_Copy: move not supported for this mode");
 826                 }
 827         } else if (mode_is_data(mode)) {
 828                 be_emit_cstring("\tmov ");
 829                 arm_emit_dest_register(irn, 0);
 830                 be_emit_cstring(", ");
 831                 arm_emit_source_register(irn, 0);
 832                         be_emit_finish_line_gas(irn);
 833         } else {
 834                 assert(0 && "move not supported for this mode");
 835                 panic("emit_be_Copy: move not supported for this mode");
 836         }
 837 }
 838
 839 /**
 840  * Emit code for a Spill.
 841  */
 842 static void emit_be_Spill(const ir_node *irn) {
 843         ir_mode *mode = get_irn_mode(be_get_Spill_val(irn));
 844
 845         if (mode_is_float(mode)) {
 846                 if (USE_FPA(cg->isa)) {
 847                         be_emit_cstring("\tstf");
 848                         arm_emit_fpa_postfix(mode);
 849                         be_emit_char(' ');
 850                 } else {
 851                         assert(0 && "spill not supported for this mode");
 852                         panic("emit_be_Spill: spill not supported for this mode");
 853                 }
 854         } else if (mode_is_dataM(mode)) {
 855                 be_emit_cstring("\tstr ");
 856         } else {
 857                 assert(0 && "spill not supported for this mode");
 858                 panic("emit_be_Spill: spill not supported for this mode");
 859         }
 860         arm_emit_source_register(irn, 1);
 861         be_emit_cstring(", [");
 862         arm_emit_source_register(irn, 0);
 863         be_emit_cstring(", #");
 864         arm_emit_offset(irn);
 865         be_emit_char(']');
 866         be_emit_finish_line_gas(irn);
 867 }
 868
 869 /**
 870  * Emit code for a Reload.
 871  */
 872 static void emit_be_Reload(const ir_node *irn) {
 873         ir_mode *mode = get_irn_mode(irn);
 874
 875         if (mode_is_float(mode)) {
 876                 if (USE_FPA(cg->isa)) {
 877                         be_emit_cstring("\tldf");
 878                         arm_emit_fpa_postfix(mode);
 879                         be_emit_char(' ');
 880                 } else {
 881                         assert(0 && "reload not supported for this mode");
 882                         panic("emit_be_Reload: reload not supported for this mode");
 883                 }
 884         } else if (mode_is_dataM(mode)) {
 885                 be_emit_cstring("\tldr ");
 886         } else {
 887                 assert(0 && "reload not supported for this mode");
 888                 panic("emit_be_Reload: reload not supported for this mode");
 889         }
 890         arm_emit_dest_register(irn, 0);
 891         be_emit_cstring(", [");
 892         arm_emit_source_register(irn, 0);
 893         be_emit_cstring(", #");
 894         arm_emit_offset(irn);
 895         be_emit_char(']');
 896         be_emit_finish_line_gas(irn);
 897 }
 898
 899 static void emit_be_Perm(const ir_node *irn) {
 900         be_emit_cstring("\teor ");
 901         arm_emit_source_register(irn, 0);
 902         be_emit_cstring(", ");
 903         arm_emit_source_register(irn, 0);
 904         be_emit_cstring(", ");
 905         arm_emit_source_register(irn, 1);
 906         be_emit_finish_line_gas(NULL);
 907
 908         be_emit_cstring("\teor ");
 909         arm_emit_source_register(irn, 1);
 910         be_emit_cstring(", ");
 911         arm_emit_source_register(irn, 0);
 912         be_emit_cstring(", ");
 913         arm_emit_source_register(irn, 1);
 914         be_emit_finish_line_gas(NULL);
 915
 916         be_emit_cstring("\teor ");
 917         arm_emit_source_register(irn, 0);
 918         be_emit_cstring(", ");
 919         arm_emit_source_register(irn, 0);
 920         be_emit_cstring(", ");
 921         arm_emit_source_register(irn, 1);
 922         be_emit_finish_line_gas(irn);
 923 }
 924
 925 /************************************************************************/
 926 /* emit                                                                 */
 927 /************************************************************************/
 928
 929 static void emit_Jmp(const ir_node *node) {
 930         ir_node *block, *next_block;
 931
 932         /* for now, the code works for scheduled and non-schedules blocks */
 933         block = get_nodes_block(node);
 934
 935         /* we have a block schedule */
 936         next_block = sched_next_block(block);
 937         if (get_cfop_target_block(node) != next_block) {
 938                 be_emit_cstring("\tb ");
 939                 arm_emit_cfop_target(node);
 940         } else {
 941                 be_emit_cstring("\t/* fallthrough to ");
 942                 arm_emit_cfop_target(node);
 943                 be_emit_cstring(" */");
 944         }
 945         be_emit_finish_line_gas(node);
 946 }
 947
 948 static void emit_arm_fpaDbl2GP(const ir_node *irn) {
 949         be_emit_cstring("\tstfd ");
 950         arm_emit_source_register(irn, 0);
 951         be_emit_cstring(", [sp, #-8]!");
 952         be_emit_pad_comment();
 953         be_emit_cstring("/* Push fp to stack */");
 954         be_emit_finish_line_gas(NULL);
 955
 956         be_emit_cstring("\tldmfd sp!, {");
 957         arm_emit_dest_register(irn, 1);
 958         be_emit_cstring(", ");
 959         arm_emit_dest_register(irn, 0);
 960         be_emit_char('}');
 961         be_emit_pad_comment();
 962         be_emit_cstring("/* Pop destination */");
 963         be_emit_finish_line_gas(irn);
 964 }
 965
 966 static void emit_arm_LdTls(const ir_node *irn) {
 967         (void) irn;
 968         panic("TLS not supported for this target");
 969         /* Er... our gcc does not support it... Install a newer toolchain. */
 970 }
 971
 972 /***********************************************************************************
 973  *                  _          __                                             _
 974  *                 (_)        / _|                                           | |
 975  *  _ __ ___   __ _ _ _ __   | |_ _ __ __ _ _ __ ___   _____      _____  _ __| | __
 976  * | '_ ` _ \ / _` | | '_ \  |  _| '__/ _` | '_ ` _ \ / _ \ \ /\ / / _ \| '__| |/ /
 977  * | | | | | | (_| | | | | | | | | | | (_| | | | | | |  __/\ V  V / (_) | |  |   <
 978  * |_| |_| |_|\__,_|_|_| |_| |_| |_|  \__,_|_| |_| |_|\___| \_/\_/ \___/|_|  |_|\_\
 979  *
 980  ***********************************************************************************/
 981
 982 static void emit_silence(const ir_node *irn) {
 983         (void) irn;
 984         /* Do nothing. */
 985 }
 986
 987 /**
 988  * The type of a emitter function.
 989  */
 990 typedef void (emit_func)(const ir_node *irn);
 991
 992 /**
 993  * Set a node emitter. Make it a bit more type safe.
 994  */
 995 static INLINE void set_emitter(ir_op *op, emit_func arm_emit_node) {
 996         op->ops.generic = (op_func)arm_emit_node;
 997 }
 998
 999 /**
1000  * Enters the emitter functions for handled nodes into the generic
1001  * pointer of an opcode.
1002  */
1003 static void arm_register_emitters(void) {
1004
1005 #define ARM_EMIT(a)  set_emitter(op_arm_##a, emit_arm_##a)
1006 #define EMIT(a)      set_emitter(op_##a, emit_##a)
1007 #define BE_EMIT(a)   set_emitter(op_be_##a, emit_be_##a)
1008 #define SILENCE(a)   set_emitter(op_##a, emit_silence)
1009
1010         /* first clear the generic function pointer for all ops */
1011         clear_irp_opcodes_generic_func();
1012
1013         /* register all emitter functions defined in spec */
1014         arm_register_spec_emitters();
1015
1016         /* other emitter functions */
1017         ARM_EMIT(CmpBra);
1018         ARM_EMIT(TstBra);
1019         ARM_EMIT(fpaCmfBra);
1020         ARM_EMIT(fpaCmfeBra);
1021         ARM_EMIT(CopyB);
1022 //      ARM_EMIT(CopyB_i);
1023 //      ARM_EMIT(Const);
1024         ARM_EMIT(SymConst);
1025         ARM_EMIT(SwitchJmp);
1026         ARM_EMIT(fpaDbl2GP);
1027         ARM_EMIT(fpaConst);
1028         ARM_EMIT(LdTls);
1029
1030         /* benode emitter */
1031         BE_EMIT(Call);
1032         BE_EMIT(IncSP);
1033         BE_EMIT(Copy);
1034         BE_EMIT(Spill);
1035         BE_EMIT(Reload);
1036         BE_EMIT(Perm);
1037
1038         /* firm emitter */
1039         EMIT(Jmp);
1040
1041         /* noisy stuff */
1042 #ifdef SILENCER
1043         SILENCE(Start);
1044         SILENCE(Proj);
1045         SILENCE(Phi);
1046         SILENCE(be_Keep);
1047         SILENCE(be_CopyKeep);
1048         SILENCE(be_RegParams);
1049         SILENCE(be_Barrier);
1050         SILENCE(be_Return);
1051 #endif
1052
1053 #undef ARM_EMIT
1054 #undef BE_EMIT
1055 #undef EMIT
1056 #undef SILENCE
1057 }
1058
1059 /**
1060  * Emits code for a node.
1061  */
1062 static void arm_emit_node(const ir_node *irn) {
1063         ir_op *op = get_irn_op(irn);
1064
1065         if (op->ops.generic) {
1066                 emit_func *emit = (emit_func *)op->ops.generic;
1067                 be_dbg_set_dbg_info(get_irn_dbg_info(irn));
1068                 (*emit)(irn);
1069         } else {
1070                 be_emit_cstring("\t/* TODO */");
1071                 be_emit_finish_line_gas(irn);
1072         }
1073 }
1074
1075 /**
1076  * emit the block label if needed.
1077  */
1078 static void arm_emit_block_header(ir_node *block, ir_node *prev)
1079 {
1080         int           n_cfgpreds;
1081         int           need_label;
1082         int           i, arity;
1083         ir_exec_freq  *exec_freq = cg->birg->exec_freq;
1084
1085         need_label = 0;
1086         n_cfgpreds = get_Block_n_cfgpreds(block);
1087         if (n_cfgpreds == 1) {
1088                 ir_node *pred       = get_Block_cfgpred(block, 0);
1089                 ir_node *pred_block = get_nodes_block(pred);
1090
1091                 /* we don't need labels for fallthrough blocks, however switch-jmps
1092                  * are no fallthroughs */
1093                 if (pred_block == prev &&
1094                                 !(is_Proj(pred) && is_arm_SwitchJmp(get_Proj_pred(pred)))) {
1095                         need_label = 0;
1096                 } else {
1097                         need_label = 1;
1098                 }
1099         } else {
1100                 need_label = 1;
1101         }
1102
1103         if (need_label) {
1104                 arm_emit_block_name(block);
1105                 be_emit_char(':');
1106
1107                 be_emit_pad_comment();
1108                 be_emit_cstring("   /* preds:");
1109
1110                 /* emit list of pred blocks in comment */
1111                 arity = get_irn_arity(block);
1112                 for (i = 0; i < arity; ++i) {
1113                         ir_node *predblock = get_Block_cfgpred_block(block, i);
1114                         be_emit_irprintf(" %d", get_irn_node_nr(predblock));
1115                 }
1116         } else {
1117                 be_emit_cstring("\t/* ");
1118                 arm_emit_block_name(block);
1119                 be_emit_cstring(": ");
1120         }
1121         if (exec_freq != NULL) {
1122                 be_emit_irprintf(" freq: %f",
1123                                  get_block_execfreq(exec_freq, block));
1124         }
1125         be_emit_cstring(" */\n");
1126         be_emit_write_line();
1127 }
1128
1129 /**
1130  * Walks over the nodes in a block connected by scheduling edges
1131  * and emits code for each node.
1132  */
1133 static void arm_gen_block(ir_node *block, ir_node *prev_block) {
1134         ir_node *irn;
1135
1136         arm_emit_block_header(block, prev_block);
1137         be_dbg_set_dbg_info(get_irn_dbg_info(block));
1138         sched_foreach(block, irn) {
1139                 arm_emit_node(irn);
1140         }
1141 }
1142
1143 /**
1144  * Emits code for function start.
1145  */
1146 void arm_func_prolog(ir_graph *irg) {
1147         ir_entity *ent = get_irg_entity(irg);
1148         const char *irg_name = get_entity_ld_name(ent);
1149
1150         be_emit_write_line();
1151         be_gas_emit_switch_section(GAS_SECTION_TEXT);
1152         be_emit_cstring("\t.align  2\n");
1153
1154         if (get_entity_visibility(ent) == visibility_external_visible)
1155                 be_emit_irprintf("\t.global %s\n", irg_name);
1156         be_emit_irprintf("%s:\n", irg_name);
1157 }
1158
1159 /**
1160  * Emits code for function end
1161  */
1162 void arm_emit_end(FILE *F, ir_graph *irg) {
1163         (void) irg;
1164         fprintf(F, "\t.ident \"firmcc\"\n");
1165 }
1166
1167 /**
1168  * Block-walker:
1169  * Sets labels for control flow nodes (jump target)
1170  */
1171 static void arm_gen_labels(ir_node *block, void *env) {
1172         ir_node *pred;
1173         int n = get_Block_n_cfgpreds(block);
1174         (void)env;
1175
1176         for (n--; n >= 0; n--) {
1177                 pred = get_Block_cfgpred(block, n);
1178                 set_irn_link(pred, block);
1179         }
1180 }
1181
1182 /**
1183  * Compare two entries of the symbol or tarval set.
1184  */
1185 static int cmp_sym_or_tv(const void *elt, const void *key, size_t size) {
1186         const sym_or_tv_t *p1 = elt;
1187         const sym_or_tv_t *p2 = key;
1188         (void) size;
1189
1190         /* as an identifier NEVER can point to a tarval, it's enough
1191            to compare it this way */
1192         return p1->u.generic != p2->u.generic;
1193 }
1194
1195 /**
1196  * Main driver. Emits the code for one routine.
1197  */
1198 void arm_gen_routine(const arm_code_gen_t *arm_cg, ir_graph *irg) {
1199         ir_node   **blk_sched;
1200         int       i, n;
1201         ir_node   *last_block = NULL;
1202         ir_entity *entity     = get_irg_entity(irg);
1203
1204         cg        = arm_cg;
1205         isa       = (const arm_isa_t *)cg->arch_env;
1206         sym_or_tv = new_set(cmp_sym_or_tv, 8);
1207
1208         arm_register_emitters();
1209
1210         be_dbg_method_begin(entity, be_abi_get_stack_layout(cg->birg->abi));
1211
1212         /* create the block schedule. For now, we don't need it earlier. */
1213         blk_sched = be_create_block_schedule(cg->irg, cg->birg->exec_freq);
1214
1215         arm_func_prolog(irg);
1216         irg_block_walk_graph(irg, arm_gen_labels, NULL, NULL);
1217
1218         n = ARR_LEN(blk_sched);
1219         for (i = 0; i < n;) {
1220                 ir_node *block, *next_bl;
1221
1222                 block   = blk_sched[i];
1223                 ++i;
1224                 next_bl = i < n ? blk_sched[i] : NULL;
1225
1226                 /* set here the link. the emitter expects to find the next block here */
1227                 set_irn_link(block, next_bl);
1228                 arm_gen_block(block, last_block);
1229                 last_block = block;
1230         }
1231
1232         be_dbg_method_end();
1233
1234         /* emit SymConst values */
1235         if (set_count(sym_or_tv) > 0) {
1236                 sym_or_tv_t *entry;
1237
1238                 be_emit_cstring("\t.align 2\n");
1239
1240                 foreach_set(sym_or_tv, entry) {
1241                         be_emit_irprintf(".L%u:\n", entry->label);
1242
1243                         if (entry->is_ident) {
1244                                 be_emit_cstring("\t.word\t");
1245                                 be_emit_ident(entry->u.id);
1246                                 be_emit_char('\n');
1247                                 be_emit_write_line();
1248                         } else {
1249                                 tarval *tv = entry->u.tv;
1250                                 int i, size = get_mode_size_bytes(get_tarval_mode(tv));
1251                                 unsigned v;
1252
1253                                 /* beware: ARM fpa uses big endian format */
1254                                 for (i = ((size + 3) & ~3) - 4; i >= 0; i -= 4) {
1255                                         /* get 32 bits */
1256                                         v =            get_tarval_sub_bits(tv, i+3);
1257                                         v = (v << 8) | get_tarval_sub_bits(tv, i+2);
1258                                         v = (v << 8) | get_tarval_sub_bits(tv, i+1);
1259                                         v = (v << 8) | get_tarval_sub_bits(tv, i+0);
1260                                         be_emit_irprintf("\t.word\t%u\n", v);
1261                                         be_emit_write_line();
1262                                 }
1263                         }
1264                 }
1265                 be_emit_char('\n');
1266                 be_emit_write_line();
1267         }
1268         del_set(sym_or_tv);
1269 }
1270
1271 void arm_init_emitter(void)
1272 {
1273         FIRM_DBG_REGISTER(dbg, "firm.be.arm.emit");
1274 }