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  * @version     $Id$
  25  *
  26  * Summary table for x86 floatingpoint compares:
  27  * (remember effect of unordered on x86: ZF=1, PF=1, CF=1)
  28  *
  29  *   pnc_Eq  => !P && E
  30  *   pnc_Lt  => !P && B
  31  *   pnc_Le  => !P && BE
  32  *   pnc_Gt  => A
  33  *   pnc_Ge  => AE
  34  *   pnc_Lg  => NE
  35  *   pnc_Leg => NP  (ordered)
  36  *   pnc_Uo  => P
  37  *   pnc_Ue  => E
  38  *   pnc_Ul  => B
  39  *   pnc_Ule => BE
  40  *   pnc_Ug  => P || A
  41  *   pnc_Uge => P || AE
  42  *   pnc_Ne  => P || NE
  43  */
  44 #include "config.h"
  45
  46 #include <limits.h>
  47
  48 #include "xmalloc.h"
  49 #include "tv.h"
  50 #include "iredges.h"
  51 #include "debug.h"
  52 #include "irgwalk.h"
  53 #include "irprintf.h"
  54 #include "irop_t.h"
  55 #include "irargs_t.h"
  56 #include "irprog_t.h"
  57 #include "iredges_t.h"
  58 #include "irtools.h"
  59 #include "execfreq.h"
  60 #include "error.h"
  61 #include "raw_bitset.h"
  62 #include "dbginfo.h"
  63 #include "lc_opts.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 (has_Block_entity(block))
 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         long       default_pn = get_ia32_default_pn(node);
