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