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