nsz Git - libfirm/blob - ir/be/ia32/ia32_emitter.c

   1 /*
   2  * Copyright (C) 1995-2011 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       This file implements the ia32 node emitter.
  23  * @author      Christian Wuerdig, Matthias Braun
  24  *
  25  * Summary table for x86 floatingpoint compares:
  26  * (remember effect of unordered on x86: ZF=1, PF=1, CF=1)
  27  *
  28  *   pnc_Eq  => !P && E
  29  *   pnc_Lt  => !P && B
  30  *   pnc_Le  => !P && BE
  31  *   pnc_Gt  => A
  32  *   pnc_Ge  => AE
  33  *   pnc_Lg  => NE
  34  *   pnc_Leg => NP  (ordered)
  35  *   pnc_Uo  => P
  36  *   pnc_Ue  => E
  37  *   pnc_Ul  => B
  38  *   pnc_Ule => BE
  39  *   pnc_Ug  => P || A
  40  *   pnc_Uge => P || AE
  41  *   pnc_Ne  => P || NE
  42  */
  43 #include "config.h"
  44
  45 #include <limits.h>
  46
  47 #include "xmalloc.h"
  48 #include "tv.h"
  49 #include "iredges.h"
  50 #include "debug.h"
  51 #include "irgwalk.h"
  52 #include "irprintf.h"
  53 #include "irop_t.h"
  54 #include "irargs_t.h"
  55 #include "irprog_t.h"
  56 #include "iredges_t.h"
  57 #include "irtools.h"
  58 #include "execfreq.h"
  59 #include "error.h"
  60 #include "raw_bitset.h"
  61 #include "dbginfo.h"
  62 #include "lc_opts.h"
  63 #include "ircons.h"
  64
  65 #include "besched.h"
  66 #include "benode.h"
  67 #include "beabi.h"
  68 #include "be_dbgout.h"
  69 #include "beemitter.h"
  70 #include "begnuas.h"
  71 #include "beirg.h"
  72 #include "be_dbgout.h"
  73
  74 #include "ia32_emitter.h"
  75 #include "ia32_common_transform.h"
  76 #include "gen_ia32_emitter.h"
  77 #include "gen_ia32_regalloc_if.h"
  78 #include "ia32_nodes_attr.h"
  79 #include "ia32_new_nodes.h"
  80 #include "ia32_architecture.h"
  81 #include "bearch_ia32_t.h"
  82
  83 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
  84
  85 #define SNPRINTF_BUF_LEN 128
  86
  87 static const ia32_isa_t *isa;
  88 static char              pic_base_label[128];
  89 static ir_label_t        exc_label_id;
  90 static int               mark_spill_reload = 0;
  91 static int               do_pic;
  92
  93 /** Return the next block in Block schedule */
  94 static ir_node *get_prev_block_sched(const ir_node *block)
  95 {
  96         return (ir_node*)get_irn_link(block);
  97 }
  98
  99 /** Checks if the current block is a fall-through target. */
 100 static int is_fallthrough(const ir_node *cfgpred)
 101 {
 102         ir_node *pred;
 103
 104         if (!is_Proj(cfgpred))
 105                 return 1;
 106         pred = get_Proj_pred(cfgpred);
 107         if (is_ia32_SwitchJmp(pred))
 108                 return 0;
 109
 110         return 1;
 111 }
 112
 113 /**
 114  * returns non-zero if the given block needs a label
 115  * because of being a jump-target (and not a fall-through)
 116  */
 117 static int block_needs_label(const ir_node *block)
 118 {
 119         int need_label = 1;
 120         int  n_cfgpreds = get_Block_n_cfgpreds(block);
 121
 122         if (get_Block_entity(block) != NULL)
 123                 return 1;
 124
 125         if (n_cfgpreds == 0) {
 126                 need_label = 0;
 127         } else if (n_cfgpreds == 1) {
 128                 ir_node *cfgpred       = get_Block_cfgpred(block, 0);
 129                 ir_node *cfgpred_block = get_nodes_block(cfgpred);
 130
 131                 if (get_prev_block_sched(block) == cfgpred_block
 132                                 && is_fallthrough(cfgpred)) {
 133                         need_label = 0;
 134                 }
 135         }
 136
 137         return need_label;
 138 }
 139
 140 /**
 141  * Add a number to a prefix. This number will not be used a second time.
 142  */
 143 static char *get_unique_label(char *buf, size_t buflen, const char *prefix)
 144 {
 145         static unsigned long id = 0;
 146         snprintf(buf, buflen, "%s%s%lu", be_gas_get_private_prefix(), prefix, ++id);
 147         return buf;
 148 }
 149
 150 /**
 151  * Emit the name of the 8bit low register
 152  */
 153 static void emit_8bit_register(const arch_register_t *reg)
 154 {
 155         const char *reg_name = arch_register_get_name(reg);
 156         assert(reg->index == REG_GP_EAX || reg->index == REG_GP_EBX
 157                         || reg->index == REG_GP_ECX || reg->index == REG_GP_EDX);
 158
 159         be_emit_char('%');
 160         be_emit_char(reg_name[1]); /* get the basic name of the register */
 161         be_emit_char('l');
 162 }
 163
 164 /**
 165  * Emit the name of the 8bit high register
 166  */
 167 static void emit_8bit_register_high(const arch_register_t *reg)
 168 {
 169         const char *reg_name = arch_register_get_name(reg);
 170         assert(reg->index == REG_GP_EAX || reg->index == REG_GP_EBX
 171                         || reg->index == REG_GP_ECX || reg->index == REG_GP_EDX);
 172
 173         be_emit_char('%');
 174         be_emit_char(reg_name[1]); /* get the basic name of the register */
 175         be_emit_char('h');
 176 }
 177
 178 static void emit_16bit_register(const arch_register_t *reg)
 179 {
 180         const char *reg_name = arch_register_get_name(reg);
 181
 182         be_emit_char('%');
 183         be_emit_string(reg_name+1); /* skip the 'e' prefix of the 32bit names */
 184 }
 185
 186 /**
 187  * emit a register, possible shortened by a mode
 188  *
 189  * @param reg   the register
 190  * @param mode  the mode of the register or NULL for full register
 191  */
 192 static void emit_register(const arch_register_t *reg, const ir_mode *mode)
 193 {
 194         const char *reg_name;
 195
 196         if (mode != NULL) {
 197                 int size = get_mode_size_bits(mode);
 198                 switch (size) {
 199                         case  8: emit_8bit_register(reg);  return;
 200                         case 16: emit_16bit_register(reg); return;
 201                 }
 202                 assert(mode_is_float(mode) || size == 32);
 203         }
 204
 205         reg_name = arch_register_get_name(reg);
 206
 207         be_emit_char('%');
 208         be_emit_string(reg_name);
 209 }
 210
 211 void ia32_emit_source_register(const ir_node *node, int pos)
 212 {
 213         const arch_register_t *reg = arch_get_irn_register_in(node, pos);
 214
 215         emit_register(reg, NULL);
 216 }
 217
 218 static void ia32_emit_entity(ir_entity *entity, int no_pic_adjust)
 219 {
 220         be_gas_emit_entity(entity);
 221
 222         if (get_entity_owner(entity) == get_tls_type()) {
 223                 if (get_entity_visibility(entity) == ir_visibility_external) {
 224                         be_emit_cstring("@INDNTPOFF");
 225                 } else {
 226                         be_emit_cstring("@NTPOFF");
 227                 }
 228         }
 229
 230         if (do_pic && !no_pic_adjust) {
 231                 be_emit_char('-');
 232                 be_emit_string(pic_base_label);
 233         }
 234 }
 235
 236 static void emit_ia32_Immediate_no_prefix(const ir_node *node)
 237 {
 238         const ia32_immediate_attr_t *attr = get_ia32_immediate_attr_const(node);
 239
 240         if (attr->symconst != NULL) {
 241                 if (attr->sc_sign)
 242                         be_emit_char('-');
 243                 ia32_emit_entity(attr->symconst, attr->no_pic_adjust);
 244         }
 245         if (attr->symconst == NULL || attr->offset != 0) {
 246                 if (attr->symconst != NULL) {
 247                         be_emit_irprintf("%+d", attr->offset);
 248                 } else {
 249                         be_emit_irprintf("0x%X", attr->offset);
 250                 }
 251         }
 252 }
 253
 254 static void emit_ia32_Immediate(const ir_node *node)
 255 {
 256         be_emit_char('$');
 257         emit_ia32_Immediate_no_prefix(node);
 258 }
 259
 260 void ia32_emit_8bit_source_register_or_immediate(const ir_node *node, int pos)
 261 {
 262         const arch_register_t *reg;
 263         const ir_node         *in = get_irn_n(node, pos);
 264         if (is_ia32_Immediate(in)) {
 265                 emit_ia32_Immediate(in);
 266                 return;
 267         }
 268
 269         reg = arch_get_irn_register_in(node, pos);
 270         emit_8bit_register(reg);
 271 }
 272
 273 void ia32_emit_8bit_high_source_register(const ir_node *node, int pos)
 274 {
 275         const arch_register_t *reg = arch_get_irn_register_in(node, pos);
 276         emit_8bit_register_high(reg);
 277 }
 278
 279 void ia32_emit_16bit_source_register_or_immediate(const ir_node *node, int pos)
 280 {
 281         const arch_register_t *reg;
 282         const ir_node         *in = get_irn_n(node, pos);
 283         if (is_ia32_Immediate(in)) {
 284                 emit_ia32_Immediate(in);
 285                 return;
 286         }
 287
 288         reg = arch_get_irn_register_in(node, pos);
 289         emit_16bit_register(reg);
 290 }
 291
 292 void ia32_emit_dest_register(const ir_node *node, int pos)
 293 {
 294         const arch_register_t *reg  = arch_get_irn_register_out(node, pos);
 295
 296         emit_register(reg, NULL);
 297 }
 298
 299 void ia32_emit_dest_register_size(const ir_node *node, int pos)
 300 {
 301         const arch_register_t *reg  = arch_get_irn_register_out(node, pos);
 302
 303         emit_register(reg, get_ia32_ls_mode(node));
 304 }
 305
 306 void ia32_emit_8bit_dest_register(const ir_node *node, int pos)
 307 {
 308         const arch_register_t *reg  = arch_get_irn_register_out(node, pos);
 309
 310         emit_register(reg, mode_Bu);
 311 }
 312
 313 void ia32_emit_x87_register(const ir_node *node, int pos)
 314 {
 315         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
 316
 317         assert(pos < 3);
 318         be_emit_char('%');
 319         be_emit_string(attr->x87[pos]->name);
 320 }
 321
 322 static void ia32_emit_mode_suffix_mode(const ir_mode *mode)
 323 {
 324         assert(mode_is_int(mode) || mode_is_reference(mode));
 325         switch (get_mode_size_bits(mode)) {
 326                 case 8:  be_emit_char('b');     return;
 327                 case 16: be_emit_char('w');     return;
 328                 case 32: be_emit_char('l');     return;
 329                 /* gas docu says q is the suffix but gcc, objdump and icc use ll
 330                  * apparently */
 331                 case 64: be_emit_cstring("ll"); return;
 332         }
 333         panic("Can't output mode_suffix for %+F", mode);
 334 }
 335
 336 void ia32_emit_mode_suffix(const ir_node *node)
 337 {
 338         ir_mode *mode = get_ia32_ls_mode(node);
 339         if (mode == NULL)
 340                 mode = mode_Iu;
 341
 342         ia32_emit_mode_suffix_mode(mode);
 343 }
 344
 345 void ia32_emit_x87_mode_suffix(const ir_node *node)
 346 {
 347         ir_mode *mode;
 348
 349         /* we only need to emit the mode on address mode */
 350         if (get_ia32_op_type(node) == ia32_Normal)
 351                 return;
 352
 353         mode = get_ia32_ls_mode(node);
 354         assert(mode != NULL);
 355
 356         if (mode_is_float(mode)) {
 357                 switch (get_mode_size_bits(mode)) {
 358                         case  32: be_emit_char('s'); return;
 359                         case  64: be_emit_char('l'); return;
 360                         /* long doubles have different sizes due to alignment on different
 361                          * platforms. */
 362                         case  80:
 363                         case  96:
 364                         case 128: be_emit_char('t'); return;
 365                 }
 366         } else {
 367                 assert(mode_is_int(mode) || mode_is_reference(mode));
 368                 switch (get_mode_size_bits(mode)) {
 369                         case 16: be_emit_char('s');     return;
 370                         case 32: be_emit_char('l');     return;
 371                         /* gas docu says q is the suffix but gcc, objdump and icc use ll
 372                          * apparently */
 373                         case 64: be_emit_cstring("ll"); return;
 374                 }
 375         }
 376         panic("Can't output mode_suffix for %+F", mode);
 377 }
 378
 379 static char get_xmm_mode_suffix(ir_mode *mode)
 380 {
 381         assert(mode_is_float(mode));
 382         switch (get_mode_size_bits(mode)) {
 383         case 32: return 's';
 384         case 64: return 'd';
 385         default: panic("Invalid XMM mode");
 386         }
 387 }
 388
 389 void ia32_emit_xmm_mode_suffix(const ir_node *node)
 390 {
 391         ir_mode *mode = get_ia32_ls_mode(node);
 392         assert(mode != NULL);
 393         be_emit_char('s');
 394         be_emit_char(get_xmm_mode_suffix(mode));
 395 }
 396
 397 void ia32_emit_xmm_mode_suffix_s(const ir_node *node)
 398 {
 399         ir_mode *mode = get_ia32_ls_mode(node);
 400         assert(mode != NULL);
 401         be_emit_char(get_xmm_mode_suffix(mode));
 402 }
 403
 404 void ia32_emit_extend_suffix(const ir_node *node)
 405 {
 406         ir_mode *mode = get_ia32_ls_mode(node);
 407         if (get_mode_size_bits(mode) == 32)
 408                 return;
 409         be_emit_char(mode_is_signed(mode) ? 's' : 'z');
 410         ia32_emit_mode_suffix_mode(mode);
 411 }
 412
 413 void ia32_emit_source_register_or_immediate(const ir_node *node, int pos)
 414 {
 415         ir_node *in = get_irn_n(node, pos);
 416         if (is_ia32_Immediate(in)) {
 417                 emit_ia32_Immediate(in);
 418         } else {
 419                 const ir_mode         *mode = get_ia32_ls_mode(node);
 420                 const arch_register_t *reg  = arch_get_irn_register_in(node, pos);
 421                 emit_register(reg, mode);
 422         }
 423 }
 424
 425 /**
 426  * Returns the target block for a control flow node.
 427  */
 428 static ir_node *get_cfop_target_block(const ir_node *irn)
 429 {
 430         assert(get_irn_mode(irn) == mode_X);
 431         return (ir_node*)get_irn_link(irn);
 432 }
 433
 434 /**
 435  * Emits the target label for a control flow node.
 436  */
 437 static void ia32_emit_cfop_target(const ir_node *node)
 438 {
 439         ir_node *block = get_cfop_target_block(node);
 440         be_gas_emit_block_name(block);
 441 }
 442
 443 /**
 444  * Emit the suffix for a compare instruction.
 445  */
 446 static void ia32_emit_condition_code(ia32_condition_code_t cc)
 447 {
 448         switch (cc) {
 449         case ia32_cc_overflow:      be_emit_cstring("o");  return;
 450         case ia32_cc_not_overflow:  be_emit_cstring("no"); return;
 451         case ia32_cc_float_below:
 452         case ia32_cc_float_unordered_below:
 453         case ia32_cc_below:         be_emit_cstring("b");  return;
 454         case ia32_cc_float_above_equal:
 455         case ia32_cc_float_unordered_above_equal:
 456         case ia32_cc_above_equal:   be_emit_cstring("ae"); return;
 457         case ia32_cc_float_equal:
 458         case ia32_cc_equal:         be_emit_cstring("e");  return;
 459         case ia32_cc_float_not_equal:
 460         case ia32_cc_not_equal:     be_emit_cstring("ne"); return;
 461         case ia32_cc_float_below_equal:
 462         case ia32_cc_float_unordered_below_equal:
 463         case ia32_cc_below_equal:   be_emit_cstring("be"); return;
 464         case ia32_cc_float_above:
 465         case ia32_cc_float_unordered_above:
 466         case ia32_cc_above:         be_emit_cstring("a");  return;
 467         case ia32_cc_sign:          be_emit_cstring("s");  return;
 468         case ia32_cc_not_sign:      be_emit_cstring("ns"); return;
 469         case ia32_cc_parity:        be_emit_cstring("p");  return;
 470         case ia32_cc_not_parity:    be_emit_cstring("np"); return;
 471         case ia32_cc_less:          be_emit_cstring("l");  return;
 472         case ia32_cc_greater_equal: be_emit_cstring("ge"); return;
 473         case ia32_cc_less_equal:    be_emit_cstring("le"); return;
 474         case ia32_cc_greater:       be_emit_cstring("g");  return;
 475         case ia32_cc_float_parity_cases:
 476         case ia32_cc_additional_float_cases:
 477                 break;
 478         }
 479         panic("Invalid ia32 condition code");
 480 }
 481
 482 typedef enum ia32_emit_mod_t {
 483         EMIT_NONE         = 0,
 484         EMIT_RESPECT_LS   = 1U << 0,
 485         EMIT_ALTERNATE_AM = 1U << 1,
 486         EMIT_LONG         = 1U << 2,
 487         EMIT_HIGH_REG     = 1U << 3,
 488         EMIT_LOW_REG      = 1U << 4
 489 } ia32_emit_mod_t;
 490 ENUM_BITSET(ia32_emit_mod_t)
 491
 492 /**
 493  * Emits address mode.
 494  */
 495 void ia32_emit_am(const ir_node *node)
 496 {
 497         ir_entity *ent       = get_ia32_am_sc(node);
 498         int        offs      = get_ia32_am_offs_int(node);
 499         ir_node   *base      = get_irn_n(node, n_ia32_base);
 500         int        has_base  = !is_ia32_NoReg_GP(base);
 501         ir_node   *idx       = get_irn_n(node, n_ia32_index);
 502         int        has_index = !is_ia32_NoReg_GP(idx);
 503
 504         /* just to be sure... */
 505         assert(!is_ia32_use_frame(node) || get_ia32_frame_ent(node) != NULL);
 506
 507         if (get_ia32_am_tls_segment(node))
 508                 be_emit_cstring("%gs:");
 509
 510         /* emit offset */
 511         if (ent != NULL) {
 512                 const ia32_attr_t *attr = get_ia32_attr_const(node);
 513                 if (is_ia32_am_sc_sign(node))
 514                         be_emit_char('-');
 515                 ia32_emit_entity(ent, attr->data.am_sc_no_pic_adjust);
 516         }
 517
 518         /* also handle special case if nothing is set */
 519         if (offs != 0 || (ent == NULL && !has_base && !has_index)) {
 520                 if (ent != NULL) {
 521                         be_emit_irprintf("%+d", offs);
 522                 } else {
 523                         be_emit_irprintf("%d", offs);
 524                 }
 525         }
 526
 527         if (has_base || has_index) {
 528                 be_emit_char('(');
 529
 530                 /* emit base */
 531                 if (has_base) {
 532                         const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_base);
 533                         emit_register(reg, NULL);
 534                 }
 535
 536                 /* emit index + scale */
 537                 if (has_index) {
 538                         const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_index);
 539                         int scale;
 540                         be_emit_char(',');
 541                         emit_register(reg, NULL);
 542
 543                         scale = get_ia32_am_scale(node);
 544                         if (scale > 0) {
 545                                 be_emit_irprintf(",%d", 1 << scale);
 546                         }
 547                 }
 548                 be_emit_char(')');
 549         }
 550 }
 551
 552 /**
 553  * fmt  parameter               output
 554  * ---- ----------------------  ---------------------------------------------
 555  * %%                           %
 556  * %AM  <node>                  address mode of the node
 557  * %AR  const arch_register_t*  address mode of the node or register
 558  * %ASx <node>                  address mode of the node or source register x
 559  * %Dx  <node>                  destination register x
 560  * %I   <node>                  immediate of the node
 561  * %L   <node>                  control flow target of the node
 562  * %M   <node>                  mode suffix of the node
 563  * %P   int                     condition code
 564  * %R   const arch_register_t*  register
 565  * %Sx  <node>                  source register x
 566  * %s   const char*             string
 567  * %u   unsigned int            unsigned int
 568  * %d   signed int              signed int
 569  *
 570  * x starts at 0
 571  * # modifier for %ASx, %D, %R, and %S uses ls mode of node to alter register width
 572  * * modifier does not prefix immediates with $, but AM with *
 573  * l modifier for %lu and %ld
 574  * > modifier to output high 8bit register (ah, bh)
 575  * < modifier to output low 8bit register (al, bl)
 576  */
 577 static void ia32_emitf(const ir_node *node, const char *fmt, ...)
 578 {
 579         va_list ap;
 580         va_start(ap, fmt);
 581
 582         for (;;) {
 583                 const char      *start = fmt;
 584                 ia32_emit_mod_t  mod   = EMIT_NONE;
 585
 586                 while (*fmt != '%' && *fmt != '\n' && *fmt != '\0')
 587                         ++fmt;
 588                 if (fmt != start) {
 589                         be_emit_string_len(start, fmt - start);
 590                 }
 591
 592                 if (*fmt == '\n') {
 593                         be_emit_finish_line_gas(node);
 594                         ++fmt;
 595                         if (*fmt == '\0')
 596                                 break;
 597                         continue;
 598                 }
 599
 600                 if (*fmt == '\0')
 601                         break;
 602
 603                 ++fmt;
 604                 for (;;) {
 605                         switch (*fmt) {
 606                         case '*': mod |= EMIT_ALTERNATE_AM; break;
 607                         case '#': mod |= EMIT_RESPECT_LS;   break;
 608                         case 'l': mod |= EMIT_LONG;         break;
 609                         case '>': mod |= EMIT_HIGH_REG;     break;
 610                         case '<': mod |= EMIT_LOW_REG;      break;
 611                         default:
 612                                 goto end_of_mods;
 613                         }
 614                         ++fmt;
 615                 }
 616 end_of_mods:
 617
 618                 switch (*fmt++) {
 619                         arch_register_t const *reg;
 620                         ir_node         const *imm;
 621
 622                         case '%':
 623                                 be_emit_char('%');
 624                                 break;
 625
 626                         case 'A': {
 627                                 switch (*fmt++) {
 628 emit_AM:
 629                                         case 'M':
 630                                                 if (mod & EMIT_ALTERNATE_AM)
 631                                                         be_emit_char('*');
 632                                                 ia32_emit_am(node);
 633                                                 break;
 634
 635                                         case 'R':
 636                                                 reg = va_arg(ap, const arch_register_t*);
 637                                                 if (get_ia32_op_type(node) == ia32_AddrModeS) {
 638                                                         goto emit_AM;
 639                                                 } else {
 640                                                         goto emit_R;
 641                                                 }
 642
 643                                         case 'S':
 644                                                 if (get_ia32_op_type(node) == ia32_AddrModeS) {
 645                                                         ++fmt;
 646                                                         goto emit_AM;
 647                                                 } else {
 648                                                         assert(get_ia32_op_type(node) == ia32_Normal);
 649                                                         goto emit_S;
 650                                                 }
 651
 652                                         default: goto unknown;
 653                                 }
 654                                 break;
 655                         }
 656
 657                         case 'D':
 658                                 if (*fmt < '0' || '9' <= *fmt)
 659                                         goto unknown;
 660                                 reg = arch_get_irn_register_out(node, *fmt++ - '0');
 661                                 goto emit_R;
 662
 663                         case 'I':
 664                                 imm = node;
 665 emit_I:
 666                                 if (!(mod & EMIT_ALTERNATE_AM))
 667                                         be_emit_char('$');
 668                                 emit_ia32_Immediate_no_prefix(imm);
 669                                 break;
 670
 671                         case 'L':
 672                                 ia32_emit_cfop_target(node);
 673                                 break;
 674
 675                         case 'M':
 676                                 ia32_emit_mode_suffix_mode(get_ia32_ls_mode(node));
 677                                 break;
 678
 679                         case 'P': {
 680                                 ia32_condition_code_t cc = va_arg(ap, ia32_condition_code_t);
 681                                 ia32_emit_condition_code(cc);
 682                                 break;
 683                         }
 684
 685                         case 'R':
 686                                 reg = va_arg(ap, const arch_register_t*);
 687 emit_R:
 688                                 if (mod & EMIT_ALTERNATE_AM)
 689                                         be_emit_char('*');
 690                                 if (mod & EMIT_HIGH_REG) {
 691                                         emit_8bit_register_high(reg);
 692                                 } else if (mod & EMIT_LOW_REG) {
 693                                         emit_8bit_register(reg);
 694                                 } else {
 695                                         emit_register(reg, mod & EMIT_RESPECT_LS ? get_ia32_ls_mode(node) : NULL);
 696                                 }
 697                                 break;
 698
 699 emit_S:
 700                         case 'S': {
 701                                 unsigned pos;
 702
 703                                 if (*fmt < '0' || '9' <= *fmt)
 704                                         goto unknown;
 705
 706                                 pos = *fmt++ - '0';
 707                                 imm = get_irn_n(node, pos);
 708                                 if (is_ia32_Immediate(imm)) {
 709                                         goto emit_I;
 710                                 } else {
 711                                         reg = arch_get_irn_register_in(node, pos);
 712                                         goto emit_R;
 713                                 }
 714                         }
 715
 716                         case 's': {
 717                                 const char *str = va_arg(ap, const char*);
 718                                 be_emit_string(str);
 719                                 break;
 720                         }
 721
 722                         case 'u':
 723                                 if (mod & EMIT_LONG) {
 724                                         unsigned long num = va_arg(ap, unsigned long);
 725                                         be_emit_irprintf("%lu", num);
 726                                 } else {
 727                                         unsigned num = va_arg(ap, unsigned);
 728                                         be_emit_irprintf("%u", num);
 729                                 }
 730                                 break;
 731
 732                         case 'd':
 733                                 if (mod & EMIT_LONG) {
 734                                         long num = va_arg(ap, long);
 735                                         be_emit_irprintf("%ld", num);
 736                                 } else {
 737                                         int num = va_arg(ap, int);
 738                                         be_emit_irprintf("%d", num);
 739                                 }
 740                                 break;
 741
 742                         default:
 743 unknown:
 744                                 panic("unknown format conversion in ia32_emitf()");
 745                 }
 746         }
 747
 748         va_end(ap);
 749 }
 750
 751 /**
 752  * Emits registers and/or address mode of a binary operation.
 753  */
 754 void ia32_emit_binop(const ir_node *node)
 755 {
 756         if (is_ia32_Immediate(get_irn_n(node, n_ia32_binary_right))) {
 757                 ia32_emitf(node, "%#S4, %#AS3");
 758         } else {
 759                 ia32_emitf(node, "%#AS4, %#S3");
 760         }
 761 }
 762
 763 /**
 764  * Emits registers and/or address mode of a binary operation.
 765  */
 766 void ia32_emit_x87_binop(const ir_node *node)
 767 {
 768         switch (get_ia32_op_type(node)) {
 769                 case ia32_Normal:
 770                         {
 771                                 const ia32_x87_attr_t *x87_attr = get_ia32_x87_attr_const(node);
 772                                 const arch_register_t *in1      = x87_attr->x87[0];
 773                                 const arch_register_t *in       = x87_attr->x87[1];
 774                                 const arch_register_t *out      = x87_attr->x87[2];
 775
 776                                 if (out == NULL) {
 777                                         out = in1;
 778                                 } else if (out == in) {
 779                                         in = in1;
 780                                 }
 781
 782                                 be_emit_char('%');
 783                                 be_emit_string(arch_register_get_name(in));
 784                                 be_emit_cstring(", %");
 785                                 be_emit_string(arch_register_get_name(out));
 786                         }
 787                         break;
 788                 case ia32_AddrModeS:
 789                         ia32_emit_am(node);
 790                         break;
 791                 case ia32_AddrModeD:
 792                 default:
 793                         assert(0 && "unsupported op type");
 794         }
 795 }
 796
 797 /**
 798  * Emits registers and/or address mode of a unary operation.
 799  */
 800 void ia32_emit_unop(const ir_node *node, int pos)
 801 {
 802         char fmt[] = "%ASx";
 803         fmt[3] = '0' + pos;
 804         ia32_emitf(node, fmt);
 805 }
 806
 807 static void emit_ia32_IMul(const ir_node *node)
 808 {
 809         ir_node               *left    = get_irn_n(node, n_ia32_IMul_left);
 810         const arch_register_t *out_reg = arch_get_irn_register_out(node, pn_ia32_IMul_res);
 811
 812         /* do we need the 3-address form? */
 813         if (is_ia32_NoReg_GP(left) ||
 814                         arch_get_irn_register_in(node, n_ia32_IMul_left) != out_reg) {
 815                 ia32_emitf(node, "\timul%M %#S4, %#AS3, %#D0\n");
 816         } else {
 817                 ia32_emitf(node, "\timul%M %#AS4, %#S3\n");
 818         }
 819 }
 820
 821 /**
 822  * walks up a tree of copies/perms/spills/reloads to find the original value
 823  * that is moved around
 824  */
 825 static ir_node *find_original_value(ir_node *node)
 826 {
 827         if (irn_visited(node))
 828                 return NULL;
 829
 830         mark_irn_visited(node);
 831         if (be_is_Copy(node)) {
 832                 return find_original_value(be_get_Copy_op(node));
 833         } else if (be_is_CopyKeep(node)) {
 834                 return find_original_value(be_get_CopyKeep_op(node));
 835         } else if (is_Proj(node)) {
 836                 ir_node *pred = get_Proj_pred(node);
 837                 if (be_is_Perm(pred)) {
 838                         return find_original_value(get_irn_n(pred, get_Proj_proj(node)));
 839                 } else if (be_is_MemPerm(pred)) {
 840                         return find_original_value(get_irn_n(pred, get_Proj_proj(node) + 1));
 841                 } else if (is_ia32_Load(pred)) {
 842                         return find_original_value(get_irn_n(pred, n_ia32_Load_mem));
 843                 } else if (is_ia32_Store(pred)) {
 844                         return find_original_value(get_irn_n(pred, n_ia32_Store_val));
 845                 } else {
 846                         return node;
 847                 }
 848         } else if (is_Phi(node)) {
 849                 int i, arity;
 850                 arity = get_irn_arity(node);
 851                 for (i = 0; i < arity; ++i) {
 852                         ir_node *in  = get_irn_n(node, i);
 853                         ir_node *res = find_original_value(in);
 854
 855                         if (res != NULL)
 856                                 return res;
 857                 }
 858                 return NULL;
 859         } else {
 860                 return node;
 861         }
 862 }
 863
 864 static int determine_final_cc(const ir_node *node, int flags_pos, int cc)
 865 {
 866         ir_node           *flags = get_irn_n(node, flags_pos);
 867         const ia32_attr_t *flags_attr;
 868         flags = skip_Proj(flags);
 869
 870         if (is_ia32_Sahf(flags)) {
 871                 ir_node *cmp = get_irn_n(flags, n_ia32_Sahf_val);
 872                 if (!(is_ia32_FucomFnstsw(cmp) || is_ia32_FucompFnstsw(cmp)
 873                                 || is_ia32_FucomppFnstsw(cmp) || is_ia32_FtstFnstsw(cmp))) {
 874                         inc_irg_visited(current_ir_graph);
 875                         cmp = find_original_value(cmp);
 876                         assert(cmp != NULL);
 877                         assert(is_ia32_FucomFnstsw(cmp) || is_ia32_FucompFnstsw(cmp)
 878                                || is_ia32_FucomppFnstsw(cmp) || is_ia32_FtstFnstsw(cmp));
 879                 }
 880
 881                 flags_attr = get_ia32_attr_const(cmp);
 882         } else {
 883                 flags_attr = get_ia32_attr_const(flags);
 884         }
 885
 886         if (flags_attr->data.ins_permuted)
 887                 cc = ia32_invert_condition_code(cc);
 888         return cc;
 889 }
 890
 891 void ia32_emit_cmp_suffix_node(const ir_node *node, int flags_pos)
 892 {
 893         ia32_condition_code_t cc = get_ia32_condcode(node);
 894         cc = determine_final_cc(node, flags_pos, cc);
 895
 896         ia32_emit_condition_code(cc);
 897 }
 898
 899 /**
 900  * Emits an exception label for a given node.
 901  */
 902 static void ia32_emit_exc_label(const ir_node *node)
 903 {
 904         be_emit_string(be_gas_insn_label_prefix());
 905         be_emit_irprintf("%lu", get_ia32_exc_label_id(node));
 906 }
 907
 908 /**
 909  * Returns the Proj with projection number proj and NOT mode_M
 910  */
 911 static ir_node *get_proj(const ir_node *node, long proj)
 912 {
 913         const ir_edge_t *edge;
 914         ir_node         *src;
 915
 916         assert(get_irn_mode(node) == mode_T && "expected mode_T node");
 917
 918         foreach_out_edge(node, edge) {
 919                 src = get_edge_src_irn(edge);
 920
 921                 assert(is_Proj(src) && "Proj expected");
 922                 if (get_irn_mode(src) == mode_M)
 923                         continue;
 924
 925                 if (get_Proj_proj(src) == proj)
 926                         return src;
 927         }
 928         return NULL;
 929 }
 930
 931 static int can_be_fallthrough(const ir_node *node)
 932 {
 933         ir_node *target_block = get_cfop_target_block(node);
 934         ir_node *block        = get_nodes_block(node);
 935         return get_prev_block_sched(target_block) == block;
 936 }
 937
 938 /**
 939  * Emits the jump sequence for a conditional jump (cmp + jmp_true + jmp_false)
 940  */
 941 static void emit_ia32_Jcc(const ir_node *node)
 942 {
 943         int                   need_parity_label = 0;
 944         ia32_condition_code_t cc                = get_ia32_condcode(node);
 945         const ir_node        *proj_true;
 946         const ir_node        *proj_false;
 947
 948         cc = determine_final_cc(node, 0, cc);
 949
 950         /* get both Projs */
 951         proj_true = get_proj(node, pn_ia32_Jcc_true);
 952         assert(proj_true && "Jcc without true Proj");
 953
 954         proj_false = get_proj(node, pn_ia32_Jcc_false);
 955         assert(proj_false && "Jcc without false Proj");
 956
 957         if (can_be_fallthrough(proj_true)) {
 958                 /* exchange both proj's so the second one can be omitted */
 959                 const ir_node *t = proj_true;
 960
 961                 proj_true  = proj_false;
 962                 proj_false = t;
 963                 cc         = ia32_negate_condition_code(cc);
 964         }
 965
 966         if (cc & ia32_cc_float_parity_cases) {
 967                 /* Some floating point comparisons require a test of the parity flag,
 968                  * which indicates that the result is unordered */
 969                 if (cc & ia32_cc_negated) {
 970                         ia32_emitf(proj_true, "\tjp %L\n");
 971                 } else {
 972                         /* we need a local label if the false proj is a fallthrough
 973                          * as the falseblock might have no label emitted then */
 974                         if (can_be_fallthrough(proj_false)) {
 975                                 need_parity_label = 1;
 976                                 ia32_emitf(proj_false, "\tjp 1f\n");
 977                         } else {
 978                                 ia32_emitf(proj_false, "\tjp %L\n");
 979                         }
 980                 }
 981         }
 982         ia32_emitf(proj_true, "\tj%P %L\n", cc);
 983         if (need_parity_label) {
 984                 ia32_emitf(NULL, "1:\n");
 985         }
 986
 987         /* the second Proj might be a fallthrough */
 988         if (can_be_fallthrough(proj_false)) {
 989                 ia32_emitf(proj_false, "\t/* fallthrough to %L */\n");
 990         } else {
 991                 ia32_emitf(proj_false, "\tjmp %L\n");
 992         }
 993 }
 994
 995 /**
 996  * Emits an ia32 Setcc. This is mostly easy but some floating point compares
 997  * are tricky.
 998  */
 999 static void emit_ia32_Setcc(const ir_node *node)