1071
1072         ia32_emitf(node, "\tjmp %*AM\n");
1073         emit_jump_table(node, default_pn, 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->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_dbg_method_begin(entity);
1890         be_gas_emit_function_prolog(entity, ia32_cg_config.function_alignment);
1891
1892         /* we use links to point to target blocks */
1893         ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK);
1894         irg_block_walk_graph(irg, ia32_gen_labels, NULL, &exc_list);
1895
1896         /* initialize next block links */
1897         n = ARR_LEN(blk_sched);
1898         for (i = 0; i < n; ++i) {
1899                 ir_node *block = blk_sched[i];
1900                 ir_node *prev  = i > 0 ? blk_sched[i-1] : NULL;
1901
1902                 set_irn_link(block, prev);
1903         }
1904
1905         for (i = 0; i < n; ++i) {
1906                 ir_node *block = blk_sched[i];
1907
1908                 ia32_gen_block(block);
1909         }
1910
1911         be_gas_emit_function_epilog(entity);
1912         be_dbg_method_end();
1913         be_emit_char('\n');
1914         be_emit_write_line();
1915
1916         ir_free_resources(irg, IR_RESOURCE_IRN_LINK);
1917
1918         /* Sort the exception table using the exception label id's.
1919            Those are ascending with ascending addresses. */
1920         qsort(exc_list, ARR_LEN(exc_list), sizeof(exc_list[0]), cmp_exc_entry);
1921         {
1922                 size_t e;
1923
1924                 for (e = 0; e < ARR_LEN(exc_list); ++e) {
1925                         be_emit_cstring("\t.long ");
1926                         ia32_emit_exc_label(exc_list[e].exc_instr);
1927                         be_emit_char('\n');
1928                         be_emit_cstring("\t.long ");
1929                         be_gas_emit_block_name(exc_list[e].block);
1930                         be_emit_char('\n');
1931                 }
1932         }
1933         DEL_ARR_F(exc_list);
1934 }
1935
1936 static const lc_opt_table_entry_t ia32_emitter_options[] = {
1937         LC_OPT_ENT_BOOL("mark_spill_reload",   "mark spills and reloads with ud opcodes", &mark_spill_reload),
1938         LC_OPT_LAST
1939 };
1940
1941 /* ==== Experimental binary emitter ==== */
1942
1943 static unsigned char reg_gp_map[N_ia32_gp_REGS];
1944 //static unsigned char reg_mmx_map[N_ia32_mmx_REGS];
1945 //static unsigned char reg_sse_map[N_ia32_xmm_REGS];
1946
1947 static void build_reg_map(void)
1948 {
1949         reg_gp_map[REG_GP_EAX] = 0x0;
1950         reg_gp_map[REG_GP_ECX] = 0x1;
1951         reg_gp_map[REG_GP_EDX] = 0x2;
1952         reg_gp_map[REG_GP_EBX] = 0x3;
1953         reg_gp_map[REG_GP_ESP] = 0x4;
1954         reg_gp_map[REG_GP_EBP] = 0x5;
1955         reg_gp_map[REG_GP_ESI] = 0x6;
1956         reg_gp_map[REG_GP_EDI] = 0x7;
1957 }
1958
1959 /** Returns the encoding for a pnc field. */
1960 static unsigned char pnc2cc(ia32_condition_code_t cc)
1961 {
1962         return cc & 0xf;
1963 }
1964
1965 /** Sign extension bit values for binops */
1966 enum SignExt {
1967         UNSIGNED_IMM = 0,  /**< unsigned immediate */
1968         SIGNEXT_IMM  = 2,  /**< sign extended immediate */
1969 };
1970
1971 /** The mod encoding of the ModR/M */
1972 enum Mod {
1973         MOD_IND          = 0x00, /**< [reg1] */
1974         MOD_IND_BYTE_OFS = 0x40, /**< [reg1 + byte ofs] */
1975         MOD_IND_WORD_OFS = 0x80, /**< [reg1 + word ofs] */
1976         MOD_REG          = 0xC0  /**< reg1 */
1977 };
1978
1979 /** create R/M encoding for ModR/M */
1980 #define ENC_RM(x) (x)
1981 /** create REG encoding for ModR/M */
1982 #define ENC_REG(x) ((x) << 3)
1983
1984 /** create encoding for a SIB byte */
1985 #define ENC_SIB(scale, index, base) ((scale) << 6 | (index) << 3 | (base))
1986
1987 /* Node: The following routines are supposed to append bytes, words, dwords
1988    to the output stream.
1989    Currently the implementation is stupid in that it still creates output
1990    for an "assembler" in the form of .byte, .long
1991    We will change this when enough infrastructure is there to create complete
1992    machine code in memory/object files */
1993
1994 static void bemit8(const unsigned char byte)
1995 {
1996         be_emit_irprintf("\t.byte 0x%x\n", byte);
1997         be_emit_write_line();
1998 }
1999
2000 static void bemit16(const unsigned short u16)
2001 {
2002         be_emit_irprintf("\t.word 0x%x\n", u16);
2003         be_emit_write_line();
2004 }
2005
2006 static void bemit32(const unsigned u32)
2007 {
2008         be_emit_irprintf("\t.long 0x%x\n", u32);
2009         be_emit_write_line();
2010 }
2011
2012 /**
2013  * Emit address of an entity. If @p is_relative is true then a relative
2014  * offset from behind the address to the entity is created.
2015  */
2016 static void bemit_entity(ir_entity *entity, bool entity_sign, int offset,
2017                          bool is_relative)
2018 {
2019         if (entity == NULL) {
2020                 bemit32(offset);
2021                 return;
2022         }
2023
2024         /* the final version should remember the position in the bytestream
2025            and patch it with the correct address at linktime... */
2026         be_emit_cstring("\t.long ");
2027         if (entity_sign)
2028                 be_emit_char('-');
2029         be_gas_emit_entity(entity);
2030
2031         if (get_entity_owner(entity) == get_tls_type()) {
2032                 if (get_entity_visibility(entity) == ir_visibility_external) {
2033                         be_emit_cstring("@INDNTPOFF");
2034                 } else {
2035                         be_emit_cstring("@NTPOFF");
2036                 }
2037         }
2038
2039         if (is_relative) {
2040                 be_emit_cstring("-.");
2041                 offset -= 4;
2042         }
2043
2044         if (offset != 0) {
2045                 be_emit_irprintf("%+d", offset);
2046         }
2047         be_emit_char('\n');
2048         be_emit_write_line();
2049 }
2050
2051 static void bemit_jmp_destination(const ir_node *dest_block)
2052 {
2053         be_emit_cstring("\t.long ");
2054         be_gas_emit_block_name(dest_block);
2055         be_emit_cstring(" - . - 4\n");
2056         be_emit_write_line();
2057 }
2058
2059 /* end emit routines, all emitters following here should only use the functions
2060    above. */
2061
2062 typedef enum reg_modifier {
2063         REG_LOW  = 0,
2064         REG_HIGH = 1
2065 } reg_modifier_t;
2066
2067 /** Create a ModR/M byte for src1,src2 registers */
2068 static void bemit_modrr(const arch_register_t *src1,
2069                         const arch_register_t *src2)
2070 {
2071         unsigned char modrm = MOD_REG;
2072         modrm |= ENC_RM(reg_gp_map[src1->index]);
2073         modrm |= ENC_REG(reg_gp_map[src2->index]);
2074         bemit8(modrm);
2075 }
2076
2077 /** Create a ModR/M8 byte for src1,src2 registers */
2078 static void bemit_modrr8(reg_modifier_t high_part1, const arch_register_t *src1,
2079                                                  reg_modifier_t high_part2, const arch_register_t *src2)
2080 {
2081         unsigned char modrm = MOD_REG;
2082         modrm |= ENC_RM(reg_gp_map[src1->index] +  (high_part1 == REG_HIGH ? 4 : 0));
2083         modrm |= ENC_REG(reg_gp_map[src2->index] + (high_part2 == REG_HIGH ? 4 : 0));
2084         bemit8(modrm);
2085 }
2086
2087 /** Create a ModR/M byte for one register and extension */
2088 static void bemit_modru(const arch_register_t *reg, unsigned ext)
2089 {
2090         unsigned char modrm = MOD_REG;
2091         assert(ext <= 7);
2092         modrm |= ENC_RM(reg_gp_map[reg->index]);
2093         modrm |= ENC_REG(ext);
2094         bemit8(modrm);
2095 }
2096
2097 /** Create a ModR/M8 byte for one register */
2098 static void bemit_modrm8(reg_modifier_t high_part, const arch_register_t *reg)
2099 {
2100         unsigned char modrm = MOD_REG;
2101         assert(reg_gp_map[reg->index] < 4);
2102         modrm |= ENC_RM(reg_gp_map[reg->index] + (high_part == REG_HIGH ? 4 : 0));
2103         modrm |= MOD_REG;
2104         bemit8(modrm);
2105 }
2106
2107 /**
2108  * Calculate the size of an signed immediate in bytes.
2109  *
2110  * @param offset  an offset
2111  */
2112 static unsigned get_signed_imm_size(int offset)
2113 {
2114         if (-128 <= offset && offset < 128) {
2115                 return 1;
2116         } else if (-32768 <= offset && offset < 32768) {
2117                 return 2;
2118         } else {
2119                 return 4;
2120         }
2121 }
2122
2123 /**
2124  * Emit an address mode.
2125  *
2126  * @param reg   content of the reg field: either a register index or an opcode extension
2127  * @param node  the node
2128  */
2129 static void bemit_mod_am(unsigned reg, const ir_node *node)
2130 {
2131         ir_entity *ent       = get_ia32_am_sc(node);
2132         int        offs      = get_ia32_am_offs_int(node);
2133         ir_node   *base      = get_irn_n(node, n_ia32_base);
2134         int        has_base  = !is_ia32_NoReg_GP(base);
2135         ir_node   *idx       = get_irn_n(node, n_ia32_index);
2136         int        has_index = !is_ia32_NoReg_GP(idx);
2137         unsigned   modrm     = 0;
2138         unsigned   sib       = 0;
2139         unsigned   emitoffs  = 0;
2140         bool       emitsib   = false;
2141         unsigned   base_enc;
2142
2143         /* set the mod part depending on displacement */
2144         if (ent != NULL) {
2145                 modrm |= MOD_IND_WORD_OFS;
2146                 emitoffs = 32;
2147         } else if (offs == 0) {
2148                 modrm |= MOD_IND;
2149                 emitoffs = 0;
2150         } else if (-128 <= offs && offs < 128) {
2151                 modrm |= MOD_IND_BYTE_OFS;
2152                 emitoffs = 8;
2153         } else {
2154                 modrm |= MOD_IND_WORD_OFS;
2155                 emitoffs = 32;
2156         }
2157
2158         if (has_base) {
2159                 const arch_register_t *base_reg = arch_get_irn_register(base);
2160                 base_enc = reg_gp_map[base_reg->index];
2161         } else {
2162                 /* Use the EBP encoding + MOD_IND if NO base register. There is
2163                  * always a 32bit offset present in this case. */
2164                 modrm    = MOD_IND;
2165                 base_enc = 0x05;
2166                 emitoffs = 32;
2167         }
2168
2169         /* Determine if we need a SIB byte. */
2170         if (has_index) {
2171                 const arch_register_t *reg_index = arch_get_irn_register(idx);
2172                 int                    scale     = get_ia32_am_scale(node);
2173                 assert(scale < 4);
2174                 /* R/M set to ESP means SIB in 32bit mode. */
2175                 modrm   |= ENC_RM(0x04);
2176                 sib      = ENC_SIB(scale, reg_gp_map[reg_index->index], base_enc);
2177                 emitsib = true;
2178         } else if (base_enc == 0x04) {
2179                 /* for the above reason we are forced to emit a SIB when base is ESP.
2180                  * Only the base is used, index must be ESP too, which means no index.
2181                  */
2182                 modrm   |= ENC_RM(0x04);
2183                 sib      = ENC_SIB(0, 0x04, 0x04);
2184                 emitsib  = true;
2185         } else {
2186                 modrm |= ENC_RM(base_enc);
2187         }
2188
2189         /* We are forced to emit an 8bit offset as EBP base without offset is a
2190          * special case for SIB without base register. */
2191         if (base_enc == 0x05 && emitoffs == 0) {
2192                 modrm    |= MOD_IND_BYTE_OFS;
2193                 emitoffs  = 8;
2194         }
2195
2196         modrm |= ENC_REG(reg);
2197
2198         bemit8(modrm);
2199         if (emitsib)
2200                 bemit8(sib);
2201
2202         /* emit displacement */
2203         if (emitoffs == 8) {
2204                 bemit8((unsigned) offs);
2205         } else if (emitoffs == 32) {
2206                 bemit_entity(ent, is_ia32_am_sc_sign(node), offs, false);
2207         }
2208 }
2209
2210 /**
2211  * Emit a binop with a immediate operand.
2212  *
2213  * @param node        the node to emit
2214  * @param opcode_eax  the opcode for the op eax, imm variant
2215  * @param opcode      the opcode for the reg, imm variant
2216  * @param ruval       the opcode extension for opcode
2217  */
2218 static void bemit_binop_with_imm(
2219         const ir_node *node,
2220         unsigned char opcode_ax,
2221         unsigned char opcode, unsigned char ruval)
2222 {
2223         /* Use in-reg, because some instructions (cmp, test) have no out-reg. */
2224         const ir_node               *op   = get_irn_n(node, n_ia32_binary_right);
2225         const ia32_immediate_attr_t *attr = get_ia32_immediate_attr_const(op);
2226         unsigned                     size;
2227
2228         /* Some instructions (test) have no short form with 32bit value + 8bit
2229          * immediate. */
2230         if (attr->symconst != NULL || opcode & SIGNEXT_IMM) {
2231                 size = 4;
2232         } else {
2233                 /* check for sign extension */
2234                 size = get_signed_imm_size(attr->offset);
2235         }
2236
2237         switch (size) {
2238         case 1:
2239                 bemit8(opcode | SIGNEXT_IMM);
2240                 /* cmp has this special mode */
2241                 if (get_ia32_op_type(node) == ia32_AddrModeS) {
2242                         bemit_mod_am(ruval, node);
2243                 } else {
2244                         const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_binary_left);
2245                         bemit_modru(reg, ruval);
2246                 }
2247                 bemit8((unsigned char)attr->offset);
2248                 return;
2249         case 2:
2250         case 4:
2251                 /* check for eax variant: this variant is shorter for 32bit immediates only */
2252                 if (get_ia32_op_type(node) == ia32_AddrModeS) {
2253                         bemit8(opcode);
2254                         bemit_mod_am(ruval, node);
2255                 } else {
2256                         const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_binary_left);
2257                         if (reg->index == REG_GP_EAX) {
2258                                 bemit8(opcode_ax);
2259                         } else {
2260                                 bemit8(opcode);
2261                                 bemit_modru(reg, ruval);
2262                         }
2263                 }
2264                 bemit_entity(attr->symconst, attr->sc_sign, attr->offset, false);
2265                 return;
2266         }
2267         panic("invalid imm size?!?");
2268 }
2269
2270 /**
2271  * Emits a binop.
2272  */
2273 static void bemit_binop_2(const ir_node *node, unsigned code)
2274 {
2275         const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_binary_left);
2276         bemit8(code);
2277         if (get_ia32_op_type(node) == ia32_Normal) {
2278                 const arch_register_t *op2 = arch_get_irn_register_in(node, n_ia32_binary_right);
2279                 bemit_modrr(op2, out);
2280         } else {
2281                 bemit_mod_am(reg_gp_map[out->index], node);
2282         }
2283 }
2284
2285 /**
2286  * Emit a binop.
2287  */
2288 static void bemit_binop(const ir_node *node, const unsigned char opcodes[4])
2289 {
2290         ir_node *right = get_irn_n(node, n_ia32_binary_right);
2291         if (is_ia32_Immediate(right)) {
2292                 bemit_binop_with_imm(node, opcodes[1], opcodes[2], opcodes[3]);
2293         } else {
2294                 bemit_binop_2(node, opcodes[0]);
2295         }
2296 }
2297
2298 /**
2299  * Emit an unop.
2300  */
2301 static void bemit_unop(const ir_node *node, unsigned char code, unsigned char ext, int input)
2302 {
2303         bemit8(code);
2304         if (get_ia32_op_type(node) == ia32_Normal) {
2305                 const arch_register_t *in = arch_get_irn_register_in(node, input);
2306                 bemit_modru(in, ext);
2307         } else {
2308                 bemit_mod_am(ext, node);
2309         }
2310 }
2311
2312 static void bemit_unop_reg(const ir_node *node, unsigned char code, int input)
2313 {
2314         const arch_register_t *out = arch_get_irn_register_out(node, 0);
2315         bemit_unop(node, code, reg_gp_map[out->index], input);
2316 }
2317
2318 static void bemit_unop_mem(const ir_node *node, unsigned char code, unsigned char ext)
2319 {
2320         unsigned size = get_mode_size_bits(get_ia32_ls_mode(node));
2321         if (size == 16)
2322                 bemit8(0x66);
2323         bemit8(size == 8 ? code : code + 1);
2324         bemit_mod_am(ext, node);
2325 }
2326
2327 static void bemit_immediate(const ir_node *node, bool relative)
2328 {
2329         const ia32_immediate_attr_t *attr = get_ia32_immediate_attr_const(node);
2330         bemit_entity(attr->symconst, attr->sc_sign, attr->offset, relative);
2331 }
2332
2333 static void bemit_copy(const ir_node *copy)
2334 {
2335         const arch_register_t *in  = arch_get_irn_register_in(copy, 0);
2336         const arch_register_t *out = arch_get_irn_register_out(copy, 0);
2337
2338         if (in == out)
2339                 return;
2340         /* copies of vf nodes aren't real... */
2341         if (arch_register_get_class(in) == &ia32_reg_classes[CLASS_ia32_vfp])
2342                 return;
2343
2344         assert(arch_register_get_class(in) == &ia32_reg_classes[CLASS_ia32_gp]);
2345         bemit8(0x8B);
2346         bemit_modrr(in, out);
2347 }
2348
2349 static void bemit_perm(const ir_node *node)
2350 {
2351         const arch_register_t       *in0  = arch_get_irn_register(get_irn_n(node, 0));
2352         const arch_register_t       *in1  = arch_get_irn_register(get_irn_n(node, 1));
2353         const arch_register_class_t *cls0 = arch_register_get_class(in0);
2354
2355         assert(cls0 == arch_register_get_class(in1) && "Register class mismatch at Perm");
2356
2357         if (cls0 == &ia32_reg_classes[CLASS_ia32_gp]) {
2358                 if (in0->index == REG_GP_EAX) {
2359                         bemit8(0x90 + reg_gp_map[in1->index]);
2360                 } else if (in1->index == REG_GP_EAX) {
2361                         bemit8(0x90 + reg_gp_map[in0->index]);
2362                 } else {
2363                         bemit8(0x87);
2364                         bemit_modrr(in0, in1);
2365                 }
2366         } else if (cls0 == &ia32_reg_classes[CLASS_ia32_xmm]) {
2367                 panic("unimplemented"); // TODO implement
2368                 //ia32_emitf(NULL, "\txorpd %R, %R\n", in1, in0);
2369                 //ia32_emitf(NULL, "\txorpd %R, %R\n", in0, in1);
2370                 //ia32_emitf(node, "\txorpd %R, %R\n", in1, in0);
2371         } else if (cls0 == &ia32_reg_classes[CLASS_ia32_vfp]) {
2372                 /* is a NOP */
2373         } else if (cls0 == &ia32_reg_classes[CLASS_ia32_st]) {
2374                 /* is a NOP */
2375         } else {
2376                 panic("unexpected register class in be_Perm (%+F)", node);
2377         }
2378 }
2379
2380 static void bemit_xor0(const ir_node *node)
2381 {
2382         const arch_register_t *out = arch_get_irn_register_out(node, 0);
2383         bemit8(0x31);
2384         bemit_modrr(out, out);
2385 }
2386
2387 static void bemit_mov_const(const ir_node *node)
2388 {
2389         const arch_register_t *out = arch_get_irn_register_out(node, 0);
2390         bemit8(0xB8 + reg_gp_map[out->index]);
2391         bemit_immediate(node, false);
2392 }
2393
2394 /**
2395  * Creates a function for a Binop with 3 possible encodings.
2396  */
2397 #define BINOP(op, op0, op1, op2, op2_ext)                                 \
2398 static void bemit_ ## op(const ir_node *node) {                           \
2399         static const unsigned char op ## _codes[] = {op0, op1, op2, op2_ext}; \
2400         bemit_binop(node, op ## _codes);                                      \
2401 }
2402
2403 /*    insn  def  eax,imm   imm */
2404 BINOP(add,  0x03, 0x05, 0x81, 0)
2405 BINOP(or,   0x0B, 0x0D, 0x81, 1)
2406 BINOP(adc,  0x13, 0x15, 0x81, 2)
2407 BINOP(sbb,  0x1B, 0x1D, 0x81, 3)
2408 BINOP(and,  0x23, 0x25, 0x81, 4)
2409 BINOP(sub,  0x2B, 0x2D, 0x81, 5)
2410 BINOP(xor,  0x33, 0x35, 0x81, 6)
2411 BINOP(test, 0x85, 0xA9, 0xF7, 0)
2412
2413 #define BINOPMEM(op, ext) \
2414 static void bemit_##op(const ir_node *node) \
2415 { \
2416         ir_node *val; \
2417         unsigned size = get_mode_size_bits(get_ia32_ls_mode(node)); \
2418         if (size == 16) \
2419                 bemit8(0x66); \
2420         val = get_irn_n(node, n_ia32_unary_op); \
2421         if (is_ia32_Immediate(val)) { \
2422                 const ia32_immediate_attr_t *attr   = get_ia32_immediate_attr_const(val); \
2423                 int                          offset = attr->offset; \
2424                 if (attr->symconst == NULL && get_signed_imm_size(offset) == 1) { \
2425                         bemit8(0x83); \
2426                         bemit_mod_am(ext, node); \
2427                         bemit8(offset); \
2428                 } else { \
2429                         bemit8(0x81); \
2430                         bemit_mod_am(ext, node); \
2431                         if (size == 16) { \
2432                                 bemit16(offset); \
2433                         } else { \
2434                                 bemit_entity(attr->symconst, attr->sc_sign, offset, false); \
2435                         } \
2436                 } \
2437         } else { \
2438                 bemit8(ext << 3 | 1); \
2439                 bemit_mod_am(reg_gp_map[arch_get_irn_register_out(val, 0)->index], node); \
2440         } \
2441 } \
2442  \
2443 static void bemit_##op##8bit(const ir_node *node) \
2444 { \
2445         ir_node *val = get_irn_n(node, n_ia32_unary_op); \
2446         if (is_ia32_Immediate(val)) { \
2447                 bemit8(0x80); \
2448                 bemit_mod_am(ext, node); \
2449                 bemit8(get_ia32_immediate_attr_const(val)->offset); \
2450         } else { \
2451                 bemit8(ext << 3); \
2452                 bemit_mod_am(reg_gp_map[arch_get_irn_register_out(val, 0)->index], node); \
2453         } \
2454 }
2455
2456 BINOPMEM(addmem,  0)
2457 BINOPMEM(ormem,   1)
2458 BINOPMEM(andmem,  4)
2459 BINOPMEM(submem,  5)
2460 BINOPMEM(xormem,  6)
2461
2462
2463 /**
2464  * Creates a function for an Unop with code /ext encoding.
2465  */
2466 #define UNOP(op, code, ext, input)              \
2467 static void bemit_ ## op(const ir_node *node) { \
2468         bemit_unop(node, code, ext, input);         \
2469 }
2470
2471 UNOP(not,     0xF7, 2, n_ia32_Not_val)
2472 UNOP(neg,     0xF7, 3, n_ia32_Neg_val)
2473 UNOP(mul,     0xF7, 4, n_ia32_Mul_right)
2474 UNOP(imul1op, 0xF7, 5, n_ia32_IMul1OP_right)
2475 UNOP(div,     0xF7, 6, n_ia32_Div_divisor)
2476 UNOP(idiv,    0xF7, 7, n_ia32_IDiv_divisor)
2477
2478 /* TODO: am support for IJmp */
2479 UNOP(ijmp,    0xFF, 4, n_ia32_IJmp_target)
2480
2481 #define SHIFT(op, ext) \
2482 static void bemit_##op(const ir_node *node) \
2483 { \
2484         const arch_register_t *out   = arch_get_irn_register_out(node, 0); \
2485         ir_node               *count = get_irn_n(node, 1); \
2486         if (is_ia32_Immediate(count)) { \
2487                 int offset = get_ia32_immediate_attr_const(count)->offset; \
2488                 if (offset == 1) { \
2489                         bemit8(0xD1); \
2490                         bemit_modru(out, ext); \
2491                 } else { \
2492                         bemit8(0xC1); \
2493                         bemit_modru(out, ext); \
2494                         bemit8(offset); \
2495                 } \
2496         } else { \
2497                 bemit8(0xD3); \
2498                 bemit_modru(out, ext); \
2499         } \
2500 } \
2501  \
2502 static void bemit_##op##mem(const ir_node *node) \
2503 { \
2504         ir_node *count; \
2505         unsigned size = get_mode_size_bits(get_ia32_ls_mode(node)); \
2506         if (size == 16) \
2507                 bemit8(0x66); \
2508         count = get_irn_n(node, 1); \
2509         if (is_ia32_Immediate(count)) { \
2510                 int offset = get_ia32_immediate_attr_const(count)->offset; \
2511                 if (offset == 1) { \
2512                         bemit8(size == 8 ? 0xD0 : 0xD1); \
2513                         bemit_mod_am(ext, node); \
2514                 } else { \
2515                         bemit8(size == 8 ? 0xC0 : 0xC1); \
2516                         bemit_mod_am(ext, node); \
2517                         bemit8(offset); \
2518                 } \
2519         } else { \
2520                 bemit8(size == 8 ? 0xD2 : 0xD3); \
2521                 bemit_mod_am(ext, node); \
2522         } \
2523 }
2524
2525 SHIFT(rol, 0)
2526 SHIFT(ror, 1)
2527 SHIFT(shl, 4)
2528 SHIFT(shr, 5)
2529 SHIFT(sar, 7)
2530
2531 static void bemit_shld(const ir_node *node)
2532 {
2533         const arch_register_t *in  = arch_get_irn_register_in(node, n_ia32_ShlD_val_low);
2534         const arch_register_t *out = arch_get_irn_register_out(node, pn_ia32_ShlD_res);
2535         ir_node *count = get_irn_n(node, n_ia32_ShlD_count);
2536         bemit8(0x0F);
2537         if (is_ia32_Immediate(count)) {
2538                 bemit8(0xA4);
2539                 bemit_modrr(out, in);
2540                 bemit8(get_ia32_immediate_attr_const(count)->offset);
2541         } else {
2542                 bemit8(0xA5);
2543                 bemit_modrr(out, in);
2544         }
2545 }
2546
2547 static void bemit_shrd(const ir_node *node)
2548 {
2549         const arch_register_t *in  = arch_get_irn_register_in(node, n_ia32_ShrD_val_low);
2550         const arch_register_t *out = arch_get_irn_register_out(node, pn_ia32_ShrD_res);
2551         ir_node *count = get_irn_n(node, n_ia32_ShrD_count);
2552         bemit8(0x0F);
2553         if (is_ia32_Immediate(count)) {
2554                 bemit8(0xAC);
2555                 bemit_modrr(out, in);
2556                 bemit8(get_ia32_immediate_attr_const(count)->offset);
2557         } else {
2558                 bemit8(0xAD);
2559                 bemit_modrr(out, in);
2560         }
2561 }
2562
2563 /**
2564  * binary emitter for setcc.
2565  */
2566 static void bemit_setcc(const ir_node *node)
2567 {
2568         const arch_register_t *dreg = arch_get_irn_register_out(node, pn_ia32_Setcc_res);
2569
2570         ia32_condition_code_t cc = get_ia32_condcode(node);
2571         cc = determine_final_cc(node, n_ia32_Setcc_eflags, cc);
2572         if (cc & ia32_cc_float_parity_cases) {
2573                 if (cc & ia32_cc_negated) {
2574                         /* set%PNC <dreg */
2575                         bemit8(0x0F);
2576                         bemit8(0x90 | pnc2cc(cc));
2577                         bemit_modrm8(REG_LOW, dreg);
2578
2579                         /* setp >dreg */
2580                         bemit8(0x0F);
2581                         bemit8(0x9A);
2582                         bemit_modrm8(REG_HIGH, dreg);
2583
2584                         /* orb %>dreg, %<dreg */
2585                         bemit8(0x08);
2586                         bemit_modrr8(REG_LOW, dreg, REG_HIGH, dreg);
2587                 } else {
2588                          /* set%PNC <dreg */
2589                         bemit8(0x0F);
2590                         bemit8(0x90 | pnc2cc(cc));
2591                         bemit_modrm8(REG_LOW, dreg);
2592
2593                         /* setnp >dreg */
2594                         bemit8(0x0F);
2595                         bemit8(0x9B);
2596                         bemit_modrm8(REG_HIGH, dreg);
2597
2598                         /* andb %>dreg, %<dreg */
2599                         bemit8(0x20);
2600                         bemit_modrr8(REG_LOW, dreg, REG_HIGH, dreg);
2601                 }
2602         } else {
2603                 /* set%PNC <dreg */
2604                 bemit8(0x0F);
2605                 bemit8(0x90 | pnc2cc(cc));
2606                 bemit_modrm8(REG_LOW, dreg);
2607         }
2608 }
2609
2610 static void bemit_cmovcc(const ir_node *node)
2611 {
2612         const ia32_attr_t     *attr         = get_ia32_attr_const(node);
2613         int                    ins_permuted = attr->data.ins_permuted;
2614         const arch_register_t *out          = arch_get_irn_register_out(node, pn_ia32_res);
2615         ia32_condition_code_t  cc           = get_ia32_condcode(node);
2616         const arch_register_t *in_true;
2617         const arch_register_t *in_false;
2618
2619         cc = determine_final_cc(node, n_ia32_CMovcc_eflags, cc);
2620
2621         in_true  = arch_get_irn_register(get_irn_n(node, n_ia32_CMovcc_val_true));
2622         in_false = arch_get_irn_register(get_irn_n(node, n_ia32_CMovcc_val_false));
2623
2624         /* should be same constraint fullfilled? */
2625         if (out == in_false) {
2626                 /* yes -> nothing to do */
2627         } else if (out == in_true) {
2628                 assert(get_ia32_op_type(node) == ia32_Normal);
2629                 ins_permuted = !ins_permuted;
2630                 in_true      = in_false;
2631         } else {
2632                 /* we need a mov */
2633                 bemit8(0x8B); // mov %in_false, %out
2634                 bemit_modrr(in_false, out);
2635         }
2636
2637         if (ins_permuted)
2638                 cc = ia32_negate_condition_code(cc);
2639
2640         if (cc & ia32_cc_float_parity_cases)
2641                 panic("cmov can't handle parity float cases");
2642
2643         bemit8(0x0F);
2644         bemit8(0x40 | pnc2cc(cc));
2645         if (get_ia32_op_type(node) == ia32_Normal) {
2646                 bemit_modrr(in_true, out);
2647         } else {
2648                 bemit_mod_am(reg_gp_map[out->index], node);
2649         }
2650 }
2651
2652 static void bemit_cmp(const ir_node *node)
2653 {
2654         unsigned  ls_size = get_mode_size_bits(get_ia32_ls_mode(node));
2655         ir_node  *right;
2656
2657         if (ls_size == 16)
2658                 bemit8(0x66);
2659
2660         right = get_irn_n(node, n_ia32_binary_right);
2661         if (is_ia32_Immediate(right)) {
2662                 /* Use in-reg, because some instructions (cmp, test) have no out-reg. */
2663                 const ir_node               *op   = get_irn_n(node, n_ia32_binary_right);
2664                 const ia32_immediate_attr_t *attr = get_ia32_immediate_attr_const(op);
2665                 unsigned                     size;
2666
2667                 if (attr->symconst != NULL) {
2668                         size = 4;
2669                 } else {
2670                         /* check for sign extension */
2671                         size = get_signed_imm_size(attr->offset);
2672                 }
2673
2674                 switch (size) {
2675                         case 1:
2676                                 bemit8(0x81 | SIGNEXT_IMM);
2677                                 /* cmp has this special mode */
2678                                 if (get_ia32_op_type(node) == ia32_AddrModeS) {
2679                                         bemit_mod_am(7, node);
2680                                 } else {
2681                                         const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_binary_left);
2682                                         bemit_modru(reg, 7);
2683                                 }
2684                                 bemit8((unsigned char)attr->offset);
2685                                 return;
2686                         case 2:
2687                         case 4:
2688                                 /* check for eax variant: this variant is shorter for 32bit immediates only */
2689                                 if (get_ia32_op_type(node) == ia32_AddrModeS) {
2690                                         bemit8(0x81);
2691                                         bemit_mod_am(7, node);
2692                                 } else {
2693                                         const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_binary_left);
2694                                         if (reg->index == REG_GP_EAX) {
2695                                                 bemit8(0x3D);
2696                                         } else {
2697                                                 bemit8(0x81);
2698                                                 bemit_modru(reg, 7);
2699                                         }
2700                                 }
2701                                 if (ls_size == 16) {
2702                                         bemit16(attr->offset);
2703                                 } else {
2704                                         bemit_entity(attr->symconst, attr->sc_sign, attr->offset, false);
2705                                 }
2706                                 return;
2707                 }
2708                 panic("invalid imm size?!?");
2709         } else {
2710                 const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_binary_left);
2711                 bemit8(0x3B);
2712                 if (get_ia32_op_type(node) == ia32_Normal) {
2713                         const arch_register_t *op2 = arch_get_irn_register_in(node, n_ia32_binary_right);
2714                         bemit_modrr(op2, out);
2715                 } else {
2716                         bemit_mod_am(reg_gp_map[out->index], node);
2717                 }
2718         }
2719 }
2720
2721 static void bemit_cmp8bit(const ir_node *node)
2722 {
2723         ir_node *right = get_irn_n(node, n_ia32_binary_right);
2724         if (is_ia32_Immediate(right)) {
2725                 if (get_ia32_op_type(node) == ia32_Normal) {
2726                         const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_Cmp_left);
2727                         if (out->index == REG_GP_EAX) {
2728                                 bemit8(0x3C);
2729                         } else {
2730                                 bemit8(0x80);
2731                                 bemit_modru(out, 7);
2732                         }
2733                 } else {
2734                         bemit8(0x80);
2735                         bemit_mod_am(7, node);
2736                 }
2737                 bemit8(get_ia32_immediate_attr_const(right)->offset);
2738         } else {
2739                 const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_Cmp_left);
2740                 bemit8(0x3A);
2741                 if (get_ia32_op_type(node) == ia32_Normal) {
2742                         const arch_register_t *in = arch_get_irn_register_in(node, n_ia32_Cmp_right);
2743                         bemit_modrr(out, in);
2744                 } else {
2745                         bemit_mod_am(reg_gp_map[out->index], node);
2746                 }
2747         }
2748 }
2749
2750 static void bemit_test8bit(const ir_node *node)
2751 {
2752         ir_node *right = get_irn_n(node, n_ia32_Test8Bit_right);
2753         if (is_ia32_Immediate(right)) {
2754                 if (get_ia32_op_type(node) == ia32_Normal) {
2755                         const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_Test8Bit_left);
2756                         if (out->index == REG_GP_EAX) {
2757                                 bemit8(0xA8);
2758                         } else {
2759                                 bemit8(0xF6);
2760                                 bemit_modru(out, 0);
2761                         }
2762                 } else {
2763                         bemit8(0xF6);
2764                         bemit_mod_am(0, node);
2765                 }
2766                 bemit8(get_ia32_immediate_attr_const(right)->offset);
2767         } else {
2768                 const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_Test8Bit_left);
2769                 bemit8(0x84);
2770                 if (get_ia32_op_type(node) == ia32_Normal) {
2771                         const arch_register_t *in = arch_get_irn_register_in(node, n_ia32_Test8Bit_right);
2772                         bemit_modrr(out, in);
2773                 } else {
2774                         bemit_mod_am(reg_gp_map[out->index], node);
2775                 }
2776         }
2777 }
2778
2779 static void bemit_imul(const ir_node *node)
2780 {
2781         ir_node *right = get_irn_n(node, n_ia32_IMul_right);
2782         /* Do we need the immediate form? */
2783         if (is_ia32_Immediate(right)) {
2784                 int imm = get_ia32_immediate_attr_const(right)->offset;
2785                 if (get_signed_imm_size(imm) == 1) {
2786                         bemit_unop_reg(node, 0x6B, n_ia32_IMul_left);
2787                         bemit8(imm);
2788                 } else {
2789                         bemit_unop_reg(node, 0x69, n_ia32_IMul_left);
2790                         bemit32(imm);
2791                 }
2792         } else {
2793                 bemit8(0x0F);
2794                 bemit_unop_reg(node, 0xAF, n_ia32_IMul_right);
2795         }
2796 }
2797
2798 static void bemit_dec(const ir_node *node)
2799 {
2800         const arch_register_t *out = arch_get_irn_register_out(node, pn_ia32_Dec_res);
2801         bemit8(0x48 + reg_gp_map[out->index]);
2802 }
2803
2804 static void bemit_inc(const ir_node *node)
2805 {
2806         const arch_register_t *out = arch_get_irn_register_out(node, pn_ia32_Inc_res);
2807         bemit8(0x40 + reg_gp_map[out->index]);
2808 }
2809
2810 #define UNOPMEM(op, code, ext) \
2811 static void bemit_##op(const ir_node *node) \
2812 { \
2813         bemit_unop_mem(node, code, ext); \
2814 }
2815
2816 UNOPMEM(notmem, 0xF6, 2)
2817 UNOPMEM(negmem, 0xF6, 3)
2818 UNOPMEM(incmem, 0xFE, 0)
2819 UNOPMEM(decmem, 0xFE, 1)
2820
2821 static void bemit_ldtls(const ir_node *node)
2822 {
2823         const arch_register_t *out = arch_get_irn_register_out(node, 0);
2824
2825         bemit8(0x65); // gs:
2826         if (out->index == REG_GP_EAX) {
2827                 bemit8(0xA1); // movl 0, %eax
2828         } else {
2829                 bemit8(0x8B); // movl 0, %reg
2830                 bemit8(MOD_IND | ENC_REG(reg_gp_map[out->index]) | ENC_RM(0x05));
2831         }
2832         bemit32(0);
2833 }
2834
2835 /**
2836  * Emit a Lea.
2837  */
2838 static void bemit_lea(const ir_node *node)
2839 {
2840         const arch_register_t *out = arch_get_irn_register_out(node, 0);
2841         bemit8(0x8D);
2842         bemit_mod_am(reg_gp_map[out->index], node);
2843 }
2844
2845 /* helper function for bemit_minus64bit */
2846 static void bemit_helper_mov(const arch_register_t *src, const arch_register_t *dst)
2847 {
2848         bemit8(0x8B); // movl %src, %dst
2849         bemit_modrr(src, dst);
2850 }
2851
2852 /* helper function for bemit_minus64bit */
2853 static void bemit_helper_neg(const arch_register_t *reg)
2854 {
2855         bemit8(0xF7); // negl %reg
2856         bemit_modru(reg, 3);
2857 }
2858
2859 /* helper function for bemit_minus64bit */
2860 static void bemit_helper_sbb0(const arch_register_t *reg)
2861 {
2862         bemit8(0x83); // sbbl $0, %reg
2863         bemit_modru(reg, 3);
2864         bemit8(0);
2865 }
2866
2867 /* helper function for bemit_minus64bit */
2868 static void bemit_helper_sbb(const arch_register_t *src, const arch_register_t *dst)
2869 {
2870         bemit8(0x1B); // sbbl %src, %dst
2871         bemit_modrr(src, dst);
2872 }
2873
2874 /* helper function for bemit_minus64bit */
2875 static void bemit_helper_xchg(const arch_register_t *src, const arch_register_t *dst)
2876 {
2877         if (src->index == REG_GP_EAX) {
2878                 bemit8(0x90 + reg_gp_map[dst->index]); // xchgl %eax, %dst
2879         } else if (dst->index == REG_GP_EAX) {
2880                 bemit8(0x90 + reg_gp_map[src->index]); // xchgl %src, %eax
2881         } else {
2882                 bemit8(0x87); // xchgl %src, %dst
2883                 bemit_modrr(src, dst);
2884         }
2885 }
2886
2887 /* helper function for bemit_minus64bit */
2888 static void bemit_helper_zero(const arch_register_t *reg)
2889 {
2890         bemit8(0x33); // xorl %reg, %reg
2891         bemit_modrr(reg, reg);
2892 }
2893
2894 static void bemit_minus64bit(const ir_node *node)
2895 {
2896         const arch_register_t *in_lo  = arch_get_irn_register_in(node, 0);
2897         const arch_register_t *in_hi  = arch_get_irn_register_in(node, 1);
2898         const arch_register_t *out_lo = arch_get_irn_register_out(node, 0);
2899         const arch_register_t *out_hi = arch_get_irn_register_out(node, 1);
2900
2901         if (out_lo == in_lo) {
2902                 if (out_hi != in_hi) {
2903                         /* a -> a, b -> d */
2904                         goto zero_neg;
2905                 } else {
2906                         /* a -> a, b -> b */
2907                         goto normal_neg;
2908                 }
2909         } else if (out_lo == in_hi) {
2910                 if (out_hi == in_lo) {
2911                         /* a -> b, b -> a */
2912                         bemit_helper_xchg(in_lo, in_hi);
2913                         goto normal_neg;
2914                 } else {
2915                         /* a -> b, b -> d */
2916                         bemit_helper_mov(in_hi, out_hi);
2917                         bemit_helper_mov(in_lo, out_lo);
2918                         goto normal_neg;
2919                 }
2920         } else {
2921                 if (out_hi == in_lo) {
2922                         /* a -> c, b -> a */
2923                         bemit_helper_mov(in_lo, out_lo);
2924                         goto zero_neg;
2925                 } else if (out_hi == in_hi) {
2926                         /* a -> c, b -> b */
2927                         bemit_helper_mov(in_lo, out_lo);
2928                         goto normal_neg;
2929                 } else {
2930                         /* a -> c, b -> d */
2931                         bemit_helper_mov(in_lo, out_lo);
2932                         goto zero_neg;
2933                 }
2934         }
2935
2936 normal_neg:
2937         bemit_helper_neg( out_hi);
2938         bemit_helper_neg( out_lo);
2939         bemit_helper_sbb0(out_hi);
2940         return;
2941
2942 zero_neg:
2943         bemit_helper_zero(out_hi);
2944         bemit_helper_neg( out_lo);
2945         bemit_helper_sbb( in_hi, out_hi);
2946 }
2947
2948 /**
2949  * Emit a single opcode.
2950  */
2951 #define EMIT_SINGLEOP(op, code)                 \
2952 static void bemit_ ## op(const ir_node *node) { \
2953         (void) node;                                \
2954         bemit8(code);                               \
2955 }
2956
2957 //EMIT_SINGLEOP(daa,  0x27)
2958 //EMIT_SINGLEOP(das,  0x2F)
2959 //EMIT_SINGLEOP(aaa,  0x37)
2960 //EMIT_SINGLEOP(aas,  0x3F)
2961 //EMIT_SINGLEOP(nop,  0x90)
2962 EMIT_SINGLEOP(cwtl,  0x98)
2963 EMIT_SINGLEOP(cltd,  0x99)
2964 //EMIT_SINGLEOP(fwait, 0x9B)
2965 EMIT_SINGLEOP(sahf,  0x9E)
2966 //EMIT_SINGLEOP(popf, 0x9D)
2967 EMIT_SINGLEOP(leave, 0xC9)
2968 EMIT_SINGLEOP(int3,  0xCC)
2969 //EMIT_SINGLEOP(iret, 0xCF)
2970 //EMIT_SINGLEOP(xlat, 0xD7)
2971 //EMIT_SINGLEOP(lock, 0xF0)
2972 EMIT_SINGLEOP(rep,   0xF3)
2973 //EMIT_SINGLEOP(halt, 0xF4)
2974 EMIT_SINGLEOP(cmc,   0xF5)
2975 EMIT_SINGLEOP(stc,   0xF9)
2976 //EMIT_SINGLEOP(cli,  0xFA)
2977 //EMIT_SINGLEOP(sti,  0xFB)
2978 //EMIT_SINGLEOP(std,  0xFD)
2979
2980 /**
2981  * Emits a MOV out, [MEM].
2982  */
2983 static void bemit_load(const ir_node *node)
2984 {
2985         const arch_register_t *out = arch_get_irn_register_out(node, 0);
2986
2987         if (out->index == REG_GP_EAX) {
2988                 ir_node   *base      = get_irn_n(node, n_ia32_base);
2989                 int        has_base  = !is_ia32_NoReg_GP(base);
2990                 ir_node   *idx       = get_irn_n(node, n_ia32_index);
2991                 int        has_index = !is_ia32_NoReg_GP(idx);
2992                 if (!has_base && !has_index) {
2993                         ir_entity *ent  = get_ia32_am_sc(node);
2994                         int        offs = get_ia32_am_offs_int(node);
2995                         /* load from constant address to EAX can be encoded
2996                            as 0xA1 [offset] */
2997                         bemit8(0xA1);
2998                         bemit_entity(ent, 0, offs, false);
2999                         return;
3000                 }
3001         }
3002         bemit8(0x8B);
3003         bemit_mod_am(reg_gp_map[out->index], node);
3004 }
3005
3006 /**
3007  * Emits a MOV [mem], in.
3008  */
3009 static void bemit_store(const ir_node *node)
3010 {
3011         const ir_node *value = get_irn_n(node, n_ia32_Store_val);
3012         unsigned       size  = get_mode_size_bits(get_ia32_ls_mode(node));
3013
3014         if (is_ia32_Immediate(value)) {
3015                 if (size == 8) {
3016                         bemit8(0xC6);
3017                         bemit_mod_am(0, node);
3018                         bemit8(get_ia32_immediate_attr_const(value)->offset);
3019                 } else if (size == 16) {
3020                         bemit8(0x66);
3021                         bemit8(0xC7);
3022                         bemit_mod_am(0, node);
3023                         bemit16(get_ia32_immediate_attr_const(value)->offset);
3024                 } else {
3025                         bemit8(0xC7);
3026                         bemit_mod_am(0, node);
3027                         bemit_immediate(value, false);
3028                 }
3029         } else {
3030                 const arch_register_t *in = arch_get_irn_register_in(node, n_ia32_Store_val);
3031
3032                 if (in->index == REG_GP_EAX) {
3033                         ir_node   *base      = get_irn_n(node, n_ia32_base);
3034                         int        has_base  = !is_ia32_NoReg_GP(base);
3035                         ir_node   *idx       = get_irn_n(node, n_ia32_index);
3036                         int        has_index = !is_ia32_NoReg_GP(idx);
3037                         if (!has_base && !has_index) {
3038                                 ir_entity *ent  = get_ia32_am_sc(node);
3039                                 int        offs = get_ia32_am_offs_int(node);
3040                                 /* store to constant address from EAX can be encoded as
3041                                  * 0xA2/0xA3 [offset]*/
3042                                 if (size == 8) {
3043                                         bemit8(0xA2);
3044                                 } else {
3045                                         if (size == 16)
3046                                                 bemit8(0x66);
3047                                         bemit8(0xA3);
3048                                 }
3049                                 bemit_entity(ent, 0, offs, false);
3050                                 return;
3051                         }
3052                 }
3053
3054                 if (size == 8) {
3055                         bemit8(0x88);
3056                 } else {
3057                         if (size == 16)
3058                                 bemit8(0x66);
3059                         bemit8(0x89);
3060                 }
3061                 bemit_mod_am(reg_gp_map[in->index], node);
3062         }
3063 }
3064
3065 static void bemit_conv_i2i(const ir_node *node)
3066 {
3067         ir_mode  *smaller_mode = get_ia32_ls_mode(node);
3068         unsigned  opcode;
3069
3070         bemit8(0x0F);
3071         /*        8 16 bit source
3072          * movzx B6 B7
3073          * movsx BE BF
3074          */
3075         opcode = 0xB6;
3076         if (mode_is_signed(smaller_mode))           opcode |= 0x08;
3077         if (get_mode_size_bits(smaller_mode) == 16) opcode |= 0x01;
3078         bemit_unop_reg(node, opcode, n_ia32_Conv_I2I_val);
3079 }
3080
3081 /**
3082  * Emit a Push.
3083  */
3084 static void bemit_push(const ir_node *node)
3085 {
3086         const ir_node *value = get_irn_n(node, n_ia32_Push_val);
3087
3088         if (is_ia32_Immediate(value)) {
3089                 const ia32_immediate_attr_t *attr
3090                         = get_ia32_immediate_attr_const(value);
3091                 unsigned size = get_signed_imm_size(attr->offset);
3092                 if (attr->symconst)
3093                         size = 4;
3094                 switch (size) {
3095                 case 1:
3096                         bemit8(0x6A);
3097                         bemit8((unsigned char)attr->offset);
3098                         break;
3099                 case 2:
3100                 case 4:
3101                         bemit8(0x68);
3102                         bemit_immediate(value, false);
3103                         break;
3104                 }
3105         } else if (is_ia32_NoReg_GP(value)) {
3106                 bemit8(0xFF);
3107                 bemit_mod_am(6, node);
3108         } else {
3109                 const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_Push_val);
3110                 bemit8(0x50 + reg_gp_map[reg->index]);
3111         }
3112 }
3113
3114 /**
3115  * Emit a Pop.
3116  */
3117 static void bemit_pop(const ir_node *node)
3118 {
3119         const arch_register_t *reg = arch_get_irn_register_out(node, pn_ia32_Pop_res);
3120         bemit8(0x58 + reg_gp_map[reg->index]);
3121 }
3122
3123 static void bemit_popmem(const ir_node *node)
3124 {
3125         bemit8(0x8F);
3126         bemit_mod_am(0, node);
3127 }
3128
3129 static void bemit_call(const ir_node *node)
3130 {
3131         ir_node *proc = get_irn_n(node, n_ia32_Call_addr);
3132
3133         if (is_ia32_Immediate(proc)) {
3134                 bemit8(0xE8);
3135                 bemit_immediate(proc, true);
3136         } else {
3137                 bemit_unop(node, 0xFF, 2, n_ia32_Call_addr);
3138         }
3139 }
3140
3141 static void bemit_jmp(const ir_node *dest_block)
3142 {
3143         bemit8(0xE9);
3144         bemit_jmp_destination(dest_block);
3145 }
3146
3147 static void bemit_jump(const ir_node *node)
3148 {
3149         if (can_be_fallthrough(node))
3150                 return;
3151
3152         bemit_jmp(get_cfop_target_block(node));
3153 }
3154
3155 static void bemit_jcc(int pnc, const ir_node *dest_block)
3156 {
3157         unsigned char cc = pnc2cc(pnc);
3158         bemit8(0x0F);
3159         bemit8(0x80 + cc);
3160         bemit_jmp_destination(dest_block);
3161 }
3162
3163 static void bemit_jp(bool odd, const ir_node *dest_block)
3164 {
3165         bemit8(0x0F);
3166         bemit8(0x8A + odd);
3167         bemit_jmp_destination(dest_block);
3168 }
3169
3170 static void bemit_ia32_jcc(const ir_node *node)
3171 {
3172         ia32_condition_code_t cc = get_ia32_condcode(node);
3173         const ir_node        *proj_true;
3174         const ir_node        *proj_false;
3175         const ir_node        *dest_true;
3176         const ir_node        *dest_false;
3177
3178         cc = determine_final_cc(node, 0, cc);
3179
3180         /* get both Projs */
3181         proj_true = get_proj(node, pn_ia32_Jcc_true);
3182         assert(proj_true && "Jcc without true Proj");
3183
3184         proj_false = get_proj(node, pn_ia32_Jcc_false);
3185         assert(proj_false && "Jcc without false Proj");
3186
3187         if (can_be_fallthrough(proj_true)) {
3188                 /* exchange both proj's so the second one can be omitted */
3189                 const ir_node *t = proj_true;
3190
3191                 proj_true  = proj_false;
3192                 proj_false = t;
3193                 cc         = ia32_negate_condition_code(cc);
3194         }
3195
3196         dest_true  = get_cfop_target_block(proj_true);
3197         dest_false = get_cfop_target_block(proj_false);
3198
3199         if (cc & ia32_cc_float_parity_cases) {
3200                 /* Some floating point comparisons require a test of the parity flag,
3201                  * which indicates that the result is unordered */
3202                 if (cc & ia32_cc_negated) {
3203                         bemit_jp(false, dest_true);
3204                 } else {
3205                         /* we need a local label if the false proj is a fallthrough
3206                          * as the falseblock might have no label emitted then */
3207                         if (can_be_fallthrough(proj_false)) {
3208                                 bemit8(0x7A);
3209                                 bemit8(0x06);  // jp + 6
3210                         } else {
3211                                 bemit_jp(false, dest_false);
3212                         }
3213                 }
3214         }
3215         bemit_jcc(cc, dest_true);
3216
3217         /* the second Proj might be a fallthrough */
3218         if (can_be_fallthrough(proj_false)) {
3219                 /* it's a fallthrough */
3220         } else {
3221                 bemit_jmp(dest_false);
3222         }
3223 }
3224
3225 static void bemit_switchjmp(const ir_node *node)
3226 {
3227         ir_entity *jump_table = get_ia32_am_sc(node);
3228         long       default_pn = get_ia32_default_pn(node);
3229
3230         bemit8(0xFF); // jmp *tbl.label(,%in,4)
3231         bemit_mod_am(0x05, node);
3232
3233         emit_jump_table(node, default_pn, jump_table, get_cfop_target_block);
3234 }
3235
3236 /**
3237  * Emits a return.
3238  */
3239 static void bemit_return(const ir_node *node)
3240 {
3241         unsigned pop = be_Return_get_pop(node);
3242         if (pop > 0 || be_Return_get_emit_pop(node)) {
3243                 bemit8(0xC2);
3244                 assert(pop <= 0xffff);
3245                 bemit16(pop);
3246         } else {
3247                 bemit8(0xC3);
3248         }
3249 }
3250
3251 static void bemit_subsp(const ir_node *node)
3252 {
3253         const arch_register_t *out;
3254         /* sub %in, %esp */
3255         bemit_sub(node);
3256         /* mov %esp, %out */
3257         bemit8(0x8B);
3258         out = arch_get_irn_register_out(node, 1);
3259         bemit8(MOD_REG | ENC_REG(reg_gp_map[out->index]) | ENC_RM(0x04));
3260 }
3261
3262 static void bemit_incsp(const ir_node *node)
3263 {
3264         int                    offs;
3265         const arch_register_t *reg;
3266         unsigned               size;
3267         unsigned               ext;
3268
3269         offs = be_get_IncSP_offset(node);
3270         if (offs == 0)
3271                 return;
3272
3273         if (offs > 0) {
3274                 ext = 5; /* sub */
3275         } else {
3276                 ext = 0; /* add */
3277                 offs = -offs;
3278         }
3279
3280         size = get_signed_imm_size(offs);
3281         bemit8(size == 1 ? 0x83 : 0x81);
3282
3283         reg  = arch_get_irn_register_out(node, 0);
3284         bemit_modru(reg, ext);
3285
3286         if (size == 1) {
3287                 bemit8(offs);
3288         } else {
3289                 bemit32(offs);
3290         }
3291 }
3292
3293 static void bemit_copybi(const ir_node *node)
3294 {
3295         unsigned size = get_ia32_copyb_size(node);
3296         if (size & 1)
3297                 bemit8(0xA4); // movsb
3298         if (size & 2) {
3299                 bemit8(0x66);
3300                 bemit8(0xA5); // movsw
3301         }
3302         size >>= 2;
3303         while (size--) {
3304                 bemit8(0xA5); // movsl
3305         }
3306 }
3307
3308 static void bemit_fbinop(const ir_node *node, unsigned code, unsigned code_to)
3309 {
3310         if (get_ia32_op_type(node) == ia32_Normal) {
3311                 const ia32_x87_attr_t *x87_attr = get_ia32_x87_attr_const(node);
3312                 const arch_register_t *in1      = x87_attr->x87[0];
3313                 const arch_register_t *in       = x87_attr->x87[1];
3314                 const arch_register_t *out      = x87_attr->x87[2];
3315
3316                 if (out == NULL) {
3317                         out = in1;
3318                 } else if (out == in) {
3319                         in = in1;
3320                 }
3321
3322                 if (out->index == 0) {
3323                         bemit8(0xD8);
3324                         bemit8(MOD_REG | ENC_REG(code) | ENC_RM(in->index));
3325                 } else {
3326                         bemit8(0xDC);
3327                         bemit8(MOD_REG | ENC_REG(code_to) | ENC_RM(out->index));
3328                 }
3329         } else {
3330                 if (get_mode_size_bits(get_ia32_ls_mode(node)) == 32) {
3331                         bemit8(0xD8);
3332                 } else {
3333                         bemit8(0xDC);
3334                 }
3335                 bemit_mod_am(code, node);
3336         }
3337 }
3338
3339 static void bemit_fbinopp(const ir_node *node, unsigned const code)
3340 {
3341         const ia32_x87_attr_t *x87_attr = get_ia32_x87_attr_const(node);
3342         const arch_register_t *out      = x87_attr->x87[2];
3343         bemit8(0xDE);
3344         bemit8(code + out->index);
3345 }
3346
3347 static void bemit_fabs(const ir_node *node)
3348 {
3349         (void)node;
3350
3351         bemit8(0xD9);
3352         bemit8(0xE1);
3353 }
3354
3355 static void bemit_fadd(const ir_node *node)
3356 {
3357         bemit_fbinop(node, 0, 0);
3358 }
3359
3360 static void bemit_faddp(const ir_node *node)
3361 {
3362         bemit_fbinopp(node, 0xC0);
3363 }
3364
3365 static void bemit_fchs(const ir_node *node)
3366 {
3367         (void)node;
3368
3369         bemit8(0xD9);
3370         bemit8(0xE0);
3371 }
3372
3373 static void bemit_fdiv(const ir_node *node)
3374 {
3375         bemit_fbinop(node, 6, 7);
3376 }
3377
3378 static void bemit_fdivp(const ir_node *node)
3379 {
3380         bemit_fbinopp(node, 0xF8);
3381 }
3382
3383 static void bemit_fdivr(const ir_node *node)
3384 {
3385         bemit_fbinop(node, 7, 6);
3386 }
3387
3388 static void bemit_fdivrp(const ir_node *node)
3389 {
3390         bemit_fbinopp(node, 0xF0);
3391 }
3392
3393 static void bemit_fild(const ir_node *node)
3394 {
3395         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3396                 case 16:
3397                         bemit8(0xDF); // filds
3398                         bemit_mod_am(0, node);
3399                         return;
3400
3401                 case 32:
3402                         bemit8(0xDB); // fildl
3403                         bemit_mod_am(0, node);
3404                         return;
3405
3406                 case 64:
3407                         bemit8(0xDF); // fildll
3408                         bemit_mod_am(5, node);
3409                         return;
3410
3411                 default:
3412                         panic("invalid mode size");
3413         }
3414 }
3415
3416 static void bemit_fist(const ir_node *node)
3417 {
3418         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3419                 case 16:
3420                         bemit8(0xDF); // fists
3421                         break;
3422
3423                 case 32:
3424                         bemit8(0xDB); // fistl
3425                         break;
3426
3427                 default:
3428                         panic("invalid mode size");
3429         }
3430         bemit_mod_am(2, node);
3431 }
3432
3433 static void bemit_fistp(const ir_node *node)
3434 {
3435         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3436                 case 16:
3437                         bemit8(0xDF); // fistps
3438                         bemit_mod_am(3, node);
3439                         return;
3440
3441                 case 32:
3442                         bemit8(0xDB); // fistpl
3443                         bemit_mod_am(3, node);
3444                         return;
3445
3446                 case 64:
3447                         bemit8(0xDF); // fistpll
3448                         bemit_mod_am(7, node);
3449                         return;
3450
3451                 default:
3452                         panic("invalid mode size");
3453         }
3454 }
3455
3456 static void bemit_fld(const ir_node *node)
3457 {
3458         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3459                 case 32:
3460                         bemit8(0xD9); // flds
3461                         bemit_mod_am(0, node);
3462                         return;
3463
3464                 case 64:
3465                         bemit8(0xDD); // fldl
3466                         bemit_mod_am(0, node);
3467                         return;
3468
3469                 case 80:
3470                 case 96:
3471                         bemit8(0xDB); // fldt
3472                         bemit_mod_am(5, node);
3473                         return;
3474
3475                 default:
3476                         panic("invalid mode size");
3477         }
3478 }
3479
3480 static void bemit_fld1(const ir_node *node)
3481 {
3482         (void)node;
3483         bemit8(0xD9);
3484         bemit8(0xE8); // fld1
3485 }
3486
3487 static void bemit_fldcw(const ir_node *node)
3488 {
3489         bemit8(0xD9); // fldcw
3490         bemit_mod_am(5, node);
3491 }
3492
3493 static void bemit_fldz(const ir_node *node)
3494 {
3495         (void)node;
3496         bemit8(0xD9);
3497         bemit8(0xEE); // fldz
3498 }
3499
3500 static void bemit_fmul(const ir_node *node)
3501 {
3502         bemit_fbinop(node, 1, 1);
3503 }
3504
3505 static void bemit_fmulp(const ir_node *node)
3506 {
3507         bemit_fbinopp(node, 0xC8);
3508 }
3509
3510 static void bemit_fpop(const ir_node *node)
3511 {
3512         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3513         bemit8(0xDD);
3514         bemit8(0xD8 + attr->x87[0]->index);
3515 }
3516
3517 static void bemit_fpush(const ir_node *node)
3518 {
3519         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3520         bemit8(0xD9);
3521         bemit8(0xC0 + attr->x87[0]->index);
3522 }
3523
3524 static void bemit_fpushcopy(const ir_node *node)
3525 {
3526         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3527         bemit8(0xD9);
3528         bemit8(0xC0 + attr->x87[0]->index);
3529 }
3530
3531 static void bemit_fst(const ir_node *node)
3532 {
3533         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3534                 case 32:
3535                         bemit8(0xD9); // fsts
3536                         break;
3537
3538                 case 64:
3539                         bemit8(0xDD); // fstl
3540                         break;
3541
3542                 default:
3543                         panic("invalid mode size");
3544         }
3545         bemit_mod_am(2, node);
3546 }
3547
3548 static void bemit_fstp(const ir_node *node)
3549 {
3550         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3551                 case 32:
3552                         bemit8(0xD9); // fstps
3553                         bemit_mod_am(3, node);
3554                         return;
3555
3556                 case 64:
3557                         bemit8(0xDD); // fstpl
3558                         bemit_mod_am(3, node);
3559                         return;
3560
3561                 case 80:
3562                 case 96:
3563                         bemit8(0xDB); // fstpt
3564                         bemit_mod_am(7, node);
3565                         return;
3566
3567                 default:
3568                         panic("invalid mode size");
3569         }
3570 }
3571
3572 static void bemit_fsub(const ir_node *node)
3573 {
3574         bemit_fbinop(node, 4, 5);
3575 }
3576
3577 static void bemit_fsubp(const ir_node *node)
3578 {
3579         bemit_fbinopp(node, 0xE8);
3580 }
3581
3582 static void bemit_fsubr(const ir_node *node)
3583 {
3584         bemit_fbinop(node, 5, 4);
3585 }
3586
3587 static void bemit_fsubrp(const ir_node *node)
3588 {
3589         bemit_fbinopp(node, 0xE0);
3590 }
3591
3592 static void bemit_fnstcw(const ir_node *node)
3593 {
3594         bemit8(0xD9); // fnstcw
3595         bemit_mod_am(7, node);
3596 }
3597
3598 static void bemit_fnstsw(void)
3599 {
3600         bemit8(0xDF); // fnstsw %ax
3601         bemit8(0xE0);
3602 }
3603
3604 static void bemit_ftstfnstsw(const ir_node *node)
3605 {
3606         (void)node;
3607
3608         bemit8(0xD9); // ftst
3609         bemit8(0xE4);
3610         bemit_fnstsw();
3611 }
3612
3613 static void bemit_fucomi(const ir_node *node)
3614 {
3615         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3616         bemit8(0xDB); // fucomi
3617         bemit8(0xE8 + attr->x87[1]->index);
3618 }
3619
3620 static void bemit_fucomip(const ir_node *node)
3621 {
3622         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3623         bemit8(0xDF); // fucomip
3624         bemit8(0xE8 + attr->x87[1]->index);
3625 }
3626
3627 static void bemit_fucomfnstsw(const ir_node *node)
3628 {
3629         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3630         bemit8(0xDD); // fucom
3631         bemit8(0xE0 + attr->x87[1]->index);
3632         bemit_fnstsw();
3633 }
3634
3635 static void bemit_fucompfnstsw(const ir_node *node)
3636 {
3637         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3638         bemit8(0xDD); // fucomp
3639         bemit8(0xE8 + attr->x87[1]->index);
3640         bemit_fnstsw();
3641 }
3642
3643 static void bemit_fucomppfnstsw(const ir_node *node)
3644 {
3645         (void)node;
3646
3647         bemit8(0xDA); // fucompp
3648         bemit8(0xE9);
3649         bemit_fnstsw();
3650 }
3651
3652 static void bemit_fxch(const ir_node *node)
3653 {
3654         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3655         bemit8(0xD9);
3656         bemit8(0xC8 + attr->x87[0]->index);
3657 }
3658
3659 /**
3660  * The type of a emitter function.
3661  */
3662 typedef void (*emit_func) (const ir_node *);
3663
3664 /**
3665  * Set a node emitter. Make it a bit more type safe.
3666  */
3667 static void register_emitter(ir_op *op, emit_func func)
3668 {
3669         op->ops.generic = (op_func) func;
3670 }
3671
3672 static void ia32_register_binary_emitters(void)
3673 {
3674         /* first clear the generic function pointer for all ops */
3675         clear_irp_opcodes_generic_func();
3676
3677         /* benode emitter */
3678         register_emitter(op_be_Copy,            bemit_copy);
3679         register_emitter(op_be_CopyKeep,        bemit_copy);
3680         register_emitter(op_be_IncSP,           bemit_incsp);
3681         register_emitter(op_be_Perm,            bemit_perm);
3682         register_emitter(op_be_Return,          bemit_return);
3683         register_emitter(op_ia32_Adc,           bemit_adc);
3684         register_emitter(op_ia32_Add,           bemit_add);
3685         register_emitter(op_ia32_AddMem,        bemit_addmem);
3686         register_emitter(op_ia32_AddMem8Bit,    bemit_addmem8bit);
3687         register_emitter(op_ia32_And,           bemit_and);
3688         register_emitter(op_ia32_AndMem,        bemit_andmem);
3689         register_emitter(op_ia32_AndMem8Bit,    bemit_andmem8bit);
3690         register_emitter(op_ia32_Breakpoint,    bemit_int3);
3691         register_emitter(op_ia32_CMovcc,        bemit_cmovcc);
3692         register_emitter(op_ia32_Call,          bemit_call);
3693         register_emitter(op_ia32_Cltd,          bemit_cltd);
3694         register_emitter(op_ia32_Cmc,           bemit_cmc);
3695         register_emitter(op_ia32_Cmp,           bemit_cmp);
3696         register_emitter(op_ia32_Cmp8Bit,       bemit_cmp8bit);
3697         register_emitter(op_ia32_Const,         bemit_mov_const);
3698         register_emitter(op_ia32_Conv_I2I,      bemit_conv_i2i);
3699         register_emitter(op_ia32_Conv_I2I8Bit,  bemit_conv_i2i);
3700         register_emitter(op_ia32_CopyB_i,       bemit_copybi);
3701         register_emitter(op_ia32_Cwtl,          bemit_cwtl);
3702         register_emitter(op_ia32_Dec,           bemit_dec);
3703         register_emitter(op_ia32_DecMem,        bemit_decmem);
3704         register_emitter(op_ia32_Div,           bemit_div);
3705         register_emitter(op_ia32_FldCW,         bemit_fldcw);
3706         register_emitter(op_ia32_FnstCW,        bemit_fnstcw);
3707         register_emitter(op_ia32_FtstFnstsw,    bemit_ftstfnstsw);
3708         register_emitter(op_ia32_FucomFnstsw,   bemit_fucomfnstsw);
3709         register_emitter(op_ia32_Fucomi,        bemit_fucomi);
3710         register_emitter(op_ia32_FucompFnstsw,  bemit_fucompfnstsw);
3711         register_emitter(op_ia32_Fucompi,       bemit_fucomip);
3712         register_emitter(op_ia32_FucomppFnstsw, bemit_fucomppfnstsw);
3713         register_emitter(op_ia32_IDiv,          bemit_idiv);
3714         register_emitter(op_ia32_IJmp,          bemit_ijmp);
3715         register_emitter(op_ia32_IMul,          bemit_imul);
3716         register_emitter(op_ia32_IMul1OP,       bemit_imul1op);
3717         register_emitter(op_ia32_Inc,           bemit_inc);
3718         register_emitter(op_ia32_IncMem,        bemit_incmem);
3719         register_emitter(op_ia32_Jcc,           bemit_ia32_jcc);
3720         register_emitter(op_ia32_Jmp,           bemit_jump);
3721         register_emitter(op_ia32_LdTls,         bemit_ldtls);
3722         register_emitter(op_ia32_Lea,           bemit_lea);
3723         register_emitter(op_ia32_Leave,         bemit_leave);
3724         register_emitter(op_ia32_Load,          bemit_load);
3725         register_emitter(op_ia32_Minus64Bit,    bemit_minus64bit);
3726         register_emitter(op_ia32_Mul,           bemit_mul);
3727         register_emitter(op_ia32_Neg,           bemit_neg);
3728         register_emitter(op_ia32_NegMem,        bemit_negmem);
3729         register_emitter(op_ia32_Not,           bemit_not);
3730         register_emitter(op_ia32_NotMem,        bemit_notmem);
3731         register_emitter(op_ia32_Or,            bemit_or);
3732         register_emitter(op_ia32_OrMem,         bemit_ormem);
3733         register_emitter(op_ia32_OrMem8Bit,     bemit_ormem8bit);
3734         register_emitter(op_ia32_Pop,           bemit_pop);
3735         register_emitter(op_ia32_PopEbp,        bemit_pop);
3736         register_emitter(op_ia32_PopMem,        bemit_popmem);
3737         register_emitter(op_ia32_Push,          bemit_push);
3738         register_emitter(op_ia32_RepPrefix,     bemit_rep);
3739         register_emitter(op_ia32_Rol,           bemit_rol);
3740         register_emitter(op_ia32_RolMem,        bemit_rolmem);
3741         register_emitter(op_ia32_Ror,           bemit_ror);
3742         register_emitter(op_ia32_RorMem,        bemit_rormem);
3743         register_emitter(op_ia32_Sahf,          bemit_sahf);
3744         register_emitter(op_ia32_Sar,           bemit_sar);
3745         register_emitter(op_ia32_SarMem,        bemit_sarmem);
3746         register_emitter(op_ia32_Sbb,           bemit_sbb);
3747         register_emitter(op_ia32_Setcc,         bemit_setcc);
3748         register_emitter(op_ia32_Shl,           bemit_shl);
3749         register_emitter(op_ia32_ShlD,          bemit_shld);
3750         register_emitter(op_ia32_ShlMem,        bemit_shlmem);
3751         register_emitter(op_ia32_Shr,           bemit_shr);
3752         register_emitter(op_ia32_ShrD,          bemit_shrd);
3753         register_emitter(op_ia32_ShrMem,        bemit_shrmem);
3754         register_emitter(op_ia32_Stc,           bemit_stc);
3755         register_emitter(op_ia32_Store,         bemit_store);
3756         register_emitter(op_ia32_Store8Bit,     bemit_store);
3757         register_emitter(op_ia32_Sub,           bemit_sub);
3758         register_emitter(op_ia32_SubMem,        bemit_submem);
3759         register_emitter(op_ia32_SubMem8Bit,    bemit_submem8bit);
3760         register_emitter(op_ia32_SubSP,         bemit_subsp);
3761         register_emitter(op_ia32_SwitchJmp,     bemit_switchjmp);
3762         register_emitter(op_ia32_Test,          bemit_test);
3763         register_emitter(op_ia32_Test8Bit,      bemit_test8bit);
3764         register_emitter(op_ia32_Xor,           bemit_xor);
3765         register_emitter(op_ia32_Xor0,          bemit_xor0);
3766         register_emitter(op_ia32_XorMem,        bemit_xormem);
3767         register_emitter(op_ia32_XorMem8Bit,    bemit_xormem8bit);
3768         register_emitter(op_ia32_fabs,          bemit_fabs);
3769         register_emitter(op_ia32_fadd,          bemit_fadd);
3770         register_emitter(op_ia32_faddp,         bemit_faddp);
3771         register_emitter(op_ia32_fchs,          bemit_fchs);
3772         register_emitter(op_ia32_fdiv,          bemit_fdiv);
3773         register_emitter(op_ia32_fdivp,         bemit_fdivp);
3774         register_emitter(op_ia32_fdivr,         bemit_fdivr);
3775         register_emitter(op_ia32_fdivrp,        bemit_fdivrp);
3776         register_emitter(op_ia32_fild,          bemit_fild);
3777         register_emitter(op_ia32_fist,          bemit_fist);
3778         register_emitter(op_ia32_fistp,         bemit_fistp);
3779         register_emitter(op_ia32_fld,           bemit_fld);
3780         register_emitter(op_ia32_fld1,          bemit_fld1);
3781         register_emitter(op_ia32_fldz,          bemit_fldz);
3782         register_emitter(op_ia32_fmul,          bemit_fmul);
3783         register_emitter(op_ia32_fmulp,         bemit_fmulp);
3784         register_emitter(op_ia32_fpop,          bemit_fpop);
3785         register_emitter(op_ia32_fpush,         bemit_fpush);
3786         register_emitter(op_ia32_fpushCopy,     bemit_fpushcopy);
3787         register_emitter(op_ia32_fst,           bemit_fst);
3788         register_emitter(op_ia32_fstp,          bemit_fstp);
3789         register_emitter(op_ia32_fsub,          bemit_fsub);
3790         register_emitter(op_ia32_fsubp,         bemit_fsubp);
3791         register_emitter(op_ia32_fsubr,         bemit_fsubr);
3792         register_emitter(op_ia32_fsubrp,        bemit_fsubrp);
3793         register_emitter(op_ia32_fxch,          bemit_fxch);
3794
3795         /* ignore the following nodes */
3796         register_emitter(op_ia32_ProduceVal,   emit_Nothing);
3797         register_emitter(op_be_Keep,           emit_Nothing);
3798         register_emitter(op_be_Start,          emit_Nothing);
3799         register_emitter(op_Phi,               emit_Nothing);
3800         register_emitter(op_Start,             emit_Nothing);
3801 }
3802
3803 static void gen_binary_block(ir_node *block)
3804 {
3805         ir_node *node;
3806
3807         ia32_emit_block_header(block);
3808
3809         /* emit the contents of the block */
3810         sched_foreach(block, node) {
3811                 ia32_emit_node(node);
3812         }
3813 }
3814
3815 void ia32_gen_binary_routine(ir_graph *irg)
3816 {
3817         ir_entity        *entity    = get_irg_entity(irg);
3818         const arch_env_t *arch_env  = be_get_irg_arch_env(irg);
3819         ia32_irg_data_t  *irg_data  = ia32_get_irg_data(irg);
3820         ir_node         **blk_sched = irg_data->blk_sched;
3821         size_t            i, n;
3822
3823         isa = (ia32_isa_t*) arch_env;
3824
3825         ia32_register_binary_emitters();
3826
3827         be_gas_emit_function_prolog(entity, ia32_cg_config.function_alignment);
3828
3829         /* we use links to point to target blocks */
3830         ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK);
3831         irg_block_walk_graph(irg, ia32_gen_labels, NULL, NULL);
3832
3833         /* initialize next block links */
3834         n = ARR_LEN(blk_sched);
3835         for (i = 0; i < n; ++i) {
3836                 ir_node *block = blk_sched[i];
3837                 ir_node *prev  = i > 0 ? blk_sched[i-1] : NULL;
3838
3839                 set_irn_link(block, prev);
3840         }
3841
3842         for (i = 0; i < n; ++i) {
3843                 ir_node *block = blk_sched[i];
3844                 gen_binary_block(block);
3845         }
3846
3847         be_gas_emit_function_epilog(entity);
3848         be_dbg_method_end();
3849         be_emit_char('\n');
3850         be_emit_write_line();
3851
3852         ir_free_resources(irg, IR_RESOURCE_IRN_LINK);
3853 }
3854
3855
3856 void ia32_init_emitter(void)
3857 {
3858         lc_opt_entry_t *be_grp;
3859         lc_opt_entry_t *ia32_grp;
3860
3861         be_grp   = lc_opt_get_grp(firm_opt_get_root(), "be");
3862         ia32_grp = lc_opt_get_grp(be_grp, "ia32");
3863
3864         lc_opt_add_table(ia32_grp, ia32_emitter_options);
3865
3866         build_reg_map();
3867
3868         FIRM_DBG_REGISTER(dbg, "firm.be.ia32.emitter");
3869 }