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 /**
2453  * binary emitter for setcc.
2454  */
2455 static void bemit_setcc(const ir_node *node)
2456 {
2457         const arch_register_t *dreg = arch_get_irn_register_out(node, pn_ia32_Setcc_res);
2458
2459         ia32_condition_code_t cc = get_ia32_condcode(node);
2460         cc = determine_final_cc(node, n_ia32_Setcc_eflags, cc);
2461         if (cc & ia32_cc_float_parity_cases) {
2462                 if (cc & ia32_cc_negated) {
2463                         /* set%PNC <dreg */
2464                         bemit8(0x0F);
2465                         bemit8(0x90 | pnc2cc(cc));
2466                         bemit_modrm8(REG_LOW, dreg);
2467
2468                         /* setp >dreg */
2469                         bemit8(0x0F);
2470                         bemit8(0x9A);
2471                         bemit_modrm8(REG_HIGH, dreg);
2472
2473                         /* orb %>dreg, %<dreg */
2474                         bemit8(0x08);
2475                         bemit_modrr8(REG_LOW, dreg, REG_HIGH, dreg);
2476                 } else {
2477                          /* set%PNC <dreg */
2478                         bemit8(0x0F);
2479                         bemit8(0x90 | pnc2cc(cc));
2480                         bemit_modrm8(REG_LOW, dreg);
2481
2482                         /* setnp >dreg */
2483                         bemit8(0x0F);
2484                         bemit8(0x9B);
2485                         bemit_modrm8(REG_HIGH, dreg);
2486
2487                         /* andb %>dreg, %<dreg */
2488                         bemit8(0x20);
2489                         bemit_modrr8(REG_LOW, dreg, REG_HIGH, dreg);
2490                 }
2491         } else {
2492                 /* set%PNC <dreg */
2493                 bemit8(0x0F);
2494                 bemit8(0x90 | pnc2cc(cc));
2495                 bemit_modrm8(REG_LOW, dreg);
2496         }
2497 }
2498
2499 static void bemit_bsf(ir_node const *const node)
2500 {
2501         bemit_0f_unop_reg(node, 0xBC, n_ia32_Bsf_operand);
2502 }
2503
2504 static void bemit_bsr(ir_node const *const node)
2505 {
2506         bemit_0f_unop_reg(node, 0xBD, n_ia32_Bsr_operand);
2507 }
2508
2509 static void bemit_cmovcc(const ir_node *node)
2510 {
2511         const ia32_attr_t     *attr         = get_ia32_attr_const(node);
2512         int                    ins_permuted = attr->data.ins_permuted;
2513         const arch_register_t *out          = arch_get_irn_register_out(node, pn_ia32_res);
2514         ia32_condition_code_t  cc           = get_ia32_condcode(node);
2515         const arch_register_t *in_true;
2516         const arch_register_t *in_false;
2517
2518         cc = determine_final_cc(node, n_ia32_CMovcc_eflags, cc);
2519
2520         in_true  = arch_get_irn_register(get_irn_n(node, n_ia32_CMovcc_val_true));
2521         in_false = arch_get_irn_register(get_irn_n(node, n_ia32_CMovcc_val_false));
2522
2523         /* should be same constraint fullfilled? */
2524         if (out == in_false) {
2525                 /* yes -> nothing to do */
2526         } else if (out == in_true) {
2527                 assert(get_ia32_op_type(node) == ia32_Normal);
2528                 ins_permuted = !ins_permuted;
2529                 in_true      = in_false;
2530         } else {
2531                 /* we need a mov */
2532                 bemit8(0x8B); // mov %in_false, %out
2533                 bemit_modrr(in_false, out);
2534         }
2535
2536         if (ins_permuted)
2537                 cc = ia32_negate_condition_code(cc);
2538
2539         if (cc & ia32_cc_float_parity_cases)
2540                 panic("cmov can't handle parity float cases");
2541
2542         bemit8(0x0F);
2543         bemit8(0x40 | pnc2cc(cc));
2544         if (get_ia32_op_type(node) == ia32_Normal) {
2545                 bemit_modrr(in_true, out);
2546         } else {
2547                 bemit_mod_am(reg_gp_map[out->index], node);
2548         }
2549 }
2550
2551 static void bemit_cmp(const ir_node *node)
2552 {
2553         unsigned  ls_size = get_mode_size_bits(get_ia32_ls_mode(node));
2554         ir_node  *right;
2555
2556         if (ls_size == 16)
2557                 bemit8(0x66);
2558
2559         right = get_irn_n(node, n_ia32_binary_right);
2560         if (is_ia32_Immediate(right)) {
2561                 /* Use in-reg, because some instructions (cmp, test) have no out-reg. */
2562                 const ir_node               *op   = get_irn_n(node, n_ia32_binary_right);
2563                 const ia32_immediate_attr_t *attr = get_ia32_immediate_attr_const(op);
2564                 unsigned                     size;
2565
2566                 if (attr->symconst != NULL) {
2567                         size = 4;
2568                 } else {
2569                         /* check for sign extension */
2570                         size = get_signed_imm_size(attr->offset);
2571                 }
2572
2573                 switch (size) {
2574                         case 1:
2575                                 bemit8(0x81 | SIGNEXT_IMM);
2576                                 /* cmp has this special mode */
2577                                 if (get_ia32_op_type(node) == ia32_AddrModeS) {
2578                                         bemit_mod_am(7, node);
2579                                 } else {
2580                                         const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_binary_left);
2581                                         bemit_modru(reg, 7);
2582                                 }
2583                                 bemit8((unsigned char)attr->offset);
2584                                 return;
2585                         case 2:
2586                         case 4:
2587                                 /* check for eax variant: this variant is shorter for 32bit immediates only */
2588                                 if (get_ia32_op_type(node) == ia32_AddrModeS) {
2589                                         bemit8(0x81);
2590                                         bemit_mod_am(7, node);
2591                                 } else {
2592                                         const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_binary_left);
2593                                         if (reg->index == REG_GP_EAX) {
2594                                                 bemit8(0x3D);
2595                                         } else {
2596                                                 bemit8(0x81);
2597                                                 bemit_modru(reg, 7);
2598                                         }
2599                                 }
2600                                 if (ls_size == 16) {
2601                                         bemit16(attr->offset);
2602                                 } else {
2603                                         bemit_entity(attr->symconst, attr->sc_sign, attr->offset, false);
2604                                 }
2605                                 return;
2606                 }
2607                 panic("invalid imm size?!?");
2608         } else {
2609                 const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_binary_left);
2610                 bemit8(0x3B);
2611                 if (get_ia32_op_type(node) == ia32_Normal) {
2612                         const arch_register_t *op2 = arch_get_irn_register_in(node, n_ia32_binary_right);
2613                         bemit_modrr(op2, out);
2614                 } else {
2615                         bemit_mod_am(reg_gp_map[out->index], node);
2616                 }
2617         }
2618 }
2619
2620 static void bemit_cmp8bit(const ir_node *node)
2621 {
2622         ir_node *right = get_irn_n(node, n_ia32_binary_right);
2623         if (is_ia32_Immediate(right)) {
2624                 if (get_ia32_op_type(node) == ia32_Normal) {
2625                         const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_Cmp_left);
2626                         if (out->index == REG_GP_EAX) {
2627                                 bemit8(0x3C);
2628                         } else {
2629                                 bemit8(0x80);
2630                                 bemit_modru(out, 7);
2631                         }
2632                 } else {
2633                         bemit8(0x80);
2634                         bemit_mod_am(7, node);
2635                 }
2636                 bemit8(get_ia32_immediate_attr_const(right)->offset);
2637         } else {
2638                 const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_Cmp_left);
2639                 bemit8(0x3A);
2640                 if (get_ia32_op_type(node) == ia32_Normal) {
2641                         const arch_register_t *in = arch_get_irn_register_in(node, n_ia32_Cmp_right);
2642                         bemit_modrr(out, in);
2643                 } else {
2644                         bemit_mod_am(reg_gp_map[out->index], node);
2645                 }
2646         }
2647 }
2648
2649 static void bemit_test8bit(const ir_node *node)
2650 {
2651         ir_node *right = get_irn_n(node, n_ia32_Test8Bit_right);
2652         if (is_ia32_Immediate(right)) {
2653                 if (get_ia32_op_type(node) == ia32_Normal) {
2654                         const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_Test8Bit_left);
2655                         if (out->index == REG_GP_EAX) {
2656                                 bemit8(0xA8);
2657                         } else {
2658                                 bemit8(0xF6);
2659                                 bemit_modru(out, 0);
2660                         }
2661                 } else {
2662                         bemit8(0xF6);
2663                         bemit_mod_am(0, node);
2664                 }
2665                 bemit8(get_ia32_immediate_attr_const(right)->offset);
2666         } else {
2667                 const arch_register_t *out = arch_get_irn_register_in(node, n_ia32_Test8Bit_left);
2668                 bemit8(0x84);
2669                 if (get_ia32_op_type(node) == ia32_Normal) {
2670                         const arch_register_t *in = arch_get_irn_register_in(node, n_ia32_Test8Bit_right);
2671                         bemit_modrr(out, in);
2672                 } else {
2673                         bemit_mod_am(reg_gp_map[out->index], node);
2674                 }
2675         }
2676 }
2677
2678 static void bemit_imul(const ir_node *node)
2679 {
2680         ir_node *right = get_irn_n(node, n_ia32_IMul_right);
2681         /* Do we need the immediate form? */
2682         if (is_ia32_Immediate(right)) {
2683                 int imm = get_ia32_immediate_attr_const(right)->offset;
2684                 if (get_signed_imm_size(imm) == 1) {
2685                         bemit_unop_reg(node, 0x6B, n_ia32_IMul_left);
2686                         bemit8(imm);
2687                 } else {
2688                         bemit_unop_reg(node, 0x69, n_ia32_IMul_left);
2689                         bemit32(imm);
2690                 }
2691         } else {
2692                 bemit_0f_unop_reg(node, 0xAF, n_ia32_IMul_right);
2693         }
2694 }
2695
2696 static void bemit_dec(const ir_node *node)
2697 {
2698         const arch_register_t *out = arch_get_irn_register_out(node, pn_ia32_Dec_res);
2699         bemit8(0x48 + reg_gp_map[out->index]);
2700 }
2701
2702 static void bemit_inc(const ir_node *node)
2703 {
2704         const arch_register_t *out = arch_get_irn_register_out(node, pn_ia32_Inc_res);
2705         bemit8(0x40 + reg_gp_map[out->index]);
2706 }
2707
2708 #define UNOPMEM(op, code, ext) \
2709 static void bemit_##op(const ir_node *node) \
2710 { \
2711         bemit_unop_mem(node, code, ext); \
2712 }
2713
2714 UNOPMEM(notmem, 0xF6, 2)
2715 UNOPMEM(negmem, 0xF6, 3)
2716 UNOPMEM(incmem, 0xFE, 0)
2717 UNOPMEM(decmem, 0xFE, 1)
2718
2719 static void bemit_ldtls(const ir_node *node)
2720 {
2721         const arch_register_t *out = arch_get_irn_register_out(node, 0);
2722
2723         bemit8(0x65); // gs:
2724         if (out->index == REG_GP_EAX) {
2725                 bemit8(0xA1); // movl 0, %eax
2726         } else {
2727                 bemit8(0x8B); // movl 0, %reg
2728                 bemit8(MOD_IND | ENC_REG(reg_gp_map[out->index]) | ENC_RM(0x05));
2729         }
2730         bemit32(0);
2731 }
2732
2733 /**
2734  * Emit a Lea.
2735  */
2736 static void bemit_lea(const ir_node *node)
2737 {
2738         const arch_register_t *out = arch_get_irn_register_out(node, 0);
2739         bemit8(0x8D);
2740         bemit_mod_am(reg_gp_map[out->index], node);
2741 }
2742
2743 /* helper function for bemit_minus64bit */
2744 static void bemit_helper_mov(const arch_register_t *src, const arch_register_t *dst)
2745 {
2746         bemit8(0x8B); // movl %src, %dst
2747         bemit_modrr(src, dst);
2748 }
2749
2750 /* helper function for bemit_minus64bit */
2751 static void bemit_helper_neg(const arch_register_t *reg)
2752 {
2753         bemit8(0xF7); // negl %reg
2754         bemit_modru(reg, 3);
2755 }
2756
2757 /* helper function for bemit_minus64bit */
2758 static void bemit_helper_sbb0(const arch_register_t *reg)
2759 {
2760         bemit8(0x83); // sbbl $0, %reg
2761         bemit_modru(reg, 3);
2762         bemit8(0);
2763 }
2764
2765 /* helper function for bemit_minus64bit */
2766 static void bemit_helper_sbb(const arch_register_t *src, const arch_register_t *dst)
2767 {
2768         bemit8(0x1B); // sbbl %src, %dst
2769         bemit_modrr(src, dst);
2770 }
2771
2772 /* helper function for bemit_minus64bit */
2773 static void bemit_helper_xchg(const arch_register_t *src, const arch_register_t *dst)
2774 {
2775         if (src->index == REG_GP_EAX) {
2776                 bemit8(0x90 + reg_gp_map[dst->index]); // xchgl %eax, %dst
2777         } else if (dst->index == REG_GP_EAX) {
2778                 bemit8(0x90 + reg_gp_map[src->index]); // xchgl %src, %eax
2779         } else {
2780                 bemit8(0x87); // xchgl %src, %dst
2781                 bemit_modrr(src, dst);
2782         }
2783 }
2784
2785 /* helper function for bemit_minus64bit */
2786 static void bemit_helper_zero(const arch_register_t *reg)
2787 {
2788         bemit8(0x33); // xorl %reg, %reg
2789         bemit_modrr(reg, reg);
2790 }
2791
2792 static void bemit_minus64bit(const ir_node *node)
2793 {
2794         const arch_register_t *in_lo  = arch_get_irn_register_in(node, 0);
2795         const arch_register_t *in_hi  = arch_get_irn_register_in(node, 1);
2796         const arch_register_t *out_lo = arch_get_irn_register_out(node, 0);
2797         const arch_register_t *out_hi = arch_get_irn_register_out(node, 1);
2798
2799         if (out_lo == in_lo) {
2800                 if (out_hi != in_hi) {
2801                         /* a -> a, b -> d */
2802                         goto zero_neg;
2803                 } else {
2804                         /* a -> a, b -> b */
2805                         goto normal_neg;
2806                 }
2807         } else if (out_lo == in_hi) {
2808                 if (out_hi == in_lo) {
2809                         /* a -> b, b -> a */
2810                         bemit_helper_xchg(in_lo, in_hi);
2811                         goto normal_neg;
2812                 } else {
2813                         /* a -> b, b -> d */
2814                         bemit_helper_mov(in_hi, out_hi);
2815                         bemit_helper_mov(in_lo, out_lo);
2816                         goto normal_neg;
2817                 }
2818         } else {
2819                 if (out_hi == in_lo) {
2820                         /* a -> c, b -> a */
2821                         bemit_helper_mov(in_lo, out_lo);
2822                         goto zero_neg;
2823                 } else if (out_hi == in_hi) {
2824                         /* a -> c, b -> b */
2825                         bemit_helper_mov(in_lo, out_lo);
2826                         goto normal_neg;
2827                 } else {
2828                         /* a -> c, b -> d */
2829                         bemit_helper_mov(in_lo, out_lo);
2830                         goto zero_neg;
2831                 }
2832         }
2833
2834 normal_neg:
2835         bemit_helper_neg( out_hi);
2836         bemit_helper_neg( out_lo);
2837         bemit_helper_sbb0(out_hi);
2838         return;
2839
2840 zero_neg:
2841         bemit_helper_zero(out_hi);
2842         bemit_helper_neg( out_lo);
2843         bemit_helper_sbb( in_hi, out_hi);
2844 }
2845
2846 /**
2847  * Emit a single opcode.
2848  */
2849 #define EMIT_SINGLEOP(op, code)                 \
2850 static void bemit_ ## op(const ir_node *node) { \
2851         (void) node;                                \
2852         bemit8(code);                               \
2853 }
2854
2855 //EMIT_SINGLEOP(daa,  0x27)
2856 //EMIT_SINGLEOP(das,  0x2F)
2857 //EMIT_SINGLEOP(aaa,  0x37)
2858 //EMIT_SINGLEOP(aas,  0x3F)
2859 //EMIT_SINGLEOP(nop,  0x90)
2860 EMIT_SINGLEOP(cwtl,  0x98)
2861 EMIT_SINGLEOP(cltd,  0x99)
2862 //EMIT_SINGLEOP(fwait, 0x9B)
2863 EMIT_SINGLEOP(sahf,  0x9E)
2864 //EMIT_SINGLEOP(popf, 0x9D)
2865 EMIT_SINGLEOP(leave, 0xC9)
2866 EMIT_SINGLEOP(int3,  0xCC)
2867 //EMIT_SINGLEOP(iret, 0xCF)
2868 //EMIT_SINGLEOP(xlat, 0xD7)
2869 //EMIT_SINGLEOP(lock, 0xF0)
2870 EMIT_SINGLEOP(rep,   0xF3)
2871 //EMIT_SINGLEOP(halt, 0xF4)
2872 EMIT_SINGLEOP(cmc,   0xF5)
2873 EMIT_SINGLEOP(stc,   0xF9)
2874 //EMIT_SINGLEOP(cli,  0xFA)
2875 //EMIT_SINGLEOP(sti,  0xFB)
2876 //EMIT_SINGLEOP(std,  0xFD)
2877
2878 /**
2879  * Emits a MOV out, [MEM].
2880  */
2881 static void bemit_load(const ir_node *node)
2882 {
2883         const arch_register_t *out = arch_get_irn_register_out(node, 0);
2884
2885         if (out->index == REG_GP_EAX) {
2886                 ir_node   *base      = get_irn_n(node, n_ia32_base);
2887                 int        has_base  = !is_ia32_NoReg_GP(base);
2888                 ir_node   *idx       = get_irn_n(node, n_ia32_index);
2889                 int        has_index = !is_ia32_NoReg_GP(idx);
2890                 if (!has_base && !has_index) {
2891                         ir_entity *ent  = get_ia32_am_sc(node);
2892                         int        offs = get_ia32_am_offs_int(node);
2893                         /* load from constant address to EAX can be encoded
2894                            as 0xA1 [offset] */
2895                         bemit8(0xA1);
2896                         bemit_entity(ent, 0, offs, false);
2897                         return;
2898                 }
2899         }
2900         bemit8(0x8B);
2901         bemit_mod_am(reg_gp_map[out->index], node);
2902 }
2903
2904 /**
2905  * Emits a MOV [mem], in.
2906  */
2907 static void bemit_store(const ir_node *node)
2908 {
2909         const ir_node *value = get_irn_n(node, n_ia32_Store_val);
2910         unsigned       size  = get_mode_size_bits(get_ia32_ls_mode(node));
2911
2912         if (is_ia32_Immediate(value)) {
2913                 if (size == 8) {
2914                         bemit8(0xC6);
2915                         bemit_mod_am(0, node);
2916                         bemit8(get_ia32_immediate_attr_const(value)->offset);
2917                 } else if (size == 16) {
2918                         bemit8(0x66);
2919                         bemit8(0xC7);
2920                         bemit_mod_am(0, node);
2921                         bemit16(get_ia32_immediate_attr_const(value)->offset);
2922                 } else {
2923                         bemit8(0xC7);
2924                         bemit_mod_am(0, node);
2925                         bemit_immediate(value, false);
2926                 }
2927         } else {
2928                 const arch_register_t *in = arch_get_irn_register_in(node, n_ia32_Store_val);
2929
2930                 if (in->index == REG_GP_EAX) {
2931                         ir_node   *base      = get_irn_n(node, n_ia32_base);
2932                         int        has_base  = !is_ia32_NoReg_GP(base);
2933                         ir_node   *idx       = get_irn_n(node, n_ia32_index);
2934                         int        has_index = !is_ia32_NoReg_GP(idx);
2935                         if (!has_base && !has_index) {
2936                                 ir_entity *ent  = get_ia32_am_sc(node);
2937                                 int        offs = get_ia32_am_offs_int(node);
2938                                 /* store to constant address from EAX can be encoded as
2939                                  * 0xA2/0xA3 [offset]*/
2940                                 if (size == 8) {
2941                                         bemit8(0xA2);
2942                                 } else {
2943                                         if (size == 16)
2944                                                 bemit8(0x66);
2945                                         bemit8(0xA3);
2946                                 }
2947                                 bemit_entity(ent, 0, offs, false);
2948                                 return;
2949                         }
2950                 }
2951
2952                 if (size == 8) {
2953                         bemit8(0x88);
2954                 } else {
2955                         if (size == 16)
2956                                 bemit8(0x66);
2957                         bemit8(0x89);
2958                 }
2959                 bemit_mod_am(reg_gp_map[in->index], node);
2960         }
2961 }
2962
2963 static void bemit_conv_i2i(const ir_node *node)
2964 {
2965         /*        8 16 bit source
2966          * movzx B6 B7
2967          * movsx BE BF */
2968         ir_mode *const smaller_mode = get_ia32_ls_mode(node);
2969         unsigned       opcode       = 0xB6;
2970         if (mode_is_signed(smaller_mode))           opcode |= 0x08;
2971         if (get_mode_size_bits(smaller_mode) == 16) opcode |= 0x01;
2972         bemit_0f_unop_reg(node, opcode, n_ia32_Conv_I2I_val);
2973 }
2974
2975 /**
2976  * Emit a Push.
2977  */
2978 static void bemit_push(const ir_node *node)
2979 {
2980         const ir_node *value = get_irn_n(node, n_ia32_Push_val);
2981
2982         if (is_ia32_Immediate(value)) {
2983                 const ia32_immediate_attr_t *attr
2984                         = get_ia32_immediate_attr_const(value);
2985                 unsigned size = get_signed_imm_size(attr->offset);
2986                 if (attr->symconst)
2987                         size = 4;
2988                 switch (size) {
2989                 case 1:
2990                         bemit8(0x6A);
2991                         bemit8((unsigned char)attr->offset);
2992                         break;
2993                 case 2:
2994                 case 4:
2995                         bemit8(0x68);
2996                         bemit_immediate(value, false);
2997                         break;
2998                 }
2999         } else if (is_ia32_NoReg_GP(value)) {
3000                 bemit8(0xFF);
3001                 bemit_mod_am(6, node);
3002         } else {
3003                 const arch_register_t *reg = arch_get_irn_register_in(node, n_ia32_Push_val);
3004                 bemit8(0x50 + reg_gp_map[reg->index]);
3005         }
3006 }
3007
3008 /**
3009  * Emit a Pop.
3010  */
3011 static void bemit_pop(const ir_node *node)
3012 {
3013         const arch_register_t *reg = arch_get_irn_register_out(node, pn_ia32_Pop_res);
3014         bemit8(0x58 + reg_gp_map[reg->index]);
3015 }
3016
3017 static void bemit_popmem(const ir_node *node)
3018 {
3019         bemit8(0x8F);
3020         bemit_mod_am(0, node);
3021 }
3022
3023 static void bemit_call(const ir_node *node)
3024 {
3025         ir_node *proc = get_irn_n(node, n_ia32_Call_addr);
3026
3027         if (is_ia32_Immediate(proc)) {
3028                 bemit8(0xE8);
3029                 bemit_immediate(proc, true);
3030         } else {
3031                 bemit_unop(node, 0xFF, 2, n_ia32_Call_addr);
3032         }
3033 }
3034
3035 static void bemit_jmp(const ir_node *dest_block)
3036 {
3037         bemit8(0xE9);
3038         bemit_jmp_destination(dest_block);
3039 }
3040
3041 static void bemit_jump(const ir_node *node)
3042 {
3043         if (can_be_fallthrough(node))
3044                 return;
3045
3046         bemit_jmp(get_cfop_target_block(node));
3047 }
3048
3049 static void bemit_jcc(ia32_condition_code_t pnc, const ir_node *dest_block)
3050 {
3051         unsigned char cc = pnc2cc(pnc);
3052         bemit8(0x0F);
3053         bemit8(0x80 + cc);
3054         bemit_jmp_destination(dest_block);
3055 }
3056
3057 static void bemit_jp(bool odd, const ir_node *dest_block)
3058 {
3059         bemit8(0x0F);
3060         bemit8(0x8A + odd);
3061         bemit_jmp_destination(dest_block);
3062 }
3063
3064 static void bemit_ia32_jcc(const ir_node *node)
3065 {
3066         ia32_condition_code_t cc = get_ia32_condcode(node);
3067         const ir_node        *proj_true;
3068         const ir_node        *proj_false;
3069         const ir_node        *dest_true;
3070         const ir_node        *dest_false;
3071
3072         cc = determine_final_cc(node, 0, cc);
3073
3074         /* get both Projs */
3075         proj_true = get_proj(node, pn_ia32_Jcc_true);
3076         assert(proj_true && "Jcc without true Proj");
3077
3078         proj_false = get_proj(node, pn_ia32_Jcc_false);
3079         assert(proj_false && "Jcc without false Proj");
3080
3081         if (can_be_fallthrough(proj_true)) {
3082                 /* exchange both proj's so the second one can be omitted */
3083                 const ir_node *t = proj_true;
3084
3085                 proj_true  = proj_false;
3086                 proj_false = t;
3087                 cc         = ia32_negate_condition_code(cc);
3088         }
3089
3090         dest_true  = get_cfop_target_block(proj_true);
3091         dest_false = get_cfop_target_block(proj_false);
3092
3093         if (cc & ia32_cc_float_parity_cases) {
3094                 /* Some floating point comparisons require a test of the parity flag,
3095                  * which indicates that the result is unordered */
3096                 if (cc & ia32_cc_negated) {
3097                         bemit_jp(false, dest_true);
3098                 } else {
3099                         /* we need a local label if the false proj is a fallthrough
3100                          * as the falseblock might have no label emitted then */
3101                         if (can_be_fallthrough(proj_false)) {
3102                                 bemit8(0x7A);
3103                                 bemit8(0x06);  // jp + 6
3104                         } else {
3105                                 bemit_jp(false, dest_false);
3106                         }
3107                 }
3108         }
3109         bemit_jcc(cc, dest_true);
3110
3111         /* the second Proj might be a fallthrough */
3112         if (can_be_fallthrough(proj_false)) {
3113                 /* it's a fallthrough */
3114         } else {
3115                 bemit_jmp(dest_false);
3116         }
3117 }
3118
3119 static void bemit_switchjmp(const ir_node *node)
3120 {
3121         ir_entity             *jump_table = get_ia32_am_sc(node);
3122         const ir_switch_table *table      = get_ia32_switch_table(node);
3123
3124         bemit8(0xFF); // jmp *tbl.label(,%in,4)
3125         bemit_mod_am(0x05, node);
3126
3127         be_emit_jump_table(node, table, jump_table, get_cfop_target_block);
3128 }
3129
3130 /**
3131  * Emits a return.
3132  */
3133 static void bemit_return(const ir_node *node)
3134 {
3135         unsigned pop = be_Return_get_pop(node);
3136         if (pop > 0 || be_Return_get_emit_pop(node)) {
3137                 bemit8(0xC2);
3138                 assert(pop <= 0xffff);
3139                 bemit16(pop);
3140         } else {
3141                 bemit8(0xC3);
3142         }
3143 }
3144
3145 static void bemit_subsp(const ir_node *node)
3146 {
3147         const arch_register_t *out;
3148         /* sub %in, %esp */
3149         bemit_sub(node);
3150         /* mov %esp, %out */
3151         bemit8(0x8B);
3152         out = arch_get_irn_register_out(node, 1);
3153         bemit8(MOD_REG | ENC_REG(reg_gp_map[out->index]) | ENC_RM(0x04));
3154 }
3155
3156 static void bemit_incsp(const ir_node *node)
3157 {
3158         int                    offs;
3159         const arch_register_t *reg;
3160         unsigned               size;
3161         unsigned               ext;
3162
3163         offs = be_get_IncSP_offset(node);
3164         if (offs == 0)
3165                 return;
3166
3167         if (offs > 0) {
3168                 ext = 5; /* sub */
3169         } else {
3170                 ext = 0; /* add */
3171                 offs = -offs;
3172         }
3173
3174         size = get_signed_imm_size(offs);
3175         bemit8(size == 1 ? 0x83 : 0x81);
3176
3177         reg  = arch_get_irn_register_out(node, 0);
3178         bemit_modru(reg, ext);
3179
3180         if (size == 1) {
3181                 bemit8(offs);
3182         } else {
3183                 bemit32(offs);
3184         }
3185 }
3186
3187 static void bemit_copybi(const ir_node *node)
3188 {
3189         unsigned size = get_ia32_copyb_size(node);
3190         if (size & 1)
3191                 bemit8(0xA4); // movsb
3192         if (size & 2) {
3193                 bemit8(0x66);
3194                 bemit8(0xA5); // movsw
3195         }
3196         size >>= 2;
3197         while (size--) {
3198                 bemit8(0xA5); // movsl
3199         }
3200 }
3201
3202 static void bemit_fbinop(const ir_node *node, unsigned code, unsigned code_to)
3203 {
3204         if (get_ia32_op_type(node) == ia32_Normal) {
3205                 const ia32_x87_attr_t *x87_attr = get_ia32_x87_attr_const(node);
3206                 const arch_register_t *in1      = x87_attr->x87[0];
3207                 const arch_register_t *in       = x87_attr->x87[1];
3208                 const arch_register_t *out      = x87_attr->x87[2];
3209
3210                 if (out == NULL) {
3211                         out = in1;
3212                 } else if (out == in) {
3213                         in = in1;
3214                 }
3215
3216                 if (out->index == 0) {
3217                         bemit8(0xD8);
3218                         bemit8(MOD_REG | ENC_REG(code) | ENC_RM(in->index));
3219                 } else {
3220                         bemit8(0xDC);
3221                         bemit8(MOD_REG | ENC_REG(code_to) | ENC_RM(out->index));
3222                 }
3223         } else {
3224                 if (get_mode_size_bits(get_ia32_ls_mode(node)) == 32) {
3225                         bemit8(0xD8);
3226                 } else {
3227                         bemit8(0xDC);
3228                 }
3229                 bemit_mod_am(code, node);
3230         }
3231 }
3232
3233 static void bemit_fbinopp(const ir_node *node, unsigned const code)
3234 {
3235         const ia32_x87_attr_t *x87_attr = get_ia32_x87_attr_const(node);
3236         const arch_register_t *out      = x87_attr->x87[2];
3237         bemit8(0xDE);
3238         bemit8(code + out->index);
3239 }
3240
3241 static void bemit_fabs(const ir_node *node)
3242 {
3243         (void)node;
3244
3245         bemit8(0xD9);
3246         bemit8(0xE1);
3247 }
3248
3249 static void bemit_fadd(const ir_node *node)
3250 {
3251         bemit_fbinop(node, 0, 0);
3252 }
3253
3254 static void bemit_faddp(const ir_node *node)
3255 {
3256         bemit_fbinopp(node, 0xC0);
3257 }
3258
3259 static void bemit_fchs(const ir_node *node)
3260 {
3261         (void)node;
3262
3263         bemit8(0xD9);
3264         bemit8(0xE0);
3265 }
3266
3267 static void bemit_fdiv(const ir_node *node)
3268 {
3269         bemit_fbinop(node, 6, 7);
3270 }
3271
3272 static void bemit_fdivp(const ir_node *node)
3273 {
3274         bemit_fbinopp(node, 0xF8);
3275 }
3276
3277 static void bemit_fdivr(const ir_node *node)
3278 {
3279         bemit_fbinop(node, 7, 6);
3280 }
3281
3282 static void bemit_fdivrp(const ir_node *node)
3283 {
3284         bemit_fbinopp(node, 0xF0);
3285 }
3286
3287 static void bemit_fild(const ir_node *node)
3288 {
3289         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3290                 case 16:
3291                         bemit8(0xDF); // filds
3292                         bemit_mod_am(0, node);
3293                         return;
3294
3295                 case 32:
3296                         bemit8(0xDB); // fildl
3297                         bemit_mod_am(0, node);
3298                         return;
3299
3300                 case 64:
3301                         bemit8(0xDF); // fildll
3302                         bemit_mod_am(5, node);
3303                         return;
3304
3305                 default:
3306                         panic("invalid mode size");
3307         }
3308 }
3309
3310 static void bemit_fist(const ir_node *node)
3311 {
3312         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3313                 case 16:
3314                         bemit8(0xDF); // fists
3315                         break;
3316
3317                 case 32:
3318                         bemit8(0xDB); // fistl
3319                         break;
3320
3321                 default:
3322                         panic("invalid mode size");
3323         }
3324         bemit_mod_am(2, node);
3325 }
3326
3327 static void bemit_fistp(const ir_node *node)
3328 {
3329         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3330                 case 16:
3331                         bemit8(0xDF); // fistps
3332                         bemit_mod_am(3, node);
3333                         return;
3334
3335                 case 32:
3336                         bemit8(0xDB); // fistpl
3337                         bemit_mod_am(3, node);
3338                         return;
3339
3340                 case 64:
3341                         bemit8(0xDF); // fistpll
3342                         bemit_mod_am(7, node);
3343                         return;
3344
3345                 default:
3346                         panic("invalid mode size");
3347         }
3348 }
3349
3350 static void bemit_fld(const ir_node *node)
3351 {
3352         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3353                 case 32:
3354                         bemit8(0xD9); // flds
3355                         bemit_mod_am(0, node);
3356                         return;
3357
3358                 case 64:
3359                         bemit8(0xDD); // fldl
3360                         bemit_mod_am(0, node);
3361                         return;
3362
3363                 case 80:
3364                 case 96:
3365                         bemit8(0xDB); // fldt
3366                         bemit_mod_am(5, node);
3367                         return;
3368
3369                 default:
3370                         panic("invalid mode size");
3371         }
3372 }
3373
3374 static void bemit_fld1(const ir_node *node)
3375 {
3376         (void)node;
3377         bemit8(0xD9);
3378         bemit8(0xE8); // fld1
3379 }
3380
3381 static void bemit_fldcw(const ir_node *node)
3382 {
3383         bemit8(0xD9); // fldcw
3384         bemit_mod_am(5, node);
3385 }
3386
3387 static void bemit_fldz(const ir_node *node)
3388 {
3389         (void)node;
3390         bemit8(0xD9);
3391         bemit8(0xEE); // fldz
3392 }
3393
3394 static void bemit_fmul(const ir_node *node)
3395 {
3396         bemit_fbinop(node, 1, 1);
3397 }
3398
3399 static void bemit_fmulp(const ir_node *node)
3400 {
3401         bemit_fbinopp(node, 0xC8);
3402 }
3403
3404 static void bemit_fpop(const ir_node *node)
3405 {
3406         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3407         bemit8(0xDD);
3408         bemit8(0xD8 + attr->x87[0]->index);
3409 }
3410
3411 static void bemit_fpush(const ir_node *node)
3412 {
3413         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3414         bemit8(0xD9);
3415         bemit8(0xC0 + attr->x87[0]->index);
3416 }
3417
3418 static void bemit_fpushcopy(const ir_node *node)
3419 {
3420         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3421         bemit8(0xD9);
3422         bemit8(0xC0 + attr->x87[0]->index);
3423 }
3424
3425 static void bemit_fst(const ir_node *node)
3426 {
3427         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3428                 case 32:
3429                         bemit8(0xD9); // fsts
3430                         break;
3431
3432                 case 64:
3433                         bemit8(0xDD); // fstl
3434                         break;
3435
3436                 default:
3437                         panic("invalid mode size");
3438         }
3439         bemit_mod_am(2, node);
3440 }
3441
3442 static void bemit_fstp(const ir_node *node)
3443 {
3444         switch (get_mode_size_bits(get_ia32_ls_mode(node))) {
3445                 case 32:
3446                         bemit8(0xD9); // fstps
3447                         bemit_mod_am(3, node);
3448                         return;
3449
3450                 case 64:
3451                         bemit8(0xDD); // fstpl
3452                         bemit_mod_am(3, node);
3453                         return;
3454
3455                 case 80:
3456                 case 96:
3457                         bemit8(0xDB); // fstpt
3458                         bemit_mod_am(7, node);
3459                         return;
3460
3461                 default:
3462                         panic("invalid mode size");
3463         }
3464 }
3465
3466 static void bemit_fsub(const ir_node *node)
3467 {
3468         bemit_fbinop(node, 4, 5);
3469 }
3470
3471 static void bemit_fsubp(const ir_node *node)
3472 {
3473         bemit_fbinopp(node, 0xE8);
3474 }
3475
3476 static void bemit_fsubr(const ir_node *node)
3477 {
3478         bemit_fbinop(node, 5, 4);
3479 }
3480
3481 static void bemit_fsubrp(const ir_node *node)
3482 {
3483         bemit_fbinopp(node, 0xE0);
3484 }
3485
3486 static void bemit_fnstcw(const ir_node *node)
3487 {
3488         bemit8(0xD9); // fnstcw
3489         bemit_mod_am(7, node);
3490 }
3491
3492 static void bemit_fnstsw(void)
3493 {
3494         bemit8(0xDF); // fnstsw %ax
3495         bemit8(0xE0);
3496 }
3497
3498 static void bemit_ftstfnstsw(const ir_node *node)
3499 {
3500         (void)node;
3501
3502         bemit8(0xD9); // ftst
3503         bemit8(0xE4);
3504         bemit_fnstsw();
3505 }
3506
3507 static void bemit_fucomi(const ir_node *node)
3508 {
3509         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3510         bemit8(0xDB); // fucomi
3511         bemit8(0xE8 + attr->x87[1]->index);
3512 }
3513
3514 static void bemit_fucomip(const ir_node *node)
3515 {
3516         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3517         bemit8(0xDF); // fucomip
3518         bemit8(0xE8 + attr->x87[1]->index);
3519 }
3520
3521 static void bemit_fucomfnstsw(const ir_node *node)
3522 {
3523         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3524         bemit8(0xDD); // fucom
3525         bemit8(0xE0 + attr->x87[1]->index);
3526         bemit_fnstsw();
3527 }
3528
3529 static void bemit_fucompfnstsw(const ir_node *node)
3530 {
3531         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3532         bemit8(0xDD); // fucomp
3533         bemit8(0xE8 + attr->x87[1]->index);
3534         bemit_fnstsw();
3535 }
3536
3537 static void bemit_fucomppfnstsw(const ir_node *node)
3538 {
3539         (void)node;
3540
3541         bemit8(0xDA); // fucompp
3542         bemit8(0xE9);
3543         bemit_fnstsw();
3544 }
3545
3546 static void bemit_fxch(const ir_node *node)
3547 {
3548         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
3549         bemit8(0xD9);
3550         bemit8(0xC8 + attr->x87[0]->index);
3551 }
3552
3553 /**
3554  * The type of a emitter function.
3555  */
3556 typedef void (*emit_func) (const ir_node *);
3557
3558 /**
3559  * Set a node emitter. Make it a bit more type safe.
3560  */
3561 static void register_emitter(ir_op *op, emit_func func)
3562 {
3563         op->ops.generic = (op_func) func;
3564 }
3565
3566 static void ia32_register_binary_emitters(void)
3567 {
3568         /* first clear the generic function pointer for all ops */
3569         ir_clear_opcodes_generic_func();
3570
3571         /* benode emitter */
3572         register_emitter(op_be_Copy,            bemit_copy);
3573         register_emitter(op_be_CopyKeep,        bemit_copy);
3574         register_emitter(op_be_IncSP,           bemit_incsp);
3575         register_emitter(op_be_Perm,            bemit_perm);
3576         register_emitter(op_be_Return,          bemit_return);
3577         register_emitter(op_ia32_Adc,           bemit_adc);
3578         register_emitter(op_ia32_Add,           bemit_add);
3579         register_emitter(op_ia32_AddMem,        bemit_addmem);
3580         register_emitter(op_ia32_AddMem8Bit,    bemit_addmem8bit);
3581         register_emitter(op_ia32_And,           bemit_and);
3582         register_emitter(op_ia32_AndMem,        bemit_andmem);
3583         register_emitter(op_ia32_AndMem8Bit,    bemit_andmem8bit);
3584         register_emitter(op_ia32_Breakpoint,    bemit_int3);
3585         register_emitter(op_ia32_Bsf,           bemit_bsf);
3586         register_emitter(op_ia32_Bsr,           bemit_bsr);
3587         register_emitter(op_ia32_CMovcc,        bemit_cmovcc);
3588         register_emitter(op_ia32_Call,          bemit_call);
3589         register_emitter(op_ia32_Cltd,          bemit_cltd);
3590         register_emitter(op_ia32_Cmc,           bemit_cmc);
3591         register_emitter(op_ia32_Cmp,           bemit_cmp);
3592         register_emitter(op_ia32_Cmp8Bit,       bemit_cmp8bit);
3593         register_emitter(op_ia32_Const,         bemit_mov_const);
3594         register_emitter(op_ia32_Conv_I2I,      bemit_conv_i2i);
3595         register_emitter(op_ia32_Conv_I2I8Bit,  bemit_conv_i2i);
3596         register_emitter(op_ia32_CopyB_i,       bemit_copybi);
3597         register_emitter(op_ia32_Cwtl,          bemit_cwtl);
3598         register_emitter(op_ia32_Dec,           bemit_dec);
3599         register_emitter(op_ia32_DecMem,        bemit_decmem);
3600         register_emitter(op_ia32_Div,           bemit_div);
3601         register_emitter(op_ia32_FldCW,         bemit_fldcw);
3602         register_emitter(op_ia32_FnstCW,        bemit_fnstcw);
3603         register_emitter(op_ia32_FtstFnstsw,    bemit_ftstfnstsw);
3604         register_emitter(op_ia32_FucomFnstsw,   bemit_fucomfnstsw);
3605         register_emitter(op_ia32_Fucomi,        bemit_fucomi);
3606         register_emitter(op_ia32_FucompFnstsw,  bemit_fucompfnstsw);
3607         register_emitter(op_ia32_Fucompi,       bemit_fucomip);
3608         register_emitter(op_ia32_FucomppFnstsw, bemit_fucomppfnstsw);
3609         register_emitter(op_ia32_IDiv,          bemit_idiv);
3610         register_emitter(op_ia32_IJmp,          bemit_ijmp);
3611         register_emitter(op_ia32_IMul,          bemit_imul);
3612         register_emitter(op_ia32_IMul1OP,       bemit_imul1op);
3613         register_emitter(op_ia32_Inc,           bemit_inc);
3614         register_emitter(op_ia32_IncMem,        bemit_incmem);
3615         register_emitter(op_ia32_Jcc,           bemit_ia32_jcc);
3616         register_emitter(op_ia32_Jmp,           bemit_jump);
3617         register_emitter(op_ia32_LdTls,         bemit_ldtls);
3618         register_emitter(op_ia32_Lea,           bemit_lea);
3619         register_emitter(op_ia32_Leave,         bemit_leave);
3620         register_emitter(op_ia32_Load,          bemit_load);
3621         register_emitter(op_ia32_Minus64Bit,    bemit_minus64bit);
3622         register_emitter(op_ia32_Mul,           bemit_mul);
3623         register_emitter(op_ia32_Neg,           bemit_neg);
3624         register_emitter(op_ia32_NegMem,        bemit_negmem);
3625         register_emitter(op_ia32_Not,           bemit_not);
3626         register_emitter(op_ia32_NotMem,        bemit_notmem);
3627         register_emitter(op_ia32_Or,            bemit_or);
3628         register_emitter(op_ia32_OrMem,         bemit_ormem);
3629         register_emitter(op_ia32_OrMem8Bit,     bemit_ormem8bit);
3630         register_emitter(op_ia32_Pop,           bemit_pop);
3631         register_emitter(op_ia32_PopEbp,        bemit_pop);
3632         register_emitter(op_ia32_PopMem,        bemit_popmem);
3633         register_emitter(op_ia32_Push,          bemit_push);
3634         register_emitter(op_ia32_RepPrefix,     bemit_rep);
3635         register_emitter(op_ia32_Rol,           bemit_rol);
3636         register_emitter(op_ia32_RolMem,        bemit_rolmem);
3637         register_emitter(op_ia32_Ror,           bemit_ror);
3638         register_emitter(op_ia32_RorMem,        bemit_rormem);
3639         register_emitter(op_ia32_Sahf,          bemit_sahf);
3640         register_emitter(op_ia32_Sar,           bemit_sar);
3641         register_emitter(op_ia32_SarMem,        bemit_sarmem);
3642         register_emitter(op_ia32_Sbb,           bemit_sbb);
3643         register_emitter(op_ia32_Setcc,         bemit_setcc);
3644         register_emitter(op_ia32_Shl,           bemit_shl);
3645         register_emitter(op_ia32_ShlD,          bemit_shld);
3646         register_emitter(op_ia32_ShlMem,        bemit_shlmem);
3647         register_emitter(op_ia32_Shr,           bemit_shr);
3648         register_emitter(op_ia32_ShrD,          bemit_shrd);
3649         register_emitter(op_ia32_ShrMem,        bemit_shrmem);
3650         register_emitter(op_ia32_Stc,           bemit_stc);
3651         register_emitter(op_ia32_Store,         bemit_store);
3652         register_emitter(op_ia32_Store8Bit,     bemit_store);
3653         register_emitter(op_ia32_Sub,           bemit_sub);
3654         register_emitter(op_ia32_SubMem,        bemit_submem);
3655         register_emitter(op_ia32_SubMem8Bit,    bemit_submem8bit);
3656         register_emitter(op_ia32_SubSP,         bemit_subsp);
3657         register_emitter(op_ia32_SwitchJmp,     bemit_switchjmp);
3658         register_emitter(op_ia32_Test,          bemit_test);
3659         register_emitter(op_ia32_Test8Bit,      bemit_test8bit);
3660         register_emitter(op_ia32_Xor,           bemit_xor);
3661         register_emitter(op_ia32_Xor0,          bemit_xor0);
3662         register_emitter(op_ia32_XorMem,        bemit_xormem);
3663         register_emitter(op_ia32_XorMem8Bit,    bemit_xormem8bit);
3664         register_emitter(op_ia32_fabs,          bemit_fabs);
3665         register_emitter(op_ia32_fadd,          bemit_fadd);
3666         register_emitter(op_ia32_faddp,         bemit_faddp);
3667         register_emitter(op_ia32_fchs,          bemit_fchs);
3668         register_emitter(op_ia32_fdiv,          bemit_fdiv);
3669         register_emitter(op_ia32_fdivp,         bemit_fdivp);
3670         register_emitter(op_ia32_fdivr,         bemit_fdivr);
3671         register_emitter(op_ia32_fdivrp,        bemit_fdivrp);
3672         register_emitter(op_ia32_fild,          bemit_fild);
3673         register_emitter(op_ia32_fist,          bemit_fist);
3674         register_emitter(op_ia32_fistp,         bemit_fistp);
3675         register_emitter(op_ia32_fld,           bemit_fld);
3676         register_emitter(op_ia32_fld1,          bemit_fld1);
3677         register_emitter(op_ia32_fldz,          bemit_fldz);
3678         register_emitter(op_ia32_fmul,          bemit_fmul);
3679         register_emitter(op_ia32_fmulp,         bemit_fmulp);
3680         register_emitter(op_ia32_fpop,          bemit_fpop);
3681         register_emitter(op_ia32_fpush,         bemit_fpush);
3682         register_emitter(op_ia32_fpushCopy,     bemit_fpushcopy);
3683         register_emitter(op_ia32_fst,           bemit_fst);
3684         register_emitter(op_ia32_fstp,          bemit_fstp);
3685         register_emitter(op_ia32_fsub,          bemit_fsub);
3686         register_emitter(op_ia32_fsubp,         bemit_fsubp);
3687         register_emitter(op_ia32_fsubr,         bemit_fsubr);
3688         register_emitter(op_ia32_fsubrp,        bemit_fsubrp);
3689         register_emitter(op_ia32_fxch,          bemit_fxch);
3690
3691         /* ignore the following nodes */
3692         register_emitter(op_ia32_ProduceVal,   emit_Nothing);
3693         register_emitter(op_be_Keep,           emit_Nothing);
3694         register_emitter(op_be_Start,          emit_Nothing);
3695         register_emitter(op_Phi,               emit_Nothing);
3696         register_emitter(op_Start,             emit_Nothing);
3697 }
3698
3699 static void gen_binary_block(ir_node *block)
3700 {
3701         ia32_emit_block_header(block);
3702
3703         /* emit the contents of the block */
3704         sched_foreach(block, node) {
3705                 ia32_emit_node(node);
3706         }
3707 }
3708
3709 void ia32_gen_binary_routine(ir_graph *irg)
3710 {
3711         ir_entity        *entity    = get_irg_entity(irg);
3712         const arch_env_t *arch_env  = be_get_irg_arch_env(irg);
3713         ia32_irg_data_t  *irg_data  = ia32_get_irg_data(irg);
3714         ir_node         **blk_sched = irg_data->blk_sched;
3715         size_t            i, n;
3716         parameter_dbg_info_t *infos;
3717
3718         isa = (ia32_isa_t*) arch_env;
3719
3720         ia32_register_binary_emitters();
3721
3722         infos = construct_parameter_infos(irg);
3723         be_gas_emit_function_prolog(entity, ia32_cg_config.function_alignment,
3724                                     NULL);
3725         xfree(infos);
3726
3727         /* we use links to point to target blocks */
3728         ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK);
3729         irg_block_walk_graph(irg, ia32_gen_labels, NULL, NULL);
3730
3731         /* initialize next block links */
3732         n = ARR_LEN(blk_sched);
3733         for (i = 0; i < n; ++i) {
3734                 ir_node *block = blk_sched[i];
3735                 ir_node *prev  = i > 0 ? blk_sched[i-1] : NULL;
3736
3737                 set_irn_link(block, prev);
3738         }
3739
3740         for (i = 0; i < n; ++i) {
3741                 ir_node *block = blk_sched[i];
3742                 gen_binary_block(block);
3743         }
3744
3745         be_gas_emit_function_epilog(entity);
3746
3747         ir_free_resources(irg, IR_RESOURCE_IRN_LINK);
3748 }
3749
3750
3751 void ia32_init_emitter(void)
3752 {
3753         lc_opt_entry_t *be_grp;
3754         lc_opt_entry_t *ia32_grp;
3755
3756         be_grp   = lc_opt_get_grp(firm_opt_get_root(), "be");
3757         ia32_grp = lc_opt_get_grp(be_grp, "ia32");
3758
3759         lc_opt_add_table(ia32_grp, ia32_emitter_options);
3760
3761         build_reg_map();
3762
3763         FIRM_DBG_REGISTER(dbg, "firm.be.ia32.emitter");
3764 }