1000 {
1001         const arch_register_t *dreg = arch_get_irn_register_out(node, pn_ia32_Setcc_res);
1002
1003         ia32_condition_code_t cc = get_ia32_condcode(node);
1004         cc = determine_final_cc(node, n_ia32_Setcc_eflags, cc);
1005         if (cc & ia32_cc_float_parity_cases) {
1006                 if (cc & ia32_cc_negated) {
1007                         ia32_emitf(node, "\tset%P %<R\n", cc, dreg);
1008                         ia32_emitf(node, "\tsetp %>R\n", dreg);
1009                         ia32_emitf(node, "\torb %>R, %<R\n", dreg, dreg);
1010                 } else {
1011                         ia32_emitf(node, "\tset%P %<R\n", cc, dreg);
1012                         ia32_emitf(node, "\tsetnp %>R\n", dreg);
1013                         ia32_emitf(node, "\tandb %>R, %<R\n", dreg, dreg);
1014                 }
1015         } else {
1016                 ia32_emitf(node, "\tset%P %#R\n", cc, dreg);
1017         }
1018 }
1019
1020 static void emit_ia32_CMovcc(const ir_node *node)
1021 {
1022         const ia32_attr_t     *attr = get_ia32_attr_const(node);
1023         const arch_register_t *out  = arch_get_irn_register_out(node, pn_ia32_res);
1024         ia32_condition_code_t  cc   = get_ia32_condcode(node);
1025         const arch_register_t *in_true;
1026         const arch_register_t *in_false;
1027
1028         cc = determine_final_cc(node, n_ia32_CMovcc_eflags, cc);
1029         /* although you can't set ins_permuted in the constructor it might still
1030          * be set by memory operand folding
1031          * Permuting inputs of a cmov means the condition is negated!
1032          */
1033         if (attr->data.ins_permuted)
1034                 cc = ia32_negate_condition_code(cc);
1035
1036         in_true  = arch_get_irn_register(get_irn_n(node, n_ia32_CMovcc_val_true));
1037         in_false = arch_get_irn_register(get_irn_n(node, n_ia32_CMovcc_val_false));
1038
1039         /* should be same constraint fullfilled? */
1040         if (out == in_false) {
1041                 /* yes -> nothing to do */
1042         } else if (out == in_true) {
1043                 const arch_register_t *tmp;
1044
1045                 assert(get_ia32_op_type(node) == ia32_Normal);
1046
1047                 cc = ia32_negate_condition_code(cc);
1048
1049                 tmp      = in_true;
1050                 in_true  = in_false;
1051                 in_false = tmp;
1052         } else {
1053                 /* we need a mov */
1054                 ia32_emitf(node, "\tmovl %R, %R\n", in_false, out);
1055         }
1056
1057         if (cc & ia32_cc_float_parity_cases) {
1058                 panic("CMov with floatingpoint compare/parity not supported yet");
1059         }
1060
1061         ia32_emitf(node, "\tcmov%P %#AR, %#R\n", cc, in_true, out);
1062 }
1063
1064 /**
1065  * Emits code for a SwitchJmp
1066  */
1067 static void emit_ia32_SwitchJmp(const ir_node *node)
1068 {
1069         ir_entity             *jump_table = get_ia32_am_sc(node);
1070         const ir_switch_table *table      = get_ia32_switch_table(node);
1071
1072         ia32_emitf(node, "\tjmp %*AM\n");
1073         be_emit_jump_table(node, table, jump_table, get_cfop_target_block);
1074 }
1075
1076 /**
1077  * Emits code for a unconditional jump.
1078  */
1079 static void emit_ia32_Jmp(const ir_node *node)
1080 {
1081         /* we have a block schedule */
1082         if (can_be_fallthrough(node)) {
1083                 ia32_emitf(node, "\t/* fallthrough to %L */\n");
1084         } else {
1085                 ia32_emitf(node, "\tjmp %L\n");
1086         }
1087 }
1088
1089 /**
1090  * Emit an inline assembler operand.
1091  *
1092  * @param node  the ia32_ASM node
1093  * @param s     points to the operand (a %c)
1094  *
1095  * @return  pointer to the first char in s NOT in the current operand
1096  */
1097 static const char* emit_asm_operand(const ir_node *node, const char *s)
1098 {
1099         const ia32_attr_t     *ia32_attr = get_ia32_attr_const(node);
1100         const ia32_asm_attr_t *attr      = CONST_CAST_IA32_ATTR(ia32_asm_attr_t,
1101                                                             ia32_attr);
1102         const arch_register_t *reg;
1103         const ia32_asm_reg_t  *asm_regs = attr->register_map;
1104         const ia32_asm_reg_t  *asm_reg;
1105         char                   c;
1106         char                   modifier = 0;
1107         int                    num;
1108         int                    p;
1109
1110         assert(*s == '%');
1111         c = *(++s);
1112
1113         /* parse modifiers */
1114         switch (c) {
1115         case 0:
1116                 ir_fprintf(stderr, "Warning: asm text (%+F) ends with %%\n", node);
1117                 be_emit_char('%');
1118                 return s + 1;
1119         case '%':
1120                 be_emit_char('%');
1121                 return s + 1;
1122         case 'w':
1123         case 'b':
1124         case 'h':
1125                 modifier = c;
1126                 ++s;
1127                 break;
1128         case '0':
1129         case '1':
1130         case '2':
1131         case '3':
1132         case '4':
1133         case '5':
1134         case '6':
1135         case '7':
1136         case '8':
1137         case '9':
1138                 break;
1139         default:
1140                 ir_fprintf(stderr,
1141                                 "Warning: asm text (%+F) contains unknown modifier '%c' for asm op\n",
1142                                 node, c);
1143                 ++s;
1144                 break;
1145         }
1146
1147         /* parse number */
1148         if (sscanf(s, "%d%n", &num, &p) != 1) {
1149                 ir_fprintf(stderr, "Warning: Couldn't parse assembler operand (%+F)\n",
1150                            node);
1151                 return s;
1152         } else {
1153                 s += p;
1154         }
1155
1156         if (num < 0 || ARR_LEN(asm_regs) <= (size_t)num) {
1157                 ir_fprintf(stderr,
1158                                 "Error: Custom assembler references invalid input/output (%+F)\n",
1159                                 node);
1160                 return s;
1161         }
1162         asm_reg = & asm_regs[num];
1163         assert(asm_reg->valid);
1164
1165         /* get register */
1166         if (asm_reg->use_input == 0) {
1167                 reg = arch_get_irn_register_out(node, asm_reg->inout_pos);
1168         } else {
1169                 ir_node *pred = get_irn_n(node, asm_reg->inout_pos);
1170
1171                 /* might be an immediate value */
1172                 if (is_ia32_Immediate(pred)) {
1173                         emit_ia32_Immediate(pred);
1174                         return s;
1175                 }
1176                 reg = arch_get_irn_register_in(node, asm_reg->inout_pos);
1177         }
1178         if (reg == NULL) {
1179                 ir_fprintf(stderr,
1180                                 "Warning: no register assigned for %d asm op (%+F)\n",
1181                                 num, node);
1182                 return s;
1183         }
1184
1185         if (asm_reg->memory) {
1186                 be_emit_char('(');
1187         }
1188
1189         /* emit it */
1190         if (modifier != 0) {
1191                 switch (modifier) {
1192                 case 'b':
1193                         emit_8bit_register(reg);
1194                         break;
1195                 case 'h':
1196                         emit_8bit_register_high(reg);
1197                         break;
1198                 case 'w':
1199                         emit_16bit_register(reg);
1200                         break;
1201                 default:
1202                         panic("Invalid asm op modifier");
1203                 }
1204         } else {
1205                 emit_register(reg, asm_reg->memory ? mode_Iu : asm_reg->mode);
1206         }
1207
1208         if (asm_reg->memory) {
1209                 be_emit_char(')');
1210         }
1211
1212         return s;
1213 }
1214
1215 /**
1216  * Emits code for an ASM pseudo op.
1217  */
1218 static void emit_ia32_Asm(const ir_node *node)
1219 {
1220         const void            *gen_attr = get_irn_generic_attr_const(node);
1221         const ia32_asm_attr_t *attr
1222                 = CONST_CAST_IA32_ATTR(ia32_asm_attr_t, gen_attr);
1223         ident                 *asm_text = attr->asm_text;
1224         const char            *s        = get_id_str(asm_text);
1225
1226         ia32_emitf(node, "#APP\t\n");
1227
1228         if (s[0] != '\t')
1229                 be_emit_char('\t');
1230
1231         while (*s != 0) {
1232                 if (*s == '%') {
1233                         s = emit_asm_operand(node, s);
1234                 } else {
1235                         be_emit_char(*s++);
1236                 }
1237         }
1238
1239         ia32_emitf(NULL, "\n#NO_APP\n");
1240 }
1241
1242
1243 /**
1244  * Emit movsb/w instructions to make mov count divideable by 4
1245  */
1246 static void emit_CopyB_prolog(unsigned size)
1247 {
1248         if (size & 1)
1249                 ia32_emitf(NULL, "\tmovsb\n");
1250         if (size & 2)
1251                 ia32_emitf(NULL, "\tmovsw\n");
1252 }
1253
1254 /**
1255  * Emit rep movsd instruction for memcopy.
1256  */
1257 static void emit_ia32_CopyB(const ir_node *node)
1258 {
1259         unsigned size = get_ia32_copyb_size(node);
1260
1261         emit_CopyB_prolog(size);
1262         ia32_emitf(node, "\trep movsd\n");
1263 }
1264
1265 /**
1266  * Emits unrolled memcopy.
1267  */
1268 static void emit_ia32_CopyB_i(const ir_node *node)
1269 {
1270         unsigned size = get_ia32_copyb_size(node);
1271
1272         emit_CopyB_prolog(size);
1273
1274         size >>= 2;
1275         while (size--) {
1276                 ia32_emitf(NULL, "\tmovsd\n");
1277         }
1278 }
1279
1280
1281 /**
1282  * Emit code for conversions (I, FP), (FP, I) and (FP, FP).
1283  */
1284 static void emit_ia32_Conv_with_FP(const ir_node *node, const char* conv_f,
1285                 const char* conv_d)
1286 {
1287         ir_mode            *ls_mode = get_ia32_ls_mode(node);
1288         int                 ls_bits = get_mode_size_bits(ls_mode);
1289         const char         *conv    = ls_bits == 32 ? conv_f : conv_d;
1290
1291         ia32_emitf(node, "\tcvt%s %AS3, %D0\n", conv);
1292 }
1293
1294 static void emit_ia32_Conv_I2FP(const ir_node *node)
1295 {
1296         emit_ia32_Conv_with_FP(node, "si2ss", "si2sd");
1297 }
1298
1299 static void emit_ia32_Conv_FP2I(const ir_node *node)
1300 {
1301         emit_ia32_Conv_with_FP(node, "ss2si", "sd2si");
1302 }
1303
1304 static void emit_ia32_Conv_FP2FP(const ir_node *node)
1305 {
1306         emit_ia32_Conv_with_FP(node, "sd2ss", "ss2sd");
1307 }
1308
1309 /**
1310  * Emits code for an Int conversion.
1311  */
1312 static void emit_ia32_Conv_I2I(const ir_node *node)
1313 {
1314         ir_mode    *smaller_mode = get_ia32_ls_mode(node);
1315         int         signed_mode  = mode_is_signed(smaller_mode);
1316         const char *sign_suffix;
1317
1318         assert(!mode_is_float(smaller_mode));
1319
1320         sign_suffix = signed_mode ? "s" : "z";
1321         ia32_emitf(node, "\tmov%s%Ml %#AS3, %D0\n", sign_suffix);
1322 }
1323
1324 /**
1325  * Emits a call
1326  */
1327 static void emit_ia32_Call(const ir_node *node)
1328 {
1329         /* Special case: Call must not have its immediates prefixed by $, instead
1330          * address mode is prefixed by *. */
1331         ia32_emitf(node, "\tcall %*AS3\n");
1332 }
1333
1334
1335 /**
1336  * Emits code to increase stack pointer.
1337  */
1338 static void emit_be_IncSP(const ir_node *node)
1339 {
1340         int offs = be_get_IncSP_offset(node);
1341
1342         if (offs == 0)
1343                 return;
1344
1345         if (offs > 0) {
1346                 ia32_emitf(node, "\tsubl $%u, %D0\n", offs);
1347         } else {
1348                 ia32_emitf(node, "\taddl $%u, %D0\n", -offs);
1349         }
1350 }
1351
1352 /**
1353  * Emits code for Copy/CopyKeep.
1354  */
1355 static void Copy_emitter(const ir_node *node, const ir_node *op)
1356 {
1357         const arch_register_t *in  = arch_get_irn_register(op);
1358         const arch_register_t *out = arch_get_irn_register(node);
1359
1360         if (in == out) {
1361                 return;
1362         }
1363         /* copies of vf nodes aren't real... */
1364         if (arch_register_get_class(in) == &ia32_reg_classes[CLASS_ia32_vfp])
1365                 return;
1366
1367         ia32_emitf(node, "\tmovl %R, %R\n", in, out);
1368 }
1369
1370 static void emit_be_Copy(const ir_node *node)
1371 {
1372         Copy_emitter(node, be_get_Copy_op(node));
1373 }
1374
1375 static void emit_be_CopyKeep(const ir_node *node)
1376 {
1377         Copy_emitter(node, be_get_CopyKeep_op(node));
1378 }
1379
1380 /**
1381  * Emits code for exchange.
1382  */
1383 static void emit_be_Perm(const ir_node *node)
1384 {
1385         const arch_register_t *in0, *in1;
1386         const arch_register_class_t *cls0, *cls1;
1387
1388         in0 = arch_get_irn_register(get_irn_n(node, 0));
1389         in1 = arch_get_irn_register(get_irn_n(node, 1));
1390
1391         cls0 = arch_register_get_class(in0);
1392         cls1 = arch_register_get_class(in1);
1393
1394         assert(cls0 == cls1 && "Register class mismatch at Perm");
1395
1396         if (cls0 == &ia32_reg_classes[CLASS_ia32_gp]) {
1397                 ia32_emitf(node, "\txchg %R, %R\n", in1, in0);
1398         } else if (cls0 == &ia32_reg_classes[CLASS_ia32_xmm]) {
1399                 ia32_emitf(NULL, "\txorpd %R, %R\n", in1, in0);
1400                 ia32_emitf(NULL, "\txorpd %R, %R\n", in0, in1);
1401                 ia32_emitf(node, "\txorpd %R, %R\n", in1, in0);
1402         } else if (cls0 == &ia32_reg_classes[CLASS_ia32_vfp]) {
1403                 /* is a NOP */
1404         } else if (cls0 == &ia32_reg_classes[CLASS_ia32_st]) {
1405                 /* is a NOP */
1406         } else {
1407                 panic("unexpected register class in be_Perm (%+F)", node);
1408         }
1409 }
1410
1411 /**
1412  * Emits code for Constant loading.
1413  */
1414 static void emit_ia32_Const(const ir_node *node)
1415 {
1416         ia32_emitf(node, "\tmovl %I, %D0\n");
1417 }
1418
1419 /* helper function for emit_ia32_Minus64Bit */
1420 static void emit_mov(const ir_node* node, const arch_register_t *src, const arch_register_t *dst)
1421 {
1422         ia32_emitf(node, "\tmovl %R, %R\n", src, dst);
1423 }
1424
1425 /* helper function for emit_ia32_Minus64Bit */
1426 static void emit_neg(const ir_node* node, const arch_register_t *reg)
1427 {
1428         ia32_emitf(node, "\tnegl %R\n", reg);
1429 }
1430
1431 /* helper function for emit_ia32_Minus64Bit */
1432 static void emit_sbb0(const ir_node* node, const arch_register_t *reg)
1433 {
1434         ia32_emitf(node, "\tsbbl $0, %R\n", reg);
1435 }
1436
1437 /* helper function for emit_ia32_Minus64Bit */
1438 static void emit_sbb(const ir_node* node, const arch_register_t *src, const arch_register_t *dst)
1439 {
1440         ia32_emitf(node, "\tsbbl %R, %R\n", src, dst);
1441 }
1442
1443 /* helper function for emit_ia32_Minus64Bit */
1444 static void emit_xchg(const ir_node* node, const arch_register_t *src, const arch_register_t *dst)
1445 {
1446         ia32_emitf(node, "\txchgl %R, %R\n", src, dst);
1447 }
1448
1449 /* helper function for emit_ia32_Minus64Bit */
1450 static void emit_zero(const ir_node* node, const arch_register_t *reg)
1451 {
1452         ia32_emitf(node, "\txorl %R, %R\n", reg, reg);
1453 }
1454
1455 static void emit_ia32_Minus64Bit(const ir_node *node)
1456 {
1457         const arch_register_t *in_lo  = arch_get_irn_register_in(node, 0);
1458         const arch_register_t *in_hi  = arch_get_irn_register_in(node, 1);
1459         const arch_register_t *out_lo = arch_get_irn_register_out(node, 0);
1460         const arch_register_t *out_hi = arch_get_irn_register_out(node, 1);
1461
1462         if (out_lo == in_lo) {
1463                 if (out_hi != in_hi) {
1464                         /* a -> a, b -> d */
1465                         goto zero_neg;
1466                 } else {
1467                         /* a -> a, b -> b */
1468                         goto normal_neg;
1469                 }
1470         } else if (out_lo == in_hi) {
1471                 if (out_hi == in_lo) {
1472                         /* a -> b, b -> a */
1473                         emit_xchg(node, in_lo, in_hi);
1474                         goto normal_neg;
1475                 } else {
1476                         /* a -> b, b -> d */
1477                         emit_mov(node, in_hi, out_hi);
1478                         emit_mov(node, in_lo, out_lo);
1479                         goto normal_neg;
1480                 }
1481         } else {
1482                 if (out_hi == in_lo) {
1483                         /* a -> c, b -> a */
1484                         emit_mov(node, in_lo, out_lo);
1485                         goto zero_neg;
1486                 } else if (out_hi == in_hi) {
1487                         /* a -> c, b -> b */
1488                         emit_mov(node, in_lo, out_lo);
1489                         goto normal_neg;
1490                 } else {
1491                         /* a -> c, b -> d */
1492                         emit_mov(node, in_lo, out_lo);
1493                         goto zero_neg;
1494                 }
1495         }
1496
1497 normal_neg:
1498         emit_neg( node, out_hi);
1499         emit_neg( node, out_lo);
1500         emit_sbb0(node, out_hi);
1501         return;
1502
1503 zero_neg:
1504         emit_zero(node, out_hi);
1505         emit_neg( node, out_lo);
1506         emit_sbb( node, in_hi, out_hi);
1507 }
1508
1509 static void emit_ia32_GetEIP(const ir_node *node)
1510 {
1511         ia32_emitf(node, "\tcall %s\n", pic_base_label);
1512         ia32_emitf(NULL, "%s:\n", pic_base_label);
1513         ia32_emitf(node, "\tpopl %D0\n");
1514 }
1515
1516 static void emit_ia32_ClimbFrame(const ir_node *node)
1517 {
1518         const ia32_climbframe_attr_t *attr = get_ia32_climbframe_attr_const(node);
1519
1520         ia32_emitf(node, "\tmovl %S0, %D0\n");
1521         ia32_emitf(node, "\tmovl $%u, %S1\n", attr->count);
1522         be_gas_emit_block_name(node);
1523         be_emit_cstring(":\n");
1524         be_emit_write_line();
1525         ia32_emitf(node, "\tmovl (%D0), %D0\n");
1526         ia32_emitf(node, "\tdec %S1\n");
1527         be_emit_cstring("\tjnz ");
1528         be_gas_emit_block_name(node);
1529         be_emit_finish_line_gas(node);
1530 }
1531
1532 static void emit_be_Return(const ir_node *node)
1533 {
1534         unsigned pop = be_Return_get_pop(node);
1535
1536         if (pop > 0 || be_Return_get_emit_pop(node)) {
1537                 ia32_emitf(node, "\tret $%u\n", pop);
1538         } else {
1539                 ia32_emitf(node, "\tret\n");
1540         }
1541 }
1542
1543 static void emit_Nothing(const ir_node *node)
1544 {
1545         (void) node;
1546 }
1547
1548
1549 /**
1550  * Enters the emitter functions for handled nodes into the generic
1551  * pointer of an opcode.
1552  */
1553 static void ia32_register_emitters(void)
1554 {
1555 #define IA32_EMIT2(a,b) op_ia32_##a->ops.generic = (op_func)emit_ia32_##b
1556 #define IA32_EMIT(a)    IA32_EMIT2(a,a)
1557 #define EMIT(a)         op_##a->ops.generic = (op_func)emit_##a
1558 #define IGN(a)          op_##a->ops.generic = (op_func)emit_Nothing
1559 #define BE_EMIT(a)      op_be_##a->ops.generic = (op_func)emit_be_##a
1560 #define BE_IGN(a)       op_be_##a->ops.generic = (op_func)emit_Nothing
1561
1562         /* first clear the generic function pointer for all ops */
1563         clear_irp_opcodes_generic_func();
1564
1565         /* register all emitter functions defined in spec */
1566         ia32_register_spec_emitters();
1567
1568         /* other ia32 emitter functions */
1569         IA32_EMIT2(Conv_I2I8Bit, Conv_I2I);
1570         IA32_EMIT(Asm);
1571         IA32_EMIT(CMovcc);
1572         IA32_EMIT(Call);
1573         IA32_EMIT(Const);
1574         IA32_EMIT(Conv_FP2FP);
1575         IA32_EMIT(Conv_FP2I);
1576         IA32_EMIT(Conv_I2FP);
1577         IA32_EMIT(Conv_I2I);
1578         IA32_EMIT(CopyB);
1579         IA32_EMIT(CopyB_i);
1580         IA32_EMIT(GetEIP);
1581         IA32_EMIT(IMul);
1582         IA32_EMIT(Jcc);
1583         IA32_EMIT(Setcc);
1584         IA32_EMIT(Minus64Bit);
1585         IA32_EMIT(SwitchJmp);
1586         IA32_EMIT(ClimbFrame);
1587         IA32_EMIT(Jmp);
1588
1589         /* benode emitter */
1590         BE_EMIT(Copy);
1591         BE_EMIT(CopyKeep);
1592         BE_EMIT(IncSP);
1593         BE_EMIT(Perm);
1594         BE_EMIT(Return);
1595
1596         BE_IGN(Keep);
1597         BE_IGN(Start);
1598
1599         /* firm emitter */
1600         IGN(Phi);
1601
1602 #undef BE_EMIT
1603 #undef EMIT
1604 #undef IGN
1605 #undef IA32_EMIT2
1606 #undef IA32_EMIT
1607 }
1608
1609 typedef void (*emit_func_ptr) (const ir_node *);
1610
1611 /**
1612  * Assign and emit an exception label if the current instruction can fail.
1613  */
1614 static void ia32_assign_exc_label(ir_node *node)
1615 {
1616         /* assign a new ID to the instruction */
1617         set_ia32_exc_label_id(node, ++exc_label_id);
1618         /* print it */
1619         ia32_emit_exc_label(node);
1620         be_emit_char(':');
1621         be_emit_pad_comment();
1622         be_emit_cstring("/* exception to Block ");
1623         ia32_emit_cfop_target(node);
1624         be_emit_cstring(" */\n");
1625         be_emit_write_line();
1626 }
1627
1628 /**
1629  * Emits code for a node.
1630  */
1631 static void ia32_emit_node(ir_node *node)
1632 {
1633         ir_op *op = get_irn_op(node);
1634
1635         DBG((dbg, LEVEL_1, "emitting code for %+F\n", node));
1636
1637         if (is_ia32_irn(node)) {
1638                 if (get_ia32_exc_label(node)) {
1639                         /* emit the exception label of this instruction */
1640                         ia32_assign_exc_label(node);
1641                 }
1642                 if (mark_spill_reload) {
1643                         if (is_ia32_is_spill(node)) {
1644                                 ia32_emitf(NULL, "\txchg %ebx, %ebx        /* spill mark */\n");
1645                         }
1646                         if (is_ia32_is_reload(node)) {
1647                                 ia32_emitf(NULL, "\txchg %edx, %edx        /* reload mark */\n");
1648                         }
1649                         if (is_ia32_is_remat(node)) {
1650                                 ia32_emitf(NULL, "\txchg %ecx, %ecx        /* remat mark */\n");
1651                         }
1652                 }
1653         }
1654         if (op->ops.generic) {
1655                 emit_func_ptr func = (emit_func_ptr) op->ops.generic;
1656
1657                 be_dbg_set_dbg_info(get_irn_dbg_info(node));
1658
1659                 (*func) (node);
1660         } else {
1661                 emit_Nothing(node);
1662                 ir_fprintf(stderr, "Error: No emit handler for node %+F (%+G, graph %+F)\n", node, node, current_ir_graph);
1663                 abort();
1664         }
1665 }
1666
1667 /**
1668  * Emits gas alignment directives
1669  */
1670 static void ia32_emit_alignment(unsigned align, unsigned skip)
1671 {
1672         ia32_emitf(NULL, "\t.p2align %u,,%u\n", align, skip);
1673 }
1674
1675 /**
1676  * Emits gas alignment directives for Labels depended on cpu architecture.
1677  */
1678 static void ia32_emit_align_label(void)
1679 {
1680         unsigned align        = ia32_cg_config.label_alignment;
1681         unsigned maximum_skip = ia32_cg_config.label_alignment_max_skip;
1682         ia32_emit_alignment(align, maximum_skip);
1683 }
1684
1685 /**
1686  * Test whether a block should be aligned.
1687  * For cpus in the P4/Athlon class it is useful to align jump labels to
1688  * 16 bytes. However we should only do that if the alignment nops before the
1689  * label aren't executed more often than we have jumps to the label.
1690  */
1691 static int should_align_block(const ir_node *block)
1692 {
1693         static const double DELTA = .0001;
1694         ir_graph     *irg         = get_irn_irg(block);
1695         ir_exec_freq *exec_freq   = be_get_irg_exec_freq(irg);
1696         ir_node      *prev        = get_prev_block_sched(block);
1697         double        block_freq;
1698         double        prev_freq = 0;  /**< execfreq of the fallthrough block */
1699         double        jmp_freq  = 0;  /**< execfreq of all non-fallthrough blocks */
1700         int           i, n_cfgpreds;
1701
1702         if (exec_freq == NULL)
1703                 return 0;
1704         if (ia32_cg_config.label_alignment_factor <= 0)
1705                 return 0;
1706
1707         block_freq = get_block_execfreq(exec_freq, block);
1708         if (block_freq < DELTA)
1709                 return 0;
1710
1711         n_cfgpreds = get_Block_n_cfgpreds(block);
1712         for (i = 0; i < n_cfgpreds; ++i) {
1713                 const ir_node *pred      = get_Block_cfgpred_block(block, i);
1714                 double         pred_freq = get_block_execfreq(exec_freq, pred);
1715
1716                 if (pred == prev) {
1717                         prev_freq += pred_freq;
1718                 } else {
1719                         jmp_freq  += pred_freq;
1720                 }
1721         }
1722
1723         if (prev_freq < DELTA && !(jmp_freq < DELTA))
1724                 return 1;
1725
1726         jmp_freq /= prev_freq;
1727
1728         return jmp_freq > ia32_cg_config.label_alignment_factor;
1729 }
1730
1731 /**
1732  * Emit the block header for a block.
1733  *
1734  * @param block       the block
1735  * @param prev_block  the previous block
1736  */
1737 static void ia32_emit_block_header(ir_node *block)
1738 {
1739         ir_graph     *irg        = current_ir_graph;
1740         int           need_label = block_needs_label(block);
1741         ir_exec_freq *exec_freq  = be_get_irg_exec_freq(irg);
1742         int           arity;
1743
1744         if (block == get_irg_end_block(irg))
1745                 return;
1746
1747         if (ia32_cg_config.label_alignment > 0) {
1748                 /* align the current block if:
1749                  * a) if should be aligned due to its execution frequency
1750                  * b) there is no fall-through here
1751                  */
1752                 if (should_align_block(block)) {
1753                         ia32_emit_align_label();
1754                 } else {
1755                         /* if the predecessor block has no fall-through,
1756                            we can always align the label. */
1757                         int i;
1758                         int has_fallthrough = 0;
1759
1760                         for (i = get_Block_n_cfgpreds(block) - 1; i >= 0; --i) {
1761                                 ir_node *cfg_pred = get_Block_cfgpred(block, i);
1762                                 if (can_be_fallthrough(cfg_pred)) {
1763                                         has_fallthrough = 1;
1764                                         break;
1765                                 }
1766                         }
1767
1768                         if (!has_fallthrough)
1769                                 ia32_emit_align_label();
1770                 }
1771         }
1772
1773         if (need_label) {
1774                 be_gas_emit_block_name(block);
1775                 be_emit_char(':');
1776
1777                 be_emit_pad_comment();
1778                 be_emit_cstring("   /* ");
1779         } else {
1780                 be_emit_cstring("\t/* ");
1781                 be_gas_emit_block_name(block);
1782                 be_emit_cstring(": ");
1783         }
1784
1785         be_emit_cstring("preds:");
1786
1787         /* emit list of pred blocks in comment */
1788         arity = get_irn_arity(block);
1789         if (arity <= 0) {
1790                 be_emit_cstring(" none");
1791         } else {
1792                 int i;
1793                 for (i = 0; i < arity; ++i) {
1794                         ir_node *predblock = get_Block_cfgpred_block(block, i);
1795                         be_emit_irprintf(" %d", get_irn_node_nr(predblock));
1796                 }
1797         }
1798         if (exec_freq != NULL) {
1799                 be_emit_irprintf(", freq: %f",
1800                                  get_block_execfreq(exec_freq, block));
1801         }
1802         be_emit_cstring(" */\n");
1803         be_emit_write_line();
1804 }
1805
1806 /**
1807  * Walks over the nodes in a block connected by scheduling edges
1808  * and emits code for each node.
1809  */
1810 static void ia32_gen_block(ir_node *block)
1811 {
1812         ir_node *node;
1813
1814         ia32_emit_block_header(block);
1815
1816         /* emit the contents of the block */
1817         be_dbg_set_dbg_info(get_irn_dbg_info(block));
1818         sched_foreach(block, node) {
1819                 ia32_emit_node(node);
1820         }
1821 }
1822
1823 typedef struct exc_entry {
1824         ir_node *exc_instr;  /** The instruction that can issue an exception. */
1825         ir_node *block;      /** The block to call then. */
1826 } exc_entry;
1827
1828 /**
1829  * Block-walker:
1830  * Sets labels for control flow nodes (jump target).
1831  * Links control predecessors to there destination blocks.
1832  */
1833 static void ia32_gen_labels(ir_node *block, void *data)
1834 {
1835         exc_entry **exc_list = (exc_entry**)data;
1836         ir_node *pred;
1837         int     n;
1838
1839         for (n = get_Block_n_cfgpreds(block) - 1; n >= 0; --n) {
1840                 pred = get_Block_cfgpred(block, n);
1841                 set_irn_link(pred, block);
1842
1843                 pred = skip_Proj(pred);
1844                 if (is_ia32_irn(pred) && get_ia32_exc_label(pred)) {
1845                         exc_entry e;
1846
1847                         e.exc_instr = pred;
1848                         e.block     = block;
1849                         ARR_APP1(exc_entry, *exc_list, e);
1850                         set_irn_link(pred, block);
1851                 }
1852         }
1853 }
1854
1855 /**
1856  * Compare two exception_entries.
1857  */
1858 static int cmp_exc_entry(const void *a, const void *b)
1859 {
1860         const exc_entry *ea = (const exc_entry*)a;
1861         const exc_entry *eb = (const exc_entry*)b;
1862
1863         if (get_ia32_exc_label_id(ea->exc_instr) < get_ia32_exc_label_id(eb->exc_instr))
1864                 return -1;
1865         return +1;
1866 }
1867
1868 /**
1869  * Main driver. Emits the code for one routine.
1870  */
1871 void ia32_gen_routine(ir_graph *irg)
1872 {
1873         ir_entity        *entity    = get_irg_entity(irg);
1874         exc_entry        *exc_list  = NEW_ARR_F(exc_entry, 0);
1875         const arch_env_t *arch_env  = be_get_irg_arch_env(irg);
1876         ia32_irg_data_t  *irg_data  = ia32_get_irg_data(irg);
1877         ir_node         **blk_sched = irg_data->blk_sched;
1878         int i, n;
1879
1880         isa      = (ia32_isa_t*) arch_env;
1881         do_pic   = be_get_irg_options(irg)->pic;
1882
1883         be_gas_elf_type_char = '@';
1884
1885         ia32_register_emitters();
1886
1887         get_unique_label(pic_base_label, sizeof(pic_base_label), "PIC_BASE");
1888
1889         be_gas_emit_function_prolog(entity, ia32_cg_config.function_alignment);
1890
1891         /* we use links to point to target blocks */
1892         ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK);
1893         irg_block_walk_graph(irg, ia32_gen_labels, NULL, &exc_list);
1894
1895         /* initialize next block links */
1896         n = ARR_LEN(blk_sched);
1897         for (i = 0; i < n; ++i) {
1898                 ir_node *block = blk_sched[i];
1899                 ir_node *prev  = i > 0 ? blk_sched[i-1] : NULL;
1900
1901                 set_irn_link(block, prev);
1902         }
1903
1904         for (i = 0; i < n; ++i) {
1905                 ir_node *block = blk_sched[i];
1906
1907                 ia32_gen_block(block);
1908         }
1909
1910         be_gas_emit_function_epilog(entity);
1911
1912         ir_free_resources(irg, IR_RESOURCE_IRN_LINK);
1913
1914         /* Sort the exception table using the exception label id's.
1915            Those are ascending with ascending addresses. */
1916         qsort(exc_list, ARR_LEN(exc_list), sizeof(exc_list[0]), cmp_exc_entry);
1917         {
1918                 size_t e;
1919
1920                 for (e = 0; e < ARR_LEN(exc_list); ++e) {
1921                         be_emit_cstring("\t.long ");
1922                         ia32_emit_exc_label(exc_list[e].exc_instr);
1923                         be_emit_char('\n');
1924                         be_emit_cstring("\t.long ");
1925                         be_gas_emit_block_name(exc_list[e].block);
1926                         be_emit_char('\n');
1927                 }
1928         }
1929         DEL_ARR_F(exc_list);
1930 }
1931
1932 static const lc_opt_table_entry_t ia32_emitter_options[] = {
1933         LC_OPT_ENT_BOOL("mark_spill_reload",   "mark spills and reloads with ud opcodes", &mark_spill_reload),
1934         LC_OPT_LAST
1935 };
1936
1937 /* ==== Experimental binary emitter ==== */
1938
1939 static unsigned char reg_gp_map[N_ia32_gp_REGS];
1940 //static unsigned char reg_mmx_map[N_ia32_mmx_REGS];
1941 //static unsigned char reg_sse_map[N_ia32_xmm_REGS];
1942
1943 static void build_reg_map(void)
1944 {
1945         reg_gp_map[REG_GP_EAX] = 0x0;
1946         reg_gp_map[REG_GP_ECX] = 0x1;
1947         reg_gp_map[REG_GP_EDX] = 0x2;
1948         reg_gp_map[REG_GP_EBX] = 0x3;
1949         reg_gp_map[REG_GP_ESP] = 0x4;
1950         reg_gp_map[REG_GP_EBP] = 0x5;
1951         reg_gp_map[REG_GP_ESI] = 0x6;
1952         reg_gp_map[REG_GP_EDI] = 0x7;
1953 }
1954
1955 /** Returns the encoding for a pnc field. */
1956 static unsigned char pnc2cc(ia32_condition_code_t cc)
1957 {
1958         return cc & 0xf;
1959 }
1960
1961 /** Sign extension bit values for binops */
1962 enum SignExt {
1963         UNSIGNED_IMM = 0,  /**< unsigned immediate */
1964         SIGNEXT_IMM  = 2,  /**< sign extended immediate */
1965 };
1966
1967 /** The mod encoding of the ModR/M */
1968 enum Mod {
1969         MOD_IND          = 0x00, /**< [reg1] */
1970         MOD_IND_BYTE_OFS = 0x40, /**< [reg1 + byte ofs] */
1971         MOD_IND_WORD_OFS = 0x80, /**< [reg1 + word ofs] */
1972         MOD_REG          = 0xC0  /**< reg1 */
1973 };
1974
1975 /** create R/M encoding for ModR/M */
1976 #define ENC_RM(x) (x)
1977 /** create REG encoding for ModR/M */
1978 #define ENC_REG(x) ((x) << 3)
1979
1980 /** create encoding for a SIB byte */
1981 #define ENC_SIB(scale, index, base) ((scale) << 6 | (index) << 3 | (base))
1982
1983 /* Node: The following routines are supposed to append bytes, words, dwords
1984    to the output stream.
1985    Currently the implementation is stupid in that it still creates output
1986    for an "assembler" in the form of .byte, .long
1987    We will change this when enough infrastructure is there to create complete
1988    machine code in memory/object files */
1989
1990 static void bemit8(const unsigned char byte)
1991 {
1992         be_emit_irprintf("\t.byte 0x%x\n", byte);
1993         be_emit_write_line();
1994 }
1995
1996 static void bemit16(const unsigned short u16)
1997 {
1998         be_emit_irprintf("\t.word 0x%x\n", u16);
1999         be_emit_write_line();
2000 }
2001
2002 static void bemit32(const unsigned u32)
2003 {
2004         be_emit_irprintf("\t.long 0x%x\n", u32);
2005         be_emit_write_line();
2006 }
2007
2008 /**
2009  * Emit address of an entity. If @p is_relative is true then a relative
2010  * offset from behind the address to the entity is created.
2011  */
2012 static void bemit_entity(ir_entity *entity, bool entity_sign, int offset,
2013                          bool is_relative)
2014 {
2015         if (entity == NULL) {
2016                 bemit32(offset);
2017                 return;
2018         }
2019
2020         /* the final version should remember the position in the bytestream
2021            and patch it with the correct address at linktime... */
2022         be_emit_cstring("\t.long ");
2023         if (entity_sign)
2024                 be_emit_char('-');
2025         be_gas_emit_entity(entity);
2026
2027         if (get_entity_owner(entity) == get_tls_type()) {
2028                 if (get_entity_visibility(entity) == ir_visibility_external) {
2029                         be_emit_cstring("@INDNTPOFF");
2030                 } else {
2031                         be_emit_cstring("@NTPOFF");
2032                 }
2033         }
2034
2035         if (is_relative) {
2036                 be_emit_cstring("-.");
2037                 offset -= 4;
2038         }
2039
2040         if (offset != 0) {
2041                 be_emit_irprintf("%+d", offset);
2042         }
2043         be_emit_char('\n');
2044         be_emit_write_line();
2045 }
2046
2047 static void bemit_jmp_destination(const ir_node *dest_block)
2048 {
2049         be_emit_cstring("\t.long ");
2050         be_gas_emit_block_name(dest_block);
2051         be_emit_cstring(" - . - 4\n");
2052         be_emit_write_line();
2053 }
2054
2055 /* end emit routines, all emitters following here should only use the functions
2056    above. */
2057
2058 typedef enum reg_modifier {
2059         REG_LOW  = 0,
2060         REG_HIGH = 1
2061 } reg_modifier_t;
2062
2063 /** Create a ModR/M byte for src1,src2 registers */
2064 static void bemit_modrr(const arch_register_t *src1,
2065                         const arch_register_t *src2)
2066 {
2067         unsigned char modrm = MOD_REG;
2068         modrm |= ENC_RM(reg_gp_map[src1->index]);
2069         modrm |= ENC_REG(reg_gp_map[src2->index]);
2070         bemit8(modrm);
2071 }
2072
2073 /** Create a ModR/M8 byte for src1,src2 registers */
2074 static void bemit_modrr8(reg_modifier_t high_part1, const arch_register_t *src1,
2075                                                  reg_modifier_t high_part2, const arch_register_t *src2)
2076 {
2077         unsigned char modrm = MOD_REG;
2078         modrm |= ENC_RM(reg_gp_map[src1->index] +  (high_part1 == REG_HIGH ? 4 : 0));
2079         modrm |= ENC_REG(reg_gp_map[src2->index] + (high_part2 == REG_HIGH ? 4 : 0));
2080         bemit8(modrm);
2081 }
2082
2083 /** Create a ModR/M byte for one register and extension */
2084 static void bemit_modru(const arch_register_t *reg, unsigned ext)
2085 {
2086         unsigned char modrm = MOD_REG;
2087         assert(ext <= 7);
2088         modrm |= ENC_RM(reg_gp_map[reg->index]);
2089         modrm |= ENC_REG(ext);
2090         bemit8(modrm);
2091 }
2092
2093 /** Create a ModR/M8 byte for one register */
2094 static void bemit_modrm8(reg_modifier_t high_part, const arch_register_t *reg)
2095 {
2096         unsigned char modrm = MOD_REG;
2097         assert(reg_gp_map[reg->index] < 4);
2098         modrm |= ENC_RM(reg_gp_map[reg->index] + (high_part == REG_HIGH ? 4 : 0));
2099         modrm |= MOD_REG;
2100         bemit8(modrm);
2101 }
2102
2103 /**
2104  * Calculate the size of an signed immediate in bytes.
2105  *
2106  * @param offset  an offset
2107  */
2108 static unsigned get_signed_imm_size(int offset)
2109 {
2110         if (-128 <= offset && offset < 128) {
2111                 return 1;
2112         } else if (-32768 <= offset && offset < 32768) {
2113                 return 2;
2114         } else {
2115                 return 4;
2116         }
2117 }
2118
2119 /**
2120  * Emit an address mode.
2121  *
2122  * @param reg   content of the reg field: either a register index or an opcode extension
2123  * @param node  the node
2124  */
2125 static void bemit_mod_am(unsigned reg, const ir_node *node)
2126 {
2127         ir_entity *ent       = get_ia32_am_sc(node);
2128         int        offs      = get_ia32_am_offs_int(node);
2129         ir_node   *base      = get_irn_n(node, n_ia32_base);
2130         int        has_base  = !is_ia32_NoReg_GP(base);
2131         ir_node   *idx       = get_irn_n(node, n_ia32_index);
2132         int        has_index = !is_ia32_NoReg_GP(idx);
2133         unsigned   modrm     = 0;
2134         unsigned   sib       = 0;
2135         unsigned   emitoffs  = 0;
2136         bool       emitsib   = false;
2137         unsigned   base_enc;
2138
2139         /* set the mod part depending on displacement */
2140         if (ent != NULL) {
2141                 modrm |= MOD_IND_WORD_OFS;
2142                 emitoffs = 32;
2143         } else if (offs == 0) {
2144                 modrm |= MOD_IND;
2145                 emitoffs = 0;
2146         } else if (-128 <= offs && offs < 128) {
2147                 modrm |= MOD_IND_BYTE_OFS;
2148                 emitoffs = 8;
2149         } else {
2150                 modrm |= MOD_IND_WORD_OFS;
2151                 emitoffs = 32;
2152         }
2153
2154         if (has_base) {
2155                 const arch_register_t *base_reg = arch_get_irn_register(base);
2156                 base_enc = reg_gp_map[base_reg->index];
2157         } else {
2158                 /* Use the EBP encoding + MOD_IND if NO base register. There is
2159                  * always a 32bit offset present in this case. */
2160                 modrm    = MOD_IND;
2161                 base_enc = 0x05;
2162                 emitoffs = 32;
2163         }
2164
2165         /* Determine if we need a SIB byte. */
2166         if (has_index) {
2167                 const arch_register_t *reg_index = arch_get_irn_register(idx);
2168                 int                    scale     = get_ia32_am_scale(node);
2169                 assert(scale < 4);
2170                 /* R/M set to ESP means SIB in 32bit mode. */
2171                 modrm   |= ENC_RM(0x04);
2172                 sib      = ENC_SIB(scale, reg_gp_map[reg_index->index], base_enc);
2173                 emitsib = true;
2174         } else if (base_enc == 0x04) {
2175                 /* for the above reason we are forced to emit a SIB when base is ESP.
2176                  * Only the base is used, index must be ESP too, which means no index.
2177                  */
2178                 modrm   |= ENC_RM(0x04);
2179                 sib      = ENC_SIB(0, 0x04, 0x04);
2180                 emitsib  = true;
2181         } else {
2182                 modrm |= ENC_RM(base_enc);
2183         }
2184
2185         /* We are forced to emit an 8bit offset as EBP base without offset is a
2186          * special case for SIB without base register. */
2187         if (base_enc == 0x05 && emitoffs == 0) {
2188                 modrm    |= MOD_IND_BYTE_OFS;
2189                 emitoffs  = 8;
2190         }
2191
2192         modrm |= ENC_REG(reg);
2193
2194         bemit8(modrm);
2195         if (emitsib)
2196                 bemit8(sib);
2197
2198         /* emit displacement */
2199         if (emitoffs == 8) {
2200                 bemit8((unsigned) offs);
2201         } else if (emitoffs == 32) {
2202                 bemit_entity(ent, is_ia32_am_sc_sign(node), offs, false);
2203         }
2204 }
2205
2206 /**
2207  * Emit a binop with a immediate operand.
2208  *
2209  * @param node        the node to emit
2210  * @param opcode_eax  the opcode for the op eax, imm variant
2211  * @param opcode      the opcode for the reg, imm variant
2212  * @param ruval       the opcode extension for opcode
2213  */
2214 static void bemit_binop_with_imm(
2215         const ir_node *node,
2216         unsigned char opcode_ax,
2217         unsigned char opcode, unsigned char ruval)
2218 {
2219         /* Use in-reg, because some instructions (cmp, test) have no out-reg. */
2220         const ir_node               *op   = get_irn_n(node, n_ia32_binary_right);
2221         const ia32_immediate_attr_t *attr = get_ia32_immediate_attr_const(op);
2222         unsigned                     size;
2223
2224         /* Some instructions (test) have no short form with 32bit value + 8bit
2225          * immediate. */
2226         if (attr->symconst != NULL || opcode & SIGNEXT_IMM) {
2227                 size = 4;
2228         } else {
2229                 /* check for sign extension */
2230                 size = get_signed_imm_size(attr->offset);
2231         }
2232
2233         switch (size) {
2234         case 1:
2235                 bemit8(opcode | SIGNEXT_IMM);
2236                 /* cmp has this special mode */
2237                 if (get_ia32_op_type(node) == ia32_AddrModeS) {
2238                         bemit_mod_am(ruval, node);
2239                 } else {
2240                         const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_binary_left);
2241                         bemit_modru(reg, ruval);
2242                 }
2243                 bemit8((unsigned char)attr->offset);
2244                 return;
2245         case 2:
2246         case 4:
2247                 /* check for eax variant: this variant is shorter for 32bit immediates only */
2248                 if (get_ia32_op_type(node) == ia32_AddrModeS) {
2249                         bemit8(opcode);
2250                         bemit_mod_am(ruval, node);
2251                 } else {
2252                         const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_binary_left);
2253                         if (reg->index == REG_GP_EAX) {
2254                                 bemit8(opcode_ax);
2255                         } else {
2256                                 bemit8(opcode);
2257                                 bemit_modru(reg, ruval);
2258                         }
2259                 }
2260                 bemit_entity(attr->symconst, attr->sc_sign, attr->offset, false);
2261                 return;
2262         }
2263         panic("invalid imm size?!?");
2264 }
2265
2266 /**
2267  * Emits a binop.
2268  */
2269 static void bemit_binop_2(const ir_node *node, unsigned code)
2270 {
2271         const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_binary_left);
2272         bemit8(code);
2273         if (get_ia32_op_type(node) == ia32_Normal) {
2274                 const arch_register_t *op2 = arch_get_irn_register_in(node, n_ia32_binary_right);
2275                 bemit_modrr(op2, out);
2276         } else {
2277                 bemit_mod_am(reg_gp_map[out->index], node);
2278         }
2279 }
2280
2281 /**
2282  * Emit a binop.
2283  */
2284 static void bemit_binop(const ir_node *node, const unsigned char opcodes[4])
2285 {
2286         ir_node *right = get_irn_n(node, n_ia32_binary_right);
2287         if (is_ia32_Immediate(right)) {
2288                 bemit_binop_with_imm(node, opcodes[1], opcodes[2], opcodes[3]);
2289         } else {
2290                 bemit_binop_2(node, opcodes[0]);
2291         }
2292 }
2293
2294 /**
2295  * Emit an unop.
2296  */
2297 static void bemit_unop(const ir_node *node, unsigned char code, unsigned char ext, int input)
2298 {
2299         bemit8(code);
2300         if (get_ia32_op_type(node) == ia32_Normal) {
2301                 const arch_register_t *in = arch_get_irn_register_in(node, input);
2302                 bemit_modru(in, ext);
2303         } else {
2304                 bemit_mod_am(ext, node);
2305         }
2306 }
2307
2308 static void bemit_unop_reg(const ir_node *node, unsigned char code, int input)
2309 {
2310         const arch_register_t *out = arch_get_irn_register_out(node, 0);
2311         bemit_unop(node, code, reg_gp_map[out->index], input);
2312 }
2313
2314 static void bemit_unop_mem(const ir_node *node, unsigned char code, unsigned char ext)
2315 {
2316         unsigned size = get_mode_size_bits(get_ia32_ls_mode(node));
2317         if (size == 16)
2318                 bemit8(0x66);
2319         bemit8(size == 8 ? code : code + 1);
2320         bemit_mod_am(ext, node);
2321 }
2322
2323 static void bemit_immediate(const ir_node *node, bool relative)
2324 {
2325         const ia32_immediate_attr_t *attr = get_ia32_immediate_attr_const(node);
2326         bemit_entity(attr->symconst, attr->sc_sign, attr->offset, relative);
2327 }
2328
2329 static void bemit_copy(const ir_node *copy)
2330 {
2331         const arch_register_t *in  = arch_get_irn_register_in(copy, 0);
2332         const arch_register_t *out = arch_get_irn_register_out(copy, 0);
2333
2334         if (in == out)
2335                 return;
2336         /* copies of vf nodes aren't real... */
2337         if (arch_register_get_class(in) == &ia32_reg_classes[CLASS_ia32_vfp])
2338                 return;
2339
2340         assert(arch_register_get_class(in) == &ia32_reg_classes[CLASS_ia32_gp]);
2341         bemit8(0x8B);
2342         bemit_modrr(in, out);
2343 }
2344
2345 static void bemit_perm(const ir_node *node)
2346 {
2347         const arch_register_t       *in0  = arch_get_irn_register(get_irn_n(node, 0));
2348         const arch_register_t       *in1  = arch_get_irn_register(get_irn_n(node, 1));
2349         const arch_register_class_t *cls0 = arch_register_get_class(in0);
2350
2351         assert(cls0 == arch_register_get_class(in1) && "Register class mismatch at Perm");
2352
2353         if (cls0 == &ia32_reg_classes[CLASS_ia32_gp]) {
2354                 if (in0->index == REG_GP_EAX) {
2355                         bemit8(0x90 + reg_gp_map[in1->index]);
2356                 } else if (in1->index == REG_GP_EAX) {
2357                         bemit8(0x90 + reg_gp_map[in0->index]);
2358                 } else {
2359                         bemit8(0x87);
2360                         bemit_modrr(in0, in1);
2361                 }
2362         } else if (cls0 == &ia32_reg_classes[CLASS_ia32_xmm]) {
2363                 panic("unimplemented"); // TODO implement
2364                 //ia32_emitf(NULL, "\txorpd %R, %R\n", in1, in0);
2365                 //ia32_emitf(NULL, "\txorpd %R, %R\n", in0, in1);
2366                 //ia32_emitf(node, "\txorpd %R, %R\n", in1, in0);
2367         } else if (cls0 == &ia32_reg_classes[CLASS_ia32_vfp]) {
2368                 /* is a NOP */
2369         } else if (cls0 == &ia32_reg_classes[CLASS_ia32_st]) {
2370                 /* is a NOP */
2371         } else {
2372                 panic("unexpected register class in be_Perm (%+F)", node);
2373         }
2374 }
2375
2376 static void bemit_xor0(const ir_node *node)
2377 {
2378         const arch_register_t *out = arch_get_irn_register_out(node, 0);
2379         bemit8(0x31);
2380         bemit_modrr(out, out);
2381 }
2382
2383 static void bemit_mov_const(const ir_node *node)
2384 {
2385         const arch_register_t *out = arch_get_irn_register_out(node, 0);
2386         bemit8(0xB8 + reg_gp_map[out->index]);
2387         bemit_immediate(node, false);
2388 }
2389
2390 /**
2391  * Creates a function for a Binop with 3 possible encodings.
2392  */
2393 #define BINOP(op, op0, op1, op2, op2_ext)                                 \
2394 static void bemit_ ## op(const ir_node *node) {                           \
2395         static const unsigned char op ## _codes[] = {op0, op1, op2, op2_ext}; \
2396         bemit_binop(node, op ## _codes);                                      \
2397 }
2398
2399 /*    insn  def  eax,imm   imm */
2400 BINOP(add,  0x03, 0x05, 0x81, 0)
2401 BINOP(or,   0x0B, 0x0D, 0x81, 1)
2402 BINOP(adc,  0x13, 0x15, 0x81, 2)
2403 BINOP(sbb,  0x1B, 0x1D, 0x81, 3)
2404 BINOP(and,  0x23, 0x25, 0x81, 4)
2405 BINOP(sub,  0x2B, 0x2D, 0x81, 5)
2406 BINOP(xor,  0x33, 0x35, 0x81, 6)
2407 BINOP(test, 0x85, 0xA9, 0xF7, 0)
2408
2409 #define BINOPMEM(op, ext) \
2410 static void bemit_##op(const ir_node *node) \
2411 { \
2412         ir_node *val; \
2413         unsigned size = get_mode_size_bits(get_ia32_ls_mode(node)); \
2414         if (size == 16) \
2415                 bemit8(0x66); \
2416         val = get_irn_n(node, n_ia32_unary_op); \
2417         if (is_ia32_Immediate(val)) { \
2418                 const ia32_immediate_attr_t *attr   = get_ia32_immediate_attr_const(val); \
2419                 int                          offset = attr->offset; \
2420                 if (attr->symconst == NULL && get_signed_imm_size(offset) == 1) { \
2421                         bemit8(0x83); \
2422                         bemit_mod_am(ext, node); \
2423                         bemit8(offset); \
2424                 } else { \
2425                         bemit8(0x81); \
2426                         bemit_mod_am(ext, node); \
2427                         if (size == 16) { \
2428                                 bemit16(offset); \
2429                         } else { \
2430                                 bemit_entity(attr->symconst, attr->sc_sign, offset, false); \
2431                         } \
2432                 } \
2433         } else { \
2434                 bemit8(ext << 3 | 1); \
2435                 bemit_mod_am(reg_gp_map[arch_get_irn_register_out(val, 0)->index], node); \
2436         } \
2437 } \
2438  \
2439 static void bemit_##op##8bit(const ir_node *node) \
2440 { \
2441         ir_node *val = get_irn_n(node, n_ia32_unary_op); \
2442         if (is_ia32_Immediate(val)) { \
2443                 bemit8(0x80); \
2444                 bemit_mod_am(ext, node); \
2445                 bemit8(get_ia32_immediate_attr_const(val)->offset); \
2446         } else { \
2447                 bemit8(ext << 3); \
2448                 bemit_mod_am(reg_gp_map[arch_get_irn_register_out(val, 0)->index], node); \
2449         } \
2450 }
2451
2452 BINOPMEM(addmem,  0)
2453 BINOPMEM(ormem,   1)
2454 BINOPMEM(andmem,  4)
2455 BINOPMEM(submem,  5)
2456 BINOPMEM(xormem,  6)
2457
2458
2459 /**
2460  * Creates a function for an Unop with code /ext encoding.
2461  */
2462 #define UNOP(op, code, ext, input)              \
2463 static void bemit_ ## op(const ir_node *node) { \
2464         bemit_unop(node, code, ext, input);         \
2465 }
2466
2467 UNOP(not,     0xF7, 2, n_ia32_Not_val)
2468 UNOP(neg,     0xF7, 3, n_ia32_Neg_val)
2469 UNOP(mul,     0xF7, 4, n_ia32_Mul_right)
2470 UNOP(imul1op, 0xF7, 5, n_ia32_IMul1OP_right)
2471 UNOP(div,     0xF7, 6, n_ia32_Div_divisor)
2472 UNOP(idiv,    0xF7, 7, n_ia32_IDiv_divisor)
2473
2474 /* TODO: am support for IJmp */
2475 UNOP(ijmp,    0xFF, 4, n_ia32_IJmp_target)
2476
2477 #define SHIFT(op, ext) \
2478 static void bemit_##op(const ir_node *node) \
2479 { \
2480         const arch_register_t *out   = arch_get_irn_register_out(node, 0); \
2481         ir_node               *count = get_irn_n(node, 1); \
2482         if (is_ia32_Immediate(count)) { \
2483                 int offset = get_ia32_immediate_attr_const(count)->offset; \
2484                 if (offset == 1) { \
2485                         bemit8(0xD1); \
2486                         bemit_modru(out, ext); \
2487                 } else { \
2488                         bemit8(0xC1); \
2489                         bemit_modru(out, ext); \
2490                         bemit8(offset); \
2491                 } \
2492         } else { \
2493                 bemit8(0xD3); \
2494                 bemit_modru(out, ext); \
2495         } \
2496 } \
2497  \
2498 static void bemit_##op##mem(const ir_node *node) \
2499 { \
2500         ir_node *count; \
2501         unsigned size = get_mode_size_bits(get_ia32_ls_mode(node)); \
2502         if (size == 16) \
2503                 bemit8(0x66); \
2504         count = get_irn_n(node, 1); \
2505         if (is_ia32_Immediate(count)) { \
2506                 int offset = get_ia32_immediate_attr_const(count)->offset; \
2507                 if (offset == 1) { \
2508                         bemit8(size == 8 ? 0xD0 : 0xD1); \
2509                         bemit_mod_am(ext, node); \
2510                 } else { \
2511                         bemit8(size == 8 ? 0xC0 : 0xC1); \
2512                         bemit_mod_am(ext, node); \
2513                         bemit8(offset); \
2514                 } \
2515         } else { \
2516                 bemit8(size == 8 ? 0xD2 : 0xD3); \
2517                 bemit_mod_am(ext, node); \
2518         } \
2519 }
2520
2521 SHIFT(rol, 0)
2522 SHIFT(ror, 1)
2523 SHIFT(shl, 4)
2524 SHIFT(shr, 5)
2525 SHIFT(sar, 7)
2526
2527 static void bemit_shld(const ir_node *node)
2528 {
2529         const arch_register_t *in  = arch_get_irn_register_in(node, n_ia32_ShlD_val_low);
2530         const arch_register_t *out = arch_get_irn_register_out(node, pn_ia32_ShlD_res);
2531         ir_node *count = get_irn_n(node, n_ia32_ShlD_count);
2532         bemit8(0x0F);
2533         if (is_ia32_Immediate(count)) {
2534                 bemit8(0xA4);
2535                 bemit_modrr(out, in);
2536                 bemit8(get_ia32_immediate_attr_const(count)->offset);
2537         } else {
2538                 bemit8(0xA5);
2539                 bemit_modrr(out, in);
2540         }
2541 }
2542
2543 static void bemit_shrd(const ir_node *node)
2544 {
2545         const arch_register_t *in  = arch_get_irn_register_in(node, n_ia32_ShrD_val_low);
2546         const arch_register_t *out = arch_get_irn_register_out(node, pn_ia32_ShrD_res);
2547         ir_node *count = get_irn_n(node, n_ia32_ShrD_count);
2548         bemit8(0x0F);
2549         if (is_ia32_Immediate(count)) {
2550                 bemit8(0xAC);
2551                 bemit_modrr(out, in);
2552                 bemit8(get_ia32_immediate_attr_const(count)->offset);
2553         } else {
2554                 bemit8(0xAD);
2555                 bemit_modrr(out, in);
2556         }
2557 }
2558
2559 /**
2560  * binary emitter for setcc.
2561  */
2562 static void bemit_setcc(const ir_node *node)
2563 {
2564         const arch_register_t *dreg = arch_get_irn_register_out(node, pn_ia32_Setcc_res);
2565
2566         ia32_condition_code_t cc = get_ia32_condcode(node);
2567         cc = determine_final_cc(node, n_ia32_Setcc_eflags, cc);
2568         if (cc & ia32_cc_float_parity_cases) {
2569                 if (cc & ia32_cc_negated) {
2570                         /* set%PNC <dreg */
2571                         bemit8(0x0F);
2572                         bemit8(0x90 | pnc2cc(cc));
2573                         bemit_modrm8(REG_LOW, dreg);
2574
2575                         /* setp >dreg */
2576                         bemit8(0x0F);
2577                         bemit8(0x9A);
2578                         bemit_modrm8(REG_HIGH, dreg);
2579
2580                         /* orb %>dreg, %<dreg */
2581                         bemit8(0x08);
2582                         bemit_modrr8(REG_LOW, dreg, REG_HIGH, dreg);
2583                 } else {
2584                          /* set%PNC <dreg */
2585                         bemit8(0x0F);
2586                         bemit8(0x90 | pnc2cc(cc));
2587                         bemit_modrm8(REG_LOW, dreg);
2588
2589                         /* setnp >dreg */
2590                         bemit8(0x0F);
2591                         bemit8(0x9B);
2592                         bemit_modrm8(REG_HIGH, dreg);
2593
2594                         /* andb %>dreg, %<dreg */
2595                         bemit8(0x20);
2596                         bemit_modrr8(REG_LOW, dreg, REG_HIGH, dreg);
2597                 }
2598         } else {
2599                 /* set%PNC <dreg */
2600                 bemit8(0x0F);
2601                 bemit8(0x90 | pnc2cc(cc));
2602                 bemit_modrm8(REG_LOW, dreg);
2603         }
2604 }
2605
2606 static void bemit_cmovcc(const ir_node *node)
2607 {
2608         const ia32_attr_t     *attr         = get_ia32_attr_const(node);
2609         int                    ins_permuted = attr->data.ins_permuted;
2610         const arch_register_t *out          = arch_get_irn_register_out(node, pn_ia32_res);
2611         ia32_condition_code_t  cc           = get_ia32_condcode(node);
2612         const arch_register_t *in_true;
2613         const arch_register_t *in_false;
2614
2615         cc = determine_final_cc(node, n_ia32_CMovcc_eflags, cc);
2616
2617         in_true  = arch_get_irn_register(get_irn_n(node, n_ia32_CMovcc_val_true));
2618         in_false = arch_get_irn_register(get_irn_n(node, n_ia32_CMovcc_val_false));
2619
2620         /* should be same constraint fullfilled? */
2621         if (out == in_false) {
2622                 /* yes -> nothing to do */
2623         } else if (out == in_true) {
2624                 assert(get_ia32_op_type(node) == ia32_Normal);
2625                 ins_permuted = !ins_permuted;
2626                 in_true      = in_false;
2627         } else {
2628                 /* we need a mov */
2629                 bemit8(0x8B); // mov %in_false, %out
2630                 bemit_modrr(in_false, out);
2631         }
2632
2633         if (ins_permuted)
2634                 cc = ia32_negate_condition_code(cc);
2635
2636         if (cc & ia32_cc_float_parity_cases)
2637                 panic("cmov can't handle parity float cases");
2638
2639         bemit8(0x0F);
2640         bemit8(0x40 | pnc2cc(cc));
2641         if (get_ia32_op_type(node) == ia32_Normal) {
2642                 bemit_modrr(in_true, out);
2643         } else {
2644                 bemit_mod_am(reg_gp_map[out->index], node);
2645         }
2646 }
2647
2648 static void bemit_cmp(const ir_node *node)
2649 {
2650         unsigned  ls_size = get_mode_size_bits(get_ia32_ls_mode(node));
2651         ir_node  *right;
2652
2653         if (ls_size == 16)
2654                 bemit8(0x66);
2655
2656         right = get_irn_n(node, n_ia32_binary_right);
2657         if (is_ia32_Immediate(right)) {
2658                 /* Use in-reg, because some instructions (cmp, test) have no out-reg. */
2659                 const ir_node               *op   = get_irn_n(node, n_ia32_binary_right);
2660                 const ia32_immediate_attr_t *attr = get_ia32_immediate_attr_const(op);
2661                 unsigned                     size;
2662
2663                 if (attr->symconst != NULL) {
2664                         size = 4;
2665                 } else {
2666                         /* check for sign extension */
2667                         size = get_signed_imm_size(attr->offset);
2668                 }
2669
2670                 switch (size) {
2671                         case 1:
2672                                 bemit8(0x81 | SIGNEXT_IMM);
2673                                 /* cmp has this special mode */
2674                                 if (get_ia32_op_type(node) == ia32_AddrModeS) {
2675                                         bemit_mod_am(7, node);
2676                                 } else {
2677                                         const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_binary_left);
2678                                         bemit_modru(reg, 7);
2679                                 }
2680                                 bemit8((unsigned char)attr->offset);
2681                                 return;
2682                         case 2:
2683                         case 4:
2684                                 /* check for eax variant: this variant is shorter for 32bit immediates only */
2685                                 if (get_ia32_op_type(node) == ia32_AddrModeS) {
2686                                         bemit8(0x81);
2687                                         bemit_mod_am(7, node);
2688                                 } else {
2689                                         const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_binary_left);
2690                                         if (reg->index == REG_GP_EAX) {
2691                                                 bemit8(0x3D);
2692                                         } else {
2693                                                 bemit8(0x81);
2694                                                 bemit_modru(reg, 7);
2695                                         }
2696                                 }
2697                                 if (ls_size == 16) {
2698                                         bemit16(attr->offset);
2699                                 } else {
2700                                         bemit_entity(attr->symconst, attr->sc_sign, attr->offset, false);
2701                                 }
2702                                 return;
2703                 }
2704                 panic("invalid imm size?!?");
2705         } else {
2706                 const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_binary_left);
2707                 bemit8(0x3B);
2708                 if (get_ia32_op_type(node) == ia32_Normal) {
2709                         const arch_register_t *op2 = arch_get_irn_register_in(node, n_ia32_binary_right);
2710                         bemit_modrr(op2, out);
2711                 } else {
2712                         bemit_mod_am(reg_gp_map[out->index], node);
2713                 }
2714         }
2715 }
2716
2717 static void bemit_cmp8bit(const ir_node *node)
2718 {
2719         ir_node *right = get_irn_n(node, n_ia32_binary_right);
2720         if (is_ia32_Immediate(right)) {
2721                 if (get_ia32_op_type(node) == ia32_Normal) {
2722                         const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_Cmp_left);
2723                         if (out->index == REG_GP_EAX) {
2724                                 bemit8(0x3C);
2725                         } else {
2726                                 bemit8(0x80);
2727                                 bemit_modru(out, 7);
2728                         }
2729                 } else {
2730                         bemit8(0x80);
2731                         bemit_mod_am(7, node);
2732                 }
2733                 bemit8(get_ia32_immediate_attr_const(right)->offset);
2734         } else {
2735                 const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_Cmp_left);
2736                 bemit8(0x3A);
2737                 if (get_ia32_op_type(node) == ia32_Normal) {
2738                         const arch_register_t *in = arch_get_irn_register_in(node, n_ia32_Cmp_right);
2739                         bemit_modrr(out, in);
2740                 } else {
2741                         bemit_mod_am(reg_gp_map[out->index], node);
2742                 }
2743         }
2744 }
2745
2746 static void bemit_test8bit(const ir_node *node)
2747 {
2748         ir_node *right = get_irn_n(node, n_ia32_Test8Bit_right);
2749         if (is_ia32_Immediate(right)) {
2750                 if (get_ia32_op_type(node) == ia32_Normal) {
2751                         const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_Test8Bit_left);
2752                         if (out->index == REG_GP_EAX) {
2753                                 bemit8(0xA8);
2754                         } else {
2755                                 bemit8(0xF6);
2756                                 bemit_modru(out, 0);
2757                         }
2758                 } else {
2759                         bemit8(0xF6);
2760                         bemit_mod_am(0, node);
2761                 }
2762                 bemit8(get_ia32_immediate_attr_const(right)->offset);
2763         } else {
2764                 const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_Test8Bit_left);
2765                 bemit8(0x84);
2766                 if (get_ia32_op_type(node) == ia32_Normal) {
2767                         const arch_register_t *in = arch_get_irn_register_in(node, n_ia32_Test8Bit_right);
2768                         bemit_modrr(out, in);
2769                 } else {
2770                         bemit_mod_am(reg_gp_map[out->index], node);
2771                 }
2772         }
2773 }
2774
2775 static void bemit_imul(const ir_node *node)
2776 {
2777         ir_node *right = get_irn_n(node, n_ia32_IMul_right);
2778         /* Do we need the immediate form? */
2779         if (is_ia32_Immediate(right)) {
2780                 int imm = get_ia32_immediate_attr_const(right)->offset;
2781                 if (get_signed_imm_size(imm) == 1) {
2782                         bemit_unop_reg(node, 0x6B, n_ia32_IMul_left);
2783                         bemit8(imm);
2784                 } else {
2785                         bemit_unop_reg(node, 0x69, n_ia32_IMul_left);
2786                         bemit32(imm);
2787                 }
2788         } else {
2789                 bemit8(0x0F);
2790                 bemit_unop_reg(node, 0xAF, n_ia32_IMul_right);
2791         }
2792 }
2793
2794 static void bemit_dec(const ir_node *node)
2795 {
2796         const arch_register_t *out = arch_get_irn_register_out(node, pn_ia32_Dec_res);
2797         bemit8(0x48 + reg_gp_map[out->index]);
2798 }
2799
2800 static void bemit_inc(const ir_node *node)
2801 {
2802         const arch_register_t *out = arch_get_irn_register_out(node, pn_ia32_Inc_res);
2803         bemit8(0x40 + reg_gp_map[out->index]);
2804 }
2805
2806 #define UNOPMEM(op, code, ext) \
2807 static void bemit_##op(const ir_node *node) \
2808 { \
2809         bemit_unop_mem(node, code, ext); \
2810 }
2811
2812 UNOPMEM(notmem, 0xF6, 2)
2813 UNOPMEM(negmem, 0xF6, 3)
2814 UNOPMEM(incmem, 0xFE, 0)
2815 UNOPMEM(decmem, 0xFE, 1)
2816
2817 static void bemit_ldtls(const ir_node *node)
2818 {
2819         const arch_register_t *out = arch_get_irn_register_out(node, 0);
2820
2821         bemit8(0x65); // gs:
2822         if (out->index == REG_GP_EAX) {
2823                 bemit8(0xA1); // movl 0, %eax
2824         } else {
2825                 bemit8(0x8B); // movl 0, %reg
2826                 bemit8(MOD_IND | ENC_REG(reg_gp_map[out->index]) | ENC_RM(0x05));
2827         }
2828         bemit32(0);
2829 }
2830
2831 /**
2832  * Emit a Lea.
2833  */
2834 static void bemit_lea(const ir_node *node)
2835 {
2836         const arch_register_t *out = arch_get_irn_register_out(node, 0);
2837         bemit8(0x8D);
2838         bemit_mod_am(reg_gp_map[out->index], node);
2839 }
2840
2841 /* helper function for bemit_minus64bit */
2842 static void bemit_helper_mov(const arch_register_t *src, const arch_register_t *dst)
2843 {
2844         bemit8(0x8B); // movl %src, %dst
2845         bemit_modrr(src, dst);
2846 }
2847
2848 /* helper function for bemit_minus64bit */
2849 static void bemit_helper_neg(const arch_register_t *reg)
2850 {
2851         bemit8(0xF7); // negl %reg
2852         bemit_modru(reg, 3);
2853 }
2854
2855 /* helper function for bemit_minus64bit */
2856 static void bemit_helper_sbb0(const arch_register_t *reg)
2857 {
2858         bemit8(0x83); // sbbl $0, %reg
2859         bemit_modru(reg, 3);
2860         bemit8(0);
2861 }
2862
2863 /* helper function for bemit_minus64bit */
2864 static void bemit_helper_sbb(const arch_register_t *src, const arch_register_t *dst)
2865 {
2866         bemit8(0x1B); // sbbl %src, %dst
2867         bemit_modrr(src, dst);
2868 }
2869
2870 /* helper function for bemit_minus64bit */
2871 static void bemit_helper_xchg(const arch_register_t *src, const arch_register_t *dst)
2872 {
2873         if (src->index == REG_GP_EAX) {
2874                 bemit8(0x90 + reg_gp_map[dst->index]); // xchgl %eax, %dst
2875         } else if (dst->index == REG_GP_EAX) {
2876                 bemit8(0x90 + reg_gp_map[src->index]); // xchgl %src, %eax
2877         } else {
2878                 bemit8(0x87); // xchgl %src, %dst
2879                 bemit_modrr(src, dst);
2880         }
2881 }
2882
2883 /* helper function for bemit_minus64bit */
2884 static void bemit_helper_zero(const arch_register_t *reg)
2885 {
2886         bemit8(0x33); // xorl %reg, %reg
2887         bemit_modrr(reg, reg);
2888 }
2889
2890 static void bemit_minus64bit(const ir_node *node)
2891 {
2892         const arch_register_t *in_lo  = arch_get_irn_register_in(node, 0);
2893         const arch_register_t *in_hi  = arch_get_irn_register_in(node, 1);
2894         const arch_register_t *out_lo = arch_get_irn_register_out(node, 0);
2895         const arch_register_t *out_hi = arch_get_irn_register_out(node, 1);
2896
2897         if (out_lo == in_lo) {
2898                 if (out_hi != in_hi) {
2899                         /* a -> a, b -> d */
2900                         goto zero_neg;
2901                 } else {
2902                         /* a -> a, b -> b */
2903                         goto normal_neg;
2904                 }
2905         } else if (out_lo == in_hi) {
2906                 if (out_hi == in_lo) {
2907                         /* a -> b, b -> a */
2908                         bemit_helper_xchg(in_lo, in_hi);
2909                         goto normal_neg;
2910                 } else {
2911                         /* a -> b, b -> d */
2912                         bemit_helper_mov(in_hi, out_hi);
2913                         bemit_helper_mov(in_lo, out_lo);
2914                         goto normal_neg;
2915                 }
2916         } else {
2917                 if (out_hi == in_lo) {
2918                         /* a -> c, b -> a */
2919                         bemit_helper_mov(in_lo, out_lo);
2920                         goto zero_neg;
2921                 } else if (out_hi == in_hi) {
2922                         /* a -> c, b -> b */
2923                         bemit_helper_mov(in_lo, out_lo);
2924                         goto normal_neg;
2925                 } else {
2926                         /* a -> c, b -> d */
2927                         bemit_helper_mov(in_lo, out_lo);
2928                         goto zero_neg;
2929                 }
2930         }
2931
2932 normal_neg:
2933         bemit_helper_neg( out_hi);
2934         bemit_helper_neg( out_lo);
2935         bemit_helper_sbb0(out_hi);
2936         return;
2937
2938 zero_neg:
2939         bemit_helper_zero(out_hi);
2940         bemit_helper_neg( out_lo);
2941         bemit_helper_sbb( in_hi, out_hi);
2942 }
2943
2944 /**
2945  * Emit a single opcode.
2946  */
2947 #define EMIT_SINGLEOP(op, code)                 \
2948 static void bemit_ ## op(const ir_node *node) { \
2949         (void) node;                                \
2950         bemit8(code);                               \
2951 }
2952
2953 //EMIT_SINGLEOP(daa,  0x27)
2954 //EMIT_SINGLEOP(das,  0x2F)
2955 //EMIT_SINGLEOP(aaa,  0x37)
2956 //EMIT_SINGLEOP(aas,  0x3F)
2957 //EMIT_SINGLEOP(nop,  0x90)
2958 EMIT_SINGLEOP(cwtl,  0x98)
2959 EMIT_SINGLEOP(cltd,  0x99)
2960 //EMIT_SINGLEOP(fwait, 0x9B)
2961 EMIT_SINGLEOP(sahf,  0x9E)
2962 //EMIT_SINGLEOP(popf, 0x9D)
2963 EMIT_SINGLEOP(leave, 0xC9)
2964 EMIT_SINGLEOP(int3,  0xCC)
2965 //EMIT_SINGLEOP(iret, 0xCF)
2966 //EMIT_SINGLEOP(xlat, 0xD7)
2967 //EMIT_SINGLEOP(lock, 0xF0)
2968 EMIT_SINGLEOP(rep,   0xF3)
2969 //EMIT_SINGLEOP(halt, 0xF4)
2970 EMIT_SINGLEOP(cmc,   0xF5)
2971 EMIT_SINGLEOP(stc,   0xF9)
2972 //EMIT_SINGLEOP(cli,  0xFA)
2973 //EMIT_SINGLEOP(sti,  0xFB)
2974 //EMIT_SINGLEOP(std,  0xFD)
2975
2976 /**
2977  * Emits a MOV out, [MEM].
2978  */
2979 static void bemit_load(const ir_node *node)
2980 {
2981         const arch_register_t *out = arch_get_irn_register_out(node, 0);
2982
2983         if (out->index == REG_GP_EAX) {
2984                 ir_node   *base      = get_irn_n(node, n_ia32_base);
2985                 int        has_base  = !is_ia32_NoReg_GP(base);
2986                 ir_node   *idx       = get_irn_n(node, n_ia32_index);
2987                 int        has_index = !is_ia32_NoReg_GP(idx);
2988                 if (!has_base && !has_index) {
2989                         ir_entity *ent  = get_ia32_am_sc(node);
2990                         int        offs = get_ia32_am_offs_int(node);
2991                         /* load from constant address to EAX can be encoded
2992                            as 0xA1 [offset] */
2993                         bemit8(0xA1);
2994                         bemit_entity(ent, 0, offs, false);
2995                         return;
2996                 }
2997         }
2998         bemit8(0x8B);
2999         bemit_mod_am(reg_gp_map[out->index], node);
3000 }
3001
3002 /**
3003  * Emits a MOV [mem], in.
3004  */
3005 static void bemit_store(const ir_node *node)
3006 {
3007         const ir_node *value = get_irn_n(node, n_ia32_Store_val);
3008         unsigned       size  = get_mode_size_bits(get_ia32_ls_mode(node));
3009
3010         if (is_ia32_Immediate(value)) {
3011                 if (size == 8) {
3012                         bemit8(0xC6);
3013                         bemit_mod_am(0, node);
3014                         bemit8(get_ia32_immediate_attr_const(value)->offset);
3015                 } else if (size == 16) {
3016                         bemit8(0x66);
3017                         bemit8(0xC7);
3018                         bemit_mod_am(0, node);
3019                         bemit16(get_ia32_immediate_attr_const(value)->offset);
3020                 } else {
3021                         bemit8(0xC7);
3022                         bemit_mod_am(0, node);
3023                         bemit_immediate(value, false);
3024                 }
3025         } else {
3026                 const arch_register_t *in = arch_get_irn_register_in(node, n_ia32_Store_val);
3027
3028                 if (in->index == REG_GP_EAX) {
3029                         ir_node   *base      = get_irn_n(node, n_ia32_base);
3030                         int        has_base  = !is_ia32_NoReg_GP(base);
3031                         ir_node   *idx       = get_irn_n(node, n_ia32_index);
3032                         int        has_index = !is_ia32_NoReg_GP(idx);
3033                         if (!has_base && !has_index) {
3034                                 ir_entity *ent  = get_ia32_am_sc(node);
3035                                 int        offs = get_ia32_am_offs_int(node);
3036                                 /* store to constant address from EAX can be encoded as
3037                                  * 0xA2/0xA3 [offset]*/
3038                                 if (size == 8) {
3039                                         bemit8(0xA2);
3040                                 } else {
3041                                         if (size == 16)
3042                                                 bemit8(0x66);
3043                                         bemit8(0xA3);
3044                                 }
3045                                 bemit_entity(ent, 0, offs, false);
3046                                 return;
3047                         }
3048                 }
3049
3050                 if (size == 8) {
3051                         bemit8(0x88);
3052                 } else {
3053                         if (size == 16)
3054                                 bemit8(0x66);
3055                         bemit8(0x89);
3056                 }
3057                 bemit_mod_am(reg_gp_map[in->index], node);
3058         }
3059 }
3060
3061 static void bemit_conv_i2i(const ir_node *node)
3062 {
3063         ir_mode  *smaller_mode = get_ia32_ls_mode(node);
3064         unsigned  opcode;
3065
3066         bemit8(0x0F);
3067         /*        8 16 bit source
3068          * movzx B6 B7
3069          * movsx BE BF
3070          */
3071         opcode = 0xB6;
3072         if (mode_is_signed(smaller_mode))           opcode |= 0x08;
3073         if (get_mode_size_bits(smaller_mode) == 16) opcode |= 0x01;
3074         bemit_unop_reg(node, opcode, n_ia32_Conv_I2I_val);
3075 }
3076
3077 /**
3078  * Emit a Push.
3079  */
3080 static void bemit_push(const ir_node *node)
3081 {
3082         const ir_node *value = get_irn_n(node, n_ia32_Push_val);
3083
3084         if (is_ia32_Immediate(value)) {
3085                 const ia32_immediate_attr_t *attr
3086                         = get_ia32_immediate_attr_const(value);
3087                 unsigned size = get_signed_imm_size(attr->offset);
3088                 if (attr->symconst)
3089                         size = 4;
3090                 switch (size) {
3091                 case 1:
3092                         bemit8(0x6A);
3093                         bemit8((unsigned char)attr->offset);
3094                         break;
3095                 case 2:
3096                 case 4:
3097                         bemit8(0x68);
3098                         bemit_immediate(value, false);
3099                         break;
3100                 }
3101         } else if (is_ia32_NoReg_GP(value)) {
3102                 bemit8(0xFF);
3103                 bemit_mod_am(6, node);
3104         } else {
3105                 const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_Push_val);
3106                 bemit8(0x50 + reg_gp_map[reg->index]);
3107         }
3108 }
3109
3110 /**
3111  * Emit a Pop.
3112  */
3113 static void bemit_pop(const ir_node *node)
3114 {
3115         const arch_register_t *reg = arch_get_irn_register_out(node, pn_ia32_Pop_res);
3116         bemit8(0x58 + reg_gp_map[reg->index]);
3117 }
3118
3119 static void bemit_popmem(const ir_node *node)
3120 {
3121         bemit8(0x8F);
3122         bemit_mod_am(0, node);
3123 }
3124
3125 static void bemit_call(const ir_node *node)
3126 {
3127         ir_node *proc = get_irn_n(node, n_ia32_Call_addr);
3128
3129         if (is_ia32_Immediate(proc)) {
3130                 bemit8(0xE8);
3131                 bemit_immediate(proc, true);
3132         } else {
3133                 bemit_unop(node, 0xFF, 2, n_ia32_Call_addr);
3134         }
3135 }
3136
3137 static void bemit_jmp(const ir_node *dest_block)
3138 {
3139         bemit8(0xE9);
3140         bemit_jmp_destination(dest_block);
3141 }
3142
3143 static void bemit_jump(const ir_node *node)
3144 {
3145         if (can_be_fallthrough(node))
3146                 return;
3147
3148         bemit_jmp(get_cfop_target_block(node));
3149 }
3150
3151 static void bemit_jcc(int pnc, const ir_node *dest_block)
3152 {
3153         unsigned char cc = pnc2cc(pnc);
3154         bemit8(0x0F);
3155         bemit8(0x80 + cc);
3156         bemit_jmp_destination(dest_block);
3157 }
3158
3159 static void bemit_jp(bool odd, const ir_node *dest_block)
3160 {
3161         bemit8(0x0F);
3162         bemit8(0x8A + odd);
3163         bemit_jmp_destination(dest_block);
3164 }
3165
3166 static void bemit_ia32_jcc(const ir_node *node)
3167 {
3168         ia32_condition_code_t cc = get_ia32_condcode(node);
3169         const ir_node        *proj_true;
3170         const ir_node        *proj_false;
3171         const ir_node        *dest_true;
3172         const ir_node        *dest_false;
3173
3174         cc = determine_final_cc(node, 0, cc);
3175
3176         /* get both Projs */
3177         proj_true = get_proj(node, pn_ia32_Jcc_true);
3178         assert(proj_true && "Jcc without true Proj");
3179
3180         proj_false = get_proj(node, pn_ia32_Jcc_false);
3181         assert(proj_false && "Jcc without false Proj");
3182
3183         if (can_be_fallthrough(proj_true)) {
3184                 /* exchange both proj's so the second one can be omitted */
3185                 const ir_node *t = proj_true;
3186
3187                 proj_true  = proj_false;
3188                 proj_false = t;
3189                 cc         = ia32_negate_condition_code(cc);
3190         }
3191
3192         dest_true  = get_cfop_target_block(proj_true);
3193         dest_false = get_cfop_target_block(proj_false);
3194
3195         if (cc & ia32_cc_float_parity_cases) {
3196                 /* Some floating point comparisons require a test of the parity flag,
3197                  * which indicates that the result is unordered */
3198                 if (cc & ia32_cc_negated) {
3199                         bemit_jp(false, dest_true);
3200                 } else {
3201                         /* we need a local label if the false proj is a fallthrough
3202                          * as the falseblock might have no label emitted then */
3203                         if (can_be_fallthrough(proj_false)) {
3204                                 bemit8(0x7A);
3205                                 bemit8(0x06);  // jp + 6
3206                         } else {
3207                                 bemit_jp(false, dest_false);
3208                         }
3209                 }
3210         }
3211         bemit_jcc(cc, dest_true);
3212
3213         /* the second Proj might be a fallthrough */
3214         if (can_be_fallthrough(proj_false)) {
3215                 /* it's a fallthrough */
3216         } else {
3217                 bemit_jmp(dest_false);
3218         }
3219 }
3220
3221 static void bemit_switchjmp(const ir_node *node)
3222 {
3223         ir_entity             *jump_table = get_ia32_am_sc(node);
3224         const ir_switch_table *table      = get_ia32_switch_table(node);
3225
3226         bemit8(0xFF); // jmp *tbl.label(,%in,4)
3227         bemit_mod_am(0x05, node);
3228
3229         be_emit_jump_table(node, table, jump_table, get_cfop_target_block);
3230 }
3231
3232 /**
3233  * Emits a return.
3234  */
3235 static void bemit_return(const ir_node *node)
3236 {
3237         unsigned pop = be_Return_get_pop(node);
3238         if (pop > 0 || be_Return_get_emit_pop(node)) {
3239                 bemit8(0xC2);
3240                 assert(pop <= 0xffff);
3241                 bemit16(pop);
3242         } else {
3243                 bemit8(0xC3);
3244         }
3245 }
3246
3247 static void bemit_subsp(const ir_node *node)
3248 {
3249         const arch_register_t *out;
3250         /* sub %in, %esp */
3251         bemit_sub(node);
3252         /* mov %esp, %out */
3253         bemit8(0x8B);
3254         out = arch_get_irn_register_out(node, 1);
3255         bemit8(MOD_REG | ENC_REG(reg_gp_map[out->index]) | ENC_RM(0x04));
3256 }
3257
3258 static void bemit_incsp(const ir_node *node)
3259 {
3260         int                    offs;
3261         const arch_register_t *reg;
3262         unsigned               size;
3263         unsigned               ext;
3264
3265         offs = be_get_IncSP_offset(node);
3266         if (offs == 0)
3267                 return;
3268
3269         if (offs > 0) {
3270                 ext = 5; /* sub */
3271         } else {
3272                 ext = 0; /* add */
3273                 offs = -offs;
3274         }
3275
3276         size = get_signed_imm_size(offs);
3277         bemit8(size == 1 ? 0x83 : 0x81);
3278
3279         reg  = arch_get_irn_register_out(node, 0);
3280         bemit_modru(reg, ext);
3281
3282         if (size == 1) {
3283                 bemit8(offs);
3284         } else {
3285                 bemit32(offs);
3286         }
3287 }
3288
3289 static void bemit_copybi(const ir_node *node)
3290 {
3291         unsigned size = get_ia32_copyb_size(node);
3292         if (size & 1)
3293                 bemit8(0xA4); // movsb
3294         if (size & 2) {
3295                 bemit8(0x66);
3296                 bemit8(0xA5); // movsw
3297         }
3298         size >>= 2;
3299         while (size--) {
3300                 bemit8(0xA5); // movsl
3301         }
3302 }
3303
3304 static void bemit_fbinop(const ir_node *node, unsigned code, unsigned code_to)
3305 {
3306         if (get_ia32_op_type(node) == ia32_Normal) {
3307                 const ia32_x87_attr_t *x87_attr = get_ia32_x87_attr_const(node);
3308                 const arch_register_t *in1      = x87_attr->x87[0];
3309                 const arch_register_t *in       = x87_attr->x87[1];
3310                 const arch_register_t *out      = x87_attr->x87[2];
3311
3312                 if (out == NULL) {
3313                         out = in1;
3314                 } else if (out == in) {
3315                         in = in1;
3316                 }
3317
3318                 if (out->index == 0) {
3319                         bemit8(0xD8);
3320                         bemit8(MOD_REG | ENC_REG(code) | ENC_RM(in->index));
3321                 } else {
3322                         bemit8(0xDC);
3323                         bemit8(MOD_REG | ENC_REG(code_to) | ENC_RM(out->index));
3324                 }
3325         } else {
3326                 if (get_mode_size_bits(get_ia32_ls_mode(node)) == 32) {
3327                         bemit8(0xD8);
3328                 } else {
3329                         bemit8(0xDC);
3330                 }
3331                 bemit_mod_am(code, node);
3332         }
3333 }
3334
3335 static void bemit_fbinopp(const ir_node *node, unsigned const code)
3336 {
3337         const ia32_x87_attr_t *x87_attr = get_ia32_x87_attr_const(node);
3338         const arch_register_t *out      = x87_attr->x87[2];
3339         bemit8(0xDE);
3340         bemit8(code + out->index);
3341 }
3342
3343 static void bemit_fabs(const ir_node *node)
3344 {
3345         (void)node;
3346
3347         bemit8(0xD9);
3348         bemit8(0xE1);
3349 }
3350
3351 static void bemit_fadd(const ir_node *node)
3352 {
3353         bemit_fbinop(node, 0, 0);
3354 }
3355
3356 static void bemit_faddp(const ir_node *node)
3357 {
3358         bemit_fbinopp(node, 0xC0);
3359 }
3360
3361 static void bemit_fchs(const ir_node *node)
3362 {
3363         (void)node;
3364
3365         bemit8(0xD9);
3366         bemit8(0xE0);
3367 }
3368
3369 static void bemit_fdiv(const ir_node *node)
3370 {
3371         bemit_fbinop(node, 6, 7);
3372 }
3373
3374 static void bemit_fdivp(const ir_node *node)
3375 {
3376         bemit_fbinopp(node, 0xF8);
3377 }
3378
3379 static void bemit_fdivr(const ir_node *node)
3380 {
3381         bemit_fbinop(node, 7, 6);
3382 }
3383
3384 static void bemit_fdivrp(const ir_node *node)
3385 {
3386         bemit_fbinopp(node, 0xF0);
3387 }
3388
3389 static void bemit_fild(const ir_node *node)
3390 {
3391         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3392                 case 16:
3393                         bemit8(0xDF); // filds
3394                         bemit_mod_am(0, node);
3395                         return;
3396
3397                 case 32:
3398                         bemit8(0xDB); // fildl
3399                         bemit_mod_am(0, node);
3400                         return;
3401
3402                 case 64:
3403                         bemit8(0xDF); // fildll
3404                         bemit_mod_am(5, node);
3405                         return;
3406
3407                 default:
3408                         panic("invalid mode size");
3409         }
3410 }
3411
3412 static void bemit_fist(const ir_node *node)
3413 {
3414         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3415                 case 16:
3416                         bemit8(0xDF); // fists
3417                         break;
3418
3419                 case 32:
3420                         bemit8(0xDB); // fistl
3421                         break;
3422
3423                 default:
3424                         panic("invalid mode size");
3425         }
3426         bemit_mod_am(2, node);
3427 }
3428
3429 static void bemit_fistp(const ir_node *node)
3430 {
3431         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3432                 case 16:
3433                         bemit8(0xDF); // fistps
3434                         bemit_mod_am(3, node);
3435                         return;
3436
3437                 case 32:
3438                         bemit8(0xDB); // fistpl
3439                         bemit_mod_am(3, node);
3440                         return;
3441
3442                 case 64:
3443                         bemit8(0xDF); // fistpll
3444                         bemit_mod_am(7, node);
3445                         return;
3446
3447                 default:
3448                         panic("invalid mode size");
3449         }
3450 }
3451
3452 static void bemit_fld(const ir_node *node)
3453 {
3454         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3455                 case 32:
3456                         bemit8(0xD9); // flds
3457                         bemit_mod_am(0, node);
3458                         return;
3459
3460                 case 64:
3461                         bemit8(0xDD); // fldl
3462                         bemit_mod_am(0, node);
3463                         return;
3464
3465                 case 80:
3466                 case 96:
3467                         bemit8(0xDB); // fldt
3468                         bemit_mod_am(5, node);
3469                         return;
3470
3471                 default:
3472                         panic("invalid mode size");
3473         }
3474 }
3475
3476 static void bemit_fld1(const ir_node *node)
3477 {
3478         (void)node;
3479         bemit8(0xD9);
3480         bemit8(0xE8); // fld1
3481 }
3482
3483 static void bemit_fldcw(const ir_node *node)
3484 {
3485         bemit8(0xD9); // fldcw
3486         bemit_mod_am(5, node);
3487 }
3488
3489 static void bemit_fldz(const ir_node *node)
3490 {
3491         (void)node;
3492         bemit8(0xD9);
3493         bemit8(0xEE); // fldz
3494 }
3495
3496 static void bemit_fmul(const ir_node *node)
3497 {
3498         bemit_fbinop(node, 1, 1);
3499 }
3500
3501 static void bemit_fmulp(const ir_node *node)
3502 {
3503         bemit_fbinopp(node, 0xC8);
3504 }
3505
3506 static void bemit_fpop(const ir_node *node)
3507 {
3508         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3509         bemit8(0xDD);
3510         bemit8(0xD8 + attr->x87[0]->index);
3511 }
3512
3513 static void bemit_fpush(const ir_node *node)
3514 {
3515         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3516         bemit8(0xD9);
3517         bemit8(0xC0 + attr->x87[0]->index);
3518 }
3519
3520 static void bemit_fpushcopy(const ir_node *node)
3521 {
3522         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3523         bemit8(0xD9);
3524         bemit8(0xC0 + attr->x87[0]->index);
3525 }
3526
3527 static void bemit_fst(const ir_node *node)
3528 {
3529         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3530                 case 32:
3531                         bemit8(0xD9); // fsts
3532                         break;
3533
3534                 case 64:
3535                         bemit8(0xDD); // fstl
3536                         break;
3537
3538                 default:
3539                         panic("invalid mode size");
3540         }
3541         bemit_mod_am(2, node);
3542 }
3543
3544 static void bemit_fstp(const ir_node *node)
3545 {
3546         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3547                 case 32:
3548                         bemit8(0xD9); // fstps
3549                         bemit_mod_am(3, node);
3550                         return;
3551
3552                 case 64:
3553                         bemit8(0xDD); // fstpl
3554                         bemit_mod_am(3, node);
3555                         return;
3556
3557                 case 80:
3558                 case 96:
3559                         bemit8(0xDB); // fstpt
3560                         bemit_mod_am(7, node);
3561                         return;
3562
3563                 default:
3564                         panic("invalid mode size");
3565         }
3566 }
3567
3568 static void bemit_fsub(const ir_node *node)
3569 {
3570         bemit_fbinop(node, 4, 5);
3571 }
3572
3573 static void bemit_fsubp(const ir_node *node)
3574 {
3575         bemit_fbinopp(node, 0xE8);
3576 }
3577
3578 static void bemit_fsubr(const ir_node *node)
3579 {
3580         bemit_fbinop(node, 5, 4);
3581 }
3582
3583 static void bemit_fsubrp(const ir_node *node)
3584 {
3585         bemit_fbinopp(node, 0xE0);
3586 }
3587
3588 static void bemit_fnstcw(const ir_node *node)
3589 {
3590         bemit8(0xD9); // fnstcw
3591         bemit_mod_am(7, node);
3592 }
3593
3594 static void bemit_fnstsw(void)
3595 {
3596         bemit8(0xDF); // fnstsw %ax
3597         bemit8(0xE0);
3598 }
3599
3600 static void bemit_ftstfnstsw(const ir_node *node)
3601 {
3602         (void)node;
3603
3604         bemit8(0xD9); // ftst
3605         bemit8(0xE4);
3606         bemit_fnstsw();
3607 }
3608
3609 static void bemit_fucomi(const ir_node *node)
3610 {
3611         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3612         bemit8(0xDB); // fucomi
3613         bemit8(0xE8 + attr->x87[1]->index);
3614 }
3615
3616 static void bemit_fucomip(const ir_node *node)
3617 {
3618         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3619         bemit8(0xDF); // fucomip
3620         bemit8(0xE8 + attr->x87[1]->index);
3621 }
3622
3623 static void bemit_fucomfnstsw(const ir_node *node)
3624 {
3625         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3626         bemit8(0xDD); // fucom
3627         bemit8(0xE0 + attr->x87[1]->index);
3628         bemit_fnstsw();
3629 }
3630
3631 static void bemit_fucompfnstsw(const ir_node *node)
3632 {
3633         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3634         bemit8(0xDD); // fucomp
3635         bemit8(0xE8 + attr->x87[1]->index);
3636         bemit_fnstsw();
3637 }
3638
3639 static void bemit_fucomppfnstsw(const ir_node *node)
3640 {
3641         (void)node;
3642
3643         bemit8(0xDA); // fucompp
3644         bemit8(0xE9);
3645         bemit_fnstsw();
3646 }
3647
3648 static void bemit_fxch(const ir_node *node)
3649 {
3650         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3651         bemit8(0xD9);
3652         bemit8(0xC8 + attr->x87[0]->index);
3653 }
3654
3655 /**
3656  * The type of a emitter function.
3657  */
3658 typedef void (*emit_func) (const ir_node *);
3659
3660 /**
3661  * Set a node emitter. Make it a bit more type safe.
3662  */
3663 static void register_emitter(ir_op *op, emit_func func)
3664 {
3665         op->ops.generic = (op_func) func;
3666 }
3667
3668 static void ia32_register_binary_emitters(void)
3669 {
3670         /* first clear the generic function pointer for all ops */
3671         clear_irp_opcodes_generic_func();
3672
3673         /* benode emitter */
3674         register_emitter(op_be_Copy,            bemit_copy);
3675         register_emitter(op_be_CopyKeep,        bemit_copy);
3676         register_emitter(op_be_IncSP,           bemit_incsp);
3677         register_emitter(op_be_Perm,            bemit_perm);
3678         register_emitter(op_be_Return,          bemit_return);
3679         register_emitter(op_ia32_Adc,           bemit_adc);
3680         register_emitter(op_ia32_Add,           bemit_add);
3681         register_emitter(op_ia32_AddMem,        bemit_addmem);
3682         register_emitter(op_ia32_AddMem8Bit,    bemit_addmem8bit);
3683         register_emitter(op_ia32_And,           bemit_and);
3684         register_emitter(op_ia32_AndMem,        bemit_andmem);
3685         register_emitter(op_ia32_AndMem8Bit,    bemit_andmem8bit);
3686         register_emitter(op_ia32_Breakpoint,    bemit_int3);
3687         register_emitter(op_ia32_CMovcc,        bemit_cmovcc);
3688         register_emitter(op_ia32_Call,          bemit_call);
3689         register_emitter(op_ia32_Cltd,          bemit_cltd);
3690         register_emitter(op_ia32_Cmc,           bemit_cmc);
3691         register_emitter(op_ia32_Cmp,           bemit_cmp);
3692         register_emitter(op_ia32_Cmp8Bit,       bemit_cmp8bit);
3693         register_emitter(op_ia32_Const,         bemit_mov_const);
3694         register_emitter(op_ia32_Conv_I2I,      bemit_conv_i2i);
3695         register_emitter(op_ia32_Conv_I2I8Bit,  bemit_conv_i2i);
3696         register_emitter(op_ia32_CopyB_i,       bemit_copybi);
3697         register_emitter(op_ia32_Cwtl,          bemit_cwtl);
3698         register_emitter(op_ia32_Dec,           bemit_dec);
3699         register_emitter(op_ia32_DecMem,        bemit_decmem);
3700         register_emitter(op_ia32_Div,           bemit_div);
3701         register_emitter(op_ia32_FldCW,         bemit_fldcw);
3702         register_emitter(op_ia32_FnstCW,        bemit_fnstcw);
3703         register_emitter(op_ia32_FtstFnstsw,    bemit_ftstfnstsw);
3704         register_emitter(op_ia32_FucomFnstsw,   bemit_fucomfnstsw);
3705         register_emitter(op_ia32_Fucomi,        bemit_fucomi);
3706         register_emitter(op_ia32_FucompFnstsw,  bemit_fucompfnstsw);
3707         register_emitter(op_ia32_Fucompi,       bemit_fucomip);
3708         register_emitter(op_ia32_FucomppFnstsw, bemit_fucomppfnstsw);
3709         register_emitter(op_ia32_IDiv,          bemit_idiv);
3710         register_emitter(op_ia32_IJmp,          bemit_ijmp);
3711         register_emitter(op_ia32_IMul,          bemit_imul);
3712         register_emitter(op_ia32_IMul1OP,       bemit_imul1op);
3713         register_emitter(op_ia32_Inc,           bemit_inc);
3714         register_emitter(op_ia32_IncMem,        bemit_incmem);
3715         register_emitter(op_ia32_Jcc,           bemit_ia32_jcc);
3716         register_emitter(op_ia32_Jmp,           bemit_jump);
3717         register_emitter(op_ia32_LdTls,         bemit_ldtls);
3718         register_emitter(op_ia32_Lea,           bemit_lea);
3719         register_emitter(op_ia32_Leave,         bemit_leave);
3720         register_emitter(op_ia32_Load,          bemit_load);
3721         register_emitter(op_ia32_Minus64Bit,    bemit_minus64bit);
3722         register_emitter(op_ia32_Mul,           bemit_mul);
3723         register_emitter(op_ia32_Neg,           bemit_neg);
3724         register_emitter(op_ia32_NegMem,        bemit_negmem);
3725         register_emitter(op_ia32_Not,           bemit_not);
3726         register_emitter(op_ia32_NotMem,        bemit_notmem);
3727         register_emitter(op_ia32_Or,            bemit_or);
3728         register_emitter(op_ia32_OrMem,         bemit_ormem);
3729         register_emitter(op_ia32_OrMem8Bit,     bemit_ormem8bit);
3730         register_emitter(op_ia32_Pop,           bemit_pop);
3731         register_emitter(op_ia32_PopEbp,        bemit_pop);
3732         register_emitter(op_ia32_PopMem,        bemit_popmem);
3733         register_emitter(op_ia32_Push,          bemit_push);
3734         register_emitter(op_ia32_RepPrefix,     bemit_rep);
3735         register_emitter(op_ia32_Rol,           bemit_rol);
3736         register_emitter(op_ia32_RolMem,        bemit_rolmem);
3737         register_emitter(op_ia32_Ror,           bemit_ror);
3738         register_emitter(op_ia32_RorMem,        bemit_rormem);
3739         register_emitter(op_ia32_Sahf,          bemit_sahf);
3740         register_emitter(op_ia32_Sar,           bemit_sar);
3741         register_emitter(op_ia32_SarMem,        bemit_sarmem);
3742         register_emitter(op_ia32_Sbb,           bemit_sbb);
3743         register_emitter(op_ia32_Setcc,         bemit_setcc);
3744         register_emitter(op_ia32_Shl,           bemit_shl);
3745         register_emitter(op_ia32_ShlD,          bemit_shld);
3746         register_emitter(op_ia32_ShlMem,        bemit_shlmem);
3747         register_emitter(op_ia32_Shr,           bemit_shr);
3748         register_emitter(op_ia32_ShrD,          bemit_shrd);
3749         register_emitter(op_ia32_ShrMem,        bemit_shrmem);
3750         register_emitter(op_ia32_Stc,           bemit_stc);
3751         register_emitter(op_ia32_Store,         bemit_store);
3752         register_emitter(op_ia32_Store8Bit,     bemit_store);
3753         register_emitter(op_ia32_Sub,           bemit_sub);
3754         register_emitter(op_ia32_SubMem,        bemit_submem);
3755         register_emitter(op_ia32_SubMem8Bit,    bemit_submem8bit);
3756         register_emitter(op_ia32_SubSP,         bemit_subsp);
3757         register_emitter(op_ia32_SwitchJmp,     bemit_switchjmp);
3758         register_emitter(op_ia32_Test,          bemit_test);
3759         register_emitter(op_ia32_Test8Bit,      bemit_test8bit);
3760         register_emitter(op_ia32_Xor,           bemit_xor);
3761         register_emitter(op_ia32_Xor0,          bemit_xor0);
3762         register_emitter(op_ia32_XorMem,        bemit_xormem);
3763         register_emitter(op_ia32_XorMem8Bit,    bemit_xormem8bit);
3764         register_emitter(op_ia32_fabs,          bemit_fabs);
3765         register_emitter(op_ia32_fadd,          bemit_fadd);
3766         register_emitter(op_ia32_faddp,         bemit_faddp);
3767         register_emitter(op_ia32_fchs,          bemit_fchs);
3768         register_emitter(op_ia32_fdiv,          bemit_fdiv);
3769         register_emitter(op_ia32_fdivp,         bemit_fdivp);
3770         register_emitter(op_ia32_fdivr,         bemit_fdivr);
3771         register_emitter(op_ia32_fdivrp,        bemit_fdivrp);
3772         register_emitter(op_ia32_fild,          bemit_fild);
3773         register_emitter(op_ia32_fist,          bemit_fist);
3774         register_emitter(op_ia32_fistp,         bemit_fistp);
3775         register_emitter(op_ia32_fld,           bemit_fld);
3776         register_emitter(op_ia32_fld1,          bemit_fld1);
3777         register_emitter(op_ia32_fldz,          bemit_fldz);
3778         register_emitter(op_ia32_fmul,          bemit_fmul);
3779         register_emitter(op_ia32_fmulp,         bemit_fmulp);
3780         register_emitter(op_ia32_fpop,          bemit_fpop);
3781         register_emitter(op_ia32_fpush,         bemit_fpush);
3782         register_emitter(op_ia32_fpushCopy,     bemit_fpushcopy);
3783         register_emitter(op_ia32_fst,           bemit_fst);
3784         register_emitter(op_ia32_fstp,          bemit_fstp);
3785         register_emitter(op_ia32_fsub,          bemit_fsub);
3786         register_emitter(op_ia32_fsubp,         bemit_fsubp);
3787         register_emitter(op_ia32_fsubr,         bemit_fsubr);
3788         register_emitter(op_ia32_fsubrp,        bemit_fsubrp);
3789         register_emitter(op_ia32_fxch,          bemit_fxch);
3790
3791         /* ignore the following nodes */
3792         register_emitter(op_ia32_ProduceVal,   emit_Nothing);
3793         register_emitter(op_be_Keep,           emit_Nothing);
3794         register_emitter(op_be_Start,          emit_Nothing);
3795         register_emitter(op_Phi,               emit_Nothing);
3796         register_emitter(op_Start,             emit_Nothing);
3797 }
3798
3799 static void gen_binary_block(ir_node *block)
3800 {
3801         ir_node *node;
3802
3803         ia32_emit_block_header(block);
3804
3805         /* emit the contents of the block */
3806         sched_foreach(block, node) {
3807                 ia32_emit_node(node);
3808         }
3809 }
3810
3811 void ia32_gen_binary_routine(ir_graph *irg)
3812 {
3813         ir_entity        *entity    = get_irg_entity(irg);
3814         const arch_env_t *arch_env  = be_get_irg_arch_env(irg);
3815         ia32_irg_data_t  *irg_data  = ia32_get_irg_data(irg);
3816         ir_node         **blk_sched = irg_data->blk_sched;
3817         size_t            i, n;
3818
3819         isa = (ia32_isa_t*) arch_env;
3820
3821         ia32_register_binary_emitters();
3822
3823         be_gas_emit_function_prolog(entity, ia32_cg_config.function_alignment);
3824
3825         /* we use links to point to target blocks */
3826         ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK);
3827         irg_block_walk_graph(irg, ia32_gen_labels, NULL, NULL);
3828
3829         /* initialize next block links */
3830         n = ARR_LEN(blk_sched);
3831         for (i = 0; i < n; ++i) {
3832                 ir_node *block = blk_sched[i];
3833                 ir_node *prev  = i > 0 ? blk_sched[i-1] : NULL;
3834
3835                 set_irn_link(block, prev);
3836         }
3837
3838         for (i = 0; i < n; ++i) {
3839                 ir_node *block = blk_sched[i];
3840                 gen_binary_block(block);
3841         }
3842
3843         be_gas_emit_function_epilog(entity);
3844
3845         ir_free_resources(irg, IR_RESOURCE_IRN_LINK);
3846 }
3847
3848
3849 void ia32_init_emitter(void)
3850 {
3851         lc_opt_entry_t *be_grp;
3852         lc_opt_entry_t *ia32_grp;
3853
3854         be_grp   = lc_opt_get_grp(firm_opt_get_root(), "be");
3855         ia32_grp = lc_opt_get_grp(be_grp, "ia32");
3856
3857         lc_opt_add_table(ia32_grp, ia32_emitter_options);
3858
3859         build_reg_map();
3860
3861         FIRM_DBG_REGISTER(dbg, "firm.be.ia32.emitter");
3862 }