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