nsz Git - libfirm/blob - ir/be/ia32/ia32_emitter.c

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