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