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 static void bemit_popcnt(ir_node const *const node)
2990 {
2991         bemit8(0xF3);
2992         bemit_0f_unop_reg(node, 0xB8, n_ia32_Popcnt_operand);
2993 }
2994
2995 /**
2996  * Emit a Push.
2997  */
2998 static void bemit_push(const ir_node *node)
2999 {
3000         const ir_node *value = get_irn_n(node, n_ia32_Push_val);
3001
3002         if (is_ia32_Immediate(value)) {
3003                 const ia32_immediate_attr_t *attr
3004                         = get_ia32_immediate_attr_const(value);
3005                 unsigned size = get_signed_imm_size(attr->offset);
3006                 if (attr->symconst)
3007                         size = 4;
3008                 switch (size) {
3009                 case 1:
3010                         bemit8(0x6A);
3011                         bemit8((unsigned char)attr->offset);
3012                         break;
3013                 case 2:
3014                 case 4:
3015                         bemit8(0x68);
3016                         bemit_immediate(value, false);
3017                         break;
3018                 }
3019         } else if (is_ia32_NoReg_GP(value)) {
3020                 bemit8(0xFF);
3021                 bemit_mod_am(6, node);
3022         } else {
3023                 const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_Push_val);
3024                 bemit8(0x50 + reg_gp_map[reg->index]);
3025         }
3026 }
3027
3028 /**
3029  * Emit a Pop.
3030  */
3031 static void bemit_pop(const ir_node *node)
3032 {
3033         const arch_register_t *reg = arch_get_irn_register_out(node, pn_ia32_Pop_res);
3034         bemit8(0x58 + reg_gp_map[reg->index]);
3035 }
3036
3037 static void bemit_popmem(const ir_node *node)
3038 {
3039         bemit8(0x8F);
3040         bemit_mod_am(0, node);
3041 }
3042
3043 static void bemit_call(const ir_node *node)
3044 {
3045         ir_node *proc = get_irn_n(node, n_ia32_Call_addr);
3046
3047         if (is_ia32_Immediate(proc)) {
3048                 bemit8(0xE8);
3049                 bemit_immediate(proc, true);
3050         } else {
3051                 bemit_unop(node, 0xFF, 2, n_ia32_Call_addr);
3052         }
3053 }
3054
3055 static void bemit_jmp(const ir_node *dest_block)
3056 {
3057         bemit8(0xE9);
3058         bemit_jmp_destination(dest_block);
3059 }
3060
3061 static void bemit_jump(const ir_node *node)
3062 {
3063         if (can_be_fallthrough(node))
3064                 return;
3065
3066         bemit_jmp(get_cfop_target_block(node));
3067 }
3068
3069 static void bemit_jcc(ia32_condition_code_t pnc, const ir_node *dest_block)
3070 {
3071         unsigned char cc = pnc2cc(pnc);
3072         bemit8(0x0F);
3073         bemit8(0x80 + cc);
3074         bemit_jmp_destination(dest_block);
3075 }
3076
3077 static void bemit_jp(bool odd, const ir_node *dest_block)
3078 {
3079         bemit8(0x0F);
3080         bemit8(0x8A + odd);
3081         bemit_jmp_destination(dest_block);
3082 }
3083
3084 static void bemit_ia32_jcc(const ir_node *node)
3085 {
3086         ia32_condition_code_t cc = get_ia32_condcode(node);
3087         const ir_node        *proj_true;
3088         const ir_node        *proj_false;
3089         const ir_node        *dest_true;
3090         const ir_node        *dest_false;
3091
3092         cc = determine_final_cc(node, 0, cc);
3093
3094         /* get both Projs */
3095         proj_true = get_proj(node, pn_ia32_Jcc_true);
3096         assert(proj_true && "Jcc without true Proj");
3097
3098         proj_false = get_proj(node, pn_ia32_Jcc_false);
3099         assert(proj_false && "Jcc without false Proj");
3100
3101         if (can_be_fallthrough(proj_true)) {
3102                 /* exchange both proj's so the second one can be omitted */
3103                 const ir_node *t = proj_true;
3104
3105                 proj_true  = proj_false;
3106                 proj_false = t;
3107                 cc         = ia32_negate_condition_code(cc);
3108         }
3109
3110         dest_true  = get_cfop_target_block(proj_true);
3111         dest_false = get_cfop_target_block(proj_false);
3112
3113         if (cc & ia32_cc_float_parity_cases) {
3114                 /* Some floating point comparisons require a test of the parity flag,
3115                  * which indicates that the result is unordered */
3116                 if (cc & ia32_cc_negated) {
3117                         bemit_jp(false, dest_true);
3118                 } else {
3119                         /* we need a local label if the false proj is a fallthrough
3120                          * as the falseblock might have no label emitted then */
3121                         if (can_be_fallthrough(proj_false)) {
3122                                 bemit8(0x7A);
3123                                 bemit8(0x06);  // jp + 6
3124                         } else {
3125                                 bemit_jp(false, dest_false);
3126                         }
3127                 }
3128         }
3129         bemit_jcc(cc, dest_true);
3130
3131         /* the second Proj might be a fallthrough */
3132         if (can_be_fallthrough(proj_false)) {
3133                 /* it's a fallthrough */
3134         } else {
3135                 bemit_jmp(dest_false);
3136         }
3137 }
3138
3139 static void bemit_switchjmp(const ir_node *node)
3140 {
3141         ir_entity             *jump_table = get_ia32_am_sc(node);
3142         const ir_switch_table *table      = get_ia32_switch_table(node);
3143
3144         bemit8(0xFF); // jmp *tbl.label(,%in,4)
3145         bemit_mod_am(0x05, node);
3146
3147         be_emit_jump_table(node, table, jump_table, get_cfop_target_block);
3148 }
3149
3150 /**
3151  * Emits a return.
3152  */
3153 static void bemit_return(const ir_node *node)
3154 {
3155         unsigned pop = be_Return_get_pop(node);
3156         if (pop > 0 || be_Return_get_emit_pop(node)) {
3157                 bemit8(0xC2);
3158                 assert(pop <= 0xffff);
3159                 bemit16(pop);
3160         } else {
3161                 bemit8(0xC3);
3162         }
3163 }
3164
3165 static void bemit_subsp(const ir_node *node)
3166 {
3167         const arch_register_t *out;
3168         /* sub %in, %esp */
3169         bemit_sub(node);
3170         /* mov %esp, %out */
3171         bemit8(0x8B);
3172         out = arch_get_irn_register_out(node, 1);
3173         bemit8(MOD_REG | ENC_REG(reg_gp_map[out->index]) | ENC_RM(0x04));
3174 }
3175
3176 static void bemit_incsp(const ir_node *node)
3177 {
3178         int                    offs;
3179         const arch_register_t *reg;
3180         unsigned               size;
3181         unsigned               ext;
3182
3183         offs = be_get_IncSP_offset(node);
3184         if (offs == 0)
3185                 return;
3186
3187         if (offs > 0) {
3188                 ext = 5; /* sub */
3189         } else {
3190                 ext = 0; /* add */
3191                 offs = -offs;
3192         }
3193
3194         size = get_signed_imm_size(offs);
3195         bemit8(size == 1 ? 0x83 : 0x81);
3196
3197         reg  = arch_get_irn_register_out(node, 0);
3198         bemit_modru(reg, ext);
3199
3200         if (size == 1) {
3201                 bemit8(offs);
3202         } else {
3203                 bemit32(offs);
3204         }
3205 }
3206
3207 static void bemit_copybi(const ir_node *node)
3208 {
3209         unsigned size = get_ia32_copyb_size(node);
3210         if (size & 1)
3211                 bemit8(0xA4); // movsb
3212         if (size & 2) {
3213                 bemit8(0x66);
3214                 bemit8(0xA5); // movsw
3215         }
3216         size >>= 2;
3217         while (size--) {
3218                 bemit8(0xA5); // movsl
3219         }
3220 }
3221
3222 static void bemit_fbinop(const ir_node *node, unsigned code, unsigned code_to)
3223 {
3224         if (get_ia32_op_type(node) == ia32_Normal) {
3225                 const ia32_x87_attr_t *x87_attr = get_ia32_x87_attr_const(node);
3226                 const arch_register_t *in1      = x87_attr->x87[0];
3227                 const arch_register_t *in       = x87_attr->x87[1];
3228                 const arch_register_t *out      = x87_attr->x87[2];
3229
3230                 if (out == NULL) {
3231                         out = in1;
3232                 } else if (out == in) {
3233                         in = in1;
3234                 }
3235
3236                 if (out->index == 0) {
3237                         bemit8(0xD8);
3238                         bemit8(MOD_REG | ENC_REG(code) | ENC_RM(in->index));
3239                 } else {
3240                         bemit8(0xDC);
3241                         bemit8(MOD_REG | ENC_REG(code_to) | ENC_RM(out->index));
3242                 }
3243         } else {
3244                 if (get_mode_size_bits(get_ia32_ls_mode(node)) == 32) {
3245                         bemit8(0xD8);
3246                 } else {
3247                         bemit8(0xDC);
3248                 }
3249                 bemit_mod_am(code, node);
3250         }
3251 }
3252
3253 static void bemit_fbinopp(const ir_node *node, unsigned const code)
3254 {
3255         const ia32_x87_attr_t *x87_attr = get_ia32_x87_attr_const(node);
3256         const arch_register_t *out      = x87_attr->x87[2];
3257         bemit8(0xDE);
3258         bemit8(code + out->index);
3259 }
3260
3261 static void bemit_fop_reg(ir_node const *const node, unsigned char const op0, unsigned char const op1)
3262 {
3263         bemit8(op0);
3264         bemit8(op1 + get_ia32_x87_attr_const(node)->x87[0]->index);
3265 }
3266
3267 static void bemit_fabs(const ir_node *node)
3268 {
3269         (void)node;
3270
3271         bemit8(0xD9);
3272         bemit8(0xE1);
3273 }
3274
3275 static void bemit_fadd(const ir_node *node)
3276 {
3277         bemit_fbinop(node, 0, 0);
3278 }
3279
3280 static void bemit_faddp(const ir_node *node)
3281 {
3282         bemit_fbinopp(node, 0xC0);
3283 }
3284
3285 static void bemit_fchs(const ir_node *node)
3286 {
3287         (void)node;
3288
3289         bemit8(0xD9);
3290         bemit8(0xE0);
3291 }
3292
3293 static void bemit_fdiv(const ir_node *node)
3294 {
3295         bemit_fbinop(node, 6, 7);
3296 }
3297
3298 static void bemit_fdivp(const ir_node *node)
3299 {
3300         bemit_fbinopp(node, 0xF8);
3301 }
3302
3303 static void bemit_fdivr(const ir_node *node)
3304 {
3305         bemit_fbinop(node, 7, 6);
3306 }
3307
3308 static void bemit_fdivrp(const ir_node *node)
3309 {
3310         bemit_fbinopp(node, 0xF0);
3311 }
3312
3313 static void bemit_ffreep(ir_node const *const node)
3314 {
3315         bemit_fop_reg(node, 0xDF, 0xC0);
3316 }
3317
3318 static void bemit_fild(const ir_node *node)
3319 {
3320         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3321                 case 16:
3322                         bemit8(0xDF); // filds
3323                         bemit_mod_am(0, node);
3324                         return;
3325
3326                 case 32:
3327                         bemit8(0xDB); // fildl
3328                         bemit_mod_am(0, node);
3329                         return;
3330
3331                 case 64:
3332                         bemit8(0xDF); // fildll
3333                         bemit_mod_am(5, node);
3334                         return;
3335
3336                 default:
3337                         panic("invalid mode size");
3338         }
3339 }
3340
3341 static void bemit_fist(const ir_node *node)
3342 {
3343         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3344                 case 16:
3345                         bemit8(0xDF); // fists
3346                         break;
3347
3348                 case 32:
3349                         bemit8(0xDB); // fistl
3350                         break;
3351
3352                 default:
3353                         panic("invalid mode size");
3354         }
3355         bemit_mod_am(2, node);
3356 }
3357
3358 static void bemit_fistp(const ir_node *node)
3359 {
3360         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3361                 case 16:
3362                         bemit8(0xDF); // fistps
3363                         bemit_mod_am(3, node);
3364                         return;
3365
3366                 case 32:
3367                         bemit8(0xDB); // fistpl
3368                         bemit_mod_am(3, node);
3369                         return;
3370
3371                 case 64:
3372                         bemit8(0xDF); // fistpll
3373                         bemit_mod_am(7, node);
3374                         return;
3375
3376                 default:
3377                         panic("invalid mode size");
3378         }
3379 }
3380
3381 static void bemit_fisttp(ir_node const *const node)
3382 {
3383         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3384         case 16: bemit8(0xDF); break; // fisttps
3385         case 32: bemit8(0xDB); break; // fisttpl
3386         case 64: bemit8(0xDD); break; // fisttpll
3387         default: panic("Invalid mode size");
3388         }
3389         bemit_mod_am(1, node);
3390 }
3391
3392 static void bemit_fld(const ir_node *node)
3393 {
3394         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3395                 case 32:
3396                         bemit8(0xD9); // flds
3397                         bemit_mod_am(0, node);
3398                         return;
3399
3400                 case 64:
3401                         bemit8(0xDD); // fldl
3402                         bemit_mod_am(0, node);
3403                         return;
3404
3405                 case 80:
3406                 case 96:
3407                         bemit8(0xDB); // fldt
3408                         bemit_mod_am(5, node);
3409                         return;
3410
3411                 default:
3412                         panic("invalid mode size");
3413         }
3414 }
3415
3416 static void bemit_fld1(const ir_node *node)
3417 {
3418         (void)node;
3419         bemit8(0xD9);
3420         bemit8(0xE8); // fld1
3421 }
3422
3423 static void bemit_fldcw(const ir_node *node)
3424 {
3425         bemit8(0xD9); // fldcw
3426         bemit_mod_am(5, node);
3427 }
3428
3429 static void bemit_fldz(const ir_node *node)
3430 {
3431         (void)node;
3432         bemit8(0xD9);
3433         bemit8(0xEE); // fldz
3434 }
3435
3436 static void bemit_fmul(const ir_node *node)
3437 {
3438         bemit_fbinop(node, 1, 1);
3439 }
3440
3441 static void bemit_fmulp(const ir_node *node)
3442 {
3443         bemit_fbinopp(node, 0xC8);
3444 }
3445
3446 static void bemit_fpop(const ir_node *node)
3447 {
3448         bemit_fop_reg(node, 0xDD, 0xD8);
3449 }
3450
3451 static void bemit_fpush(const ir_node *node)
3452 {
3453         bemit_fop_reg(node, 0xD9, 0xC0);
3454 }
3455
3456 static void bemit_fpushcopy(const ir_node *node)
3457 {
3458         bemit_fop_reg(node, 0xD9, 0xC0);
3459 }
3460
3461 static void bemit_fst(const ir_node *node)
3462 {
3463         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3464                 case 32:
3465                         bemit8(0xD9); // fsts
3466                         break;
3467
3468                 case 64:
3469                         bemit8(0xDD); // fstl
3470                         break;
3471
3472                 default:
3473                         panic("invalid mode size");
3474         }
3475         bemit_mod_am(2, node);
3476 }
3477
3478 static void bemit_fstp(const ir_node *node)
3479 {
3480         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3481                 case 32:
3482                         bemit8(0xD9); // fstps
3483                         bemit_mod_am(3, node);
3484                         return;
3485
3486                 case 64:
3487                         bemit8(0xDD); // fstpl
3488                         bemit_mod_am(3, node);
3489                         return;
3490
3491                 case 80:
3492                 case 96:
3493                         bemit8(0xDB); // fstpt
3494                         bemit_mod_am(7, node);
3495                         return;
3496
3497                 default:
3498                         panic("invalid mode size");
3499         }
3500 }
3501
3502 static void bemit_fsub(const ir_node *node)
3503 {
3504         bemit_fbinop(node, 4, 5);
3505 }
3506
3507 static void bemit_fsubp(const ir_node *node)
3508 {
3509         bemit_fbinopp(node, 0xE8);
3510 }
3511
3512 static void bemit_fsubr(const ir_node *node)
3513 {
3514         bemit_fbinop(node, 5, 4);
3515 }
3516
3517 static void bemit_fsubrp(const ir_node *node)
3518 {
3519         bemit_fbinopp(node, 0xE0);
3520 }
3521
3522 static void bemit_fnstcw(const ir_node *node)
3523 {
3524         bemit8(0xD9); // fnstcw
3525         bemit_mod_am(7, node);
3526 }
3527
3528 static void bemit_fnstsw(void)
3529 {
3530         bemit8(0xDF); // fnstsw %ax
3531         bemit8(0xE0);
3532 }
3533
3534 static void bemit_ftstfnstsw(const ir_node *node)
3535 {
3536         (void)node;
3537
3538         bemit8(0xD9); // ftst
3539         bemit8(0xE4);
3540         bemit_fnstsw();
3541 }
3542
3543 static void bemit_fucomi(const ir_node *node)
3544 {
3545         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3546         bemit8(0xDB); // fucomi
3547         bemit8(0xE8 + attr->x87[1]->index);
3548 }
3549
3550 static void bemit_fucomip(const ir_node *node)
3551 {
3552         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3553         bemit8(0xDF); // fucomip
3554         bemit8(0xE8 + attr->x87[1]->index);
3555 }
3556
3557 static void bemit_fucomfnstsw(const ir_node *node)
3558 {
3559         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3560         bemit8(0xDD); // fucom
3561         bemit8(0xE0 + attr->x87[1]->index);
3562         bemit_fnstsw();
3563 }
3564
3565 static void bemit_fucompfnstsw(const ir_node *node)
3566 {
3567         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3568         bemit8(0xDD); // fucomp
3569         bemit8(0xE8 + attr->x87[1]->index);
3570         bemit_fnstsw();
3571 }
3572
3573 static void bemit_fucomppfnstsw(const ir_node *node)
3574 {
3575         (void)node;
3576
3577         bemit8(0xDA); // fucompp
3578         bemit8(0xE9);
3579         bemit_fnstsw();
3580 }
3581
3582 static void bemit_fxch(const ir_node *node)
3583 {
3584         bemit_fop_reg(node, 0xD9, 0xC8);
3585 }
3586
3587 /**
3588  * The type of a emitter function.
3589  */
3590 typedef void (*emit_func) (const ir_node *);
3591
3592 /**
3593  * Set a node emitter. Make it a bit more type safe.
3594  */
3595 static void register_emitter(ir_op *op, emit_func func)
3596 {
3597         op->ops.generic = (op_func) func;
3598 }
3599
3600 static void ia32_register_binary_emitters(void)
3601 {
3602         /* first clear the generic function pointer for all ops */
3603         ir_clear_opcodes_generic_func();
3604
3605         /* benode emitter */
3606         register_emitter(op_be_Copy,            bemit_copy);
3607         register_emitter(op_be_CopyKeep,        bemit_copy);
3608         register_emitter(op_be_IncSP,           bemit_incsp);
3609         register_emitter(op_be_Perm,            bemit_perm);
3610         register_emitter(op_be_Return,          bemit_return);
3611         register_emitter(op_ia32_Adc,           bemit_adc);
3612         register_emitter(op_ia32_Add,           bemit_add);
3613         register_emitter(op_ia32_AddMem,        bemit_addmem);
3614         register_emitter(op_ia32_AddMem8Bit,    bemit_addmem8bit);
3615         register_emitter(op_ia32_And,           bemit_and);
3616         register_emitter(op_ia32_AndMem,        bemit_andmem);
3617         register_emitter(op_ia32_AndMem8Bit,    bemit_andmem8bit);
3618         register_emitter(op_ia32_Asm,           emit_ia32_Asm); // TODO implement binary emitter
3619         register_emitter(op_ia32_Breakpoint,    bemit_int3);
3620         register_emitter(op_ia32_Bsf,           bemit_bsf);
3621         register_emitter(op_ia32_Bsr,           bemit_bsr);
3622         register_emitter(op_ia32_Bswap,         bemit_bswap);
3623         register_emitter(op_ia32_CMovcc,        bemit_cmovcc);
3624         register_emitter(op_ia32_Call,          bemit_call);
3625         register_emitter(op_ia32_Cltd,          bemit_cltd);
3626         register_emitter(op_ia32_Cmc,           bemit_cmc);
3627         register_emitter(op_ia32_Cmp,           bemit_cmp);
3628         register_emitter(op_ia32_Cmp8Bit,       bemit_cmp8bit);
3629         register_emitter(op_ia32_Const,         bemit_mov_const);
3630         register_emitter(op_ia32_Conv_I2I,      bemit_conv_i2i);
3631         register_emitter(op_ia32_Conv_I2I8Bit,  bemit_conv_i2i);
3632         register_emitter(op_ia32_CopyB_i,       bemit_copybi);
3633         register_emitter(op_ia32_Cwtl,          bemit_cwtl);
3634         register_emitter(op_ia32_Dec,           bemit_dec);
3635         register_emitter(op_ia32_DecMem,        bemit_decmem);
3636         register_emitter(op_ia32_Div,           bemit_div);
3637         register_emitter(op_ia32_FldCW,         bemit_fldcw);
3638         register_emitter(op_ia32_FnstCW,        bemit_fnstcw);
3639         register_emitter(op_ia32_FtstFnstsw,    bemit_ftstfnstsw);
3640         register_emitter(op_ia32_FucomFnstsw,   bemit_fucomfnstsw);
3641         register_emitter(op_ia32_Fucomi,        bemit_fucomi);
3642         register_emitter(op_ia32_FucompFnstsw,  bemit_fucompfnstsw);
3643         register_emitter(op_ia32_Fucompi,       bemit_fucomip);
3644         register_emitter(op_ia32_FucomppFnstsw, bemit_fucomppfnstsw);
3645         register_emitter(op_ia32_IDiv,          bemit_idiv);
3646         register_emitter(op_ia32_IJmp,          bemit_ijmp);
3647         register_emitter(op_ia32_IMul,          bemit_imul);
3648         register_emitter(op_ia32_IMul1OP,       bemit_imul1op);
3649         register_emitter(op_ia32_Inc,           bemit_inc);
3650         register_emitter(op_ia32_IncMem,        bemit_incmem);
3651         register_emitter(op_ia32_Jcc,           bemit_ia32_jcc);
3652         register_emitter(op_ia32_Jmp,           bemit_jump);
3653         register_emitter(op_ia32_LdTls,         bemit_ldtls);
3654         register_emitter(op_ia32_Lea,           bemit_lea);
3655         register_emitter(op_ia32_Leave,         bemit_leave);
3656         register_emitter(op_ia32_Load,          bemit_load);
3657         register_emitter(op_ia32_Minus64Bit,    bemit_minus64bit);
3658         register_emitter(op_ia32_Mul,           bemit_mul);
3659         register_emitter(op_ia32_Neg,           bemit_neg);
3660         register_emitter(op_ia32_NegMem,        bemit_negmem);
3661         register_emitter(op_ia32_Not,           bemit_not);
3662         register_emitter(op_ia32_NotMem,        bemit_notmem);
3663         register_emitter(op_ia32_Or,            bemit_or);
3664         register_emitter(op_ia32_OrMem,         bemit_ormem);
3665         register_emitter(op_ia32_OrMem8Bit,     bemit_ormem8bit);
3666         register_emitter(op_ia32_Pop,           bemit_pop);
3667         register_emitter(op_ia32_PopEbp,        bemit_pop);
3668         register_emitter(op_ia32_PopMem,        bemit_popmem);
3669         register_emitter(op_ia32_Popcnt,        bemit_popcnt);
3670         register_emitter(op_ia32_Push,          bemit_push);
3671         register_emitter(op_ia32_RepPrefix,     bemit_rep);
3672         register_emitter(op_ia32_Rol,           bemit_rol);
3673         register_emitter(op_ia32_RolMem,        bemit_rolmem);
3674         register_emitter(op_ia32_Ror,           bemit_ror);
3675         register_emitter(op_ia32_RorMem,        bemit_rormem);
3676         register_emitter(op_ia32_Sahf,          bemit_sahf);
3677         register_emitter(op_ia32_Sar,           bemit_sar);
3678         register_emitter(op_ia32_SarMem,        bemit_sarmem);
3679         register_emitter(op_ia32_Sbb,           bemit_sbb);
3680         register_emitter(op_ia32_Sbb0,          bemit_sbb0);
3681         register_emitter(op_ia32_Setcc,         bemit_setcc);
3682         register_emitter(op_ia32_Shl,           bemit_shl);
3683         register_emitter(op_ia32_ShlD,          bemit_shld);
3684         register_emitter(op_ia32_ShlMem,        bemit_shlmem);
3685         register_emitter(op_ia32_Shr,           bemit_shr);
3686         register_emitter(op_ia32_ShrD,          bemit_shrd);
3687         register_emitter(op_ia32_ShrMem,        bemit_shrmem);
3688         register_emitter(op_ia32_Stc,           bemit_stc);
3689         register_emitter(op_ia32_Store,         bemit_store);
3690         register_emitter(op_ia32_Store8Bit,     bemit_store);
3691         register_emitter(op_ia32_Sub,           bemit_sub);
3692         register_emitter(op_ia32_SubMem,        bemit_submem);
3693         register_emitter(op_ia32_SubMem8Bit,    bemit_submem8bit);
3694         register_emitter(op_ia32_SubSP,         bemit_subsp);
3695         register_emitter(op_ia32_SwitchJmp,     bemit_switchjmp);
3696         register_emitter(op_ia32_Test,          bemit_test);
3697         register_emitter(op_ia32_Test8Bit,      bemit_test8bit);
3698         register_emitter(op_ia32_Xor,           bemit_xor);
3699         register_emitter(op_ia32_Xor0,          bemit_xor0);
3700         register_emitter(op_ia32_XorMem,        bemit_xormem);
3701         register_emitter(op_ia32_XorMem8Bit,    bemit_xormem8bit);
3702         register_emitter(op_ia32_fabs,          bemit_fabs);
3703         register_emitter(op_ia32_fadd,          bemit_fadd);
3704         register_emitter(op_ia32_faddp,         bemit_faddp);
3705         register_emitter(op_ia32_fchs,          bemit_fchs);
3706         register_emitter(op_ia32_fdiv,          bemit_fdiv);
3707         register_emitter(op_ia32_fdivp,         bemit_fdivp);
3708         register_emitter(op_ia32_fdivr,         bemit_fdivr);
3709         register_emitter(op_ia32_fdivrp,        bemit_fdivrp);
3710         register_emitter(op_ia32_ffreep,        bemit_ffreep);
3711         register_emitter(op_ia32_fild,          bemit_fild);
3712         register_emitter(op_ia32_fist,          bemit_fist);
3713         register_emitter(op_ia32_fistp,         bemit_fistp);
3714         register_emitter(op_ia32_fisttp,        bemit_fisttp);
3715         register_emitter(op_ia32_fld,           bemit_fld);
3716         register_emitter(op_ia32_fld1,          bemit_fld1);
3717         register_emitter(op_ia32_fldz,          bemit_fldz);
3718         register_emitter(op_ia32_fmul,          bemit_fmul);
3719         register_emitter(op_ia32_fmulp,         bemit_fmulp);
3720         register_emitter(op_ia32_fpop,          bemit_fpop);
3721         register_emitter(op_ia32_fpush,         bemit_fpush);
3722         register_emitter(op_ia32_fpushCopy,     bemit_fpushcopy);
3723         register_emitter(op_ia32_fst,           bemit_fst);
3724         register_emitter(op_ia32_fstp,          bemit_fstp);
3725         register_emitter(op_ia32_fsub,          bemit_fsub);
3726         register_emitter(op_ia32_fsubp,         bemit_fsubp);
3727         register_emitter(op_ia32_fsubr,         bemit_fsubr);
3728         register_emitter(op_ia32_fsubrp,        bemit_fsubrp);
3729         register_emitter(op_ia32_fxch,          bemit_fxch);
3730
3731         /* ignore the following nodes */
3732         register_emitter(op_ia32_ProduceVal,   emit_Nothing);
3733         register_emitter(op_ia32_Unknown,      emit_Nothing);
3734         register_emitter(op_be_Keep,           emit_Nothing);
3735         register_emitter(op_be_Start,          emit_Nothing);
3736         register_emitter(op_Phi,               emit_Nothing);
3737         register_emitter(op_Start,             emit_Nothing);
3738 }
3739
3740 static void gen_binary_block(ir_node *block)
3741 {
3742         ia32_emit_block_header(block);
3743
3744         /* emit the contents of the block */
3745         sched_foreach(block, node) {
3746                 ia32_emit_node(node);
3747         }
3748 }
3749
3750 void ia32_gen_binary_routine(ir_graph *irg)
3751 {
3752         ir_entity        *entity    = get_irg_entity(irg);
3753         const arch_env_t *arch_env  = be_get_irg_arch_env(irg);
3754         ia32_irg_data_t  *irg_data  = ia32_get_irg_data(irg);
3755         ir_node         **blk_sched = irg_data->blk_sched;
3756         size_t            i, n;
3757         parameter_dbg_info_t *infos;
3758
3759         isa = (ia32_isa_t*) arch_env;
3760
3761         ia32_register_binary_emitters();
3762
3763         infos = construct_parameter_infos(irg);
3764         be_gas_emit_function_prolog(entity, ia32_cg_config.function_alignment,
3765                                     NULL);
3766         xfree(infos);
3767
3768         /* we use links to point to target blocks */
3769         ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK);
3770         irg_block_walk_graph(irg, ia32_gen_labels, NULL, NULL);
3771
3772         /* initialize next block links */
3773         n = ARR_LEN(blk_sched);
3774         for (i = 0; i < n; ++i) {
3775                 ir_node *block = blk_sched[i];
3776                 ir_node *prev  = i > 0 ? blk_sched[i-1] : NULL;
3777
3778                 set_irn_link(block, prev);
3779         }
3780
3781         for (i = 0; i < n; ++i) {
3782                 ir_node *block = blk_sched[i];
3783                 gen_binary_block(block);
3784         }
3785
3786         be_gas_emit_function_epilog(entity);
3787
3788         ir_free_resources(irg, IR_RESOURCE_IRN_LINK);
3789 }
3790
3791
3792 void ia32_init_emitter(void)
3793 {
3794         lc_opt_entry_t *be_grp;
3795         lc_opt_entry_t *ia32_grp;
3796
3797         be_grp   = lc_opt_get_grp(firm_opt_get_root(), "be");
3798         ia32_grp = lc_opt_get_grp(be_grp, "ia32");
3799
3800         lc_opt_add_table(ia32_grp, ia32_emitter_options);
3801
3802         build_reg_map();
3803
3804         FIRM_DBG_REGISTER(dbg, "firm.be.ia32.emitter");
3805 }