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