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

   1 /*
   2  * Copyright (C) 1995-2008 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 #include "config.h"
  27
  28 #include <limits.h>
  29
  30 #include "xmalloc.h"
  31 #include "tv.h"
  32 #include "iredges.h"
  33 #include "debug.h"
  34 #include "irgwalk.h"
  35 #include "irprintf.h"
  36 #include "irop_t.h"
  37 #include "irargs_t.h"
  38 #include "irprog_t.h"
  39 #include "iredges_t.h"
  40 #include "irtools.h"
  41 #include "execfreq.h"
  42 #include "error.h"
  43 #include "raw_bitset.h"
  44 #include "dbginfo.h"
  45 #include "lc_opts.h"
  46
  47 #include "../besched.h"
  48 #include "../benode.h"
  49 #include "../beabi.h"
  50 #include "../be_dbgout.h"
  51 #include "../beemitter.h"
  52 #include "../begnuas.h"
  53 #include "../beirg.h"
  54 #include "../be_dbgout.h"
  55
  56 #include "ia32_emitter.h"
  57 #include "gen_ia32_emitter.h"
  58 #include "gen_ia32_regalloc_if.h"
  59 #include "ia32_nodes_attr.h"
  60 #include "ia32_new_nodes.h"
  61 #include "ia32_map_regs.h"
  62 #include "ia32_architecture.h"
  63 #include "bearch_ia32_t.h"
  64
  65 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
  66
  67 #define BLOCK_PREFIX ".L"
  68
  69 #define SNPRINTF_BUF_LEN 128
  70
  71 static const ia32_isa_t *isa;
  72 static ia32_code_gen_t  *cg;
  73 static char              pic_base_label[128];
  74 static ir_label_t        exc_label_id;
  75 static int               mark_spill_reload = 0;
  76 static int               do_pic;
  77
  78 /** Return the next block in Block schedule */
  79 static ir_node *get_prev_block_sched(const ir_node *block)
  80 {
  81         return get_irn_link(block);
  82 }
  83
  84 /** Checks if the current block is a fall-through target. */
  85 static int is_fallthrough(const ir_node *cfgpred)
  86 {
  87         ir_node *pred;
  88
  89         if (!is_Proj(cfgpred))
  90                 return 1;
  91         pred = get_Proj_pred(cfgpred);
  92         if (is_ia32_SwitchJmp(pred))
  93                 return 0;
  94
  95         return 1;
  96 }
  97
  98 /**
  99  * returns non-zero if the given block needs a label
 100  * because of being a jump-target (and not a fall-through)
 101  */
 102 static int block_needs_label(const ir_node *block)
 103 {
 104         int need_label = 1;
 105         int  n_cfgpreds = get_Block_n_cfgpreds(block);
 106
 107         if (has_Block_entity(block))
 108                 return 1;
 109
 110         if (n_cfgpreds == 0) {
 111                 need_label = 0;
 112         } else if (n_cfgpreds == 1) {
 113                 ir_node *cfgpred       = get_Block_cfgpred(block, 0);
 114                 ir_node *cfgpred_block = get_nodes_block(cfgpred);
 115
 116                 if (get_prev_block_sched(block) == cfgpred_block
 117                                 && is_fallthrough(cfgpred)) {
 118                         need_label = 0;
 119                 }
 120         }
 121
 122         return need_label;
 123 }
 124
 125 /**
 126  * Returns the register at in position pos.
 127  */
 128 static const arch_register_t *get_in_reg(const ir_node *irn, int pos)
 129 {
 130         ir_node               *op;
 131         const arch_register_t *reg = NULL;
 132
 133         assert(get_irn_arity(irn) > pos && "Invalid IN position");
 134
 135         /* The out register of the operator at position pos is the
 136            in register we need. */
 137         op = get_irn_n(irn, pos);
 138
 139         reg = arch_get_irn_register(op);
 140
 141         assert(reg && "no in register found");
 142
 143         if (reg == &ia32_gp_regs[REG_GP_NOREG])
 144                 panic("trying to emit noreg for %+F input %d", irn, pos);
 145
 146         /* in case of unknown register: just return a valid register */
 147         if (reg == &ia32_gp_regs[REG_GP_UKNWN]) {
 148                 const arch_register_req_t *req = arch_get_register_req(irn, pos);
 149
 150                 if (arch_register_req_is(req, limited)) {
 151                         /* in case of limited requirements: get the first allowed register */
 152                         unsigned idx = rbitset_next(req->limited, 0, 1);
 153                         reg = arch_register_for_index(req->cls, idx);
 154                 } else {
 155                         /* otherwise get first register in class */
 156                         reg = arch_register_for_index(req->cls, 0);
 157                 }
 158         }
 159
 160         return reg;
 161 }
 162
 163 /**
 164  * Returns the register at out position pos.
 165  */
 166 static const arch_register_t *get_out_reg(const ir_node *irn, int pos)
 167 {
 168         ir_node               *proj;
 169         const arch_register_t *reg = NULL;
 170
 171         /* 1st case: irn is not of mode_T, so it has only                 */
 172         /*           one OUT register -> good                             */
 173         /* 2nd case: irn is of mode_T -> collect all Projs and ask the    */
 174         /*           Proj with the corresponding projnum for the register */
 175
 176         if (get_irn_mode(irn) != mode_T) {
 177                 assert(pos == 0);
 178                 reg = arch_get_irn_register(irn);
 179         } else if (is_ia32_irn(irn)) {
 180                 reg = arch_irn_get_register(irn, pos);
 181         } else {
 182                 const ir_edge_t *edge;
 183
 184                 foreach_out_edge(irn, edge) {
 185                         proj = get_edge_src_irn(edge);
 186                         assert(is_Proj(proj) && "non-Proj from mode_T node");
 187                         if (get_Proj_proj(proj) == pos) {
 188                                 reg = arch_get_irn_register(proj);
 189                                 break;
 190                         }
 191                 }
 192         }
 193
 194         assert(reg && "no out register found");
 195         return reg;
 196 }
 197
 198 /**
 199  * Add a number to a prefix. This number will not be used a second time.
 200  */
 201 static char *get_unique_label(char *buf, size_t buflen, const char *prefix)
 202 {
 203         static unsigned long id = 0;
 204         snprintf(buf, buflen, "%s%lu", prefix, ++id);
 205         return buf;
 206 }
 207
 208 /*************************************************************
 209  *             _       _    __   _          _
 210  *            (_)     | |  / _| | |        | |
 211  *  _ __  _ __ _ _ __ | |_| |_  | |__   ___| |_ __   ___ _ __
 212  * | '_ \| '__| | '_ \| __|  _| | '_ \ / _ \ | '_ \ / _ \ '__|
 213  * | |_) | |  | | | | | |_| |   | | | |  __/ | |_) |  __/ |
 214  * | .__/|_|  |_|_| |_|\__|_|   |_| |_|\___|_| .__/ \___|_|
 215  * | |                                       | |
 216  * |_|                                       |_|
 217  *************************************************************/
 218
 219 /**
 220  * Emit the name of the 8bit low register
 221  */
 222 static void emit_8bit_register(const arch_register_t *reg)
 223 {
 224         const char *reg_name = arch_register_get_name(reg);
 225
 226         be_emit_char('%');
 227         be_emit_char(reg_name[1]);
 228         be_emit_char('l');
 229 }
 230
 231 /**
 232  * Emit the name of the 8bit high register
 233  */
 234 static void emit_8bit_register_high(const arch_register_t *reg)
 235 {
 236         const char *reg_name = arch_register_get_name(reg);
 237
 238         be_emit_char('%');
 239         be_emit_char(reg_name[1]);
 240         be_emit_char('h');
 241 }
 242
 243 static void emit_16bit_register(const arch_register_t *reg)
 244 {
 245         const char *reg_name = ia32_get_mapped_reg_name(isa->regs_16bit, reg);
 246
 247         be_emit_char('%');
 248         be_emit_string(reg_name);
 249 }
 250
 251 /**
 252  * emit a register, possible shortened by a mode
 253  *
 254  * @param reg   the register
 255  * @param mode  the mode of the register or NULL for full register
 256  */
 257 static void emit_register(const arch_register_t *reg, const ir_mode *mode)
 258 {
 259         const char *reg_name;
 260
 261         if (mode != NULL) {
 262                 int size = get_mode_size_bits(mode);
 263                 switch (size) {
 264                         case  8: emit_8bit_register(reg);  return;
 265                         case 16: emit_16bit_register(reg); return;
 266                 }
 267                 assert(mode_is_float(mode) || size == 32);
 268         }
 269
 270         reg_name = arch_register_get_name(reg);
 271
 272         be_emit_char('%');
 273         be_emit_string(reg_name);
 274 }
 275
 276 void ia32_emit_source_register(const ir_node *node, int pos)
 277 {
 278         const arch_register_t *reg = get_in_reg(node, pos);
 279
 280         emit_register(reg, NULL);
 281 }
 282
 283 static void ia32_emit_entity(ir_entity *entity, int no_pic_adjust)
 284 {
 285         set_entity_backend_marked(entity, 1);
 286         be_gas_emit_entity(entity);
 287
 288         if (get_entity_owner(entity) == get_tls_type()) {
 289                 if (get_entity_visibility(entity) == visibility_external_allocated) {
 290                         be_emit_cstring("@INDNTPOFF");
 291                 } else {
 292                         be_emit_cstring("@NTPOFF");
 293                 }
 294         }
 295
 296         if (do_pic && !no_pic_adjust) {
 297                 be_emit_char('-');
 298                 be_emit_string(pic_base_label);
 299         }
 300 }
 301
 302 static void emit_ia32_Immediate_no_prefix(const ir_node *node)
 303 {
 304         const ia32_immediate_attr_t *attr = get_ia32_immediate_attr_const(node);
 305
 306         if (attr->symconst != NULL) {
 307                 if (attr->sc_sign)
 308                         be_emit_char('-');
 309                 ia32_emit_entity(attr->symconst, attr->no_pic_adjust);
 310         }
 311         if (attr->symconst == NULL || attr->offset != 0) {
 312                 if (attr->symconst != NULL) {
 313                         be_emit_irprintf("%+d", attr->offset);
 314                 } else {
 315                         be_emit_irprintf("0x%X", attr->offset);
 316                 }
 317         }
 318 }
 319
 320 static void emit_ia32_Immediate(const ir_node *node)
 321 {
 322         be_emit_char('$');
 323         emit_ia32_Immediate_no_prefix(node);
 324 }
 325
 326 void ia32_emit_8bit_source_register_or_immediate(const ir_node *node, int pos)
 327 {
 328         const arch_register_t *reg;
 329         const ir_node         *in = get_irn_n(node, pos);
 330         if (is_ia32_Immediate(in)) {
 331                 emit_ia32_Immediate(in);
 332                 return;
 333         }
 334
 335         reg = get_in_reg(node, pos);
 336         emit_8bit_register(reg);
 337 }
 338
 339 void ia32_emit_8bit_high_source_register(const ir_node *node, int pos)
 340 {
 341         const arch_register_t *reg = get_in_reg(node, pos);
 342         emit_8bit_register_high(reg);
 343 }
 344
 345 void ia32_emit_16bit_source_register_or_immediate(const ir_node *node, int pos)
 346 {
 347         const arch_register_t *reg;
 348         const ir_node         *in = get_irn_n(node, pos);
 349         if (is_ia32_Immediate(in)) {
 350                 emit_ia32_Immediate(in);
 351                 return;
 352         }
 353
 354         reg = get_in_reg(node, pos);
 355         emit_16bit_register(reg);
 356 }
 357
 358 void ia32_emit_dest_register(const ir_node *node, int pos)
 359 {
 360         const arch_register_t *reg  = get_out_reg(node, pos);
 361
 362         emit_register(reg, NULL);
 363 }
 364
 365 void ia32_emit_dest_register_size(const ir_node *node, int pos)
 366 {
 367         const arch_register_t *reg  = get_out_reg(node, pos);
 368
 369         emit_register(reg, get_ia32_ls_mode(node));
 370 }
 371
 372 void ia32_emit_8bit_dest_register(const ir_node *node, int pos)
 373 {
 374         const arch_register_t *reg  = get_out_reg(node, pos);
 375
 376         emit_register(reg, mode_Bu);
 377 }
 378
 379 void ia32_emit_x87_register(const ir_node *node, int pos)
 380 {
 381         const ia32_x87_attr_t *attr = get_ia32_x87_attr_const(node);
 382
 383         assert(pos < 3);
 384         be_emit_char('%');
 385         be_emit_string(attr->x87[pos]->name);
 386 }
 387
 388 static void ia32_emit_mode_suffix_mode(const ir_mode *mode)
 389 {
 390         assert(mode_is_int(mode) || mode_is_reference(mode));
 391         switch (get_mode_size_bits(mode)) {
 392                 case 8:  be_emit_char('b');     return;
 393                 case 16: be_emit_char('w');     return;
 394                 case 32: be_emit_char('l');     return;
 395                 /* gas docu says q is the suffix but gcc, objdump and icc use ll
 396                  * apparently */
 397                 case 64: be_emit_cstring("ll"); return;
 398         }
 399         panic("Can't output mode_suffix for %+F", mode);
 400 }
 401
 402 void ia32_emit_mode_suffix(const ir_node *node)
 403 {
 404         ir_mode *mode = get_ia32_ls_mode(node);
 405         if (mode == NULL)
 406                 mode = mode_Iu;
 407
 408         ia32_emit_mode_suffix_mode(mode);
 409 }
 410
 411 void ia32_emit_x87_mode_suffix(const ir_node *node)
 412 {
 413         ir_mode *mode;
 414
 415         /* we only need to emit the mode on address mode */
 416         if (get_ia32_op_type(node) == ia32_Normal)
 417                 return;
 418
 419         mode = get_ia32_ls_mode(node);
 420         assert(mode != NULL);
 421
 422         if (mode_is_float(mode)) {
 423                 switch (get_mode_size_bits(mode)) {
 424                         case 32: be_emit_char('s'); return;
 425                         case 64: be_emit_char('l'); return;
 426                         case 80:
 427                         case 96: be_emit_char('t'); return;
 428                 }
 429         } else {
 430                 assert(mode_is_int(mode));
 431                 switch (get_mode_size_bits(mode)) {
 432                         case 16: be_emit_char('s');     return;
 433                         case 32: be_emit_char('l');     return;
 434                         /* gas docu says q is the suffix but gcc, objdump and icc use ll
 435                          * apparently */
 436                         case 64: be_emit_cstring("ll"); return;
 437                 }
 438         }
 439         panic("Can't output mode_suffix for %+F", mode);
 440 }
 441
 442 static char get_xmm_mode_suffix(ir_mode *mode)
 443 {
 444         assert(mode_is_float(mode));
 445         switch(get_mode_size_bits(mode)) {
 446         case 32: return 's';
 447         case 64: return 'd';
 448         default: panic("Invalid XMM mode");
 449         }
 450 }
 451
 452 void ia32_emit_xmm_mode_suffix(const ir_node *node)
 453 {
 454         ir_mode *mode = get_ia32_ls_mode(node);
 455         assert(mode != NULL);
 456         be_emit_char('s');
 457         be_emit_char(get_xmm_mode_suffix(mode));
 458 }
 459
 460 void ia32_emit_xmm_mode_suffix_s(const ir_node *node)
 461 {
 462         ir_mode *mode = get_ia32_ls_mode(node);
 463         assert(mode != NULL);
 464         be_emit_char(get_xmm_mode_suffix(mode));
 465 }
 466
 467 void ia32_emit_extend_suffix(const ir_node *node)
 468 {
 469         ir_mode *mode = get_ia32_ls_mode(node);
 470         if (get_mode_size_bits(mode) == 32)
 471                 return;
 472         be_emit_char(mode_is_signed(mode) ? 's' : 'z');
 473         ia32_emit_mode_suffix_mode(mode);
 474 }
 475
 476 void ia32_emit_source_register_or_immediate(const ir_node *node, int pos)
 477 {
 478         ir_node *in = get_irn_n(node, pos);
 479         if (is_ia32_Immediate(in)) {
 480                 emit_ia32_Immediate(in);
 481         } else {
 482                 const ir_mode         *mode = get_ia32_ls_mode(node);
 483                 const arch_register_t *reg  = get_in_reg(node, pos);
 484                 emit_register(reg, mode);
 485         }
 486 }
 487
 488 /**
 489  * Returns the target block for a control flow node.
 490  */
 491 static ir_node *get_cfop_target_block(const ir_node *irn)
 492 {
 493         assert(get_irn_mode(irn) == mode_X);
 494         return get_irn_link(irn);
 495 }
 496
 497 /**
 498  * Emits a block label for the given block.
 499  */
 500 static void ia32_emit_block_name(const ir_node *block)
 501 {
 502         if (has_Block_entity(block)) {
 503                 ir_entity *entity = get_Block_entity(block);
 504                 be_gas_emit_entity(entity);
 505         } else {
 506                 be_emit_cstring(BLOCK_PREFIX);
 507                 be_emit_irprintf("%ld", get_irn_node_nr(block));
 508         }
 509 }
 510
 511 /**
 512  * Emits the target label for a control flow node.
 513  */
 514 static void ia32_emit_cfop_target(const ir_node *node)
 515 {
 516         ir_node *block = get_cfop_target_block(node);
 517         ia32_emit_block_name(block);
 518 }
 519
 520 /*
 521  * positive conditions for signed compares
 522  */
 523 static const char *const cmp2condition_s[] = {
 524         NULL, /* always false */
 525         "e",  /* == */
 526         "l",  /* <  */
 527         "le", /* <= */
 528         "g",  /* >  */
 529         "ge", /* >= */
 530         "ne", /* != */
 531         NULL  /* always true */
 532 };
 533
 534 /*
 535  * positive conditions for unsigned compares
 536  */
 537 static const char *const cmp2condition_u[] = {
 538         NULL, /* always false */
 539         "e",  /* == */
 540         "b",  /* <  */
 541         "be", /* <= */
 542         "a",  /* >  */
 543         "ae", /* >= */
 544         "ne", /* != */
 545         NULL  /* always true */
 546 };
 547
 548 /**
 549  * Emit the suffix for a compare instruction.
 550  */
 551 static void ia32_emit_cmp_suffix(int pnc)
 552 {
 553         const char *str;
 554
 555         if (pnc == ia32_pn_Cmp_parity) {
 556                 be_emit_char('p');
 557                 return;
 558         }
 559         if (pnc & ia32_pn_Cmp_float || pnc & ia32_pn_Cmp_unsigned) {
 560                 str = cmp2condition_u[pnc & 7];
 561         } else {
 562                 str = cmp2condition_s[pnc & 7];
 563         }
 564
 565         be_emit_string(str);
 566 }
 567
 568 typedef enum ia32_emit_mod_t {
 569         EMIT_RESPECT_LS   = 1U << 0,
 570         EMIT_ALTERNATE_AM = 1U << 1,
 571         EMIT_LONG         = 1U << 2
 572 } ia32_emit_mod_t;
 573
 574 /**
 575  * Emits address mode.
 576  */
 577 void ia32_emit_am(const ir_node *node)
 578 {
 579         ir_entity *ent       = get_ia32_am_sc(node);
 580         int        offs      = get_ia32_am_offs_int(node);
 581         ir_node   *base      = get_irn_n(node, n_ia32_base);
 582         int        has_base  = !is_ia32_NoReg_GP(base);
 583         ir_node   *index     = get_irn_n(node, n_ia32_index);
 584         int        has_index = !is_ia32_NoReg_GP(index);
 585
 586         /* just to be sure... */
 587         assert(!is_ia32_use_frame(node) || get_ia32_frame_ent(node) != NULL);
 588
 589         /* emit offset */
 590         if (ent != NULL) {
 591                 const ia32_attr_t *attr = get_ia32_attr_const(node);
 592                 if (is_ia32_am_sc_sign(node))
 593                         be_emit_char('-');
 594                 ia32_emit_entity(ent, attr->data.am_sc_no_pic_adjust);
 595         }
 596
 597         /* also handle special case if nothing is set */
 598         if (offs != 0 || (ent == NULL && !has_base && !has_index)) {
 599                 if (ent != NULL) {
 600                         be_emit_irprintf("%+d", offs);
 601                 } else {
 602                         be_emit_irprintf("%d", offs);
 603                 }
 604         }
 605
 606         if (has_base || has_index) {
 607                 be_emit_char('(');
 608
 609                 /* emit base */
 610                 if (has_base) {
 611                         const arch_register_t *reg = get_in_reg(node, n_ia32_base);
 612                         emit_register(reg, NULL);
 613                 }
 614
 615                 /* emit index + scale */
 616                 if (has_index) {
 617                         const arch_register_t *reg = get_in_reg(node, n_ia32_index);
 618                         int scale;
 619                         be_emit_char(',');
 620                         emit_register(reg, NULL);
 621
 622                         scale = get_ia32_am_scale(node);
 623                         if (scale > 0) {
 624                                 be_emit_irprintf(",%d", 1 << scale);
 625                         }
 626                 }
 627                 be_emit_char(')');
 628         }
 629 }
 630
 631 /**
 632  * fmt  parameter               output
 633  * ---- ----------------------  ---------------------------------------------
 634  * %%                           %
 635  * %AM  <node>                  address mode of the node
 636  * %AR  const arch_register_t*  address mode of the node or register
 637  * %ASx <node>                  address mode of the node or source register x
 638  * %Dx  <node>                  destination register x
 639  * %I   <node>                  immediate of the node
 640  * %L   <node>                  control flow target of the node
 641  * %M   <node>                  mode suffix of the node
 642  * %P   int                     condition code
 643  * %R   const arch_register_t*  register
 644  * %Sx  <node>                  source register x
 645  * %s   const char*             string
 646  * %u   unsigned int            unsigned int
 647  * %d   signed int              signed int
 648  *
 649  * x starts at 0
 650  * # modifier for %ASx, %D and %S uses ls mode of node to alter register width
 651  * * modifier does not prefix immediates with $, but AM with *
 652  * l modifier for %lu and %ld
 653  */
 654 static void ia32_emitf(const ir_node *node, const char *fmt, ...)
 655 {
 656         va_list ap;
 657         va_start(ap, fmt);
 658
 659         for (;;) {
 660                 const char      *start = fmt;
 661                 ia32_emit_mod_t  mod   = 0;
 662
 663                 while (*fmt != '%' && *fmt != '\n' && *fmt != '\0')
 664                         ++fmt;
 665                 if (fmt != start) {
 666                         be_emit_string_len(start, fmt - start);
 667                 }
 668
 669                 if (*fmt == '\n') {
 670                         be_emit_finish_line_gas(node);
 671                         ++fmt;
 672                         if (*fmt == '\0')
 673                                 break;
 674                         continue;
 675                 }
 676
 677                 if (*fmt == '\0')
 678                         break;
 679
 680                 ++fmt;
 681                 if (*fmt == '*') {
 682                         mod |= EMIT_ALTERNATE_AM;
 683                         ++fmt;
 684                 }
 685
 686                 if (*fmt == '#') {
 687                         mod |= EMIT_RESPECT_LS;
 688                         ++fmt;
 689                 }
 690
 691                 if (*fmt == 'l') {
 692                         mod |= EMIT_LONG;
 693                         ++fmt;
 694                 }
 695
 696                 switch (*fmt++) {
 697                         case '%':
 698                                 be_emit_char('%');
 699                                 break;
 700
 701                         case 'A': {
 702                                 switch (*fmt++) {
 703                                         case 'M':
 704                                                 if (mod & EMIT_ALTERNATE_AM)
 705                                                         be_emit_char('*');
 706
 707                                                 ia32_emit_am(node);
 708                                                 break;
 709
 710                                         case 'R': {
 711                                                 const arch_register_t *reg = va_arg(ap, const arch_register_t*);
 712                                                 if (mod & EMIT_ALTERNATE_AM)
 713                                                         be_emit_char('*');
 714                                                 if (get_ia32_op_type(node) == ia32_AddrModeS) {
 715                                                         ia32_emit_am(node);
 716                                                 } else {
 717                                                         emit_register(reg, NULL);
 718                                                 }
 719                                                 break;
 720                                         }
 721
 722                                         case 'S':
 723                                                 if (get_ia32_op_type(node) == ia32_AddrModeS) {
 724                                                         if (mod & EMIT_ALTERNATE_AM)
 725                                                                 be_emit_char('*');
 726                                                         ia32_emit_am(node);
 727                                                         ++fmt;
 728                                                 } else {
 729                                                         assert(get_ia32_op_type(node) == ia32_Normal);
 730                                                         goto emit_S;
 731                                                 }
 732                                                 break;
 733
 734                                         default: goto unknown;
 735                                 }
 736                                 break;
 737                         }
 738
 739                         case 'D': {
 740                                 unsigned               pos;
 741                                 const arch_register_t *reg;
 742
 743                                 if (*fmt < '0' || '9' <= *fmt)
 744                                         goto unknown;
 745
 746                                 pos = *fmt++ - '0';
 747                                 reg = get_out_reg(node, pos);
 748                                 emit_register(reg, mod & EMIT_RESPECT_LS ? get_ia32_ls_mode(node) : NULL);
 749                                 break;
 750                         }
 751
 752                         case 'I':
 753                                 if (!(mod & EMIT_ALTERNATE_AM))
 754                                         be_emit_char('$');
 755                                 emit_ia32_Immediate_no_prefix(node);
 756                                 break;
 757
 758                         case 'L':
 759                                 ia32_emit_cfop_target(node);
 760                                 break;
 761
 762                         case 'M': {
 763                                 ia32_emit_mode_suffix_mode(get_ia32_ls_mode(node));
 764                                 break;
 765                         }
 766
 767                         case 'P': {
 768                                 int pnc = va_arg(ap, int);
 769                                 ia32_emit_cmp_suffix(pnc);
 770                                 break;
 771                         }
 772
 773                         case 'R': {
 774                                 const arch_register_t *reg = va_arg(ap, const arch_register_t*);
 775                                 emit_register(reg, NULL);
 776                                 break;
 777                         }
 778
 779 emit_S:
 780                         case 'S': {
 781                                 unsigned       pos;
 782                                 const ir_node *in;
 783
 784                                 if (*fmt < '0' || '9' <= *fmt)
 785                                         goto unknown;
 786
 787                                 pos = *fmt++ - '0';
 788                                 in  = get_irn_n(node, pos);
 789                                 if (is_ia32_Immediate(in)) {
 790                                         if (!(mod & EMIT_ALTERNATE_AM))
 791                                                 be_emit_char('$');
 792                                         emit_ia32_Immediate_no_prefix(in);
 793                                 } else {
 794                                         const arch_register_t *reg;
 795
 796                                         if (mod & EMIT_ALTERNATE_AM)
 797                                                 be_emit_char('*');
 798                                         reg = get_in_reg(node, pos);
 799                                         emit_register(reg, mod & EMIT_RESPECT_LS ? get_ia32_ls_mode(node) : NULL);
 800                                 }
 801                                 break;
 802                         }
 803
 804                         case 's': {
 805                                 const char *str = va_arg(ap, const char*);
 806                                 be_emit_string(str);
 807                                 break;
 808                         }
 809
 810                         case 'u':
 811                                 if (mod & EMIT_LONG) {
 812                                         unsigned long num = va_arg(ap, unsigned long);
 813                                         be_emit_irprintf("%lu", num);
 814                                 } else {
 815                                         unsigned num = va_arg(ap, unsigned);
 816                                         be_emit_irprintf("%u", num);
 817                                 }
 818                                 break;
 819
 820                         case 'd':
 821                                 if (mod & EMIT_LONG) {
 822                                         long num = va_arg(ap, long);
 823                                         be_emit_irprintf("%ld", num);
 824                                 } else {
 825                                         int num = va_arg(ap, int);
 826                                         be_emit_irprintf("%d", num);
 827                                 }
 828                                 break;
 829
 830                         default:
 831 unknown:
 832                                 panic("unknown format conversion in ia32_emitf()");
 833                 }
 834         }
 835
 836         va_end(ap);
 837 }
 838
 839 /**
 840  * Emits registers and/or address mode of a binary operation.
 841  */
 842 void ia32_emit_binop(const ir_node *node)
 843 {
 844         if (is_ia32_Immediate(get_irn_n(node, n_ia32_binary_right))) {
 845                 ia32_emitf(node, "%#S4, %#AS3");
 846         } else {
 847                 ia32_emitf(node, "%#AS4, %#S3");
 848         }
 849 }
 850
 851 /**
 852  * Emits registers and/or address mode of a binary operation.
 853  */
 854 void ia32_emit_x87_binop(const ir_node *node)
 855 {
 856         switch(get_ia32_op_type(node)) {
 857                 case ia32_Normal:
 858                         {
 859                                 const ia32_x87_attr_t *x87_attr = get_ia32_x87_attr_const(node);
 860                                 const arch_register_t *in1      = x87_attr->x87[0];
 861                                 const arch_register_t *in       = x87_attr->x87[1];
 862                                 const arch_register_t *out      = x87_attr->x87[2];
 863
 864                                 if (out == NULL) {
 865                                         out = in1;
 866                                 } else if (out == in) {
 867                                         in = in1;
 868                                 }
 869
 870                                 be_emit_char('%');
 871                                 be_emit_string(arch_register_get_name(in));
 872                                 be_emit_cstring(", %");
 873                                 be_emit_string(arch_register_get_name(out));
 874                         }
 875                         break;
 876                 case ia32_AddrModeS:
 877                         ia32_emit_am(node);
 878                         break;
 879                 case ia32_AddrModeD:
 880                 default:
 881                         assert(0 && "unsupported op type");
 882         }
 883 }
 884
 885 /**
 886  * Emits registers and/or address mode of a unary operation.
 887  */
 888 void ia32_emit_unop(const ir_node *node, int pos)
 889 {
 890         char fmt[] = "%ASx";
 891         fmt[3] = '0' + pos;
 892         ia32_emitf(node, fmt);
 893 }
 894
 895 static void emit_ia32_IMul(const ir_node *node)
 896 {
 897         ir_node               *left    = get_irn_n(node, n_ia32_IMul_left);
 898         const arch_register_t *out_reg = get_out_reg(node, pn_ia32_IMul_res);
 899
 900         /* do we need the 3-address form? */
 901         if (is_ia32_NoReg_GP(left) ||
 902                         get_in_reg(node, n_ia32_IMul_left) != out_reg) {
 903                 ia32_emitf(node, "\timul%M %#S4, %#AS3, %#D0\n");
 904         } else {
 905                 ia32_emitf(node, "\timul%M %#AS4, %#S3\n");
 906         }
 907 }
 908
 909 /**
 910  * walks up a tree of copies/perms/spills/reloads to find the original value
 911  * that is moved around
 912  */
 913 static ir_node *find_original_value(ir_node *node)
 914 {
 915         if (irn_visited(node))
 916                 return NULL;
 917
 918         mark_irn_visited(node);
 919         if (be_is_Copy(node)) {
 920                 return find_original_value(be_get_Copy_op(node));
 921         } else if (be_is_CopyKeep(node)) {
 922                 return find_original_value(be_get_CopyKeep_op(node));
 923         } else if (is_Proj(node)) {
 924                 ir_node *pred = get_Proj_pred(node);
 925                 if (be_is_Perm(pred)) {
 926                         return find_original_value(get_irn_n(pred, get_Proj_proj(node)));
 927                 } else if (be_is_MemPerm(pred)) {
 928                         return find_original_value(get_irn_n(pred, get_Proj_proj(node) + 1));
 929                 } else if (is_ia32_Load(pred)) {
 930                         return find_original_value(get_irn_n(pred, n_ia32_Load_mem));
 931                 } else {
 932                         return node;
 933                 }
 934         } else if (is_ia32_Store(node)) {
 935                 return find_original_value(get_irn_n(node, n_ia32_Store_val));
 936         } else if (is_Phi(node)) {
 937                 int i, arity;
 938                 arity = get_irn_arity(node);
 939                 for (i = 0; i < arity; ++i) {
 940                         ir_node *in  = get_irn_n(node, i);
 941                         ir_node *res = find_original_value(in);
 942
 943                         if (res != NULL)
 944                                 return res;
 945                 }
 946                 return NULL;
 947         } else {
 948                 return node;
 949         }
 950 }
 951
 952 static int determine_final_pnc(const ir_node *node, int flags_pos,
 953                                int pnc)
 954 {
 955         ir_node           *flags = get_irn_n(node, flags_pos);
 956         const ia32_attr_t *flags_attr;
 957         flags = skip_Proj(flags);
 958
 959         if (is_ia32_Sahf(flags)) {
 960                 ir_node *cmp = get_irn_n(flags, n_ia32_Sahf_val);
 961                 if (!(is_ia32_FucomFnstsw(cmp) || is_ia32_FucompFnstsw(cmp)
 962                                 || is_ia32_FucomppFnstsw(cmp) || is_ia32_FtstFnstsw(cmp))) {
 963                         inc_irg_visited(current_ir_graph);
 964                         cmp = find_original_value(cmp);
 965                         assert(cmp != NULL);
 966                         assert(is_ia32_FucomFnstsw(cmp) || is_ia32_FucompFnstsw(cmp)
 967                                || is_ia32_FucomppFnstsw(cmp) || is_ia32_FtstFnstsw(cmp));
 968                 }
 969
 970                 flags_attr = get_ia32_attr_const(cmp);
 971                 if (flags_attr->data.ins_permuted)
 972                         pnc = get_mirrored_pnc(pnc);
 973                 pnc |= ia32_pn_Cmp_float;
 974         } else if (is_ia32_Ucomi(flags) || is_ia32_Fucomi(flags)
 975                         || is_ia32_Fucompi(flags)) {
 976                 flags_attr = get_ia32_attr_const(flags);
 977
 978                 if (flags_attr->data.ins_permuted)
 979                         pnc = get_mirrored_pnc(pnc);
 980                 pnc |= ia32_pn_Cmp_float;
 981         } else {
 982                 flags_attr = get_ia32_attr_const(flags);
 983
 984                 if (flags_attr->data.ins_permuted)
 985                         pnc = get_mirrored_pnc(pnc);
 986                 if (flags_attr->data.cmp_unsigned)
 987                         pnc |= ia32_pn_Cmp_unsigned;
 988         }
 989
 990         return pnc;
 991 }
 992
 993 static pn_Cmp ia32_get_negated_pnc(pn_Cmp pnc)
 994 {
 995         ir_mode *mode = pnc & ia32_pn_Cmp_float ? mode_F : mode_Iu;
 996         return get_negated_pnc(pnc, mode);
 997 }
 998
 999 void ia32_emit_cmp_suffix_node(const ir_node *node,
1000                                int flags_pos)
1001 {
1002         const ia32_attr_t *attr = get_ia32_attr_const(node);
1003
1004         pn_Cmp pnc = get_ia32_condcode(node);
1005
1006         pnc = determine_final_pnc(node, flags_pos, pnc);
1007         if (attr->data.ins_permuted)
1008                 pnc = ia32_get_negated_pnc(pnc);
1009
1010         ia32_emit_cmp_suffix(pnc);
1011 }
1012
1013 /**
1014  * Emits an exception label for a given node.
1015  */
1016 static void ia32_emit_exc_label(const ir_node *node)
1017 {
1018         be_emit_string(be_gas_insn_label_prefix());
1019         be_emit_irprintf("%lu", get_ia32_exc_label_id(node));
1020 }
1021
1022 /**
1023  * Returns the Proj with projection number proj and NOT mode_M
1024  */
1025 static ir_node *get_proj(const ir_node *node, long proj)
1026 {
1027         const ir_edge_t *edge;
1028         ir_node         *src;
1029
1030         assert(get_irn_mode(node) == mode_T && "expected mode_T node");
1031
1032         foreach_out_edge(node, edge) {
1033                 src = get_edge_src_irn(edge);
1034
1035                 assert(is_Proj(src) && "Proj expected");
1036                 if (get_irn_mode(src) == mode_M)
1037                         continue;
1038
1039                 if (get_Proj_proj(src) == proj)
1040                         return src;
1041         }
1042         return NULL;
1043 }
1044
1045 static int can_be_fallthrough(const ir_node *node)
1046 {
1047         ir_node *target_block = get_cfop_target_block(node);
1048         ir_node *block        = get_nodes_block(node);
1049         return get_prev_block_sched(target_block) == block;
1050 }
1051
1052 /**
1053  * Emits the jump sequence for a conditional jump (cmp + jmp_true + jmp_false)
1054  */
1055 static void emit_ia32_Jcc(const ir_node *node)
1056 {
1057         int            need_parity_label = 0;
1058         const ir_node *proj_true;
1059         const ir_node *proj_false;
1060         const ir_node *block;
1061         pn_Cmp         pnc = get_ia32_condcode(node);
1062
1063         pnc = determine_final_pnc(node, 0, pnc);
1064
1065         /* get both Projs */
1066         proj_true = get_proj(node, pn_ia32_Jcc_true);
1067         assert(proj_true && "Jcc without true Proj");
1068
1069         proj_false = get_proj(node, pn_ia32_Jcc_false);
1070         assert(proj_false && "Jcc without false Proj");
1071
1072         block      = get_nodes_block(node);
1073
1074         if (can_be_fallthrough(proj_true)) {
1075                 /* exchange both proj's so the second one can be omitted */
1076                 const ir_node *t = proj_true;
1077
1078                 proj_true  = proj_false;
1079                 proj_false = t;
1080                 pnc        = ia32_get_negated_pnc(pnc);
1081         }
1082
1083         if (pnc & ia32_pn_Cmp_float) {
1084                 /* Some floating point comparisons require a test of the parity flag,
1085                  * which indicates that the result is unordered */
1086                 switch (pnc & 15) {
1087                         case pn_Cmp_Uo: {
1088                                 ia32_emitf(proj_true, "\tjp %L\n");
1089                                 break;
1090                         }
1091
1092                         case pn_Cmp_Leg:
1093                                 ia32_emitf(proj_true, "\tjnp %L\n");
1094                                 break;
1095
1096                         case pn_Cmp_Eq:
1097                         case pn_Cmp_Lt:
1098                         case pn_Cmp_Le:
1099                                 /* we need a local label if the false proj is a fallthrough
1100                                  * as the falseblock might have no label emitted then */
1101                                 if (can_be_fallthrough(proj_false)) {
1102                                         need_parity_label = 1;
1103                                         ia32_emitf(proj_false, "\tjp 1f\n");
1104                                 } else {
1105                                         ia32_emitf(proj_false, "\tjp %L\n");
1106                                 }
1107                                 goto emit_jcc;
1108
1109                         case pn_Cmp_Ug:
1110                         case pn_Cmp_Uge:
1111                         case pn_Cmp_Ne:
1112                                 ia32_emitf(proj_true, "\tjp %L\n");
1113                                 goto emit_jcc;
1114
1115                         default:
1116                                 goto emit_jcc;
1117                 }
1118         } else {
1119 emit_jcc:
1120                 ia32_emitf(proj_true, "\tj%P %L\n", pnc);
1121         }
1122
1123         if (need_parity_label) {
1124                 ia32_emitf(NULL, "1:\n");
1125         }
1126
1127         /* the second Proj might be a fallthrough */
1128         if (can_be_fallthrough(proj_false)) {
1129                 ia32_emitf(proj_false, "\t/* fallthrough to %L */\n");
1130         } else {
1131                 ia32_emitf(proj_false, "\tjmp %L\n");
1132         }
1133 }
1134
1135 static void emit_ia32_CMov(const ir_node *node)
1136 {
1137         const ia32_attr_t     *attr         = get_ia32_attr_const(node);
1138         int                    ins_permuted = attr->data.ins_permuted;
1139         const arch_register_t *out          = arch_irn_get_register(node, pn_ia32_res);
1140         pn_Cmp                 pnc          = get_ia32_condcode(node);
1141         const arch_register_t *in_true;
1142         const arch_register_t *in_false;
1143
1144         pnc = determine_final_pnc(node, n_ia32_CMov_eflags, pnc);
1145
1146         in_true  = arch_get_irn_register(get_irn_n(node, n_ia32_CMov_val_true));
1147         in_false = arch_get_irn_register(get_irn_n(node, n_ia32_CMov_val_false));
1148
1149         /* should be same constraint fullfilled? */
1150         if (out == in_false) {
1151                 /* yes -> nothing to do */
1152         } else if (out == in_true) {
1153                 const arch_register_t *tmp;
1154
1155                 assert(get_ia32_op_type(node) == ia32_Normal);
1156
1157                 ins_permuted = !ins_permuted;
1158
1159                 tmp      = in_true;
1160                 in_true  = in_false;
1161                 in_false = tmp;
1162         } else {
1163                 /* we need a mov */
1164                 ia32_emitf(node, "\tmovl %R, %R\n", in_false, out);
1165         }
1166
1167         if (ins_permuted)
1168                 pnc = ia32_get_negated_pnc(pnc);
1169
1170         /* TODO: handling of Nans isn't correct yet */
1171
1172         ia32_emitf(node, "\tcmov%P %#AR, %#R\n", pnc, in_true, out);
1173 }
1174
1175 /*********************************************************
1176  *                 _ _       _
1177  *                (_) |     (_)
1178  *   ___ _ __ ___  _| |_     _ _   _ _ __ ___  _ __  ___
1179  *  / _ \ '_ ` _ \| | __|   | | | | | '_ ` _ \| '_ \/ __|
1180  * |  __/ | | | | | | |_    | | |_| | | | | | | |_) \__ \
1181  *  \___|_| |_| |_|_|\__|   | |\__,_|_| |_| |_| .__/|___/
1182  *                         _/ |               | |
1183  *                        |__/                |_|
1184  *********************************************************/
1185
1186 /* jump table entry (target and corresponding number) */
1187 typedef struct _branch_t {
1188         ir_node *target;
1189         int      value;
1190 } branch_t;
1191
1192 /* jump table for switch generation */
1193 typedef struct _jmp_tbl_t {
1194         ir_node  *defProj;         /**< default target */
1195         long      min_value;       /**< smallest switch case */
1196         long      max_value;       /**< largest switch case */
1197         long      num_branches;    /**< number of jumps */
1198         char     *label;           /**< label of the jump table */
1199         branch_t *branches;        /**< jump array */
1200 } jmp_tbl_t;
1201
1202 /**
1203  * Compare two variables of type branch_t. Used to sort all switch cases
1204  */
1205 static int ia32_cmp_branch_t(const void *a, const void *b)
1206 {
1207         branch_t *b1 = (branch_t *)a;
1208         branch_t *b2 = (branch_t *)b;
1209
1210         if (b1->value <= b2->value)
1211                 return -1;
1212         else
1213                 return 1;
1214 }
1215
1216 /**
1217  * Emits code for a SwitchJmp (creates a jump table if
1218  * possible otherwise a cmp-jmp cascade). Port from
1219  * cggg ia32 backend
1220  */
1221 static void emit_ia32_SwitchJmp(const ir_node *node)
1222 {
1223         unsigned long       interval;
1224         int                 last_value, i;
1225         long                pnc;
1226         long                default_pn;
1227         jmp_tbl_t           tbl;
1228         ir_node            *proj;
1229         const ir_edge_t    *edge;
1230
1231         /* fill the table structure */
1232         tbl.label        = XMALLOCN(char, SNPRINTF_BUF_LEN);
1233         tbl.label        = get_unique_label(tbl.label, SNPRINTF_BUF_LEN, ".TBL_");
1234         tbl.defProj      = NULL;
1235         tbl.num_branches = get_irn_n_edges(node) - 1;
1236         tbl.branches     = XMALLOCNZ(branch_t, tbl.num_branches);
1237         tbl.min_value    = INT_MAX;
1238         tbl.max_value    = INT_MIN;
1239
1240         default_pn = get_ia32_condcode(node);
1241         i = 0;
1242         /* go over all proj's and collect them */
1243         foreach_out_edge(node, edge) {
1244                 proj = get_edge_src_irn(edge);
1245                 assert(is_Proj(proj) && "Only proj allowed at SwitchJmp");
1246
1247                 pnc = get_Proj_proj(proj);
1248
1249                 /* check for default proj */
1250                 if (pnc == default_pn) {
1251                         assert(tbl.defProj == NULL && "found two default Projs at SwitchJmp");
1252                         tbl.defProj = proj;
1253                 } else {
1254                         tbl.min_value = pnc < tbl.min_value ? pnc : tbl.min_value;
1255                         tbl.max_value = pnc > tbl.max_value ? pnc : tbl.max_value;
1256
1257                         /* create branch entry */
1258                         tbl.branches[i].target = proj;
1259                         tbl.branches[i].value  = pnc;
1260                         ++i;
1261                 }
1262
1263         }
1264         assert(i == tbl.num_branches);
1265
1266         /* sort the branches by their number */
1267         qsort(tbl.branches, tbl.num_branches, sizeof(tbl.branches[0]), ia32_cmp_branch_t);
1268
1269         /* two-complement's magic make this work without overflow */
1270         interval = tbl.max_value - tbl.min_value;
1271
1272         /* emit the table */
1273         ia32_emitf(node,        "\tcmpl $%u, %S0\n", interval);
1274         ia32_emitf(tbl.defProj, "\tja %L\n");
1275
1276         if (tbl.num_branches > 1) {
1277                 /* create table */
1278                 ia32_emitf(node, "\tjmp *%s(,%S0,4)\n", tbl.label);
1279
1280                 be_gas_emit_switch_section(GAS_SECTION_RODATA);
1281                 ia32_emitf(NULL, "\t.align 4\n");
1282                 ia32_emitf(NULL, "%s:\n", tbl.label);
1283
1284                 last_value = tbl.branches[0].value;
1285                 for (i = 0; i != tbl.num_branches; ++i) {
1286                         while (last_value != tbl.branches[i].value) {
1287                                 ia32_emitf(tbl.defProj, ".long %L\n");
1288                                 ++last_value;
1289                         }
1290                         ia32_emitf(tbl.branches[i].target, ".long %L\n");
1291                         ++last_value;
1292                 }
1293                 be_gas_emit_switch_section(GAS_SECTION_TEXT);
1294         } else {
1295                 /* one jump is enough */
1296                 ia32_emitf(tbl.branches[0].target, "\tjmp %L\n");
1297         }
1298
1299         if (tbl.label)
1300                 free(tbl.label);
1301         if (tbl.branches)
1302                 free(tbl.branches);
1303 }
1304
1305 /**
1306  * Emits code for a unconditional jump.
1307  */
1308 static void emit_Jmp(const ir_node *node)
1309 {
1310         ir_node *block;
1311
1312         /* for now, the code works for scheduled and non-schedules blocks */
1313         block = get_nodes_block(node);
1314
1315         /* we have a block schedule */
1316         if (can_be_fallthrough(node)) {
1317                 ia32_emitf(node, "\t/* fallthrough to %L */\n");
1318         } else {
1319                 ia32_emitf(node, "\tjmp %L\n");
1320         }
1321 }
1322
1323 /**
1324  * Emit an inline assembler operand.
1325  *
1326  * @param node  the ia32_ASM node
1327  * @param s     points to the operand (a %c)
1328  *
1329  * @return  pointer to the first char in s NOT in the current operand
1330  */
1331 static const char* emit_asm_operand(const ir_node *node, const char *s)
1332 {
1333         const ia32_attr_t     *ia32_attr = get_ia32_attr_const(node);
1334         const ia32_asm_attr_t *attr      = CONST_CAST_IA32_ATTR(ia32_asm_attr_t,
1335                                                             ia32_attr);
1336         const arch_register_t *reg;
1337         const ia32_asm_reg_t  *asm_regs = attr->register_map;
1338         const ia32_asm_reg_t  *asm_reg;
1339         const char            *reg_name;
1340         char                   c;
1341         char                   modifier = 0;
1342         int                    num      = -1;
1343         int                    p;
1344
1345         assert(*s == '%');
1346         c = *(++s);
1347
1348         /* parse modifiers */
1349         switch(c) {
1350         case 0:
1351                 ir_fprintf(stderr, "Warning: asm text (%+F) ends with %%\n", node);
1352                 be_emit_char('%');
1353                 return s + 1;
1354         case '%':
1355                 be_emit_char('%');
1356                 return s + 1;
1357         case 'w':
1358         case 'b':
1359         case 'h':
1360                 modifier = c;
1361                 ++s;
1362                 break;
1363         case '0':
1364         case '1':
1365         case '2':
1366         case '3':
1367         case '4':
1368         case '5':
1369         case '6':
1370         case '7':
1371         case '8':
1372         case '9':
1373                 break;
1374         default:
1375                 ir_fprintf(stderr,
1376                                 "Warning: asm text (%+F) contains unknown modifier '%c' for asm op\n",
1377                                 node, c);
1378                 ++s;
1379                 break;
1380         }
1381
1382         /* parse number */
1383         sscanf(s, "%d%n", &num, &p);
1384         if (num < 0) {
1385                 ir_fprintf(stderr, "Warning: Couldn't parse assembler operand (%+F)\n",
1386                            node);
1387                 return s;
1388         } else {
1389                 s += p;
1390         }
1391
1392         if (num < 0 || ARR_LEN(asm_regs) <= num) {
1393                 ir_fprintf(stderr,
1394                                 "Error: Custom assembler references invalid input/output (%+F)\n",
1395                                 node);
1396                 return s;
1397         }
1398         asm_reg = & asm_regs[num];
1399         assert(asm_reg->valid);
1400
1401         /* get register */
1402         if (asm_reg->use_input == 0) {
1403                 reg = get_out_reg(node, asm_reg->inout_pos);
1404         } else {
1405                 ir_node *pred = get_irn_n(node, asm_reg->inout_pos);
1406
1407                 /* might be an immediate value */
1408                 if (is_ia32_Immediate(pred)) {
1409                         emit_ia32_Immediate(pred);
1410                         return s;
1411                 }
1412                 reg = get_in_reg(node, asm_reg->inout_pos);
1413         }
1414         if (reg == NULL) {
1415                 ir_fprintf(stderr,
1416                                 "Warning: no register assigned for %d asm op (%+F)\n",
1417                                 num, node);
1418                 return s;
1419         }
1420
1421         if (asm_reg->memory) {
1422                 be_emit_char('(');
1423         }
1424
1425         /* emit it */
1426         if (modifier != 0) {
1427                 be_emit_char('%');
1428                 switch(modifier) {
1429                 case 'b':
1430                         reg_name = ia32_get_mapped_reg_name(isa->regs_8bit, reg);
1431                         break;
1432                 case 'h':
1433                         reg_name = ia32_get_mapped_reg_name(isa->regs_8bit_high, reg);
1434                         break;
1435                 case 'w':
1436                         reg_name = ia32_get_mapped_reg_name(isa->regs_16bit, reg);
1437                         break;
1438                 default:
1439                         panic("Invalid asm op modifier");
1440                 }
1441                 be_emit_string(reg_name);
1442         } else {
1443                 emit_register(reg, asm_reg->mode);
1444         }
1445
1446         if (asm_reg->memory) {
1447                 be_emit_char(')');
1448         }
1449
1450         return s;
1451 }
1452
1453 /**
1454  * Emits code for an ASM pseudo op.
1455  */
1456 static void emit_ia32_Asm(const ir_node *node)
1457 {
1458         const void            *gen_attr = get_irn_generic_attr_const(node);
1459         const ia32_asm_attr_t *attr
1460                 = CONST_CAST_IA32_ATTR(ia32_asm_attr_t, gen_attr);
1461         ident                 *asm_text = attr->asm_text;
1462         const char            *s        = get_id_str(asm_text);
1463
1464         ia32_emitf(node, "#APP\t\n");
1465
1466         if (s[0] != '\t')
1467                 be_emit_char('\t');
1468
1469         while(*s != 0) {
1470                 if (*s == '%') {
1471                         s = emit_asm_operand(node, s);
1472                 } else {
1473                         be_emit_char(*s++);
1474                 }
1475         }
1476
1477         ia32_emitf(NULL, "\n#NO_APP\n");
1478 }
1479
1480 /**********************************
1481  *   _____                  ____
1482  *  / ____|                |  _ \
1483  * | |     ___  _ __  _   _| |_) |
1484  * | |    / _ \| '_ \| | | |  _ <
1485  * | |___| (_) | |_) | |_| | |_) |
1486  *  \_____\___/| .__/ \__, |____/
1487  *             | |     __/ |
1488  *             |_|    |___/
1489  **********************************/
1490
1491 /**
1492  * Emit movsb/w instructions to make mov count divideable by 4
1493  */
1494 static void emit_CopyB_prolog(unsigned size)
1495 {
1496         if (size & 1)
1497                 ia32_emitf(NULL, "\tmovsb\n");
1498         if (size & 2)
1499                 ia32_emitf(NULL, "\tmovsw\n");
1500 }
1501
1502 /**
1503  * Emit rep movsd instruction for memcopy.
1504  */
1505 static void emit_ia32_CopyB(const ir_node *node)
1506 {
1507         unsigned size = get_ia32_copyb_size(node);
1508
1509         emit_CopyB_prolog(size);
1510         ia32_emitf(node, "\trep movsd\n");
1511 }
1512
1513 /**
1514  * Emits unrolled memcopy.
1515  */
1516 static void emit_ia32_CopyB_i(const ir_node *node)
1517 {
1518         unsigned size = get_ia32_copyb_size(node);
1519
1520         emit_CopyB_prolog(size);
1521
1522         size >>= 2;
1523         while (size--) {
1524                 ia32_emitf(NULL, "\tmovsd\n");
1525         }
1526 }
1527
1528
1529
1530 /***************************
1531  *   _____
1532  *  / ____|
1533  * | |     ___  _ ____   __
1534  * | |    / _ \| '_ \ \ / /
1535  * | |___| (_) | | | \ V /
1536  *  \_____\___/|_| |_|\_/
1537  *
1538  ***************************/
1539
1540 /**
1541  * Emit code for conversions (I, FP), (FP, I) and (FP, FP).
1542  */
1543 static void emit_ia32_Conv_with_FP(const ir_node *node, const char* conv_f,
1544                 const char* conv_d)
1545 {
1546         ir_mode            *ls_mode = get_ia32_ls_mode(node);
1547         int                 ls_bits = get_mode_size_bits(ls_mode);
1548         const char         *conv    = ls_bits == 32 ? conv_f : conv_d;
1549
1550         ia32_emitf(node, "\tcvt%s %AS3, %D0\n", conv);
1551 }
1552
1553 static void emit_ia32_Conv_I2FP(const ir_node *node)
1554 {
1555         emit_ia32_Conv_with_FP(node, "si2ss", "si2sd");
1556 }
1557
1558 static void emit_ia32_Conv_FP2I(const ir_node *node)
1559 {
1560         emit_ia32_Conv_with_FP(node, "ss2si", "sd2si");
1561 }
1562
1563 static void emit_ia32_Conv_FP2FP(const ir_node *node)
1564 {
1565         emit_ia32_Conv_with_FP(node, "sd2ss", "ss2sd");
1566 }
1567
1568 /**
1569  * Emits code for an Int conversion.
1570  */
1571 static void emit_ia32_Conv_I2I(const ir_node *node)
1572 {
1573         ir_mode *smaller_mode = get_ia32_ls_mode(node);
1574         int      signed_mode  = mode_is_signed(smaller_mode);
1575         const char *sign_suffix;
1576
1577         assert(!mode_is_float(smaller_mode));
1578
1579         sign_suffix = signed_mode ? "s" : "z";
1580         ia32_emitf(node, "\tmov%s%Ml %#AS3, %D0\n", sign_suffix);
1581 }
1582
1583 /**
1584  * Emits a call
1585  */
1586 static void emit_ia32_Call(const ir_node *node)
1587 {
1588         /* Special case: Call must not have its immediates prefixed by $, instead
1589          * address mode is prefixed by *. */
1590         ia32_emitf(node, "\tcall %*AS3\n");
1591 }
1592
1593
1594 /*******************************************
1595  *  _                          _
1596  * | |                        | |
1597  * | |__   ___ _ __   ___   __| | ___  ___
1598  * | '_ \ / _ \ '_ \ / _ \ / _` |/ _ \/ __|
1599  * | |_) |  __/ | | | (_) | (_| |  __/\__ \
1600  * |_.__/ \___|_| |_|\___/ \__,_|\___||___/
1601  *
1602  *******************************************/
1603
1604 /**
1605  * Emits code to increase stack pointer.
1606  */
1607 static void emit_be_IncSP(const ir_node *node)
1608 {
1609         int offs = be_get_IncSP_offset(node);
1610
1611         if (offs == 0)
1612                 return;
1613
1614         if (offs > 0) {
1615                 ia32_emitf(node, "\tsubl $%u, %D0\n", offs);
1616         } else {
1617                 ia32_emitf(node, "\taddl $%u, %D0\n", -offs);
1618         }
1619 }
1620
1621 /**
1622  * Emits code for Copy/CopyKeep.
1623  */
1624 static void Copy_emitter(const ir_node *node, const ir_node *op)
1625 {
1626         const arch_register_t *in  = arch_get_irn_register(op);
1627         const arch_register_t *out = arch_get_irn_register(node);
1628
1629         if (in == out) {
1630                 return;
1631         }
1632         if (is_unknown_reg(in))
1633                 return;
1634         /* copies of vf nodes aren't real... */
1635         if (arch_register_get_class(in) == &ia32_reg_classes[CLASS_ia32_vfp])
1636                 return;
1637
1638         if (get_irn_mode(node) == mode_E) {
1639                 ia32_emitf(node, "\tmovsd %R, %R\n", in, out);
1640         } else {
1641                 ia32_emitf(node, "\tmovl %R, %R\n", in, out);
1642         }
1643 }
1644
1645 static void emit_be_Copy(const ir_node *node)
1646 {
1647         Copy_emitter(node, be_get_Copy_op(node));
1648 }
1649
1650 static void emit_be_CopyKeep(const ir_node *node)
1651 {
1652         Copy_emitter(node, be_get_CopyKeep_op(node));
1653 }
1654
1655 /**
1656  * Emits code for exchange.
1657  */
1658 static void emit_be_Perm(const ir_node *node)
1659 {
1660         const arch_register_t *in0, *in1;
1661         const arch_register_class_t *cls0, *cls1;
1662
1663         in0 = arch_get_irn_register(get_irn_n(node, 0));
1664         in1 = arch_get_irn_register(get_irn_n(node, 1));
1665
1666         cls0 = arch_register_get_class(in0);
1667         cls1 = arch_register_get_class(in1);
1668
1669         assert(cls0 == cls1 && "Register class mismatch at Perm");
1670
1671         if (cls0 == &ia32_reg_classes[CLASS_ia32_gp]) {
1672                 ia32_emitf(node, "\txchg %R, %R\n", in1, in0);
1673         } else if (cls0 == &ia32_reg_classes[CLASS_ia32_xmm]) {
1674                 ia32_emitf(NULL, "\txorpd %R, %R\n", in1, in0);
1675                 ia32_emitf(NULL, "\txorpd %R, %R\n", in0, in1);
1676                 ia32_emitf(node, "\txorpd %R, %R\n", in1, in0);
1677         } else if (cls0 == &ia32_reg_classes[CLASS_ia32_vfp]) {
1678                 /* is a NOP */
1679         } else if (cls0 == &ia32_reg_classes[CLASS_ia32_st]) {
1680                 /* is a NOP */
1681         } else {
1682                 panic("unexpected register class in be_Perm (%+F)", node);
1683         }
1684 }
1685
1686 /**
1687  * Emits code for Constant loading.
1688  */
1689 static void emit_ia32_Const(const ir_node *node)
1690 {
1691         ia32_emitf(node, "\tmovl %I, %D0\n");
1692 }
1693
1694 /**
1695  * Emits code to load the TLS base
1696  */
1697 static void emit_ia32_LdTls(const ir_node *node)
1698 {
1699         ia32_emitf(node, "\tmovl %%gs:0, %D0\n");
1700 }
1701
1702 /* helper function for emit_ia32_Minus64Bit */
1703 static void emit_mov(const ir_node* node, const arch_register_t *src, const arch_register_t *dst)
1704 {
1705         ia32_emitf(node, "\tmovl %R, %R\n", src, dst);
1706 }
1707
1708 /* helper function for emit_ia32_Minus64Bit */
1709 static void emit_neg(const ir_node* node, const arch_register_t *reg)
1710 {
1711         ia32_emitf(node, "\tnegl %R\n", reg);
1712 }
1713
1714 /* helper function for emit_ia32_Minus64Bit */
1715 static void emit_sbb0(const ir_node* node, const arch_register_t *reg)
1716 {
1717         ia32_emitf(node, "\tsbbl $0, %R\n", reg);
1718 }
1719
1720 /* helper function for emit_ia32_Minus64Bit */
1721 static void emit_sbb(const ir_node* node, const arch_register_t *src, const arch_register_t *dst)
1722 {
1723         ia32_emitf(node, "\tsbbl %R, %R\n", src, dst);
1724 }
1725
1726 /* helper function for emit_ia32_Minus64Bit */
1727 static void emit_xchg(const ir_node* node, const arch_register_t *src, const arch_register_t *dst)
1728 {
1729         ia32_emitf(node, "\txchgl %R, %R\n", src, dst);
1730 }
1731
1732 /* helper function for emit_ia32_Minus64Bit */
1733 static void emit_zero(const ir_node* node, const arch_register_t *reg)
1734 {
1735         ia32_emitf(node, "\txorl %R, %R\n", reg, reg);
1736 }
1737
1738 static void emit_ia32_Minus64Bit(const ir_node *node)
1739 {
1740         const arch_register_t *in_lo  = get_in_reg(node, 0);
1741         const arch_register_t *in_hi  = get_in_reg(node, 1);
1742         const arch_register_t *out_lo = get_out_reg(node, 0);
1743         const arch_register_t *out_hi = get_out_reg(node, 1);
1744
1745         if (out_lo == in_lo) {
1746                 if (out_hi != in_hi) {
1747                         /* a -> a, b -> d */
1748                         goto zero_neg;
1749                 } else {
1750                         /* a -> a, b -> b */
1751                         goto normal_neg;
1752                 }
1753         } else if (out_lo == in_hi) {
1754                 if (out_hi == in_lo) {
1755                         /* a -> b, b -> a */
1756                         emit_xchg(node, in_lo, in_hi);
1757                         goto normal_neg;
1758                 } else {
1759                         /* a -> b, b -> d */
1760                         emit_mov(node, in_hi, out_hi);
1761                         emit_mov(node, in_lo, out_lo);
1762                         goto normal_neg;
1763                 }
1764         } else {
1765                 if (out_hi == in_lo) {
1766                         /* a -> c, b -> a */
1767                         emit_mov(node, in_lo, out_lo);
1768                         goto zero_neg;
1769                 } else if (out_hi == in_hi) {
1770                         /* a -> c, b -> b */
1771                         emit_mov(node, in_lo, out_lo);
1772                         goto normal_neg;
1773                 } else {
1774                         /* a -> c, b -> d */
1775                         emit_mov(node, in_lo, out_lo);
1776                         goto zero_neg;
1777                 }
1778         }
1779
1780 normal_neg:
1781         emit_neg( node, out_hi);
1782         emit_neg( node, out_lo);
1783         emit_sbb0(node, out_hi);
1784         return;
1785
1786 zero_neg:
1787         emit_zero(node, out_hi);
1788         emit_neg( node, out_lo);
1789         emit_sbb( node, in_hi, out_hi);
1790 }
1791
1792 static void emit_ia32_GetEIP(const ir_node *node)
1793 {
1794         ia32_emitf(node, "\tcall %s\n", pic_base_label);
1795         ia32_emitf(NULL, "%s:\n", pic_base_label);
1796         ia32_emitf(node, "\tpopl %D0\n");
1797 }
1798
1799 static void emit_ia32_ClimbFrame(const ir_node *node)
1800 {
1801         const ia32_climbframe_attr_t *attr = get_ia32_climbframe_attr_const(node);
1802
1803         ia32_emitf(node, "\tmovl %S0, %D0\n");
1804         ia32_emitf(node, "\tmovl $%u, %S1\n", attr->count);
1805         ia32_emitf(NULL, BLOCK_PREFIX "%ld:\n", get_irn_node_nr(node));
1806         ia32_emitf(node, "\tmovl (%D0), %D0\n");
1807         ia32_emitf(node, "\tdec %S1\n");
1808         ia32_emitf(node, "\tjnz " BLOCK_PREFIX "%ld\n", get_irn_node_nr(node));
1809 }
1810
1811 static void emit_be_Return(const ir_node *node)
1812 {
1813         unsigned pop = be_Return_get_pop(node);
1814
1815         if (pop > 0 || be_Return_get_emit_pop(node)) {
1816                 ia32_emitf(node, "\tret $%u\n", pop);
1817         } else {
1818                 ia32_emitf(node, "\tret\n");
1819         }
1820 }
1821
1822 static void emit_Nothing(const ir_node *node)
1823 {
1824         (void) node;
1825 }
1826
1827
1828 /***********************************************************************************
1829  *                  _          __                                             _
1830  *                 (_)        / _|                                           | |
1831  *  _ __ ___   __ _ _ _ __   | |_ _ __ __ _ _ __ ___   _____      _____  _ __| | __
1832  * | '_ ` _ \ / _` | | '_ \  |  _| '__/ _` | '_ ` _ \ / _ \ \ /\ / / _ \| '__| |/ /
1833  * | | | | | | (_| | | | | | | | | | | (_| | | | | | |  __/\ V  V / (_) | |  |   <
1834  * |_| |_| |_|\__,_|_|_| |_| |_| |_|  \__,_|_| |_| |_|\___| \_/\_/ \___/|_|  |_|\_\
1835  *
1836  ***********************************************************************************/
1837
1838 /**
1839  * Enters the emitter functions for handled nodes into the generic
1840  * pointer of an opcode.
1841  */
1842 static void ia32_register_emitters(void)
1843 {
1844 #define IA32_EMIT2(a,b) op_ia32_##a->ops.generic = (op_func)emit_ia32_##b
1845 #define IA32_EMIT(a)    IA32_EMIT2(a,a)
1846 #define EMIT(a)         op_##a->ops.generic = (op_func)emit_##a
1847 #define IGN(a)                  op_##a->ops.generic = (op_func)emit_Nothing
1848 #define BE_EMIT(a)      op_be_##a->ops.generic = (op_func)emit_be_##a
1849 #define BE_IGN(a)               op_be_##a->ops.generic = (op_func)emit_Nothing
1850
1851         /* first clear the generic function pointer for all ops */
1852         clear_irp_opcodes_generic_func();
1853
1854         /* register all emitter functions defined in spec */
1855         ia32_register_spec_emitters();
1856
1857         /* other ia32 emitter functions */
1858         IA32_EMIT2(Conv_I2I8Bit, Conv_I2I);
1859         IA32_EMIT(Asm);
1860         IA32_EMIT(CMov);
1861         IA32_EMIT(Call);
1862         IA32_EMIT(Const);
1863         IA32_EMIT(Conv_FP2FP);
1864         IA32_EMIT(Conv_FP2I);
1865         IA32_EMIT(Conv_I2FP);
1866         IA32_EMIT(Conv_I2I);
1867         IA32_EMIT(CopyB);
1868         IA32_EMIT(CopyB_i);
1869         IA32_EMIT(GetEIP);
1870         IA32_EMIT(IMul);
1871         IA32_EMIT(Jcc);
1872         IA32_EMIT(LdTls);
1873         IA32_EMIT(Minus64Bit);
1874         IA32_EMIT(SwitchJmp);
1875         IA32_EMIT(ClimbFrame);
1876
1877         /* benode emitter */
1878         BE_EMIT(Copy);
1879         BE_EMIT(CopyKeep);
1880         BE_EMIT(IncSP);
1881         BE_EMIT(Perm);
1882         BE_EMIT(Return);
1883
1884         BE_IGN(Barrier);
1885         BE_IGN(Keep);
1886         BE_IGN(RegParams);
1887
1888         /* firm emitter */
1889         EMIT(Jmp);
1890         IGN(Phi);
1891         IGN(Start);
1892
1893 #undef BE_EMIT
1894 #undef EMIT
1895 #undef IGN
1896 #undef IA32_EMIT2
1897 #undef IA32_EMIT
1898 }
1899
1900 typedef void (*emit_func_ptr) (const ir_node *);
1901
1902 /**
1903  * Assign and emit an exception label if the current instruction can fail.
1904  */
1905 static void ia32_assign_exc_label(ir_node *node)
1906 {
1907         /* assign a new ID to the instruction */
1908         set_ia32_exc_label_id(node, ++exc_label_id);
1909         /* print it */
1910         ia32_emit_exc_label(node);
1911         be_emit_char(':');
1912         be_emit_pad_comment();
1913         be_emit_cstring("/* exception to Block ");
1914         ia32_emit_cfop_target(node);
1915         be_emit_cstring(" */\n");
1916         be_emit_write_line();
1917 }
1918
1919 /**
1920  * Emits code for a node.
1921  */
1922 static void ia32_emit_node(ir_node *node)
1923 {
1924         ir_op *op = get_irn_op(node);
1925
1926         DBG((dbg, LEVEL_1, "emitting code for %+F\n", node));
1927
1928         if (is_ia32_irn(node)) {
1929                 if (get_ia32_exc_label(node)) {
1930                         /* emit the exception label of this instruction */
1931                         ia32_assign_exc_label(node);
1932                 }
1933                 if (mark_spill_reload) {
1934                         if (is_ia32_is_spill(node)) {
1935                                 ia32_emitf(NULL, "\txchg %ebx, %ebx        /* spill mark */\n");
1936                         }
1937                         if (is_ia32_is_reload(node)) {
1938                                 ia32_emitf(NULL, "\txchg %edx, %edx        /* reload mark */\n");
1939                         }
1940                         if (is_ia32_is_remat(node)) {
1941                                 ia32_emitf(NULL, "\txchg %ecx, %ecx        /* remat mark */\n");
1942                         }
1943                 }
1944         }
1945         if (op->ops.generic) {
1946                 emit_func_ptr func = (emit_func_ptr) op->ops.generic;
1947
1948                 be_dbg_set_dbg_info(get_irn_dbg_info(node));
1949
1950                 (*func) (node);
1951         } else {
1952                 emit_Nothing(node);
1953                 ir_fprintf(stderr, "Error: No emit handler for node %+F (%+G, graph %+F)\n", node, node, current_ir_graph);
1954                 abort();
1955         }
1956 }
1957
1958 /**
1959  * Emits gas alignment directives
1960  */
1961 static void ia32_emit_alignment(unsigned align, unsigned skip)
1962 {
1963         ia32_emitf(NULL, "\t.p2align %u,,%u\n", align, skip);
1964 }
1965
1966 /**
1967  * Emits gas alignment directives for Labels depended on cpu architecture.
1968  */
1969 static void ia32_emit_align_label(void)
1970 {
1971         unsigned align        = ia32_cg_config.label_alignment;
1972         unsigned maximum_skip = ia32_cg_config.label_alignment_max_skip;
1973         ia32_emit_alignment(align, maximum_skip);
1974 }
1975
1976 /**
1977  * Test whether a block should be aligned.
1978  * For cpus in the P4/Athlon class it is useful to align jump labels to
1979  * 16 bytes. However we should only do that if the alignment nops before the
1980  * label aren't executed more often than we have jumps to the label.
1981  */
1982 static int should_align_block(const ir_node *block)
1983 {
1984         static const double DELTA = .0001;
1985         ir_exec_freq *exec_freq   = cg->birg->exec_freq;
1986         ir_node      *prev        = get_prev_block_sched(block);
1987         double        block_freq;
1988         double        prev_freq = 0;  /**< execfreq of the fallthrough block */
1989         double        jmp_freq  = 0;  /**< execfreq of all non-fallthrough blocks */
1990         int           i, n_cfgpreds;
1991
1992         if (exec_freq == NULL)
1993                 return 0;
1994         if (ia32_cg_config.label_alignment_factor <= 0)
1995                 return 0;
1996
1997         block_freq = get_block_execfreq(exec_freq, block);
1998         if (block_freq < DELTA)
1999                 return 0;
2000
2001         n_cfgpreds = get_Block_n_cfgpreds(block);
2002         for(i = 0; i < n_cfgpreds; ++i) {
2003                 const ir_node *pred      = get_Block_cfgpred_block(block, i);
2004                 double         pred_freq = get_block_execfreq(exec_freq, pred);
2005
2006                 if (pred == prev) {
2007                         prev_freq += pred_freq;
2008                 } else {
2009                         jmp_freq  += pred_freq;
2010                 }
2011         }
2012
2013         if (prev_freq < DELTA && !(jmp_freq < DELTA))
2014                 return 1;
2015
2016         jmp_freq /= prev_freq;
2017
2018         return jmp_freq > ia32_cg_config.label_alignment_factor;
2019 }
2020
2021 /**
2022  * Emit the block header for a block.
2023  *
2024  * @param block       the block
2025  * @param prev_block  the previous block
2026  */
2027 static void ia32_emit_block_header(ir_node *block)
2028 {
2029         ir_graph     *irg = current_ir_graph;
2030         int           need_label = block_needs_label(block);
2031         int           i, arity;
2032         ir_exec_freq *exec_freq = cg->birg->exec_freq;
2033
2034         if (block == get_irg_end_block(irg))
2035                 return;
2036
2037         if (ia32_cg_config.label_alignment > 0) {
2038                 /* align the current block if:
2039                  * a) if should be aligned due to its execution frequency
2040                  * b) there is no fall-through here
2041                  */
2042                 if (should_align_block(block)) {
2043                         ia32_emit_align_label();
2044                 } else {
2045                         /* if the predecessor block has no fall-through,
2046                            we can always align the label. */
2047                         int i;
2048                         int has_fallthrough = 0;
2049
2050                         for (i = get_Block_n_cfgpreds(block) - 1; i >= 0; --i) {
2051                                 ir_node *cfg_pred = get_Block_cfgpred(block, i);
2052                                 if (can_be_fallthrough(cfg_pred)) {
2053                                         has_fallthrough = 1;
2054                                         break;
2055                                 }
2056                         }
2057
2058                         if (!has_fallthrough)
2059                                 ia32_emit_align_label();
2060                 }
2061         }
2062
2063         if (need_label) {
2064                 ia32_emit_block_name(block);
2065                 be_emit_char(':');
2066
2067                 be_emit_pad_comment();
2068                 be_emit_cstring("   /* ");
2069         } else {
2070                 be_emit_cstring("\t/* ");
2071                 ia32_emit_block_name(block);
2072                 be_emit_cstring(": ");
2073         }
2074
2075         be_emit_cstring("preds:");
2076
2077         /* emit list of pred blocks in comment */
2078         arity = get_irn_arity(block);
2079         if (arity <= 0) {
2080                 be_emit_cstring(" none");
2081         } else {
2082                 for (i = 0; i < arity; ++i) {
2083                         ir_node *predblock = get_Block_cfgpred_block(block, i);
2084                         be_emit_irprintf(" %d", get_irn_node_nr(predblock));
2085                 }
2086         }
2087         if (exec_freq != NULL) {
2088                 be_emit_irprintf(", freq: %f",
2089                                  get_block_execfreq(exec_freq, block));
2090         }
2091         be_emit_cstring(" */\n");
2092         be_emit_write_line();
2093 }
2094
2095 /**
2096  * Walks over the nodes in a block connected by scheduling edges
2097  * and emits code for each node.
2098  */
2099 static void ia32_gen_block(ir_node *block)
2100 {
2101         ir_node *node;
2102
2103         ia32_emit_block_header(block);
2104
2105         /* emit the contents of the block */
2106         be_dbg_set_dbg_info(get_irn_dbg_info(block));
2107         sched_foreach(block, node) {
2108                 ia32_emit_node(node);
2109         }
2110 }
2111
2112 typedef struct exc_entry {
2113         ir_node *exc_instr;  /** The instruction that can issue an exception. */
2114         ir_node *block;      /** The block to call then. */
2115 } exc_entry;
2116
2117 /**
2118  * Block-walker:
2119  * Sets labels for control flow nodes (jump target).
2120  * Links control predecessors to there destination blocks.
2121  */
2122 static void ia32_gen_labels(ir_node *block, void *data)
2123 {
2124         exc_entry **exc_list = data;
2125         ir_node *pred;
2126         int     n;
2127
2128         for (n = get_Block_n_cfgpreds(block) - 1; n >= 0; --n) {
2129                 pred = get_Block_cfgpred(block, n);
2130                 set_irn_link(pred, block);
2131
2132                 pred = skip_Proj(pred);
2133                 if (is_ia32_irn(pred) && get_ia32_exc_label(pred)) {
2134                         exc_entry e;
2135
2136                         e.exc_instr = pred;
2137                         e.block     = block;
2138                         ARR_APP1(exc_entry, *exc_list, e);
2139                         set_irn_link(pred, block);
2140                 }
2141         }
2142 }
2143
2144 /**
2145  * Compare two exception_entries.
2146  */
2147 static int cmp_exc_entry(const void *a, const void *b)
2148 {
2149         const exc_entry *ea = a;
2150         const exc_entry *eb = b;
2151
2152         if (get_ia32_exc_label_id(ea->exc_instr) < get_ia32_exc_label_id(eb->exc_instr))
2153                 return -1;
2154         return +1;
2155 }
2156
2157 /**
2158  * Main driver. Emits the code for one routine.
2159  */
2160 void ia32_gen_routine(ia32_code_gen_t *ia32_cg, ir_graph *irg)
2161 {
2162         ir_entity *entity     = get_irg_entity(irg);
2163         exc_entry *exc_list   = NEW_ARR_F(exc_entry, 0);
2164         int i, n;
2165
2166         cg       = ia32_cg;
2167         isa      = cg->isa;
2168         do_pic   = cg->birg->main_env->options->pic;
2169
2170         ia32_register_emitters();
2171
2172         get_unique_label(pic_base_label, sizeof(pic_base_label), ".PIC_BASE");
2173
2174         be_dbg_method_begin(entity, be_abi_get_stack_layout(cg->birg->abi));
2175         be_gas_emit_function_prolog(entity, ia32_cg_config.function_alignment);
2176
2177         /* we use links to point to target blocks */
2178         ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK);
2179         irg_block_walk_graph(irg, ia32_gen_labels, NULL, &exc_list);
2180
2181         /* initialize next block links */
2182         n = ARR_LEN(cg->blk_sched);
2183         for (i = 0; i < n; ++i) {
2184                 ir_node *block = cg->blk_sched[i];
2185                 ir_node *prev  = i > 0 ? cg->blk_sched[i-1] : NULL;
2186
2187                 set_irn_link(block, prev);
2188         }
2189
2190         for (i = 0; i < n; ++i) {
2191                 ir_node *block = cg->blk_sched[i];
2192
2193                 ia32_gen_block(block);
2194         }
2195
2196         be_gas_emit_function_epilog(entity);
2197         be_dbg_method_end();
2198         be_emit_char('\n');
2199         be_emit_write_line();
2200
2201         ir_free_resources(irg, IR_RESOURCE_IRN_LINK);
2202
2203         /* Sort the exception table using the exception label id's.
2204            Those are ascending with ascending addresses. */
2205         qsort(exc_list, ARR_LEN(exc_list), sizeof(exc_list[0]), cmp_exc_entry);
2206         {
2207                 int i;
2208
2209                 for (i = 0; i < ARR_LEN(exc_list); ++i) {
2210                         be_emit_cstring("\t.long ");
2211                         ia32_emit_exc_label(exc_list[i].exc_instr);
2212                         be_emit_char('\n');
2213                         be_emit_cstring("\t.long ");
2214                         ia32_emit_block_name(exc_list[i].block);
2215                         be_emit_char('\n');
2216                 }
2217         }
2218         DEL_ARR_F(exc_list);
2219 }
2220
2221 static const lc_opt_table_entry_t ia32_emitter_options[] = {
2222         LC_OPT_ENT_BOOL("mark_spill_reload",   "mark spills and reloads with ud opcodes", &mark_spill_reload),
2223         LC_OPT_LAST
2224 };
2225
2226 /* ==== Experimental binary emitter ==== */
2227
2228 static unsigned char reg_map[N_ia32_gp_REGS];
2229
2230 static void build_reg_map(void)
2231 {
2232         reg_map[REG_EAX] = 0x0;
2233         reg_map[REG_ECX] = 0x1;
2234         reg_map[REG_EDX] = 0x2;
2235         reg_map[REG_EBX] = 0x3;
2236         reg_map[REG_ESP] = 0x4;
2237         reg_map[REG_EBP] = 0x5;
2238         reg_map[REG_ESI] = 0x6;
2239         reg_map[REG_EDI] = 0x7;
2240 }
2241
2242 /* Node: The following routines are supposed to append bytes, words, dwords
2243    to the output stream.
2244    Currently the implementation is stupid in that it still creates output
2245    for an "assembler" in the form of .byte, .long
2246    We will change this when enough infrastructure is there to create complete
2247    machine code in memory/object files */
2248
2249 static void bemit8(const unsigned char byte)
2250 {
2251         be_emit_irprintf("\t.byte 0x%x\n", byte);
2252         be_emit_write_line();
2253 }
2254
2255 static void bemit16(const unsigned u16)
2256 {
2257         be_emit_irprintf("\t.word 0x%x\n", u16);
2258         be_emit_write_line();
2259 }
2260
2261 static void bemit32(const unsigned u32)
2262 {
2263         be_emit_irprintf("\t.long 0x%x\n", u32);
2264         be_emit_write_line();
2265 }
2266
2267 static void bemit_entity(ir_entity *entity, bool entity_sign, int offset,
2268                          bool is_relative)
2269 {
2270         if (entity == NULL) {
2271                 bemit32(offset);
2272                 return;
2273         }
2274
2275         /* the final version should remember the position in the bytestream
2276            and patch it with the correct address at linktime... */
2277         be_emit_cstring("\t.long ");
2278         if (entity_sign)
2279                 be_emit_char('-');
2280         set_entity_backend_marked(entity, 1);
2281         be_gas_emit_entity(entity);
2282
2283         if (is_relative) {
2284                 be_emit_cstring("-.");
2285         }
2286
2287         if (offset != 0) {
2288                 be_emit_irprintf("%+d", offset);
2289         }
2290         be_emit_char('\n');
2291         be_emit_write_line();
2292 }
2293
2294 /* end emit routines, all emitters following here should only use the functions
2295    above. */
2296
2297 static void bemit_modrr(const arch_register_t *op1_dest,
2298                         const arch_register_t *op2)
2299 {
2300         unsigned char modrm = 0xC0;
2301         modrm |= reg_map[op1_dest->index];
2302         modrm |= reg_map[op2->index] << 3;
2303         bemit8(modrm);
2304 }
2305
2306 static void bemit_modru(const arch_register_t *dest, unsigned val)
2307 {
2308         assert(val <= 7);
2309         unsigned char modrm = 0xC0;
2310         modrm |= reg_map[dest->index];
2311         modrm |= val << 3;
2312         bemit8(modrm);
2313 }
2314
2315 static unsigned get_imm_size(ir_entity *entity, int offset)
2316 {
2317         if (entity != NULL)
2318                 return 32;
2319         if (offset >= -127 && offset < 128) {
2320                 return 8;
2321         } else if (offset >= -32768 && offset < 32767) {
2322                 return 16;
2323         } else {
2324                 return 32;
2325         }
2326 }
2327
2328 static void bemit_binop_with_imm(const ir_node *node, unsigned opimm8,
2329                                  unsigned opimm32, unsigned ruval)
2330 {
2331         const arch_register_t       *reg  = get_out_reg(node, 0);
2332         const ir_node               *op   = get_irn_n(node, n_ia32_binary_right);
2333         const ia32_immediate_attr_t *attr = get_ia32_immediate_attr_const(op);
2334         unsigned size = get_imm_size(attr->symconst, attr->offset);
2335
2336         switch (size) {
2337         case 8:
2338                 bemit8(opimm8);
2339                 bemit_modru(reg, ruval);
2340                 bemit8(attr->offset);
2341                 return;
2342         case 16:
2343         case 32:
2344                 bemit8(opimm32);
2345                 bemit_modru(reg, ruval);
2346                 bemit_entity(attr->symconst, attr->sc_sign, attr->offset, false);
2347                 return;
2348         }
2349         panic("invalid imm size?!?");
2350 }
2351
2352 static void bemit_modsourceam(unsigned dest_reg, const ir_node *node)
2353 {
2354         ir_entity *ent       = get_ia32_am_sc(node);
2355         int        offs      = get_ia32_am_offs_int(node);
2356         ir_node   *base      = get_irn_n(node, n_ia32_base);
2357         int        has_base  = !is_ia32_NoReg_GP(base);
2358         ir_node   *index     = get_irn_n(node, n_ia32_index);
2359         int        has_index = !is_ia32_NoReg_GP(index);
2360         unsigned   modrm     = 0;
2361         unsigned   sib       = 0;
2362         unsigned   emitoffs  = 0;
2363         bool       emitsib   = false;
2364
2365         /* set the mod part depending on displacement */
2366         if (ent != NULL) {
2367                 modrm |= 0x80;
2368                 emitoffs = 32;
2369         } else if (offs == 0) {
2370                 emitoffs = 0;
2371         } else if (offs >= -127 && offs <= 128) {
2372                 modrm |= 0x40;
2373                 emitoffs = 8;
2374         } else {
2375                 modrm |= 0x80;
2376                 emitoffs = 32;
2377         }
2378
2379         /* determine if we need a SIB byte */
2380         if (has_index) {
2381                 const arch_register_t *reg_index = arch_get_irn_register(index);
2382                 assert(reg_index->index != REG_ESP);
2383                 sib |= reg_map[reg_index->index] << 3;
2384
2385                 if (has_base) {
2386                         const arch_register_t *reg = arch_get_irn_register(base);
2387                         sib |= reg_map[reg->index];
2388                 } else {
2389                         sib |= 0x05;
2390                 }
2391
2392                 int scale = get_ia32_am_scale(node);
2393                 assert(scale < 4);
2394                 sib |= scale << 6;
2395                 emitsib = true;
2396         }
2397
2398         /* determine modrm byte */
2399         if (emitsib) {
2400                 modrm |= 0x04;
2401         } else if (has_base) {
2402                 const arch_register_t *reg = arch_get_irn_register(base);
2403                 /* we are forced to emit a sib when base is ESP */
2404                 if (reg->index == REG_ESP) {
2405                         sib     = 0x24;
2406                         emitsib = true;
2407
2408                 /* we are forced to emit a 32bit offset as EBP base without
2409                    offset is a special case for displacement without base */
2410                 } else if (reg->index == REG_EBP && emitoffs == 0) {
2411                         assert( (modrm & 0xC0) == 0);
2412                         emitoffs  = 8;
2413                         modrm    |= 0x40;
2414                 }
2415                 modrm |= reg_map[reg->index];
2416         } else {
2417                 modrm    = 0x05;
2418                 emitoffs = 32;
2419         }
2420
2421         modrm |= dest_reg << 3;
2422
2423         bemit8(modrm);
2424         if (emitsib)
2425                 bemit8(sib);
2426
2427         /* emit displacement */
2428         if (emitoffs == 8) {
2429                 bemit8((unsigned) offs);
2430         } else if (emitoffs == 32) {
2431                 bemit_entity(ent, is_ia32_am_sc_sign(node), offs, false);
2432         }
2433 }
2434
2435 static void bemit_binop(const ir_node *node, unsigned modrr, unsigned am)
2436 {
2437         const arch_register_t *out = get_in_reg(node, n_ia32_binary_left);
2438         if (get_ia32_op_type(node) == ia32_AddrModeS) {
2439                 bemit8(am);
2440                 bemit_modsourceam(reg_map[out->index], node);
2441         } else {
2442                 const arch_register_t *op2 = get_in_reg(node, n_ia32_binary_right);
2443                 assert(get_ia32_op_type(node) == ia32_Normal);
2444                 bemit8(modrr);
2445                 bemit_modrr(out, op2);
2446         }
2447 }
2448
2449 static void bemit_immediate(const ir_node *node, bool relative)
2450 {
2451         const ia32_immediate_attr_t *attr = get_ia32_immediate_attr_const(node);
2452         bemit_entity(attr->symconst, attr->sc_sign, attr->offset, relative);
2453 }
2454
2455 static void bemit_copy(const ir_node *copy)
2456 {
2457         const ir_node *op = be_get_Copy_op(copy);
2458         const arch_register_t *in  = arch_get_irn_register(op);
2459         const arch_register_t *out = arch_get_irn_register(copy);
2460
2461         if (in == out || is_unknown_reg(in))
2462                 return;
2463         /* copies of vf nodes aren't real... */
2464         if (arch_register_get_class(in) == &ia32_reg_classes[CLASS_ia32_vfp])
2465                 return;
2466
2467         if (get_irn_mode(copy) == mode_E) {
2468                 panic("NIY");
2469         } else {
2470                 assert(arch_register_get_class(in) == &ia32_reg_classes[CLASS_ia32_gp]);
2471                 bemit8(0x89);
2472                 bemit_modrr(out, in);
2473         }
2474 }
2475
2476 static void bemit_xor0(const ir_node *node)
2477 {
2478         const arch_register_t *out = get_out_reg(node, 0);
2479         bemit8(0x31);
2480         bemit_modrr(out, out);
2481 }
2482
2483 static void bemit_const(const ir_node *node)
2484 {
2485         const arch_register_t *out = get_out_reg(node, 0);
2486         bemit8(0xB8 + reg_map[out->index]);
2487         bemit_immediate(node, false);
2488 }
2489
2490 static void bemit_add(const ir_node *node)
2491 {
2492         ir_node *right = get_irn_n(node, n_ia32_binary_right);
2493         if (is_ia32_Immediate(right)) {
2494                 /* TODO: there's a shorter variant with DEST=EAX */
2495                 bemit_binop_with_imm(node, 0x83, 0x81, 0);
2496         } else {
2497                 bemit_binop(node, 0x01, 0x03);
2498         }
2499 }
2500
2501 static void bemit_sub(const ir_node *node)
2502 {
2503         ir_node *right = get_irn_n(node, n_ia32_binary_right);
2504         if (is_ia32_Immediate(right)) {
2505                 /* TODO: there's a shorter variant with DEST=EAX */
2506                 bemit_binop_with_imm(node, 0x83, 0x81, 5);
2507         } else {
2508                 bemit_binop(node, 0x29, 0x2B);
2509         }
2510 }
2511
2512 static void bemit_xor(const ir_node *node)
2513 {
2514         ir_node *right = get_irn_n(node, n_ia32_binary_right);
2515         if (is_ia32_Immediate(right)) {
2516                 /* TODO: there's a shorter variant with DEST=EAX */
2517                 bemit_binop_with_imm(node, 0x83, 0x81, 6);
2518         } else {
2519                 bemit_binop(node, 0x31, 0x33);
2520         }
2521 }
2522
2523 static void bemit_not(const ir_node *node)
2524 {
2525         const arch_register_t *reg = get_out_reg(node, 0);
2526         bemit8(0xF7);
2527         bemit_modru(reg, 2);
2528 }
2529
2530 static void bemit_lea(const ir_node *node)
2531 {
2532         const arch_register_t *out = get_out_reg(node, 0);
2533         bemit8(0x8D);
2534         bemit_modsourceam(reg_map[out->index], node);
2535 }
2536
2537 static void bemit_cltd(const ir_node *node)
2538 {
2539         (void) node;
2540         bemit8(0x99);
2541 }
2542
2543 static void bemit_load(const ir_node *node)
2544 {
2545         const arch_register_t *out = get_out_reg(node, 0);
2546
2547         /* TODO: load from constant address to EAX can be encoded
2548            as 0xA1 [offset] */
2549         bemit8(0x8B);
2550         bemit_modsourceam(reg_map[out->index], node);
2551 }
2552
2553 static void bemit_store(const ir_node *node)
2554 {
2555         const ir_node *value = get_irn_n(node, n_ia32_Store_val);
2556
2557         if (is_ia32_Immediate(value)) {
2558                 bemit8(0xC7);
2559                 bemit_modsourceam(0, node);
2560                 bemit_immediate(value, false);
2561         } else {
2562                 /* TODO: store to constant address from EAX can be encoded as
2563                    0xA3 [offset]*/
2564                 const arch_register_t *in = get_in_reg(node, n_ia32_Store_val);
2565                 bemit8(0x89);
2566                 bemit_modsourceam(reg_map[in->index], node);
2567         }
2568 }
2569
2570 static void bemit_push(const ir_node *node)
2571 {
2572         const ir_node *value = get_irn_n(node, n_ia32_Push_val);
2573
2574         if (is_ia32_Immediate(value)) {
2575                 const ia32_immediate_attr_t *attr
2576                         = get_ia32_immediate_attr_const(value);
2577                 unsigned size = get_imm_size(attr->symconst, attr->offset);
2578                 /* TODO: check for bitsizes different from 32... */
2579                 switch (size) {
2580                 case 8:
2581                         bemit8(0x6A);
2582                         bemit8(attr->offset);
2583                         break;
2584                 case 16:
2585                 case 32:
2586                         bemit8(0x68);
2587                         bemit_immediate(value, false);
2588                         break;
2589                 }
2590         } else {
2591                 bemit8(0xFF);
2592                 bemit_modsourceam(6, node);
2593         }
2594 }
2595
2596 static void bemit_pop(const ir_node *node)
2597 {
2598         const arch_register_t *reg = get_out_reg(node, pn_ia32_Pop_res);
2599         /* TODO: check for AM pop */
2600         bemit8(0x58 + reg_map[reg->index]);
2601 }
2602
2603 static void bemit_call(const ir_node *node)
2604 {
2605         ir_node *proc = get_irn_n(node, n_ia32_Call_addr);
2606
2607         if (is_ia32_Immediate(proc)) {
2608                 bemit8(0xE8);
2609                 bemit_immediate(proc, true);
2610         } else {
2611                 panic("indirect call NIY");
2612         }
2613 }
2614
2615 static void bemit_return(const ir_node *node)
2616 {
2617         unsigned pop = be_Return_get_pop(node);
2618         if (pop > 0 || be_Return_get_emit_pop(node)) {
2619                 bemit8(0xC2);
2620                 assert(pop <= 0xffff);
2621                 bemit16(pop);
2622         } else {
2623                 bemit8(0xC3);
2624         }
2625 }
2626
2627 static void bemit_incsp(const ir_node *node)
2628 {
2629         const arch_register_t *reg  = get_out_reg(node, 0);
2630         int                    offs = be_get_IncSP_offset(node);
2631         unsigned               size = get_imm_size(NULL, offs);
2632
2633         if (offs > 0) {
2634                 bemit8(size == 8 ? 0x83 : 0x81);
2635                 bemit_modru(reg, 5); /* sub */
2636                 if (size == 8) {
2637                         bemit8(offs);
2638                 } else {
2639                         bemit32(offs);
2640                 }
2641         } else if (offs < 0) {
2642                 bemit8(size == 8 ? 0x83 : 0x81);
2643                 bemit_modru(reg, 0); /* add */
2644                 if (size == 8) {
2645                         bemit8(-offs);
2646                 } else {
2647                         bemit32(-offs);
2648                 }
2649         }
2650 }
2651
2652 /**
2653  * The type of a emitter function.
2654  */
2655 typedef void (*emit_func) (const ir_node *);
2656
2657 /**
2658  * Set a node emitter. Make it a bit more type safe.
2659  */
2660 static void register_emitter(ir_op *op, emit_func func)
2661 {
2662         op->ops.generic = (op_func) func;
2663 }
2664
2665 static void ia32_register_binary_emitters(void)
2666 {
2667         /* first clear the generic function pointer for all ops */
2668         clear_irp_opcodes_generic_func();
2669
2670         /* benode emitter */
2671         register_emitter(op_be_Copy, bemit_copy);
2672         register_emitter(op_be_Return, bemit_return);
2673         register_emitter(op_be_IncSP, bemit_incsp);
2674         register_emitter(op_ia32_Add, bemit_add);
2675         register_emitter(op_ia32_Call, bemit_call);
2676         register_emitter(op_ia32_Cltd, bemit_cltd);
2677         register_emitter(op_ia32_Sub, bemit_sub);
2678         register_emitter(op_ia32_Xor0, bemit_xor0);
2679         register_emitter(op_ia32_Xor, bemit_xor);
2680         register_emitter(op_ia32_Const, bemit_const);
2681         register_emitter(op_ia32_Lea, bemit_lea);
2682         register_emitter(op_ia32_Load, bemit_load);
2683         register_emitter(op_ia32_Not, bemit_not);
2684         register_emitter(op_ia32_Push, bemit_push);
2685         register_emitter(op_ia32_Pop, bemit_pop);
2686         register_emitter(op_ia32_Store, bemit_store);
2687
2688         /* ignore the following nodes */
2689         register_emitter(op_ia32_ProduceVal, emit_Nothing);
2690         register_emitter(op_be_Barrier, emit_Nothing);
2691         register_emitter(op_be_Keep, emit_Nothing);
2692         register_emitter(op_be_RegParams, emit_Nothing);
2693         register_emitter(op_Phi, emit_Nothing);
2694         register_emitter(op_Start, emit_Nothing);
2695 }
2696
2697 static void gen_binary_block(ir_node *block)
2698 {
2699         ir_node *node;
2700
2701         ia32_emit_block_header(block);
2702
2703         /* emit the contents of the block */
2704         sched_foreach(block, node) {
2705                 ia32_emit_node(node);
2706         }
2707 }
2708
2709 void ia32_gen_binary_routine(ia32_code_gen_t *ia32_cg, ir_graph *irg)
2710 {
2711         ir_entity *entity     = get_irg_entity(irg);
2712         int i, n;
2713
2714         cg  = ia32_cg;
2715         isa = cg->isa;
2716
2717         ia32_register_binary_emitters();
2718
2719         be_gas_emit_function_prolog(entity, ia32_cg_config.function_alignment);
2720
2721         /* we use links to point to target blocks */
2722         ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK);
2723         irg_block_walk_graph(irg, ia32_gen_labels, NULL, NULL);
2724
2725         /* initialize next block links */
2726         n = ARR_LEN(cg->blk_sched);
2727         for (i = 0; i < n; ++i) {
2728                 ir_node *block = cg->blk_sched[i];
2729                 ir_node *prev  = i > 0 ? cg->blk_sched[i-1] : NULL;
2730
2731                 set_irn_link(block, prev);
2732         }
2733
2734         for (i = 0; i < n; ++i) {
2735                 ir_node *block = cg->blk_sched[i];
2736                 gen_binary_block(block);
2737         }
2738
2739         be_gas_emit_function_epilog(entity);
2740         be_dbg_method_end();
2741         be_emit_char('\n');
2742         be_emit_write_line();
2743
2744         ir_free_resources(irg, IR_RESOURCE_IRN_LINK);
2745 }
2746
2747
2748
2749
2750 void ia32_init_emitter(void)
2751 {
2752         lc_opt_entry_t *be_grp;
2753         lc_opt_entry_t *ia32_grp;
2754
2755         be_grp   = lc_opt_get_grp(firm_opt_get_root(), "be");
2756         ia32_grp = lc_opt_get_grp(be_grp, "ia32");
2757
2758         lc_opt_add_table(ia32_grp, ia32_emitter_options);
2759
2760         build_reg_map();
2761
2762         FIRM_DBG_REGISTER(dbg, "firm.be.ia32.emitter");
2763 }