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