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
  53 #include "arm_emitter.h"
  54 #include "gen_arm_emitter.h"
  55 #include "arm_nodes_attr.h"
  56 #include "arm_new_nodes.h"
  57 #include "arm_map_regs.h"
  58 #include "gen_arm_regalloc_if.h"
  59
  60 #include "../benode_t.h"
  61
  62 #define BLOCK_PREFIX ".L"
  63
  64 #define SNPRINTF_BUF_LEN 128
  65
  66 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
  67
  68 static const arch_env_t     *arch_env = NULL;
  69 static const arm_code_gen_t *cg;
  70 static const arm_isa_t      *isa;
  71 static set                  *sym_or_tv;
  72
  73 /**
  74  * Returns the register at in position pos.
  75  */
  76 static const arch_register_t *get_in_reg(const ir_node *irn, int pos) {
  77         ir_node                *op;
  78         const arch_register_t  *reg = NULL;
  79
  80         assert(get_irn_arity(irn) > pos && "Invalid IN position");
  81
  82         /* The out register of the operator at position pos is the
  83            in register we need. */
  84         op = get_irn_n(irn, pos);
  85
  86         reg = arch_get_irn_register(arch_env, op);
  87
  88         assert(reg && "no in register found");
  89
  90         /* in case of a joker register: just return a valid register */
  91         if (arch_register_type_is(reg, joker)) {
  92                 const arch_register_req_t *req;
  93
  94                 /* ask for the requirements */
  95                 req = arch_get_register_req(arch_env, irn, pos);
  96
  97                 if (arch_register_req_is(req, limited)) {
  98                         /* in case of limited requirements: get the first allowed register */
  99                         unsigned idx = rbitset_next(req->limited, 0, 1);
 100                         reg = arch_register_for_index(req->cls, idx);
 101                 } else {
 102                         /* otherwise get first register in class */
 103                         reg = arch_register_for_index(req->cls, 0);
 104                 }
 105         }
 106         return reg;
 107 }
 108
 109
 110 /**
 111  * Returns the register at out position pos.
 112  */
 113 static const arch_register_t *get_out_reg(const ir_node *node, int pos)
 114 {
 115     ir_node                *proj;
 116     const arch_register_t  *reg = NULL;
 117
 118     /* 1st case: irn is not of mode_T, so it has only                 */
 119     /*           one OUT register -> good                             */
 120     /* 2nd case: irn is of mode_T -> collect all Projs and ask the    */
 121     /*           Proj with the corresponding projnum for the register */
 122
 123     if (get_irn_mode(node) != mode_T) {
 124         reg = arch_get_irn_register(arch_env, node);
 125     } else if (is_arm_irn(node)) {
 126         reg = get_arm_out_reg(node, pos);
 127     } else {
 128         const ir_edge_t *edge;
 129
 130         foreach_out_edge(node, edge) {
 131             proj = get_edge_src_irn(edge);
 132             assert(is_Proj(proj) && "non-Proj from mode_T node");
 133             if (get_Proj_proj(proj) == pos) {
 134                 reg = arch_get_irn_register(arch_env, proj);
 135                 break;
 136             }
 137         }
 138     }
 139
 140     assert(reg && "no out register found");
 141     return reg;
 142 }
 143
 144 /*************************************************************
 145  *             _       _    __   _          _
 146  *            (_)     | |  / _| | |        | |
 147  *  _ __  _ __ _ _ __ | |_| |_  | |__   ___| |_ __   ___ _ __
 148  * | '_ \| '__| | '_ \| __|  _| | '_ \ / _ \ | '_ \ / _ \ '__|
 149  * | |_) | |  | | | | | |_| |   | | | |  __/ | |_) |  __/ |
 150  * | .__/|_|  |_|_| |_|\__|_|   |_| |_|\___|_| .__/ \___|_|
 151  * | |                                       | |
 152  * |_|                                       |_|
 153  *************************************************************/
 154
 155 /**
 156  * Emit the name of the source register at given input position.
 157  */
 158 void arm_emit_source_register(const ir_node *node, int pos) {
 159         const arch_register_t *reg = get_in_reg(node, pos);
 160         be_emit_string(arch_register_get_name(reg));
 161 }
 162
 163 /**
 164  * Emit the name of the destination register at given output position.
 165  */
 166 void arm_emit_dest_register(const ir_node *node, int pos) {
 167         const arch_register_t *reg = get_out_reg(node, pos);
 168         be_emit_string(arch_register_get_name(reg));
 169 }
 170
 171 /**
 172  * Emit a node's offset.
 173  */
 174 void arm_emit_offset(const ir_node *node) {
 175         int offset = 0;
 176         ir_op *irn_op = get_irn_op(node);
 177
 178         if (irn_op == op_be_Reload || irn_op == op_be_Spill) {
 179                 ir_entity *ent = be_get_frame_entity(node);
 180                 offset = get_entity_offset(ent);
 181         } else if (irn_op == op_be_IncSP) {
 182                 offset = - be_get_IncSP_offset(node);
 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         if (bits == 32)
 196                 be_emit_char('s');
 197         else if (bits == 64)
 198                 be_emit_char('d');
 199         else
 200                 be_emit_char('e');
 201 }
 202
 203 /**
 204  * Emit the instruction suffix depending on the mode.
 205  */
 206 void arm_emit_mode(const ir_node *node) {
 207         ir_mode *mode;
 208
 209         if (is_arm_irn(node)) {
 210                 const arm_attr_t *attr = get_arm_attr_const(node);
 211                 mode = attr->op_mode ? attr->op_mode : get_irn_mode(node);
 212         } else {
 213                 mode = get_irn_mode(node);
 214         }
 215         arm_emit_fpa_postfix(mode);
 216 }
 217
 218 /**
 219  * Emit a const or SymConst value.
 220  */
 221 void arm_emit_immediate(const ir_node *node) {
 222         const arm_attr_t *attr = get_arm_attr_const(node);
 223
 224         if (ARM_GET_SHF_MOD(attr) == ARM_SHF_IMM) {
 225                 be_emit_irprintf("#0x%X", arm_decode_imm_w_shift(get_arm_imm_value(node)));
 226         } else if (ARM_GET_FPA_IMM(attr)) {
 227                 be_emit_irprintf("#%s", arm_get_fpa_imm_name(get_arm_imm_value(node)));
 228         } else if (is_arm_SymConst(node))
 229                 be_emit_ident(get_arm_symconst_id(node));
 230         else {
 231                 assert(!"not a Constant");
 232         }
 233 }
 234
 235 /**
 236  * Returns the tarval or offset of an arm node as a string.
 237  */
 238 void arm_emit_shift(const ir_node *node) {
 239         arm_shift_modifier mod;
 240
 241         mod = get_arm_shift_modifier(node);
 242         if (ARM_HAS_SHIFT(mod)) {
 243                 long v = get_arm_imm_value(node);
 244
 245                 be_emit_irprintf(", %s #%l", arm_shf_mod_name(mod), v);
 246         }
 247 }
 248
 249 /** An entry in the sym_or_tv set. */
 250 typedef struct sym_or_tv_t {
 251         union {
 252                 ident  *id;          /**< An ident. */
 253                 tarval *tv;          /**< A tarval. */
 254                 const void *generic; /**< For generic compare. */
 255         } u;
 256         unsigned label;      /**< the associated label. */
 257         char is_ident;       /**< Non-zero if an ident is stored. */
 258 } sym_or_tv_t;
 259
 260 /**
 261  * Returns a unique label. This number will not be used a second time.
 262  */
 263 static unsigned get_unique_label(void) {
 264         static unsigned id = 0;
 265         return ++id;
 266 }
 267
 268 /**
 269  * Emit a SymConst.
 270  */
 271 static void emit_arm_SymConst(const ir_node *irn) {
 272         sym_or_tv_t key, *entry;
 273         unsigned label;
 274
 275         key.u.id     = get_arm_symconst_id(irn);
 276         key.is_ident = 1;
 277         key.label    = 0;
 278         entry = (sym_or_tv_t *)set_insert(sym_or_tv, &key, sizeof(key), HASH_PTR(key.u.generic));
 279         if (entry->label == 0) {
 280                 /* allocate a label */
 281                 entry->label = get_unique_label();
 282         }
 283         label = entry->label;
 284
 285         /* load the symbol indirect */
 286         be_emit_cstring("\tldr ");
 287         arm_emit_dest_register(irn, 0);
 288         be_emit_irprintf(", .L%u", label);
 289         be_emit_finish_line_gas(irn);
 290 }
 291
 292 /**
 293  * Emit a floating point fpa constant.
 294  */
 295 static void emit_arm_fpaConst(const ir_node *irn) {
 296         sym_or_tv_t key, *entry;
 297         unsigned label;
 298         ir_mode *mode;
 299
 300         key.u.tv     = get_fpaConst_value(irn);
 301         key.is_ident = 0;
 302         key.label    = 0;
 303         entry = (sym_or_tv_t *)set_insert(sym_or_tv, &key, sizeof(key), HASH_PTR(key.u.generic));
 304         if (entry->label == 0) {
 305                 /* allocate a label */
 306                 entry->label = get_unique_label();
 307         }
 308         label = entry->label;
 309
 310         /* load the tarval indirect */
 311         mode = get_irn_mode(irn);
 312         be_emit_cstring("\tldf");
 313         arm_emit_fpa_postfix(mode);
 314         be_emit_char(' ');
 315
 316         arm_emit_dest_register(irn, 0);
 317         be_emit_irprintf(", .L%u", label);
 318         be_emit_finish_line_gas(irn);
 319 }
 320
 321 /**
 322  * Returns the next block in a block schedule.
 323  */
 324 static ir_node *sched_next_block(const ir_node *block) {
 325     return get_irn_link(block);
 326 }
 327
 328 /**
 329  * Returns the target block for a control flow node.
 330  */
 331 static ir_node *get_cfop_target_block(const ir_node *irn) {
 332         return get_irn_link(irn);
 333 }
 334
 335 /**
 336  * Emits a block label for the given block.
 337  */
 338 static void arm_emit_block_name(const ir_node *block) {
 339         if (has_Block_label(block)) {
 340                 be_emit_string(be_gas_label_prefix());
 341                 be_emit_irprintf("%lu", get_Block_label(block));
 342         } else {
 343                 be_emit_cstring(BLOCK_PREFIX);
 344                 be_emit_irprintf("%d", get_irn_node_nr(block));
 345         }
 346 }
 347
 348 /**
 349  * Emit the target label for a control flow node.
 350  */
 351 static void arm_emit_cfop_target(const ir_node *irn) {
 352         ir_node *block = get_cfop_target_block(irn);
 353
 354         arm_emit_block_name(block);
 355 }
 356
 357 /**
 358  * Emit a Compare with conditional branch.
 359  */
 360 static void emit_arm_CmpBra(const ir_node *irn) {
 361         const ir_edge_t *edge;
 362         const ir_node *proj_true  = NULL;
 363         const ir_node *proj_false = NULL;
 364         const ir_node *block;
 365         const ir_node *next_block;
 366         ir_node *op1 = get_irn_n(irn, 0);
 367         ir_mode *opmode = get_irn_mode(op1);
 368         const char *suffix;
 369         int proj_num = get_arm_CondJmp_proj_num(irn);
 370
 371         foreach_out_edge(irn, edge) {
 372                 ir_node *proj = get_edge_src_irn(edge);
 373                 long nr = get_Proj_proj(proj);
 374                 if (nr == pn_Cond_true) {
 375                         proj_true = proj;
 376                 } else {
 377                         proj_false = proj;
 378                 }
 379         }
 380
 381         /* for now, the code works for scheduled and non-schedules blocks */
 382         block = get_nodes_block(irn);
 383
 384         /* we have a block schedule */
 385         next_block = sched_next_block(block);
 386
 387         if (proj_num == pn_Cmp_False) {
 388                 /* always false: should not happen */
 389                 be_emit_cstring("\tb ");
 390                 arm_emit_cfop_target(proj_false);
 391                 be_emit_finish_line_gas(proj_false);
 392         } else if (proj_num == pn_Cmp_True) {
 393                 /* always true: should not happen */
 394                 be_emit_cstring("\tb ");
 395                 arm_emit_cfop_target(proj_true);
 396                 be_emit_finish_line_gas(proj_true);
 397         } else {
 398                 if (mode_is_float(opmode)) {
 399                         suffix = "ICHWILLIMPLEMENTIERTWERDEN";
 400
 401                         be_emit_cstring("\tfcmp ");
 402                         arm_emit_source_register(irn, 0);
 403                         be_emit_cstring(", ");
 404                         arm_emit_source_register(irn, 1);
 405                         be_emit_finish_line_gas(irn);
 406
 407                         be_emit_cstring("\tfmstat");
 408                         be_emit_pad_comment();
 409                         be_emit_cstring("/* FCSPR -> CPSR */");
 410                         be_emit_finish_line_gas(NULL);
 411                 } else {
 412                         if (get_cfop_target_block(proj_true) == next_block) {
 413                                 /* exchange both proj's so the second one can be omitted */
 414                                 const ir_node *t = proj_true;
 415
 416                                 proj_true  = proj_false;
 417                                 proj_false = t;
 418                                 proj_num   = get_negated_pnc(proj_num, mode_Iu);
 419                         }
 420                         switch (proj_num) {
 421                                 case pn_Cmp_Eq:  suffix = "eq"; break;
 422                                 case pn_Cmp_Lt:  suffix = "lt"; break;
 423                                 case pn_Cmp_Le:  suffix = "le"; break;
 424                                 case pn_Cmp_Gt:  suffix = "gt"; break;
 425                                 case pn_Cmp_Ge:  suffix = "ge"; break;
 426                                 case pn_Cmp_Lg:  suffix = "ne"; break;
 427                                 case pn_Cmp_Leg: suffix = "al"; break;
 428                                 default: assert(!"Cmp unsupported"); suffix = "al";
 429                         }
 430                         be_emit_cstring("\tcmp ");
 431                         arm_emit_source_register(irn, 0);
 432                         be_emit_cstring(", ");
 433                         arm_emit_source_register(irn, 1);
 434                         be_emit_finish_line_gas(irn);
 435                 }
 436
 437                 /* emit the true proj */
 438                 be_emit_irprintf("\tb%s ", suffix);
 439                 arm_emit_cfop_target(proj_true);
 440                 be_emit_finish_line_gas(proj_true);
 441
 442                 if (get_cfop_target_block(proj_false) == next_block) {
 443                         be_emit_cstring("\t/* fallthrough to ");
 444                         arm_emit_cfop_target(proj_false);
 445                         be_emit_cstring(" */");
 446                         be_emit_finish_line_gas(proj_false);
 447                 } else {
 448                         be_emit_cstring("b ");
 449                         arm_emit_cfop_target(proj_false);
 450                         be_emit_finish_line_gas(proj_false);
 451                 }
 452         }
 453 }
 454
 455 /**
 456  * Emit a Compare with conditional branch.
 457  */
 458 static void emit_arm_fpaCmfBra(const ir_node *irn) {
 459         (void) irn;
 460 }
 461
 462 /**
 463  * Emit a Compare with conditional branch.
 464  */
 465 static void emit_arm_fpaCmfeBra(const ir_node *irn) {
 466         (void) irn;
 467 }
 468
 469 /** Sort register in ascending order. */
 470 static int reg_cmp(const void *a, const void *b) {
 471         const arch_register_t * const *ra = a;
 472         const arch_register_t * const *rb = b;
 473
 474         return *ra < *rb ? -1 : (*ra != *rb);
 475 }
 476
 477 /**
 478  * Create the CopyB instruction sequence.
 479  */
 480 static void emit_arm_CopyB(const ir_node *irn) {
 481         unsigned size = (unsigned)get_arm_imm_value(irn);
 482
 483         const char *tgt = arch_register_get_name(get_in_reg(irn, 0));
 484         const char *src = arch_register_get_name(get_in_reg(irn, 1));
 485         const char *t0, *t1, *t2, *t3;
 486
 487         const arch_register_t *tmpregs[4];
 488
 489         /* collect the temporary registers and sort them, we need ascending order */
 490         tmpregs[0] = get_in_reg(irn, 2);
 491         tmpregs[1] = get_in_reg(irn, 3);
 492         tmpregs[2] = get_in_reg(irn, 4);
 493         tmpregs[3] = &arm_gp_regs[REG_R12];
 494
 495         /* Note: R12 is always the last register because the RA did not assign higher ones */
 496         qsort((void *)tmpregs, 3, sizeof(tmpregs[0]), reg_cmp);
 497
 498         /* need ascending order */
 499         t0 = arch_register_get_name(tmpregs[0]);
 500         t1 = arch_register_get_name(tmpregs[1]);
 501         t2 = arch_register_get_name(tmpregs[2]);
 502         t3 = arch_register_get_name(tmpregs[3]);
 503
 504         be_emit_cstring("/* MemCopy (");
 505         be_emit_string(src);
 506         be_emit_cstring(")->(");
 507         arm_emit_source_register(irn, 0);
 508         be_emit_irprintf(" [%u bytes], Uses ", size);
 509         be_emit_string(t0);
 510         be_emit_cstring(", ");
 511         be_emit_string(t1);
 512         be_emit_cstring(", ");
 513         be_emit_string(t2);
 514         be_emit_cstring(", and ");
 515         be_emit_string(t3);
 516         be_emit_cstring("*/");
 517         be_emit_finish_line_gas(NULL);
 518
 519         assert(size > 0 && "CopyB needs size > 0" );
 520
 521         if (size & 3) {
 522                 assert(!"strange hack enabled: copy more bytes than needed!");
 523                 size += 4;
 524         }
 525
 526         size >>= 2;
 527         switch (size & 3) {
 528         case 0:
 529                 break;
 530         case 1:
 531                 be_emit_cstring("\tldr ");
 532                 be_emit_string(t3);
 533                 be_emit_cstring(", [");
 534                 be_emit_string(src);
 535                 be_emit_cstring(", #0]");
 536                 be_emit_finish_line_gas(NULL);
 537
 538                 be_emit_cstring("\tstr ");
 539                 be_emit_string(t3);
 540                 be_emit_cstring(", [");
 541                 be_emit_string(tgt);
 542                 be_emit_cstring(", #0]");
 543                 be_emit_finish_line_gas(irn);
 544                 break;
 545         case 2:
 546                 be_emit_cstring("\tldmia ");
 547                 be_emit_string(src);
 548                 be_emit_cstring("!, {");
 549                 be_emit_string(t0);
 550                 be_emit_cstring(", ");
 551                 be_emit_string(t1);
 552                 be_emit_char('}');
 553                 be_emit_finish_line_gas(NULL);
 554
 555                 be_emit_cstring("\tstmia ");
 556                 be_emit_string(tgt);
 557                 be_emit_cstring("!, {");
 558                 be_emit_string(t0);
 559                 be_emit_cstring(", ");
 560                 be_emit_string(t1);
 561                 be_emit_char('}');
 562                 be_emit_finish_line_gas(irn);
 563                 break;
 564         case 3:
 565                 be_emit_cstring("\tldmia ");
 566                 be_emit_string(src);
 567                 be_emit_cstring("!, {");
 568                 be_emit_string(t0);
 569                 be_emit_cstring(", ");
 570                 be_emit_string(t1);
 571                 be_emit_cstring(", ");
 572                 be_emit_string(t2);
 573                 be_emit_char('}');
 574                 be_emit_finish_line_gas(NULL);
 575
 576                 be_emit_cstring("\tstmia ");
 577                 be_emit_string(tgt);
 578                 be_emit_cstring("!, {");
 579                 be_emit_string(t0);
 580                 be_emit_cstring(", ");
 581                 be_emit_string(t1);
 582                 be_emit_cstring(", ");
 583                 be_emit_string(t2);
 584                 be_emit_char('}');
 585                 be_emit_finish_line_gas(irn);
 586                 break;
 587         }
 588         size >>= 2;
 589         while (size) {
 590                 be_emit_cstring("\tldmia ");
 591                 be_emit_string(src);
 592                 be_emit_cstring("!, {");
 593                 be_emit_string(t0);
 594                 be_emit_cstring(", ");
 595                 be_emit_string(t1);
 596                 be_emit_cstring(", ");
 597                 be_emit_string(t2);
 598                 be_emit_cstring(", ");
 599                 be_emit_string(t3);
 600                 be_emit_char('}');
 601                 be_emit_finish_line_gas(NULL);
 602
 603                 be_emit_cstring("\tstmia ");
 604                 be_emit_string(tgt);
 605                 be_emit_cstring("!, {");
 606                 be_emit_string(t0);
 607                 be_emit_cstring(", ");
 608                 be_emit_string(t1);
 609                 be_emit_cstring(", ");
 610                 be_emit_string(t2);
 611                 be_emit_cstring(", ");
 612                 be_emit_string(t3);
 613                 be_emit_char('}');
 614                 be_emit_finish_line_gas(irn);
 615                 --size;
 616         }
 617 }
 618
 619 static void emit_arm_SwitchJmp(const ir_node *irn) {
 620         const ir_edge_t    *edge;
 621         ir_node            *proj;
 622         int i;
 623         ir_node **projs;
 624         int n_projs;
 625         int block_nr;
 626         ir_node *default_proj = NULL;
 627
 628         block_nr = get_irn_node_nr(irn);
 629         n_projs = get_arm_SwitchJmp_n_projs(irn);
 630
 631         projs = xcalloc(n_projs , sizeof(ir_node*));
 632
 633         foreach_out_edge(irn, edge) {
 634                 proj = get_edge_src_irn(edge);
 635                 assert(is_Proj(proj) && "Only proj allowed at SwitchJmp");
 636
 637                 if (get_Proj_proj(proj) == get_arm_SwitchJmp_default_proj_num(irn))
 638                         default_proj = proj;
 639
 640                 projs[get_Proj_proj(proj)] = proj;
 641         }
 642         assert(default_proj != NULL && "SwitchJmp should have a Default Proj");
 643
 644         /*
 645            CMP %1S, n_projs - 1
 646            BHI default
 647         */
 648
 649         be_emit_cstring("\tcmp ");
 650         arm_emit_source_register(irn, 0);
 651         be_emit_irprintf(", #%u", n_projs - 1);
 652         be_emit_finish_line_gas(irn);
 653
 654         be_emit_cstring("\tbhi ");
 655         arm_emit_cfop_target(default_proj);
 656         be_emit_finish_line_gas(default_proj);
 657
 658         /*
 659            LDR %r12, .TABLE_X_START
 660            ADD %r12, %r12, [%1S, LSL #2]
 661            LDR %r15, %r12
 662          */
 663
 664         be_emit_irprintf("\tldr %%r12, TABLE_%d_START", block_nr);
 665         be_emit_finish_line_gas(NULL);
 666
 667         be_emit_irprintf("\tadd %%r12, %%r12, ");
 668         arm_emit_source_register(irn, 0);
 669         be_emit_cstring(", LSL #2");
 670         be_emit_finish_line_gas(NULL);
 671
 672         be_emit_cstring("\tldr %r15, [%r12, #0]");
 673         be_emit_finish_line_gas(NULL);
 674
 675         be_emit_irprintf("TABLE_%d_START:\n\t.word\tTABLE_%d", block_nr, block_nr);
 676         be_emit_finish_line_gas(NULL);
 677         be_emit_irprintf("\t.align 2");
 678         be_emit_finish_line_gas(NULL);
 679         be_emit_irprintf("TABLE_%d:", block_nr);
 680         be_emit_finish_line_gas(NULL);
 681
 682         for (i = 0; i < n_projs; ++i) {
 683                 proj = projs[i];
 684                 if (proj == NULL) {
 685                         proj = projs[get_arm_SwitchJmp_default_proj_num(irn)];
 686                 }
 687                 be_emit_cstring("\t.word\t");
 688                 arm_emit_cfop_target(proj);
 689                 be_emit_finish_line_gas(proj);
 690         }
 691         be_emit_irprintf("\t.align 2\n");
 692         be_emit_finish_line_gas(NULL);
 693         xfree(projs);
 694 }
 695
 696 /************************************************************************/
 697 /* emit_be                                                              */
 698 /************************************************************************/
 699
 700 static void emit_be_Call(const ir_node *irn) {
 701         ir_entity *ent = be_Call_get_entity(irn);
 702
 703         be_emit_cstring("\tbl ");
 704         if (ent) {
 705                 set_entity_backend_marked(ent, 1);
 706                 be_emit_ident(get_entity_ld_ident(ent));
 707         } else {
 708                 arm_emit_source_register(irn, be_pos_Call_ptr);
 709         }
 710         be_emit_finish_line_gas(irn);
 711 }
 712
 713 /** Emit an IncSP node */
 714 static void emit_be_IncSP(const ir_node *irn) {
 715         int offs = be_get_IncSP_offset(irn);
 716
 717         if (offs != 0) {
 718                 be_emit_cstring("\tadd ");
 719                 arm_emit_dest_register(irn, 0);
 720                 be_emit_cstring(", ");
 721                 arm_emit_source_register(irn, 0);
 722                 be_emit_cstring(", #");
 723                 arm_emit_offset(irn);
 724         } else {
 725                 be_emit_cstring("\t/* omitted IncSP(");
 726                 arm_emit_offset(irn);
 727                 be_emit_cstring(") */");
 728         }
 729         be_emit_finish_line_gas(irn);
 730 }
 731
 732 static void emit_be_Copy(const ir_node *irn) {
 733         ir_mode *mode = get_irn_mode(irn);
 734
 735         if (get_in_reg(irn, 0) == get_out_reg(irn, 0)) {
 736                 be_emit_cstring("\t/* omitted Copy: ");
 737                 arm_emit_source_register(irn, 0);
 738                 be_emit_cstring(" -> ");
 739                 arm_emit_dest_register(irn, 0);
 740                 be_emit_finish_line_gas(irn);
 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 static const char *last_name = NULL;
 989 static unsigned last_line = -1;
 990 static unsigned num = -1;
 991
 992 /**
 993  * Emit the debug support for node node.
 994  */
 995 static void arm_emit_dbg(const ir_node *irn) {
 996         dbg_info *db = get_irn_dbg_info(irn);
 997         unsigned lineno;
 998         const char *fname = ir_retrieve_dbg_info(db, &lineno);
 999
1000         if (! cg->birg->main_env->options->stabs_debug_support)
1001                 return;
1002
1003         if (fname) {
1004                 if (last_name != fname) {
1005                         last_line = -1;
1006                         be_dbg_include_begin(cg->birg->main_env->db_handle, fname);
1007                         last_name = fname;
1008                 }
1009                 if (last_line != lineno) {
1010                         char name[64];
1011
1012                         snprintf(name, sizeof(name), ".LM%u", ++num);
1013                         last_line = lineno;
1014                         be_dbg_line(cg->birg->main_env->db_handle, lineno, name);
1015                         be_emit_string(name);
1016                         be_emit_cstring(":\n");
1017                         be_emit_write_line();
1018                 }
1019         }
1020 }
1021
1022 /**
1023  * Emits code for a node.
1024  */
1025 static void arm_emit_node(const ir_node *irn) {
1026         ir_op *op = get_irn_op(irn);
1027
1028         if (op->ops.generic) {
1029                 emit_func *emit = (emit_func *)op->ops.generic;
1030                 arm_emit_dbg(irn);
1031                 (*emit)(irn);
1032         } else {
1033                 be_emit_cstring("\t/* TODO */");
1034                 be_emit_finish_line_gas(irn);
1035         }
1036 }
1037
1038 /**
1039  * emit the block label if needed.
1040  */
1041 static void arm_emit_block_header(ir_node *block, ir_node *prev)
1042 {
1043         int           n_cfgpreds;
1044         int           need_label;
1045         int           i, arity;
1046         ir_exec_freq  *exec_freq = cg->birg->exec_freq;
1047
1048         need_label = 0;
1049         n_cfgpreds = get_Block_n_cfgpreds(block);
1050         if (n_cfgpreds == 1) {
1051                 ir_node *pred       = get_Block_cfgpred(block, 0);
1052                 ir_node *pred_block = get_nodes_block(pred);
1053
1054                 /* we don't need labels for fallthrough blocks, however switch-jmps
1055                  * are no fallthroughs */
1056                 if (pred_block == prev &&
1057                                 !(is_Proj(pred) && is_arm_SwitchJmp(get_Proj_pred(pred)))) {
1058                         need_label = 0;
1059                 } else {
1060                         need_label = 1;
1061                 }
1062         } else {
1063                 need_label = 1;
1064         }
1065
1066         if (need_label) {
1067                 arm_emit_block_name(block);
1068                 be_emit_char(':');
1069
1070                 be_emit_pad_comment();
1071                 be_emit_cstring("   /* preds:");
1072
1073                 /* emit list of pred blocks in comment */
1074                 arity = get_irn_arity(block);
1075                 for (i = 0; i < arity; ++i) {
1076                         ir_node *predblock = get_Block_cfgpred_block(block, i);
1077                         be_emit_irprintf(" %d", get_irn_node_nr(predblock));
1078                 }
1079         } else {
1080                 be_emit_cstring("\t/* ");
1081                 arm_emit_block_name(block);
1082                 be_emit_cstring(": ");
1083         }
1084         if (exec_freq != NULL) {
1085                 be_emit_irprintf(" freq: %f",
1086                                  get_block_execfreq(exec_freq, block));
1087         }
1088         be_emit_cstring(" */\n");
1089         be_emit_write_line();
1090 }
1091
1092 /**
1093  * Walks over the nodes in a block connected by scheduling edges
1094  * and emits code for each node.
1095  */
1096 static void arm_gen_block(ir_node *block, ir_node *prev_block) {
1097         ir_node *irn;
1098
1099         arm_emit_block_header(block, prev_block);
1100         arm_emit_dbg(block);
1101         sched_foreach(block, irn) {
1102                 arm_emit_node(irn);
1103         }
1104 }
1105
1106 /**
1107  * Emits code for function start.
1108  */
1109 void arm_func_prolog(ir_graph *irg) {
1110         ir_entity *ent = get_irg_entity(irg);
1111         const char *irg_name = get_entity_ld_name(ent);
1112
1113         be_emit_write_line();
1114         be_gas_emit_switch_section(GAS_SECTION_TEXT);
1115         be_emit_cstring("\t.align  2\n");
1116
1117         if (get_entity_visibility(ent) == visibility_external_visible)
1118                 be_emit_irprintf("\t.global %s\n", irg_name);
1119         be_emit_irprintf("%s:\n", irg_name);
1120 }
1121
1122 /**
1123  * Emits code for function end
1124  */
1125 void arm_emit_end(FILE *F, ir_graph *irg) {
1126         (void) irg;
1127         fprintf(F, "\t.ident \"firmcc\"\n");
1128 }
1129
1130 /**
1131  * Block-walker:
1132  * Sets labels for control flow nodes (jump target)
1133  */
1134 static void arm_gen_labels(ir_node *block, void *env) {
1135         ir_node *pred;
1136         int n = get_Block_n_cfgpreds(block);
1137         (void)env;
1138
1139         for (n--; n >= 0; n--) {
1140                 pred = get_Block_cfgpred(block, n);
1141                 set_irn_link(pred, block);
1142         }
1143 }
1144
1145 /**
1146  * Compare two entries of the symbol or tarval set.
1147  */
1148 static int cmp_sym_or_tv(const void *elt, const void *key, size_t size) {
1149         const sym_or_tv_t *p1 = elt;
1150         const sym_or_tv_t *p2 = key;
1151         (void) size;
1152
1153         /* as an identifier NEVER can point to a tarval, it's enough
1154            to compare it this way */
1155         return p1->u.generic != p2->u.generic;
1156 }
1157
1158 /**
1159  * Main driver. Emits the code for one routine.
1160  */
1161 void arm_gen_routine(const arm_code_gen_t *arm_cg, ir_graph *irg) {
1162         ir_node **blk_sched;
1163         int i, n;
1164         ir_node *last_block = NULL;
1165
1166         cg        = arm_cg;
1167         arch_env  = cg->arch_env;
1168         sym_or_tv = new_set(cmp_sym_or_tv, 8);
1169
1170
1171         arm_register_emitters();
1172
1173         /* create the block schedule. For now, we don't need it earlier. */
1174         blk_sched = be_create_block_schedule(cg->irg, cg->birg->exec_freq);
1175
1176         arm_func_prolog(irg);
1177         irg_block_walk_graph(irg, arm_gen_labels, NULL, NULL);
1178
1179         n = ARR_LEN(blk_sched);
1180         for (i = 0; i < n;) {
1181                 ir_node *block, *next_bl;
1182
1183                 block   = blk_sched[i];
1184                 ++i;
1185                 next_bl = i < n ? blk_sched[i] : NULL;
1186
1187                 /* set here the link. the emitter expects to find the next block here */
1188                 set_irn_link(block, next_bl);
1189                 arm_gen_block(block, last_block);
1190                 last_block = block;
1191         }
1192
1193         /* emit SymConst values */
1194         if (set_count(sym_or_tv) > 0) {
1195                 sym_or_tv_t *entry;
1196
1197                 be_emit_cstring("\t.align 2\n");
1198
1199                 foreach_set(sym_or_tv, entry) {
1200                         be_emit_irprintf(".L%u:\n", entry->label);
1201
1202                         if (entry->is_ident) {
1203                                 be_emit_cstring("\t.word\t");
1204                                 be_emit_ident(entry->u.id);
1205                                 be_emit_char('\n');
1206                                 be_emit_write_line();
1207                         } else {
1208                                 tarval *tv = entry->u.tv;
1209                                 int i, size = get_mode_size_bytes(get_tarval_mode(tv));
1210                                 unsigned v;
1211
1212                                 /* beware: ARM fpa uses big endian format */
1213                                 for (i = ((size + 3) & ~3) - 4; i >= 0; i -= 4) {
1214                                         /* get 32 bits */
1215                                         v =            get_tarval_sub_bits(tv, i+3);
1216                                         v = (v << 8) | get_tarval_sub_bits(tv, i+2);
1217                                         v = (v << 8) | get_tarval_sub_bits(tv, i+1);
1218                                         v = (v << 8) | get_tarval_sub_bits(tv, i+0);
1219                                         be_emit_irprintf("\t.word\t%u\n", v);
1220                                         be_emit_write_line();
1221                                 }
1222                         }
1223                 }
1224                 be_emit_char('\n');
1225                 be_emit_write_line();
1226         }
1227         del_set(sym_or_tv);
1228 }
1229
1230 void arm_init_emitter(void)
1231 {
1232         FIRM_DBG_REGISTER(dbg, "firm.be.arm.emit");
1233 }