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

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