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