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