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                 long v = get_arm_imm_value(node);
 245
 246                 be_emit_irprintf(", %s #%l", 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  * Emit a Compare with conditional branch.
 458  */
 459 static void emit_arm_fpaCmfBra(const ir_node *irn) {
 460         (void) irn;
 461 }
 462
 463 /**
 464  * Emit a Compare with conditional branch.
 465  */
 466 static void emit_arm_fpaCmfeBra(const ir_node *irn) {
 467         (void) irn;
 468 }
 469
 470 /** Sort register in ascending order. */
 471 static int reg_cmp(const void *a, const void *b) {
 472         const arch_register_t * const *ra = a;
 473         const arch_register_t * const *rb = b;
 474
 475         return *ra < *rb ? -1 : (*ra != *rb);
 476 }
 477
 478 /**
 479  * Create the CopyB instruction sequence.
 480  */
 481 static void emit_arm_CopyB(const ir_node *irn) {
 482         unsigned size = (unsigned)get_arm_imm_value(irn);
 483
 484         const char *tgt = arch_register_get_name(get_in_reg(irn, 0));
 485         const char *src = arch_register_get_name(get_in_reg(irn, 1));
 486         const char *t0, *t1, *t2, *t3;
 487
 488         const arch_register_t *tmpregs[4];
 489
 490         /* collect the temporary registers and sort them, we need ascending order */
 491         tmpregs[0] = get_in_reg(irn, 2);
 492         tmpregs[1] = get_in_reg(irn, 3);
 493         tmpregs[2] = get_in_reg(irn, 4);
 494         tmpregs[3] = &arm_gp_regs[REG_R12];
 495
 496         /* Note: R12 is always the last register because the RA did not assign higher ones */
 497         qsort((void *)tmpregs, 3, sizeof(tmpregs[0]), reg_cmp);
 498
 499         /* need ascending order */
 500         t0 = arch_register_get_name(tmpregs[0]);
 501         t1 = arch_register_get_name(tmpregs[1]);
 502         t2 = arch_register_get_name(tmpregs[2]);
 503         t3 = arch_register_get_name(tmpregs[3]);
 504
 505         be_emit_cstring("/* MemCopy (");
 506         be_emit_string(src);
 507         be_emit_cstring(")->(");
 508         arm_emit_source_register(irn, 0);
 509         be_emit_irprintf(" [%u bytes], Uses ", size);
 510         be_emit_string(t0);
 511         be_emit_cstring(", ");
 512         be_emit_string(t1);
 513         be_emit_cstring(", ");
 514         be_emit_string(t2);
 515         be_emit_cstring(", and ");
 516         be_emit_string(t3);
 517         be_emit_cstring("*/");
 518         be_emit_finish_line_gas(NULL);
 519
 520         assert(size > 0 && "CopyB needs size > 0" );
 521
 522         if (size & 3) {
 523                 assert(!"strange hack enabled: copy more bytes than needed!");
 524                 size += 4;
 525         }
 526
 527         size >>= 2;
 528         switch (size & 3) {
 529         case 0:
 530                 break;
 531         case 1:
 532                 be_emit_cstring("\tldr ");
 533                 be_emit_string(t3);
 534                 be_emit_cstring(", [");
 535                 be_emit_string(src);
 536                 be_emit_cstring(", #0]");
 537                 be_emit_finish_line_gas(NULL);
 538
 539                 be_emit_cstring("\tstr ");
 540                 be_emit_string(t3);
 541                 be_emit_cstring(", [");
 542                 be_emit_string(tgt);
 543                 be_emit_cstring(", #0]");
 544                 be_emit_finish_line_gas(irn);
 545                 break;
 546         case 2:
 547                 be_emit_cstring("\tldmia ");
 548                 be_emit_string(src);
 549                 be_emit_cstring("!, {");
 550                 be_emit_string(t0);
 551                 be_emit_cstring(", ");
 552                 be_emit_string(t1);
 553                 be_emit_char('}');
 554                 be_emit_finish_line_gas(NULL);
 555
 556                 be_emit_cstring("\tstmia ");
 557                 be_emit_string(tgt);
 558                 be_emit_cstring("!, {");
 559                 be_emit_string(t0);
 560                 be_emit_cstring(", ");
 561                 be_emit_string(t1);
 562                 be_emit_char('}');
 563                 be_emit_finish_line_gas(irn);
 564                 break;
 565         case 3:
 566                 be_emit_cstring("\tldmia ");
 567                 be_emit_string(src);
 568                 be_emit_cstring("!, {");
 569                 be_emit_string(t0);
 570                 be_emit_cstring(", ");
 571                 be_emit_string(t1);
 572                 be_emit_cstring(", ");
 573                 be_emit_string(t2);
 574                 be_emit_char('}');
 575                 be_emit_finish_line_gas(NULL);
 576
 577                 be_emit_cstring("\tstmia ");
 578                 be_emit_string(tgt);
 579                 be_emit_cstring("!, {");
 580                 be_emit_string(t0);
 581                 be_emit_cstring(", ");
 582                 be_emit_string(t1);
 583                 be_emit_cstring(", ");
 584                 be_emit_string(t2);
 585                 be_emit_char('}');
 586                 be_emit_finish_line_gas(irn);
 587                 break;
 588         }
 589         size >>= 2;
 590         while (size) {
 591                 be_emit_cstring("\tldmia ");
 592                 be_emit_string(src);
 593                 be_emit_cstring("!, {");
 594                 be_emit_string(t0);
 595                 be_emit_cstring(", ");
 596                 be_emit_string(t1);
 597                 be_emit_cstring(", ");
 598                 be_emit_string(t2);
 599                 be_emit_cstring(", ");
 600                 be_emit_string(t3);
 601                 be_emit_char('}');
 602                 be_emit_finish_line_gas(NULL);
 603
 604                 be_emit_cstring("\tstmia ");
 605                 be_emit_string(tgt);
 606                 be_emit_cstring("!, {");
 607                 be_emit_string(t0);
 608                 be_emit_cstring(", ");
 609                 be_emit_string(t1);
 610                 be_emit_cstring(", ");
 611                 be_emit_string(t2);
 612                 be_emit_cstring(", ");
 613                 be_emit_string(t3);
 614                 be_emit_char('}');
 615                 be_emit_finish_line_gas(irn);
 616                 --size;
 617         }
 618 }
 619
 620 static void emit_arm_SwitchJmp(const ir_node *irn) {
 621         const ir_edge_t    *edge;
 622         ir_node            *proj;
 623         int i;
 624         ir_node **projs;
 625         int n_projs;
 626         int block_nr;
 627         ir_node *default_proj = NULL;
 628
 629         block_nr = get_irn_node_nr(irn);
 630         n_projs = get_arm_SwitchJmp_n_projs(irn);
 631
 632         projs = xcalloc(n_projs , sizeof(ir_node*));
 633
 634         foreach_out_edge(irn, edge) {
 635                 proj = get_edge_src_irn(edge);
 636                 assert(is_Proj(proj) && "Only proj allowed at SwitchJmp");
 637
 638                 if (get_Proj_proj(proj) == get_arm_SwitchJmp_default_proj_num(irn))
 639                         default_proj = proj;
 640
 641                 projs[get_Proj_proj(proj)] = proj;
 642         }
 643         assert(default_proj != NULL && "SwitchJmp should have a Default Proj");
 644
 645         /*
 646            CMP %1S, n_projs - 1
 647            BHI default
 648         */
 649
 650         be_emit_cstring("\tcmp ");
 651         arm_emit_source_register(irn, 0);
 652         be_emit_irprintf(", #%u", n_projs - 1);
 653         be_emit_finish_line_gas(irn);
 654
 655         be_emit_cstring("\tbhi ");
 656         arm_emit_cfop_target(default_proj);
 657         be_emit_finish_line_gas(default_proj);
 658
 659         /*
 660            LDR %r12, .TABLE_X_START
 661            ADD %r12, %r12, [%1S, LSL #2]
 662            LDR %r15, %r12
 663          */
 664
 665         be_emit_irprintf("\tldr %%r12, TABLE_%d_START", block_nr);
 666         be_emit_finish_line_gas(NULL);
 667
 668         be_emit_irprintf("\tadd %%r12, %%r12, ");
 669         arm_emit_source_register(irn, 0);
 670         be_emit_cstring(", LSL #2");
 671         be_emit_finish_line_gas(NULL);
 672
 673         be_emit_cstring("\tldr %r15, [%r12, #0]");
 674         be_emit_finish_line_gas(NULL);
 675
 676         be_emit_irprintf("TABLE_%d_START:\n\t.word\tTABLE_%d", block_nr, block_nr);
 677         be_emit_finish_line_gas(NULL);
 678         be_emit_irprintf("\t.align 2");
 679         be_emit_finish_line_gas(NULL);
 680         be_emit_irprintf("TABLE_%d:", block_nr);
 681         be_emit_finish_line_gas(NULL);
 682
 683         for (i = 0; i < n_projs; ++i) {
 684                 proj = projs[i];
 685                 if (proj == NULL) {
 686                         proj = projs[get_arm_SwitchJmp_default_proj_num(irn)];
 687                 }
 688                 be_emit_cstring("\t.word\t");
 689                 arm_emit_cfop_target(proj);
 690                 be_emit_finish_line_gas(proj);
 691         }
 692         be_emit_irprintf("\t.align 2\n");
 693         be_emit_finish_line_gas(NULL);
 694         xfree(projs);
 695 }
 696
 697 /************************************************************************/
 698 /* emit_be                                                              */
 699 /************************************************************************/
 700
 701 static void emit_be_Call(const ir_node *irn) {
 702         ir_entity *ent = be_Call_get_entity(irn);
 703
 704         be_emit_cstring("\tbl ");
 705         if (ent) {
 706                 set_entity_backend_marked(ent, 1);
 707                 be_emit_ident(get_entity_ld_ident(ent));
 708         } else {
 709                 arm_emit_source_register(irn, be_pos_Call_ptr);
 710         }
 711         be_emit_finish_line_gas(irn);
 712 }
 713
 714 /** Emit an IncSP node */
 715 static void emit_be_IncSP(const ir_node *irn) {
 716         int offs = -be_get_IncSP_offset(irn);
 717
 718         if (offs != 0) {
 719                 if (offs < 0) {
 720                         be_emit_cstring("\tsub ");
 721                         offs = -offs;
 722                 } else {
 723                         be_emit_cstring("\tadd ");
 724                 }
 725                 arm_emit_dest_register(irn, 0);
 726                 be_emit_cstring(", ");
 727                 arm_emit_source_register(irn, 0);
 728                 be_emit_irprintf(", #%x", offs);
 729         } else {
 730                 /* omitted IncSP(0) */
 731                 return;
 732         }
 733         be_emit_finish_line_gas(irn);
 734 }
 735
 736 static void emit_be_Copy(const ir_node *irn) {
 737         ir_mode *mode = get_irn_mode(irn);
 738
 739         if (get_in_reg(irn, 0) == get_out_reg(irn, 0)) {
 740                 /* omitted Copy */
 741                 return;
 742         }
 743
 744         if (mode_is_float(mode)) {
 745                 if (USE_FPA(isa)) {
 746                         be_emit_cstring("\tmvf");
 747                         arm_emit_mode(irn);
 748                         be_emit_char(' ');
 749                         arm_emit_dest_register(irn, 0);
 750                         be_emit_cstring(", ");
 751                         arm_emit_source_register(irn, 0);
 752                         be_emit_finish_line_gas(irn);
 753                 } else {
 754                         assert(0 && "move not supported for this mode");
 755                         panic("emit_be_Copy: move not supported for this mode");
 756                 }
 757         } else if (mode_is_data(mode)) {
 758                 be_emit_cstring("\tmov ");
 759                 arm_emit_dest_register(irn, 0);
 760                 be_emit_cstring(", ");
 761                 arm_emit_source_register(irn, 0);
 762                         be_emit_finish_line_gas(irn);
 763         } else {
 764                 assert(0 && "move not supported for this mode");
 765                 panic("emit_be_Copy: move not supported for this mode");
 766         }
 767 }
 768
 769 /**
 770  * Emit code for a Spill.
 771  */
 772 static void emit_be_Spill(const ir_node *irn) {
 773         ir_mode *mode = get_irn_mode(be_get_Spill_val(irn));
 774
 775         if (mode_is_float(mode)) {
 776                 if (USE_FPA(cg->isa)) {
 777                         be_emit_cstring("\tstf");
 778                         arm_emit_fpa_postfix(mode);
 779                         be_emit_char(' ');
 780                 } else {
 781                         assert(0 && "spill not supported for this mode");
 782                         panic("emit_be_Spill: spill not supported for this mode");
 783                 }
 784         } else if (mode_is_dataM(mode)) {
 785                 be_emit_cstring("\tstr ");
 786         } else {
 787                 assert(0 && "spill not supported for this mode");
 788                 panic("emit_be_Spill: spill not supported for this mode");
 789         }
 790         arm_emit_source_register(irn, 1);
 791         be_emit_cstring(", [");
 792         arm_emit_source_register(irn, 0);
 793         be_emit_cstring(", #");
 794         arm_emit_offset(irn);
 795         be_emit_char(']');
 796         be_emit_finish_line_gas(irn);
 797 }
 798
 799 /**
 800  * Emit code for a Reload.
 801  */
 802 static void emit_be_Reload(const ir_node *irn) {
 803         ir_mode *mode = get_irn_mode(irn);
 804
 805         if (mode_is_float(mode)) {
 806                 if (USE_FPA(cg->isa)) {
 807                         be_emit_cstring("\tldf");
 808                         arm_emit_fpa_postfix(mode);
 809                         be_emit_char(' ');
 810                 } else {
 811                         assert(0 && "reload not supported for this mode");
 812                         panic("emit_be_Reload: reload not supported for this mode");
 813                 }
 814         } else if (mode_is_dataM(mode)) {
 815                 be_emit_cstring("\tldr ");
 816         } else {
 817                 assert(0 && "reload not supported for this mode");
 818                 panic("emit_be_Reload: reload not supported for this mode");
 819         }
 820         arm_emit_dest_register(irn, 0);
 821         be_emit_cstring(", [");
 822         arm_emit_source_register(irn, 0);
 823         be_emit_cstring(", #");
 824         arm_emit_offset(irn);
 825         be_emit_char(']');
 826         be_emit_finish_line_gas(irn);
 827 }
 828
 829 static void emit_be_Perm(const ir_node *irn) {
 830         be_emit_cstring("\teor ");
 831         arm_emit_source_register(irn, 0);
 832         be_emit_cstring(", ");
 833         arm_emit_source_register(irn, 0);
 834         be_emit_cstring(", ");
 835         arm_emit_source_register(irn, 1);
 836         be_emit_finish_line_gas(NULL);
 837
 838         be_emit_cstring("\teor ");
 839         arm_emit_source_register(irn, 1);
 840         be_emit_cstring(", ");
 841         arm_emit_source_register(irn, 0);
 842         be_emit_cstring(", ");
 843         arm_emit_source_register(irn, 1);
 844         be_emit_finish_line_gas(NULL);
 845
 846         be_emit_cstring("\teor ");
 847         arm_emit_source_register(irn, 0);
 848         be_emit_cstring(", ");
 849         arm_emit_source_register(irn, 0);
 850         be_emit_cstring(", ");
 851         arm_emit_source_register(irn, 1);
 852         be_emit_finish_line_gas(irn);
 853 }
 854
 855 /************************************************************************/
 856 /* emit                                                                 */
 857 /************************************************************************/
 858
 859 static void emit_Jmp(const ir_node *node) {
 860         ir_node *block, *next_block;
 861
 862         /* for now, the code works for scheduled and non-schedules blocks */
 863         block = get_nodes_block(node);
 864
 865         /* we have a block schedule */
 866         next_block = sched_next_block(block);
 867         if (get_cfop_target_block(node) != next_block) {
 868                 be_emit_cstring("\tb ");
 869                 arm_emit_cfop_target(node);
 870         } else {
 871                 be_emit_cstring("\t/* fallthrough to ");
 872                 arm_emit_cfop_target(node);
 873                 be_emit_cstring(" */");
 874         }
 875         be_emit_finish_line_gas(node);
 876 }
 877
 878 static void emit_arm_fpaDbl2GP(const ir_node *irn) {
 879         be_emit_cstring("\tstfd ");
 880         arm_emit_source_register(irn, 0);
 881         be_emit_cstring(", [sp, #-8]!");
 882         be_emit_pad_comment();
 883         be_emit_cstring("/* Push fp to stack */");
 884         be_emit_finish_line_gas(NULL);
 885
 886         be_emit_cstring("\tldmfd sp!, {");
 887         arm_emit_dest_register(irn, 1);
 888         be_emit_cstring(", ");
 889         arm_emit_dest_register(irn, 0);
 890         be_emit_char('}');
 891         be_emit_pad_comment();
 892         be_emit_cstring("/* Pop destination */");
 893         be_emit_finish_line_gas(irn);
 894 }
 895
 896 static void emit_arm_LdTls(const ir_node *irn) {
 897         (void) irn;
 898         panic("TLS not supported for this target\n");
 899         /* Er... our gcc does not support it... Install a newer toolchain. */
 900 }
 901
 902 /***********************************************************************************
 903  *                  _          __                                             _
 904  *                 (_)        / _|                                           | |
 905  *  _ __ ___   __ _ _ _ __   | |_ _ __ __ _ _ __ ___   _____      _____  _ __| | __
 906  * | '_ ` _ \ / _` | | '_ \  |  _| '__/ _` | '_ ` _ \ / _ \ \ /\ / / _ \| '__| |/ /
 907  * | | | | | | (_| | | | | | | | | | | (_| | | | | | |  __/\ V  V / (_) | |  |   <
 908  * |_| |_| |_|\__,_|_|_| |_| |_| |_|  \__,_|_| |_| |_|\___| \_/\_/ \___/|_|  |_|\_\
 909  *
 910  ***********************************************************************************/
 911
 912 static void emit_silence(const ir_node *irn) {
 913         (void) irn;
 914         /* Do nothing. */
 915 }
 916
 917 /**
 918  * The type of a emitter function.
 919  */
 920 typedef void (emit_func)(const ir_node *irn);
 921
 922 /**
 923  * Set a node emitter. Make it a bit more type safe.
 924  */
 925 static INLINE void set_emitter(ir_op *op, emit_func arm_emit_node) {
 926         op->ops.generic = (op_func)arm_emit_node;
 927 }
 928
 929 /**
 930  * Enters the emitter functions for handled nodes into the generic
 931  * pointer of an opcode.
 932  */
 933 static void arm_register_emitters(void) {
 934
 935 #define ARM_EMIT(a)  set_emitter(op_arm_##a, emit_arm_##a)
 936 #define EMIT(a)      set_emitter(op_##a, emit_##a)
 937 #define BE_EMIT(a)   set_emitter(op_be_##a, emit_be_##a)
 938 #define SILENCE(a)   set_emitter(op_##a, emit_silence)
 939
 940         /* first clear the generic function pointer for all ops */
 941         clear_irp_opcodes_generic_func();
 942
 943         /* register all emitter functions defined in spec */
 944         arm_register_spec_emitters();
 945
 946         /* other emitter functions */
 947         ARM_EMIT(CmpBra);
 948         ARM_EMIT(fpaCmfBra);
 949         ARM_EMIT(fpaCmfeBra);
 950         ARM_EMIT(CopyB);
 951 //      ARM_EMIT(CopyB_i);
 952 //      ARM_EMIT(Const);
 953         ARM_EMIT(SymConst);
 954         ARM_EMIT(SwitchJmp);
 955         ARM_EMIT(fpaDbl2GP);
 956         ARM_EMIT(fpaConst);
 957         ARM_EMIT(LdTls);
 958
 959         /* benode emitter */
 960         BE_EMIT(Call);
 961         BE_EMIT(IncSP);
 962         BE_EMIT(Copy);
 963         BE_EMIT(Spill);
 964         BE_EMIT(Reload);
 965         BE_EMIT(Perm);
 966
 967         /* firm emitter */
 968         EMIT(Jmp);
 969
 970         /* noisy stuff */
 971 #ifdef SILENCER
 972         SILENCE(Start);
 973         SILENCE(Proj);
 974         SILENCE(Phi);
 975         SILENCE(be_Keep);
 976         SILENCE(be_CopyKeep);
 977         SILENCE(be_RegParams);
 978         SILENCE(be_Barrier);
 979         SILENCE(be_Return);
 980 #endif
 981
 982 #undef ARM_EMIT
 983 #undef BE_EMIT
 984 #undef EMIT
 985 #undef SILENCE
 986 }
 987
 988 /**
 989  * Emits code for a node.
 990  */
 991 static void arm_emit_node(const ir_node *irn) {
 992         ir_op *op = get_irn_op(irn);
 993
 994         if (op->ops.generic) {
 995                 emit_func *emit = (emit_func *)op->ops.generic;
 996                 be_dbg_set_dbg_info(get_irn_dbg_info(irn));
 997                 (*emit)(irn);
 998         } else {
 999                 be_emit_cstring("\t/* TODO */");
1000                 be_emit_finish_line_gas(irn);
1001         }
1002 }
1003
1004 /**
1005  * emit the block label if needed.
1006  */
1007 static void arm_emit_block_header(ir_node *block, ir_node *prev)
1008 {
1009         int           n_cfgpreds;
1010         int           need_label;
1011         int           i, arity;
1012         ir_exec_freq  *exec_freq = cg->birg->exec_freq;
1013
1014         need_label = 0;
1015         n_cfgpreds = get_Block_n_cfgpreds(block);
1016         if (n_cfgpreds == 1) {
1017                 ir_node *pred       = get_Block_cfgpred(block, 0);
1018                 ir_node *pred_block = get_nodes_block(pred);
1019
1020                 /* we don't need labels for fallthrough blocks, however switch-jmps
1021                  * are no fallthroughs */
1022                 if (pred_block == prev &&
1023                                 !(is_Proj(pred) && is_arm_SwitchJmp(get_Proj_pred(pred)))) {
1024                         need_label = 0;
1025                 } else {
1026                         need_label = 1;
1027                 }
1028         } else {
1029                 need_label = 1;
1030         }
1031
1032         if (need_label) {
1033                 arm_emit_block_name(block);
1034                 be_emit_char(':');
1035
1036                 be_emit_pad_comment();
1037                 be_emit_cstring("   /* preds:");
1038
1039                 /* emit list of pred blocks in comment */
1040                 arity = get_irn_arity(block);
1041                 for (i = 0; i < arity; ++i) {
1042                         ir_node *predblock = get_Block_cfgpred_block(block, i);
1043                         be_emit_irprintf(" %d", get_irn_node_nr(predblock));
1044                 }
1045         } else {
1046                 be_emit_cstring("\t/* ");
1047                 arm_emit_block_name(block);
1048                 be_emit_cstring(": ");
1049         }
1050         if (exec_freq != NULL) {
1051                 be_emit_irprintf(" freq: %f",
1052                                  get_block_execfreq(exec_freq, block));
1053         }
1054         be_emit_cstring(" */\n");
1055         be_emit_write_line();
1056 }
1057
1058 /**
1059  * Walks over the nodes in a block connected by scheduling edges
1060  * and emits code for each node.
1061  */
1062 static void arm_gen_block(ir_node *block, ir_node *prev_block) {
1063         ir_node *irn;
1064
1065         arm_emit_block_header(block, prev_block);
1066         be_dbg_set_dbg_info(get_irn_dbg_info(block));
1067         sched_foreach(block, irn) {
1068                 arm_emit_node(irn);
1069         }
1070 }
1071
1072 /**
1073  * Emits code for function start.
1074  */
1075 void arm_func_prolog(ir_graph *irg) {
1076         ir_entity *ent = get_irg_entity(irg);
1077         const char *irg_name = get_entity_ld_name(ent);
1078
1079         be_emit_write_line();
1080         be_gas_emit_switch_section(GAS_SECTION_TEXT);
1081         be_emit_cstring("\t.align  2\n");
1082
1083         if (get_entity_visibility(ent) == visibility_external_visible)
1084                 be_emit_irprintf("\t.global %s\n", irg_name);
1085         be_emit_irprintf("%s:\n", irg_name);
1086 }
1087
1088 /**
1089  * Emits code for function end
1090  */
1091 void arm_emit_end(FILE *F, ir_graph *irg) {
1092         (void) irg;
1093         fprintf(F, "\t.ident \"firmcc\"\n");
1094 }
1095
1096 /**
1097  * Block-walker:
1098  * Sets labels for control flow nodes (jump target)
1099  */
1100 static void arm_gen_labels(ir_node *block, void *env) {
1101         ir_node *pred;
1102         int n = get_Block_n_cfgpreds(block);
1103         (void)env;
1104
1105         for (n--; n >= 0; n--) {
1106                 pred = get_Block_cfgpred(block, n);
1107                 set_irn_link(pred, block);
1108         }
1109 }
1110
1111 /**
1112  * Compare two entries of the symbol or tarval set.
1113  */
1114 static int cmp_sym_or_tv(const void *elt, const void *key, size_t size) {
1115         const sym_or_tv_t *p1 = elt;
1116         const sym_or_tv_t *p2 = key;
1117         (void) size;
1118
1119         /* as an identifier NEVER can point to a tarval, it's enough
1120            to compare it this way */
1121         return p1->u.generic != p2->u.generic;
1122 }
1123
1124 /**
1125  * Main driver. Emits the code for one routine.
1126  */
1127 void arm_gen_routine(const arm_code_gen_t *arm_cg, ir_graph *irg) {
1128         ir_node **blk_sched;
1129         int i, n;
1130         ir_node *last_block = NULL;
1131
1132         cg        = arm_cg;
1133         isa       = (const arm_isa_t *)cg->arch_env;
1134         arch_env  = cg->arch_env;
1135         sym_or_tv = new_set(cmp_sym_or_tv, 8);
1136
1137         arm_register_emitters();
1138
1139         /* create the block schedule. For now, we don't need it earlier. */
1140         blk_sched = be_create_block_schedule(cg->irg, cg->birg->exec_freq);
1141
1142         arm_func_prolog(irg);
1143         irg_block_walk_graph(irg, arm_gen_labels, NULL, NULL);
1144
1145         n = ARR_LEN(blk_sched);
1146         for (i = 0; i < n;) {
1147                 ir_node *block, *next_bl;
1148
1149                 block   = blk_sched[i];
1150                 ++i;
1151                 next_bl = i < n ? blk_sched[i] : NULL;
1152
1153                 /* set here the link. the emitter expects to find the next block here */
1154                 set_irn_link(block, next_bl);
1155                 arm_gen_block(block, last_block);
1156                 last_block = block;
1157         }
1158
1159         /* emit SymConst values */
1160         if (set_count(sym_or_tv) > 0) {
1161                 sym_or_tv_t *entry;
1162
1163                 be_emit_cstring("\t.align 2\n");
1164
1165                 foreach_set(sym_or_tv, entry) {
1166                         be_emit_irprintf(".L%u:\n", entry->label);
1167
1168                         if (entry->is_ident) {
1169                                 be_emit_cstring("\t.word\t");
1170                                 be_emit_ident(entry->u.id);
1171                                 be_emit_char('\n');
1172                                 be_emit_write_line();
1173                         } else {
1174                                 tarval *tv = entry->u.tv;
1175                                 int i, size = get_mode_size_bytes(get_tarval_mode(tv));
1176                                 unsigned v;
1177
1178                                 /* beware: ARM fpa uses big endian format */
1179                                 for (i = ((size + 3) & ~3) - 4; i >= 0; i -= 4) {
1180                                         /* get 32 bits */
1181                                         v =            get_tarval_sub_bits(tv, i+3);
1182                                         v = (v << 8) | get_tarval_sub_bits(tv, i+2);
1183                                         v = (v << 8) | get_tarval_sub_bits(tv, i+1);
1184                                         v = (v << 8) | get_tarval_sub_bits(tv, i+0);
1185                                         be_emit_irprintf("\t.word\t%u\n", v);
1186                                         be_emit_write_line();
1187                                 }
1188                         }
1189                 }
1190                 be_emit_char('\n');
1191                 be_emit_write_line();
1192         }
1193         del_set(sym_or_tv);
1194 }
1195
1196 void arm_init_emitter(void)
1197 {
1198         FIRM_DBG_REGISTER(dbg, "firm.be.arm.emit");
1199 }