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

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