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

   1 /**
   2  * This file implements the node emitter.
   3  * @author Christian Wuerdig, Matthias Braun
   4  * $Id$
   5  */
   6 #ifdef HAVE_CONFIG_H
   7 #include <config.h>
   8 #endif
   9
  10 #include <limits.h>
  11
  12 #include "xmalloc.h"
  13 #include "tv.h"
  14 #include "iredges.h"
  15 #include "debug.h"
  16 #include "irgwalk.h"
  17 #include "irprintf.h"
  18 #include "irop_t.h"
  19 #include "irargs_t.h"
  20 #include "irprog_t.h"
  21 #include "iredges_t.h"
  22 #include "execfreq.h"
  23 #include "error.h"
  24 #include "raw_bitset.h"
  25
  26 #include "../besched_t.h"
  27 #include "../benode_t.h"
  28 #include "../beabi.h"
  29 #include "../be_dbgout.h"
  30 #include "../beemitter.h"
  31 #include "../begnuas.h"
  32
  33 #include "ia32_emitter.h"
  34 #include "gen_ia32_emitter.h"
  35 #include "gen_ia32_regalloc_if.h"
  36 #include "ia32_nodes_attr.h"
  37 #include "ia32_new_nodes.h"
  38 #include "ia32_map_regs.h"
  39 #include "bearch_ia32_t.h"
  40
  41 #define BLOCK_PREFIX ".L"
  42
  43 #define SNPRINTF_BUF_LEN 128
  44
  45 /* global arch_env for lc_printf functions */
  46 static const arch_env_t *arch_env = NULL;
  47
  48 /**
  49  * Returns the register at in position pos.
  50  */
  51 static const arch_register_t *get_in_reg(const ir_node *irn, int pos) {
  52         ir_node                *op;
  53         const arch_register_t  *reg = NULL;
  54
  55         assert(get_irn_arity(irn) > pos && "Invalid IN position");
  56
  57         /* The out register of the operator at position pos is the
  58            in register we need. */
  59         op = get_irn_n(irn, pos);
  60
  61         reg = arch_get_irn_register(arch_env, op);
  62
  63         assert(reg && "no in register found");
  64
  65         /* in case of a joker register: just return a valid register */
  66         if (arch_register_type_is(reg, joker)) {
  67                 const arch_register_req_t *req;
  68
  69                 /* ask for the requirements */
  70                 req = arch_get_register_req(arch_env, irn, pos);
  71
  72                 if (arch_register_req_is(req, limited)) {
  73                         /* in case of limited requirements: get the first allowed register */
  74                         unsigned idx = rbitset_next(req->limited, 0, 1);
  75                         reg = arch_register_for_index(req->cls, idx);
  76                 } else {
  77                         /* otherwise get first register in class */
  78                         reg = arch_register_for_index(req->cls, 0);
  79                 }
  80         }
  81
  82         return reg;
  83 }
  84
  85 /**
  86  * Returns the register at out position pos.
  87  */
  88 static const arch_register_t *get_out_reg(const ir_node *irn, int pos) {
  89         ir_node                *proj;
  90         const arch_register_t  *reg = NULL;
  91
  92         /* 1st case: irn is not of mode_T, so it has only                 */
  93         /*           one OUT register -> good                             */
  94         /* 2nd case: irn is of mode_T -> collect all Projs and ask the    */
  95         /*           Proj with the corresponding projnum for the register */
  96
  97         if (get_irn_mode(irn) != mode_T) {
  98                 reg = arch_get_irn_register(arch_env, irn);
  99         } else if (is_ia32_irn(irn)) {
 100                 reg = get_ia32_out_reg(irn, pos);
 101         } else {
 102                 const ir_edge_t *edge;
 103
 104                 foreach_out_edge(irn, edge) {
 105                         proj = get_edge_src_irn(edge);
 106                         assert(is_Proj(proj) && "non-Proj from mode_T node");
 107                         if (get_Proj_proj(proj) == pos) {
 108                                 reg = arch_get_irn_register(arch_env, proj);
 109                                 break;
 110                         }
 111                 }
 112         }
 113
 114         assert(reg && "no out register found");
 115         return reg;
 116 }
 117
 118 /**
 119  * Returns an ident for the given tarval tv.
 120  */
 121 static ident *get_ident_for_tv(tarval *tv) {
 122         char buf[256];
 123         tarval_snprintf(buf, sizeof(buf), tv);
 124         return new_id_from_str(buf);
 125 }
 126
 127 /**
 128  * Determine the gnu assembler suffix that indicates a mode
 129  */
 130 static char get_mode_suffix(const ir_mode *mode) {
 131         if(mode_is_float(mode)) {
 132                 switch(get_mode_size_bits(mode)) {
 133                 case 32:
 134                         return 's';
 135                 case 64:
 136                         return 'l';
 137                 case 80:
 138                         return 't';
 139                 }
 140         } else {
 141                 assert(mode_is_int(mode) || mode_is_reference(mode));
 142                 switch(get_mode_size_bits(mode)) {
 143                 case 64:
 144                         return 'q';
 145                 case 32:
 146                         return 'l';
 147                 case 16:
 148                         return 'w';
 149                 case 8:
 150                         return 'b';
 151                 }
 152         }
 153         panic("Can't output mode_suffix for %+F\n", mode);
 154 }
 155
 156 static int produces_result(const ir_node *node) {
 157         return !(is_ia32_St(node) ||
 158                 is_ia32_Store8Bit(node) ||
 159                 is_ia32_CondJmp(node) ||
 160                 is_ia32_xCondJmp(node) ||
 161                 is_ia32_CmpSet(node) ||
 162                 is_ia32_xCmpSet(node) ||
 163                 is_ia32_SwitchJmp(node));
 164 }
 165
 166 static const char *ia32_get_reg_name_for_mode(ia32_emit_env_t *env, ir_mode *mode, const arch_register_t *reg) {
 167         switch(get_mode_size_bits(mode)) {
 168                 case 8:
 169                         return ia32_get_mapped_reg_name(env->isa->regs_8bit, reg);
 170                 case 16:
 171                         return ia32_get_mapped_reg_name(env->isa->regs_16bit, reg);
 172                 default:
 173                         return (char *)arch_register_get_name(reg);
 174         }
 175 }
 176
 177 /**
 178  * Add a number to a prefix. This number will not be used a second time.
 179  */
 180 static char *get_unique_label(char *buf, size_t buflen, const char *prefix) {
 181         static unsigned long id = 0;
 182         snprintf(buf, buflen, "%s%lu", prefix, ++id);
 183         return buf;
 184 }
 185
 186 /*************************************************************
 187  *             _       _    __   _          _
 188  *            (_)     | |  / _| | |        | |
 189  *  _ __  _ __ _ _ __ | |_| |_  | |__   ___| |_ __   ___ _ __
 190  * | '_ \| '__| | '_ \| __|  _| | '_ \ / _ \ | '_ \ / _ \ '__|
 191  * | |_) | |  | | | | | |_| |   | | | |  __/ | |_) |  __/ |
 192  * | .__/|_|  |_|_| |_|\__|_|   |_| |_|\___|_| .__/ \___|_|
 193  * | |                                       | |
 194  * |_|                                       |_|
 195  *************************************************************/
 196
 197 // we have no C++ and can't define an implicit ia32_emit_env_t* cast to
 198 // be_emit_env_t* so we cheat a bit...
 199 #define be_emit_char(env,c)             be_emit_char(env->emit,c)
 200 #define be_emit_string(env,s)           be_emit_string(env->emit,s)
 201 #undef be_emit_cstring
 202 #define be_emit_cstring(env,x)          { be_emit_string_len(env->emit, x, sizeof(x)-1); }
 203 #define be_emit_ident(env,i)            be_emit_ident(env->emit,i)
 204 #define be_emit_write_line(env)         be_emit_write_line(env->emit)
 205 #define be_emit_finish_line_gas(env,n)  be_emit_finish_line_gas(env->emit,n)
 206 #define be_emit_pad_comment(env)        be_emit_pad_comment(env->emit)
 207
 208 void ia32_emit_source_register(ia32_emit_env_t *env, const ir_node *node, int pos)
 209 {
 210         const arch_register_t *reg = get_in_reg(node, pos);
 211         const char *reg_name = arch_register_get_name(reg);
 212
 213         assert(pos < get_irn_arity(node));
 214
 215         be_emit_char(env, '%');
 216         be_emit_string(env, reg_name);
 217 }
 218
 219 void ia32_emit_dest_register(ia32_emit_env_t *env, const ir_node *node, int pos) {
 220         const arch_register_t *reg = get_out_reg(node, pos);
 221         const char *reg_name = arch_register_get_name(reg);
 222
 223         be_emit_char(env, '%');
 224         be_emit_string(env, reg_name);
 225 }
 226
 227 void ia32_emit_x87_name(ia32_emit_env_t *env, const ir_node *node, int pos)
 228 {
 229         ia32_attr_t *attr = get_ia32_attr(node);
 230
 231         assert(pos < 3);
 232         be_emit_char(env, '%');
 233         be_emit_string(env, attr->x87[pos]->name);
 234 }
 235
 236 void ia32_emit_immediate(ia32_emit_env_t *env, const ir_node *node)
 237 {
 238         tarval *tv;
 239         ident *id;
 240
 241         switch(get_ia32_immop_type(node)) {
 242         case ia32_ImmConst:
 243                 tv = get_ia32_Immop_tarval(node);
 244                 id = get_ident_for_tv(tv);
 245                 break;
 246         case ia32_ImmSymConst:
 247                 id = get_ia32_Immop_symconst(node);
 248                 break;
 249         default:
 250                 assert(0);
 251                 be_emit_string(env, "BAD");
 252                 return;
 253         }
 254
 255         be_emit_ident(env, id);
 256 }
 257
 258 void ia32_emit_mode_suffix(ia32_emit_env_t *env, const ir_mode *mode)
 259 {
 260         be_emit_char(env, get_mode_suffix(mode));
 261 }
 262
 263 void ia32_emit_x87_mode_suffix(ia32_emit_env_t *env, const ir_node *node)
 264 {
 265         ir_mode *mode = get_ia32_ls_mode(node);
 266         if(mode != NULL)
 267                 ia32_emit_mode_suffix(env, mode);
 268 }
 269
 270 static char get_xmm_mode_suffix(ir_mode *mode)
 271 {
 272         assert(mode_is_float(mode));
 273         switch(get_mode_size_bits(mode)) {
 274         case 32:
 275                 return 's';
 276         case 64:
 277                 return 'd';
 278         default:
 279                 assert(0);
 280         }
 281         return '%';
 282 }
 283
 284 void ia32_emit_xmm_mode_suffix(ia32_emit_env_t *env, const ir_node *node)
 285 {
 286         ir_mode *mode = get_ia32_ls_mode(node);
 287         assert(mode != NULL);
 288         be_emit_char(env, 's');
 289         be_emit_char(env, get_xmm_mode_suffix(mode));
 290 }
 291
 292 void ia32_emit_xmm_mode_suffix_s(ia32_emit_env_t *env, const ir_node *node)
 293 {
 294         ir_mode *mode = get_ia32_ls_mode(node);
 295         assert(mode != NULL);
 296         be_emit_char(env, get_xmm_mode_suffix(mode));
 297 }
 298
 299 void ia32_emit_extend_suffix(ia32_emit_env_t *env, const ir_mode *mode)
 300 {
 301         if(get_mode_size_bits(mode) == 32)
 302                 return;
 303         if(mode_is_signed(mode)) {
 304                 be_emit_char(env, 's');
 305         } else {
 306                 be_emit_char(env, 'z');
 307         }
 308 }
 309
 310 static void ia32_emit_function_object(ia32_emit_env_t *env, const char *name)
 311 {
 312         switch (be_gas_flavour) {
 313         case GAS_FLAVOUR_NORMAL:
 314                 be_emit_cstring(env, "\t.type\t");
 315                 be_emit_string(env, name);
 316                 be_emit_cstring(env, ", @function\n");
 317                 be_emit_write_line(env);
 318                 break;
 319         case GAS_FLAVOUR_MINGW:
 320                 be_emit_cstring(env, "\t.def\t");
 321                 be_emit_string(env, name);
 322                 be_emit_cstring(env, ";\t.scl\t2;\t.type\t32;\t.endef\n");
 323                 be_emit_write_line(env);
 324                 break;
 325         default:
 326                 break;
 327         }
 328 }
 329
 330 static void ia32_emit_function_size(ia32_emit_env_t *env, const char *name)
 331 {
 332         switch (be_gas_flavour) {
 333         case GAS_FLAVOUR_NORMAL:
 334                 be_emit_cstring(env, "\t.size\t");
 335                 be_emit_string(env, name);
 336                 be_emit_cstring(env, ", .-");
 337                 be_emit_string(env, name);
 338                 be_emit_char(env, '\n');
 339                 be_emit_write_line(env);
 340                 break;
 341         default:
 342                 break;
 343         }
 344 }
 345
 346
 347
 348 /**
 349  * Emits registers and/or address mode of a binary operation.
 350  */
 351 void ia32_emit_binop(ia32_emit_env_t *env, const ir_node *node) {
 352         switch(get_ia32_op_type(node)) {
 353                 case ia32_Normal:
 354                         if (is_ia32_ImmConst(node) || is_ia32_ImmSymConst(node)) {
 355                                 be_emit_char(env, '$');
 356                                 ia32_emit_immediate(env, node);
 357                                 be_emit_cstring(env, ", ");
 358                                 ia32_emit_source_register(env, node, 2);
 359                         } else {
 360                                 const arch_register_t *in1 = get_in_reg(node, 2);
 361                                 const arch_register_t *in2 = get_in_reg(node, 3);
 362                                 const arch_register_t *out = produces_result(node) ? get_out_reg(node, 0) : NULL;
 363                                 const arch_register_t *in;
 364                                 const char            *in_name;
 365
 366                                 in      = out ? (REGS_ARE_EQUAL(out, in2) ? in1 : in2) : in2;
 367                                 out     = out ? out : in1;
 368                                 in_name = arch_register_get_name(in);
 369
 370                                 if (is_ia32_emit_cl(node)) {
 371                                         assert(REGS_ARE_EQUAL(&ia32_gp_regs[REG_ECX], in) && "shift operation needs ecx");
 372                                         in_name = "cl";
 373                                 }
 374
 375                                 be_emit_char(env, '%');
 376                                 be_emit_string(env, in_name);
 377                                 be_emit_cstring(env, ", %");
 378                                 be_emit_string(env, arch_register_get_name(out));
 379                         }
 380                         break;
 381                 case ia32_AddrModeS:
 382                         if (is_ia32_ImmConst(node) || is_ia32_ImmSymConst(node)) {
 383                                 assert(!produces_result(node) && "Source AM with Const must not produce result");
 384                                 ia32_emit_am(env, node);
 385                                 be_emit_cstring(env, ", $");
 386                                 ia32_emit_immediate(env, node);
 387                         } else if (produces_result(node)) {
 388                                 ia32_emit_am(env, node);
 389                                 be_emit_cstring(env, ", ");
 390                                 ia32_emit_dest_register(env, node, 0);
 391                         } else {
 392                                 ia32_emit_am(env, node);
 393                                 be_emit_cstring(env, ", ");
 394                                 ia32_emit_source_register(env, node, 2);
 395                         }
 396                         break;
 397                 case ia32_AddrModeD:
 398                         if (is_ia32_ImmConst(node) || is_ia32_ImmSymConst(node)) {
 399                                 be_emit_char(env, '$');
 400                                 ia32_emit_immediate(env, node);
 401                                 be_emit_cstring(env, ", ");
 402                                 ia32_emit_am(env, node);
 403                         } else {
 404                                 const arch_register_t *in1 = get_in_reg(node, get_irn_arity(node) == 5 ? 3 : 2);
 405                                 ir_mode               *mode = get_ia32_ls_mode(node);
 406                                 const char            *in_name;
 407
 408                                 in_name = ia32_get_reg_name_for_mode(env, mode, in1);
 409
 410                                 if (is_ia32_emit_cl(node)) {
 411                                         assert(REGS_ARE_EQUAL(&ia32_gp_regs[REG_ECX], in1) && "shift operation needs ecx");
 412                                         in_name = "cl";
 413                                 }
 414
 415                                 be_emit_char(env, '%');
 416                                 be_emit_string(env, in_name);
 417                                 be_emit_cstring(env, ", ");
 418                                 ia32_emit_am(env, node);
 419                         }
 420                         break;
 421                 default:
 422                         assert(0 && "unsupported op type");
 423         }
 424 }
 425
 426 /**
 427  * Emits registers and/or address mode of a binary operation.
 428  */
 429 void ia32_emit_x87_binop(ia32_emit_env_t *env, const ir_node *node) {
 430         switch(get_ia32_op_type(node)) {
 431                 case ia32_Normal:
 432                         if (is_ia32_ImmConst(node) || is_ia32_ImmSymConst(node)) {
 433                                 // should not happen...
 434                                 assert(0);
 435                         } else {
 436                                 ia32_attr_t *attr = get_ia32_attr(node);
 437                                 const arch_register_t *in1 = attr->x87[0];
 438                                 const arch_register_t *in2 = attr->x87[1];
 439                                 const arch_register_t *out = attr->x87[2];
 440                                 const arch_register_t *in;
 441
 442                                 in  = out ? (REGS_ARE_EQUAL(out, in2) ? in1 : in2) : in2;
 443                                 out = out ? out : in1;
 444
 445                                 be_emit_char(env, '%');
 446                                 be_emit_string(env, arch_register_get_name(in));
 447                                 be_emit_cstring(env, ", %");
 448                                 be_emit_string(env, arch_register_get_name(out));
 449                         }
 450                         break;
 451                 case ia32_AddrModeS:
 452                 case ia32_AddrModeD:
 453                         ia32_emit_am(env, node);
 454                         break;
 455                 default:
 456                         assert(0 && "unsupported op type");
 457         }
 458 }
 459
 460 /**
 461  * Emits registers and/or address mode of a unary operation.
 462  */
 463 void ia32_emit_unop(ia32_emit_env_t *env, const ir_node *node) {
 464         switch(get_ia32_op_type(node)) {
 465                 case ia32_Normal:
 466                         if (is_ia32_ImmConst(node) || is_ia32_ImmSymConst(node)) {
 467                                 be_emit_char(env, '$');
 468                                 ia32_emit_immediate(env, node);
 469                         } else {
 470                                 if (is_ia32_Mul(node) || is_ia32_IMul1OP(node)) {
 471                                         ia32_emit_source_register(env, node, 3);
 472                                 } else if(is_ia32_IDiv(node) || is_ia32_Div(node)) {
 473                                         ia32_emit_source_register(env, node, 4);
 474                                 } else if(is_ia32_Push(node)) {
 475                                         ia32_emit_source_register(env, node, 2);
 476                                 } else if(is_ia32_Pop(node)) {
 477                                         ia32_emit_dest_register(env, node, 1);
 478                                 } else {
 479                                         ia32_emit_dest_register(env, node, 0);
 480                                 }
 481                         }
 482                         break;
 483                 case ia32_AddrModeS:
 484                 case ia32_AddrModeD:
 485                         ia32_emit_am(env, node);
 486                         break;
 487                 default:
 488                         assert(0 && "unsupported op type");
 489         }
 490 }
 491
 492 /**
 493  * Emits address mode.
 494  */
 495 void ia32_emit_am(ia32_emit_env_t *env, const ir_node *node) {
 496         ia32_am_flavour_t am_flav = get_ia32_am_flavour(node);
 497         ident *id = get_ia32_am_sc(node);
 498         int offs = get_ia32_am_offs_int(node);
 499
 500         /* just to be sure... */
 501         assert(!is_ia32_use_frame(node) || get_ia32_frame_ent(node) != NULL);
 502
 503         /* emit offset */
 504         if (id != NULL) {
 505                 if (is_ia32_am_sc_sign(node))
 506                         be_emit_char(env, '-');
 507                 be_emit_ident(env, id);
 508         }
 509
 510         if(offs != 0) {
 511                 if(id != NULL) {
 512                         be_emit_irprintf(env->emit, "%+d", offs);
 513                 } else {
 514                         be_emit_irprintf(env->emit, "%d", offs);
 515                 }
 516         }
 517
 518         if (am_flav & (ia32_B | ia32_I)) {
 519                 be_emit_char(env, '(');
 520
 521                 /* emit base */
 522                 if (am_flav & ia32_B) {
 523                         ia32_emit_source_register(env, node, 0);
 524                 }
 525
 526                 /* emit index + scale */
 527                 if (am_flav & ia32_I) {
 528                         be_emit_char(env, ',');
 529                         ia32_emit_source_register(env, node, 1);
 530
 531                         if (am_flav & ia32_S) {
 532                                 be_emit_irprintf(env->emit, ",%d", 1 << get_ia32_am_scale(node));
 533                         }
 534                 }
 535                 be_emit_char(env, ')');
 536         }
 537 }
 538
 539 /*************************************************
 540  *                 _ _                         _
 541  *                (_) |                       | |
 542  *   ___ _ __ ___  _| |_    ___ ___  _ __   __| |
 543  *  / _ \ '_ ` _ \| | __|  / __/ _ \| '_ \ / _` |
 544  * |  __/ | | | | | | |_  | (_| (_) | | | | (_| |
 545  *  \___|_| |_| |_|_|\__|  \___\___/|_| |_|\__,_|
 546  *
 547  *************************************************/
 548
 549 #undef IA32_DO_EMIT
 550 #define IA32_DO_EMIT(irn) ia32_fprintf_format(F, irn, cmd_buf, cmnt_buf)
 551
 552 /*
 553  * coding of conditions
 554  */
 555 struct cmp2conditon_t {
 556         const char *name;
 557         pn_Cmp      num;
 558 };
 559
 560 /*
 561  * positive conditions for signed compares
 562  */
 563 static const struct cmp2conditon_t cmp2condition_s[] = {
 564         { NULL,              pn_Cmp_False },  /* always false */
 565         { "e",               pn_Cmp_Eq },     /* == */
 566         { "l",               pn_Cmp_Lt },     /* < */
 567         { "le",              pn_Cmp_Le },     /* <= */
 568         { "g",               pn_Cmp_Gt },     /* > */
 569         { "ge",              pn_Cmp_Ge },     /* >= */
 570         { "ne",              pn_Cmp_Lg },     /* != */
 571         { NULL,              pn_Cmp_Leg},     /* Floating point: ordered */
 572         { NULL,              pn_Cmp_Uo },     /* Floating point: unordered */
 573         { "e",               pn_Cmp_Ue },     /* Floating point: unordered or == */
 574         { "b",               pn_Cmp_Ul },     /* Floating point: unordered or < */
 575         { "be",              pn_Cmp_Ule },    /* Floating point: unordered or <= */
 576         { "a",               pn_Cmp_Ug },     /* Floating point: unordered or > */
 577         { "ae",              pn_Cmp_Uge },    /* Floating point: unordered or >= */
 578         { "ne",              pn_Cmp_Ne },     /* Floating point: unordered or != */
 579         { NULL,              pn_Cmp_True },   /* always true */
 580 };
 581
 582 /*
 583  * positive conditions for unsigned compares
 584  */
 585 static const struct cmp2conditon_t cmp2condition_u[] = {
 586         { NULL,              pn_Cmp_False },  /* always false */
 587         { "e",               pn_Cmp_Eq },     /* == */
 588         { "b",               pn_Cmp_Lt },     /* < */
 589         { "be",              pn_Cmp_Le },     /* <= */
 590         { "a",               pn_Cmp_Gt },     /* > */
 591         { "ae",              pn_Cmp_Ge },     /* >= */
 592         { "ne",              pn_Cmp_Lg },     /* != */
 593         { NULL,              pn_Cmp_True },   /* always true */
 594 };
 595
 596 /*
 597  * returns the condition code
 598  */
 599 static const char *get_cmp_suffix(int cmp_code)
 600 {
 601         assert( (cmp2condition_s[cmp_code & 15].num) == (cmp_code & 15));
 602         assert( (cmp2condition_u[cmp_code & 7].num) == (cmp_code & 7));
 603
 604         if((cmp_code & ia32_pn_Cmp_Unsigned)) {
 605                 return cmp2condition_u[cmp_code & 7].name;
 606         } else {
 607                 return cmp2condition_s[cmp_code & 15].name;
 608         }
 609 }
 610
 611 void ia32_emit_cmp_suffix(ia32_emit_env_t *env, long pnc)
 612 {
 613         be_emit_string(env, get_cmp_suffix(pnc));
 614 }
 615
 616
 617 /**
 618  * Returns the target block for a control flow node.
 619  */
 620 static ir_node *get_cfop_target_block(const ir_node *irn) {
 621         return get_irn_link(irn);
 622 }
 623
 624 /**
 625  * Returns the target label for a control flow node.
 626  */
 627 void ia32_emit_cfop_target(ia32_emit_env_t * env, const ir_node *node) {
 628         ir_node *block = get_cfop_target_block(node);
 629
 630         be_emit_cstring(env, BLOCK_PREFIX);
 631         be_emit_irprintf(env->emit, "%d", get_irn_node_nr(block));
 632 }
 633
 634 /** Return the next block in Block schedule */
 635 static ir_node *next_blk_sched(const ir_node *block) {
 636         return get_irn_link(block);
 637 }
 638
 639 /**
 640  * Returns the Proj with projection number proj and NOT mode_M
 641  */
 642 static ir_node *get_proj(const ir_node *node, long proj) {
 643         const ir_edge_t *edge;
 644         ir_node         *src;
 645
 646         assert(get_irn_mode(node) == mode_T && "expected mode_T node");
 647
 648         foreach_out_edge(node, edge) {
 649                 src = get_edge_src_irn(edge);
 650
 651                 assert(is_Proj(src) && "Proj expected");
 652                 if (get_irn_mode(src) == mode_M)
 653                         continue;
 654
 655                 if (get_Proj_proj(src) == proj)
 656                         return src;
 657         }
 658         return NULL;
 659 }
 660
 661 /**
 662  * Emits the jump sequence for a conditional jump (cmp + jmp_true + jmp_false)
 663  */
 664 static void finish_CondJmp(ia32_emit_env_t *env, const ir_node *node,
 665                            ir_mode *mode, long pnc) {
 666         const ir_node *proj_true;
 667         const ir_node *proj_false;
 668         const ir_node *block;
 669         const ir_node *next_block;
 670         int flipped = 0;
 671
 672         /* get both Proj's */
 673         proj_true = get_proj(node, pn_Cond_true);
 674         assert(proj_true && "CondJmp without true Proj");
 675
 676         proj_false = get_proj(node, pn_Cond_false);
 677         assert(proj_false && "CondJmp without false Proj");
 678
 679         /* for now, the code works for scheduled and non-schedules blocks */
 680         block = get_nodes_block(node);
 681
 682         /* we have a block schedule */
 683         next_block = next_blk_sched(block);
 684
 685         if (get_cfop_target_block(proj_true) == next_block) {
 686                 /* exchange both proj's so the second one can be omitted */
 687                 const ir_node *t = proj_true;
 688
 689                 proj_true  = proj_false;
 690                 proj_false = t;
 691                 flipped    = 1;
 692                 pnc        = get_negated_pnc(pnc, mode);
 693         }
 694
 695         /* in case of unordered compare, check for parity */
 696         if (pnc & pn_Cmp_Uo) {
 697                 be_emit_cstring(env, "\tjp ");
 698                 ia32_emit_cfop_target(env, proj_true);
 699                 be_emit_finish_line_gas(env, proj_true);
 700         }
 701
 702         be_emit_cstring(env, "\tj");
 703         ia32_emit_cmp_suffix(env, pnc);
 704         be_emit_char(env, ' ');
 705         ia32_emit_cfop_target(env, proj_true);
 706         be_emit_finish_line_gas(env, proj_true);
 707
 708         /* the second Proj might be a fallthrough */
 709         if (get_cfop_target_block(proj_false) != next_block) {
 710                 be_emit_cstring(env, "\tjmp ");
 711                 ia32_emit_cfop_target(env, proj_false);
 712                 be_emit_finish_line_gas(env, proj_false);
 713         } else {
 714                 be_emit_cstring(env, "\t/* fallthrough to");
 715                 ia32_emit_cfop_target(env, proj_false);
 716                 be_emit_cstring(env, " */");
 717                 be_emit_finish_line_gas(env, proj_false);
 718         }
 719 }
 720
 721 /**
 722  * Emits code for conditional jump.
 723  */
 724 static void CondJmp_emitter(ia32_emit_env_t *env, const ir_node *node) {
 725         be_emit_cstring(env, "\tcmp ");
 726         ia32_emit_binop(env, node);
 727         be_emit_finish_line_gas(env, node);
 728
 729         finish_CondJmp(env, node, mode_Iu, get_ia32_pncode(node));
 730 }
 731
 732 /**
 733  * Emits code for conditional jump with two variables.
 734  */
 735 static void emit_ia32_CondJmp(ia32_emit_env_t *env, const ir_node *node) {
 736         CondJmp_emitter(env, node);
 737 }
 738
 739 /**
 740  * Emits code for conditional test and jump.
 741  */
 742 static void TestJmp_emitter(ia32_emit_env_t *env, const ir_node *node) {
 743         if(is_ia32_ImmSymConst(node) || is_ia32_ImmConst(node)) {
 744                 be_emit_cstring(env, "\ttest $");
 745                 ia32_emit_immediate(env, node);
 746                 be_emit_cstring(env, ", ");
 747                 ia32_emit_source_register(env, node, 0);
 748                 be_emit_finish_line_gas(env, node);
 749         } else {
 750                 be_emit_cstring(env, "\ttest ");
 751                 ia32_emit_source_register(env, node, 1);
 752                 be_emit_cstring(env, ", ");
 753                 ia32_emit_source_register(env, node, 0);
 754                 be_emit_finish_line_gas(env, node);
 755         }
 756         finish_CondJmp(env, node, mode_Iu, get_ia32_pncode(node));
 757 }
 758
 759 /**
 760  * Emits code for conditional test and jump with two variables.
 761  */
 762 static void emit_ia32_TestJmp(ia32_emit_env_t *env, const ir_node *node) {
 763         TestJmp_emitter(env, node);
 764 }
 765
 766 static void emit_ia32_CJmp(ia32_emit_env_t *env, const ir_node *node) {
 767         be_emit_cstring(env, "/* omitted redundant test */");
 768         be_emit_finish_line_gas(env, node);
 769
 770         finish_CondJmp(env, node, mode_Is, get_ia32_pncode(node));
 771 }
 772
 773 static void emit_ia32_CJmpAM(ia32_emit_env_t *env, const ir_node *node) {
 774         be_emit_cstring(env, "/* omitted redundant test/cmp */");
 775         be_emit_finish_line_gas(env, node);
 776
 777         finish_CondJmp(env, node, mode_Is, get_ia32_pncode(node));
 778 }
 779
 780 /**
 781  * Emits code for conditional SSE floating point jump with two variables.
 782  */
 783 static void emit_ia32_xCondJmp(ia32_emit_env_t *env, const ir_node *node) {
 784         be_emit_cstring(env, "\tucomi");
 785         ia32_emit_xmm_mode_suffix(env, node);
 786         be_emit_char(env, ' ');
 787         ia32_emit_binop(env, node);
 788         be_emit_finish_line_gas(env, node);
 789
 790         finish_CondJmp(env, node, mode_F, get_ia32_pncode(node));
 791 }
 792
 793 /**
 794  * Emits code for conditional x87 floating point jump with two variables.
 795  */
 796 static void emit_ia32_x87CondJmp(ia32_emit_env_t *env, const ir_node *node) {
 797         ia32_attr_t *attr = get_ia32_attr(node);
 798         const char *reg = attr->x87[1]->name;
 799         long pnc = get_ia32_pncode(node);
 800
 801         switch (get_ia32_irn_opcode(node)) {
 802         case iro_ia32_fcomrJmp:
 803                 pnc = get_inversed_pnc(pnc);
 804                 reg = attr->x87[0]->name;
 805         case iro_ia32_fcomJmp:
 806         default:
 807                 be_emit_cstring(env, "\tfucom ");
 808                 break;
 809         case iro_ia32_fcomrpJmp:
 810                 pnc = get_inversed_pnc(pnc);
 811                 reg = attr->x87[0]->name;
 812         case iro_ia32_fcompJmp:
 813                 be_emit_cstring(env, "\tfucomp ");
 814                 break;
 815         case iro_ia32_fcomrppJmp:
 816                 pnc = get_inversed_pnc(pnc);
 817         case iro_ia32_fcomppJmp:
 818                 be_emit_cstring(env, "\tfucompp ");
 819                 reg = "";
 820                 break;
 821         }
 822
 823         if(reg[0] != '\0') {
 824                 be_emit_char(env, '%');
 825                 be_emit_string(env, reg);
 826         }
 827         be_emit_finish_line_gas(env, node);
 828
 829         be_emit_cstring(env, "\tfnstsw %ax");
 830         be_emit_finish_line_gas(env, node);
 831         be_emit_cstring(env, "\tsahf");
 832         be_emit_finish_line_gas(env, node);
 833
 834         finish_CondJmp(env, node, mode_E, pnc);
 835 }
 836
 837 static void CMov_emitter(ia32_emit_env_t *env, const ir_node *node) {
 838         long pnc = get_ia32_pncode(node);
 839         int is_PsiCondCMov = is_ia32_PsiCondCMov(node);
 840         int idx_left  = 2 - is_PsiCondCMov;
 841         int idx_right = 3 - is_PsiCondCMov;
 842         const arch_register_t *in1, *in2, *out;
 843
 844         out = arch_get_irn_register(env->arch_env, node);
 845         in1 = arch_get_irn_register(env->arch_env, get_irn_n(node, idx_left));
 846         in2 = arch_get_irn_register(env->arch_env, get_irn_n(node, idx_right));
 847
 848         /* we have to emit the cmp first, because the destination register */
 849         /* could be one of the compare registers                           */
 850         if (is_ia32_CmpCMov(node)) {
 851                 be_emit_cstring(env, "\tcmp ");
 852                 ia32_emit_source_register(env, node, 1);
 853                 be_emit_cstring(env, ", ");
 854                 ia32_emit_source_register(env, node, 0);
 855         } else if (is_ia32_xCmpCMov(node)) {
 856                 be_emit_cstring(env, "\tucomis");
 857                 ia32_emit_mode_suffix(env, get_irn_mode(node));
 858                 be_emit_char(env, ' ');
 859                 ia32_emit_source_register(env, node, 1);
 860                 be_emit_cstring(env, ", ");
 861                 ia32_emit_source_register(env, node, 0);
 862         } else if (is_PsiCondCMov) {
 863                 /* omit compare because flags are already set by And/Or */
 864                 be_emit_cstring(env, "\ttest ");
 865                 ia32_emit_source_register(env, node, 0);
 866                 be_emit_cstring(env, ", ");
 867                 ia32_emit_source_register(env, node, 0);
 868         } else {
 869                 assert(0 && "unsupported CMov");
 870         }
 871         be_emit_finish_line_gas(env, node);
 872
 873         if (REGS_ARE_EQUAL(out, in2)) {
 874                 /* best case: default in == out -> do nothing */
 875         } else if (REGS_ARE_EQUAL(out, in1)) {
 876                 ir_node *n = (ir_node*) node;
 877                 /* true in == out -> need complement compare and exchange true and default in */
 878                 ir_node *t = get_irn_n(n, idx_left);
 879                 set_irn_n(n, idx_left, get_irn_n(n, idx_right));
 880                 set_irn_n(n, idx_right, t);
 881
 882                 pnc = get_negated_pnc(pnc, get_irn_mode(node));
 883         } else {
 884                 /* out is different from in: need copy default -> out */
 885                 if (is_PsiCondCMov) {
 886                         be_emit_cstring(env, "\tmovl ");
 887                         ia32_emit_dest_register(env, node, 2);
 888                         be_emit_cstring(env, ", ");
 889                         ia32_emit_dest_register(env, node, 0);
 890                 } else {
 891                         be_emit_cstring(env, "\tmovl ");
 892                         ia32_emit_source_register(env, node, 3);
 893                         be_emit_cstring(env, ", ");
 894                         ia32_emit_dest_register(env, node, 0);
 895                 }
 896                 be_emit_finish_line_gas(env, node);
 897         }
 898
 899         if (is_PsiCondCMov) {
 900                 be_emit_cstring(env, "\tcmov");
 901                 ia32_emit_cmp_suffix(env, pnc);
 902                 be_emit_cstring(env, "l ");
 903                 ia32_emit_source_register(env, node, 1);
 904                 be_emit_cstring(env, ", ");
 905                 ia32_emit_dest_register(env, node, 0);
 906         } else {
 907                 be_emit_cstring(env, "\tcmov");
 908                 ia32_emit_cmp_suffix(env, pnc);
 909                 be_emit_cstring(env, "l ");
 910                 ia32_emit_source_register(env, node, 2);
 911                 be_emit_cstring(env, ", ");
 912                 ia32_emit_dest_register(env, node, 0);
 913         }
 914         be_emit_finish_line_gas(env, node);
 915 }
 916
 917 static void emit_ia32_CmpCMov(ia32_emit_env_t *env, const ir_node *node) {
 918         CMov_emitter(env, node);
 919 }
 920
 921 static void emit_ia32_PsiCondCMov(ia32_emit_env_t *env, const ir_node *node) {
 922         CMov_emitter(env, node);
 923 }
 924
 925 static void emit_ia32_xCmpCMov(ia32_emit_env_t *env, const ir_node *node) {
 926         CMov_emitter(env, node);
 927 }
 928
 929 static void Set_emitter(ia32_emit_env_t *env, const ir_node *node, ir_mode *mode) {
 930         int pnc = get_ia32_pncode(node);
 931         const char *reg8bit;
 932         const arch_register_t *out;
 933
 934         out     = arch_get_irn_register(env->arch_env, node);
 935         reg8bit = ia32_get_mapped_reg_name(env->isa->regs_8bit, out);
 936
 937         if (is_ia32_CmpSet(node)) {
 938                 be_emit_cstring(env, "\tcmp ");
 939                 ia32_emit_binop(env, node);
 940         } else if (is_ia32_xCmpSet(node)) {
 941                 be_emit_cstring(env, "\tucomis");
 942                 ia32_emit_mode_suffix(env, get_irn_mode(get_irn_n(node, 2)));
 943                 be_emit_char(env, ' ');
 944                 ia32_emit_binop(env, node);
 945         } else if (is_ia32_PsiCondSet(node)) {
 946                 be_emit_cstring(env, "\tcmp $0, ");
 947                 ia32_emit_source_register(env, node, 0);
 948         } else {
 949                 assert(0 && "unsupported Set");
 950         }
 951         be_emit_finish_line_gas(env, node);
 952
 953         /* use mov to clear target because it doesn't affect the eflags */
 954         be_emit_cstring(env, "\tmovl $0, %");
 955         be_emit_string(env, arch_register_get_name(out));
 956         be_emit_finish_line_gas(env, node);
 957
 958         be_emit_cstring(env, "\tset");
 959         ia32_emit_cmp_suffix(env, pnc);
 960         be_emit_cstring(env, " %");
 961         be_emit_string(env, reg8bit);
 962         be_emit_finish_line_gas(env, node);
 963 }
 964
 965 static void emit_ia32_CmpSet(ia32_emit_env_t *env, const ir_node *node) {
 966         Set_emitter(env, node, get_irn_mode(get_irn_n(node, 2)));
 967 }
 968
 969 static void emit_ia32_PsiCondSet(ia32_emit_env_t *env, const ir_node *node) {
 970         Set_emitter(env, node, get_irn_mode(get_irn_n(node, 0)));
 971 }
 972
 973 static void emit_ia32_xCmpSet(ia32_emit_env_t *env, const ir_node *node) {
 974         Set_emitter(env, node, get_irn_mode(get_irn_n(node, 2)));
 975 }
 976
 977 static void emit_ia32_xCmp(ia32_emit_env_t *env, const ir_node *node) {
 978         int  sse_pnc  = -1;
 979         long pnc      = get_ia32_pncode(node);
 980         long unord    = pnc & pn_Cmp_Uo;
 981
 982         assert( (pnc & ia32_pn_Cmp_Unsigned) == 0);
 983
 984         switch (pnc) {
 985                 case pn_Cmp_Leg: /* odered */
 986                         sse_pnc = 7;
 987                         break;
 988                 case pn_Cmp_Uo:  /* unordered */
 989                         sse_pnc = 3;
 990                         break;
 991                 case pn_Cmp_Ue:
 992                 case pn_Cmp_Eq:  /* == */
 993                         sse_pnc = 0;
 994                         break;
 995                 case pn_Cmp_Ul:
 996                 case pn_Cmp_Lt:  /* < */
 997                         sse_pnc = 1;
 998                         break;
 999                 case pn_Cmp_Ule:
1000                 case pn_Cmp_Le: /* <= */
1001                         sse_pnc = 2;
1002                         break;
1003                 case pn_Cmp_Ug:
1004                 case pn_Cmp_Gt:  /* > */
1005                         sse_pnc = 6;
1006                         break;
1007                 case pn_Cmp_Uge:
1008                 case pn_Cmp_Ge: /* >= */
1009                         sse_pnc = 5;
1010                         break;
1011                 case pn_Cmp_Ne:
1012                 case pn_Cmp_Lg:  /* != */
1013                         sse_pnc = 4;
1014                         break;
1015         }
1016
1017         assert(sse_pnc >= 0 && "unsupported compare");
1018
1019         if (unord && sse_pnc != 3) {
1020                 /*
1021                         We need a separate compare against unordered.
1022                         Quick and Dirty solution:
1023                         - get some memory on stack
1024                         - compare
1025                         - store result
1026                         - compare
1027                         - and result and stored result
1028                     - cleanup stack
1029                 */
1030                 be_emit_cstring(env, "\tsubl $8, %esp");
1031                 be_emit_finish_line_gas(env, node);
1032
1033                 be_emit_cstring(env, "\tcmpsd $3, ");
1034                 ia32_emit_binop(env, node);
1035                 be_emit_finish_line_gas(env, node);
1036
1037                 be_emit_cstring(env, "\tmovsd ");
1038                 ia32_emit_dest_register(env, node, 0);
1039                 be_emit_cstring(env, ", (%esp)");
1040                 be_emit_finish_line_gas(env, node);
1041         }
1042
1043         be_emit_cstring(env, "\tcmpsd ");
1044         be_emit_irprintf(env->emit, "%d, ", sse_pnc);
1045         ia32_emit_binop(env, node);
1046         be_emit_finish_line_gas(env, node);
1047
1048         if (unord && sse_pnc != 3) {
1049                 be_emit_cstring(env, "\tandpd (%esp), ");
1050                 ia32_emit_dest_register(env, node, 0);
1051                 be_emit_finish_line_gas(env, node);
1052
1053                 be_emit_cstring(env, "\taddl $8, %esp");
1054                 be_emit_finish_line_gas(env, node);
1055         }
1056 }
1057
1058 /*********************************************************
1059  *                 _ _       _
1060  *                (_) |     (_)
1061  *   ___ _ __ ___  _| |_     _ _   _ _ __ ___  _ __  ___
1062  *  / _ \ '_ ` _ \| | __|   | | | | | '_ ` _ \| '_ \/ __|
1063  * |  __/ | | | | | | |_    | | |_| | | | | | | |_) \__ \
1064  *  \___|_| |_| |_|_|\__|   | |\__,_|_| |_| |_| .__/|___/
1065  *                         _/ |               | |
1066  *                        |__/                |_|
1067  *********************************************************/
1068
1069 /* jump table entry (target and corresponding number) */
1070 typedef struct _branch_t {
1071         ir_node *target;
1072         int      value;
1073 } branch_t;
1074
1075 /* jump table for switch generation */
1076 typedef struct _jmp_tbl_t {
1077         ir_node  *defProj;         /**< default target */
1078         int       min_value;       /**< smallest switch case */
1079         int       max_value;       /**< largest switch case */
1080         int       num_branches;    /**< number of jumps */
1081         char     *label;           /**< label of the jump table */
1082         branch_t *branches;        /**< jump array */
1083 } jmp_tbl_t;
1084
1085 /**
1086  * Compare two variables of type branch_t. Used to sort all switch cases
1087  */
1088 static int ia32_cmp_branch_t(const void *a, const void *b) {
1089         branch_t *b1 = (branch_t *)a;
1090         branch_t *b2 = (branch_t *)b;
1091
1092         if (b1->value <= b2->value)
1093                 return -1;
1094         else
1095                 return 1;
1096 }
1097
1098 /**
1099  * Emits code for a SwitchJmp (creates a jump table if
1100  * possible otherwise a cmp-jmp cascade). Port from
1101  * cggg ia32 backend
1102  */
1103 static void emit_ia32_SwitchJmp(ia32_emit_env_t *env, const ir_node *node) {
1104         unsigned long       interval;
1105         int                 last_value, i;
1106         long                pnc;
1107         jmp_tbl_t           tbl;
1108         ir_node            *proj;
1109         const ir_edge_t    *edge;
1110
1111         /* fill the table structure */
1112         tbl.label        = xmalloc(SNPRINTF_BUF_LEN);
1113         tbl.label        = get_unique_label(tbl.label, SNPRINTF_BUF_LEN, ".TBL_");
1114         tbl.defProj      = NULL;
1115         tbl.num_branches = get_irn_n_edges(node);
1116         tbl.branches     = xcalloc(tbl.num_branches, sizeof(tbl.branches[0]));
1117         tbl.min_value    = INT_MAX;
1118         tbl.max_value    = INT_MIN;
1119
1120         i = 0;
1121         /* go over all proj's and collect them */
1122         foreach_out_edge(node, edge) {
1123                 proj = get_edge_src_irn(edge);
1124                 assert(is_Proj(proj) && "Only proj allowed at SwitchJmp");
1125
1126                 pnc = get_Proj_proj(proj);
1127
1128                 /* create branch entry */
1129                 tbl.branches[i].target = proj;
1130                 tbl.branches[i].value  = pnc;
1131
1132                 tbl.min_value = pnc < tbl.min_value ? pnc : tbl.min_value;
1133                 tbl.max_value = pnc > tbl.max_value ? pnc : tbl.max_value;
1134
1135                 /* check for default proj */
1136                 if (pnc == get_ia32_pncode(node)) {
1137                         assert(tbl.defProj == NULL && "found two defProjs at SwitchJmp");
1138                         tbl.defProj = proj;
1139                 }
1140
1141                 i++;
1142         }
1143
1144         /* sort the branches by their number */
1145         qsort(tbl.branches, tbl.num_branches, sizeof(tbl.branches[0]), ia32_cmp_branch_t);
1146
1147         /* two-complement's magic make this work without overflow */
1148         interval = tbl.max_value - tbl.min_value;
1149
1150         /* emit the table */
1151         be_emit_cstring(env, "\tcmpl $");
1152         be_emit_irprintf(env->emit, "%u, ", interval);
1153         ia32_emit_source_register(env, node, 0);
1154         be_emit_finish_line_gas(env, node);
1155
1156         be_emit_cstring(env, "\tja ");
1157         ia32_emit_cfop_target(env, tbl.defProj);
1158         be_emit_finish_line_gas(env, node);
1159
1160         if (tbl.num_branches > 1) {
1161                 /* create table */
1162                 be_emit_cstring(env, "\tjmp *");
1163                 be_emit_string(env, tbl.label);
1164                 be_emit_cstring(env, "(,");
1165                 ia32_emit_source_register(env, node, 0);
1166                 be_emit_cstring(env, ",4)");
1167                 be_emit_finish_line_gas(env, node);
1168
1169                 be_gas_emit_switch_section(env->emit, GAS_SECTION_RODATA);
1170                 be_emit_cstring(env, "\t.align 4\n");
1171                 be_emit_write_line(env);
1172
1173                 be_emit_string(env, tbl.label);
1174                 be_emit_cstring(env, ":\n");
1175                 be_emit_write_line(env);
1176
1177                 be_emit_cstring(env, ".long ");
1178                 ia32_emit_cfop_target(env, tbl.branches[0].target);
1179                 be_emit_finish_line_gas(env, NULL);
1180
1181                 last_value = tbl.branches[0].value;
1182                 for (i = 1; i < tbl.num_branches; ++i) {
1183                         while (++last_value < tbl.branches[i].value) {
1184                                 be_emit_cstring(env, ".long ");
1185                                 ia32_emit_cfop_target(env, tbl.defProj);
1186                                 be_emit_finish_line_gas(env, NULL);
1187                         }
1188                         be_emit_cstring(env, ".long ");
1189                         ia32_emit_cfop_target(env, tbl.branches[i].target);
1190                         be_emit_finish_line_gas(env, NULL);
1191                 }
1192                 be_gas_emit_switch_section(env->emit, GAS_SECTION_TEXT);
1193         } else {
1194                 /* one jump is enough */
1195                 be_emit_cstring(env, "\tjmp ");
1196                 ia32_emit_cfop_target(env, tbl.branches[0].target);
1197                 be_emit_finish_line_gas(env, node);
1198         }
1199
1200         if (tbl.label)
1201                 free(tbl.label);
1202         if (tbl.branches)
1203                 free(tbl.branches);
1204 }
1205
1206 /**
1207  * Emits code for a unconditional jump.
1208  */
1209 static void emit_Jmp(ia32_emit_env_t *env, const ir_node *node) {
1210         ir_node *block, *next_block;
1211
1212         /* for now, the code works for scheduled and non-schedules blocks */
1213         block = get_nodes_block(node);
1214
1215         /* we have a block schedule */
1216         next_block = next_blk_sched(block);
1217         if (get_cfop_target_block(node) != next_block) {
1218                 be_emit_cstring(env, "\tjmp ");
1219                 ia32_emit_cfop_target(env, node);
1220         } else {
1221                 be_emit_cstring(env, "\t/* fallthrough to ");
1222                 ia32_emit_cfop_target(env, node);
1223                 be_emit_cstring(env, " */");
1224         }
1225         be_emit_finish_line_gas(env, node);
1226 }
1227
1228 /**********************************
1229  *   _____                  ____
1230  *  / ____|                |  _ \
1231  * | |     ___  _ __  _   _| |_) |
1232  * | |    / _ \| '_ \| | | |  _ <
1233  * | |___| (_) | |_) | |_| | |_) |
1234  *  \_____\___/| .__/ \__, |____/
1235  *             | |     __/ |
1236  *             |_|    |___/
1237  **********************************/
1238
1239 /**
1240  * Emit movsb/w instructions to make mov count divideable by 4
1241  */
1242 static void emit_CopyB_prolog(ia32_emit_env_t *env, int rem) {
1243         be_emit_cstring(env, "\tcld");
1244         be_emit_finish_line_gas(env, NULL);
1245
1246         switch(rem) {
1247         case 1:
1248                 be_emit_cstring(env, "\tmovsb");
1249                 be_emit_finish_line_gas(env, NULL);
1250                 break;
1251         case 2:
1252                 be_emit_cstring(env, "\tmovsw");
1253                 be_emit_finish_line_gas(env, NULL);
1254                 break;
1255         case 3:
1256                 be_emit_cstring(env, "\tmovsb");
1257                 be_emit_finish_line_gas(env, NULL);
1258                 be_emit_cstring(env, "\tmovsw");
1259                 be_emit_finish_line_gas(env, NULL);
1260                 break;
1261         }
1262 }
1263
1264 /**
1265  * Emit rep movsd instruction for memcopy.
1266  */
1267 static void emit_ia32_CopyB(ia32_emit_env_t *env, const ir_node *node) {
1268         tarval *tv = get_ia32_Immop_tarval(node);
1269         int    rem = get_tarval_long(tv);
1270
1271         emit_CopyB_prolog(env, rem);
1272
1273         be_emit_cstring(env, "\trep movsd");
1274         be_emit_finish_line_gas(env, node);
1275 }
1276
1277 /**
1278  * Emits unrolled memcopy.
1279  */
1280 static void emit_ia32_CopyB_i(ia32_emit_env_t *env, const ir_node *node) {
1281         tarval *tv   = get_ia32_Immop_tarval(node);
1282         int     size = get_tarval_long(tv);
1283
1284         emit_CopyB_prolog(env, size & 0x3);
1285
1286         size >>= 2;
1287         while (size--) {
1288                 be_emit_cstring(env, "\tmovsd");
1289                 be_emit_finish_line_gas(env, NULL);
1290         }
1291 }
1292
1293
1294
1295 /***************************
1296  *   _____
1297  *  / ____|
1298  * | |     ___  _ ____   __
1299  * | |    / _ \| '_ \ \ / /
1300  * | |___| (_) | | | \ V /
1301  *  \_____\___/|_| |_|\_/
1302  *
1303  ***************************/
1304
1305 /**
1306  * Emit code for conversions (I, FP), (FP, I) and (FP, FP).
1307  */
1308 static void emit_ia32_Conv_with_FP(ia32_emit_env_t *env, const ir_node *node) {
1309         ir_mode            *ls_mode = get_ia32_ls_mode(node);
1310         int                 ls_bits = get_mode_size_bits(ls_mode);
1311
1312         be_emit_cstring(env, "\tcvt");
1313
1314         if(is_ia32_Conv_I2FP(node)) {
1315                 if(ls_bits == 32) {
1316                         be_emit_cstring(env, "si2ss");
1317                 } else {
1318                         be_emit_cstring(env, "si2sd");
1319                 }
1320         } else if(is_ia32_Conv_FP2I(node)) {
1321                 if(ls_bits == 32) {
1322                         be_emit_cstring(env, "ss2si");
1323                 } else {
1324                         be_emit_cstring(env, "sd2si");
1325                 }
1326         } else {
1327                 assert(is_ia32_Conv_FP2FP(node));
1328                 if(ls_bits == 32) {
1329                         be_emit_cstring(env, "sd2ss");
1330                 } else {
1331                         be_emit_cstring(env, "ss2sd");
1332                 }
1333         }
1334         be_emit_char(env, ' ');
1335
1336         switch(get_ia32_op_type(node)) {
1337                 case ia32_Normal:
1338                         ia32_emit_source_register(env, node, 2);
1339                         be_emit_cstring(env, ", ");
1340                         ia32_emit_dest_register(env, node, 0);
1341                         break;
1342                 case ia32_AddrModeS:
1343                         ia32_emit_dest_register(env, node, 0);
1344                         be_emit_cstring(env, ", ");
1345                         ia32_emit_am(env, node);
1346                         break;
1347                 default:
1348                         assert(0 && "unsupported op type for Conv");
1349         }
1350         be_emit_finish_line_gas(env, node);
1351 }
1352
1353 static void emit_ia32_Conv_I2FP(ia32_emit_env_t *env, const ir_node *node) {
1354         emit_ia32_Conv_with_FP(env, node);
1355 }
1356
1357 static void emit_ia32_Conv_FP2I(ia32_emit_env_t *env, const ir_node *node) {
1358         emit_ia32_Conv_with_FP(env, node);
1359 }
1360
1361 static void emit_ia32_Conv_FP2FP(ia32_emit_env_t *env, const ir_node *node) {
1362         emit_ia32_Conv_with_FP(env, node);
1363 }
1364
1365 /**
1366  * Emits code for an Int conversion.
1367  */
1368 static void emit_ia32_Conv_I2I(ia32_emit_env_t *env, const ir_node *node) {
1369         const char *sign_suffix;
1370         ir_mode *smaller_mode = get_ia32_ls_mode(node);
1371         int smaller_bits = get_mode_size_bits(smaller_mode);
1372         int signed_mode;
1373         const arch_register_t *in_reg, *out_reg;
1374
1375         assert(!mode_is_float(smaller_mode));
1376         assert(smaller_bits == 8 || smaller_bits == 16 || smaller_bits == 32);
1377
1378         signed_mode = mode_is_signed(smaller_mode);
1379         if(smaller_bits == 32) {
1380                 // this should not happen as it's no convert
1381                 assert(0);
1382                 sign_suffix = "";
1383         } else {
1384                 sign_suffix = signed_mode ? "s" : "z";
1385         }
1386
1387         switch(get_ia32_op_type(node)) {
1388                 case ia32_Normal:
1389                         in_reg  = get_in_reg(node, 2);
1390                         out_reg = get_out_reg(node, 0);
1391
1392                         if (REGS_ARE_EQUAL(in_reg, &ia32_gp_regs[REG_EAX]) &&
1393                                 REGS_ARE_EQUAL(out_reg, in_reg)                &&
1394                                 signed_mode)
1395                         {
1396                                 /* argument and result are both in EAX and */
1397                                 /* signedness is ok: -> use converts       */
1398                                 if (smaller_bits == 8) {
1399                                         be_emit_cstring(env, "\tcbtw");
1400                                 } else if (smaller_bits == 16) {
1401                                         be_emit_cstring(env, "\tcwtl");
1402                                 } else {
1403                                         assert(0);
1404                                 }
1405                         } else if (REGS_ARE_EQUAL(out_reg, in_reg) && !signed_mode) {
1406                                 /* argument and result are in the same register */
1407                                 /* and signedness is ok: -> use and with mask   */
1408                                 int mask = (1 << smaller_bits) - 1;
1409                                 be_emit_cstring(env, "\tandl $0x");
1410                                 be_emit_irprintf(env->emit, "%x, ", mask);
1411                                 ia32_emit_dest_register(env, node, 0);
1412                         } else {
1413                                 const char *sreg = ia32_get_reg_name_for_mode(env, smaller_mode, in_reg);
1414
1415                                 be_emit_cstring(env, "\tmov");
1416                                 be_emit_string(env, sign_suffix);
1417                                 ia32_emit_mode_suffix(env, smaller_mode);
1418                                 be_emit_cstring(env, "l %");
1419                                 be_emit_string(env, sreg);
1420                                 be_emit_cstring(env, ", ");
1421                                 ia32_emit_dest_register(env, node, 0);
1422                         }
1423                         break;
1424                 case ia32_AddrModeS: {
1425                         be_emit_cstring(env, "\tmov");
1426                         be_emit_string(env, sign_suffix);
1427                         ia32_emit_mode_suffix(env, smaller_mode);
1428                         be_emit_cstring(env, "l %");
1429                         ia32_emit_am(env, node);
1430                         be_emit_cstring(env, ", ");
1431                         ia32_emit_dest_register(env, node, 0);
1432                         break;
1433                 }
1434                 default:
1435                         assert(0 && "unsupported op type for Conv");
1436         }
1437         be_emit_finish_line_gas(env, node);
1438 }
1439
1440 /**
1441  * Emits code for an 8Bit Int conversion.
1442  */
1443 void emit_ia32_Conv_I2I8Bit(ia32_emit_env_t *env, const ir_node *node) {
1444         emit_ia32_Conv_I2I(env, node);
1445 }
1446
1447
1448 /*******************************************
1449  *  _                          _
1450  * | |                        | |
1451  * | |__   ___ _ __   ___   __| | ___  ___
1452  * | '_ \ / _ \ '_ \ / _ \ / _` |/ _ \/ __|
1453  * | |_) |  __/ | | | (_) | (_| |  __/\__ \
1454  * |_.__/ \___|_| |_|\___/ \__,_|\___||___/
1455  *
1456  *******************************************/
1457
1458 /**
1459  * Emits a backend call
1460  */
1461 static void emit_be_Call(ia32_emit_env_t *env, const ir_node *node) {
1462         ir_entity *ent = be_Call_get_entity(node);
1463
1464         be_emit_cstring(env, "\tcall ");
1465         if (ent) {
1466                 be_emit_string(env, get_entity_ld_name(ent));
1467         } else {
1468                 be_emit_char(env, '*');
1469                 ia32_emit_dest_register(env, get_irn_n(node, be_pos_Call_ptr), 0);
1470         }
1471         be_emit_finish_line_gas(env, node);
1472 }
1473
1474 /**
1475  * Emits code to increase stack pointer.
1476  */
1477 static void emit_be_IncSP(ia32_emit_env_t *env, const ir_node *node) {
1478         int offs = be_get_IncSP_offset(node);
1479
1480         if (offs == 0)
1481                 return;
1482
1483         if (offs > 0) {
1484                 be_emit_cstring(env, "\tsubl $");
1485                 be_emit_irprintf(env->emit, "%u, ", offs);
1486                 ia32_emit_source_register(env, node, 0);
1487         } else {
1488                 be_emit_cstring(env, "\taddl $");
1489                 be_emit_irprintf(env->emit, "%u, ", -offs);
1490                 ia32_emit_source_register(env, node, 0);
1491         }
1492         be_emit_finish_line_gas(env, node);
1493 }
1494
1495 /**
1496  * Emits code to set stack pointer.
1497  */
1498 static void emit_be_SetSP(ia32_emit_env_t *env, const ir_node *node) {
1499         be_emit_cstring(env, "\tmovl ");
1500         ia32_emit_source_register(env, node, 2);
1501         be_emit_cstring(env, ", ");
1502         ia32_emit_dest_register(env, node, 0);
1503         be_emit_finish_line_gas(env, node);
1504 }
1505
1506 /**
1507  * Emits code for Copy/CopyKeep.
1508  */
1509 static void Copy_emitter(ia32_emit_env_t *env, const ir_node *node, const ir_node *op) {
1510         const arch_env_t *aenv = env->arch_env;
1511
1512         if (REGS_ARE_EQUAL(arch_get_irn_register(aenv, node), arch_get_irn_register(aenv, op)) ||
1513                 arch_register_type_is(arch_get_irn_register(aenv, op), virtual))
1514                 return;
1515
1516         if (mode_is_float(get_irn_mode(node))) {
1517                 be_emit_cstring(env, "\tmovsd ");
1518                 ia32_emit_source_register(env, node, 0);
1519                 be_emit_cstring(env, ", ");
1520                 ia32_emit_dest_register(env, node, 0);
1521         } else {
1522                 be_emit_cstring(env, "\tmovl ");
1523                 ia32_emit_source_register(env, node, 0);
1524                 be_emit_cstring(env, ", ");
1525                 ia32_emit_dest_register(env, node, 0);
1526         }
1527         be_emit_finish_line_gas(env, node);
1528 }
1529
1530 static void emit_be_Copy(ia32_emit_env_t *env, const ir_node *node) {
1531         Copy_emitter(env, node, be_get_Copy_op(node));
1532 }
1533
1534 static void emit_be_CopyKeep(ia32_emit_env_t *env, const ir_node *node) {
1535         Copy_emitter(env, node, be_get_CopyKeep_op(node));
1536 }
1537
1538 /**
1539  * Emits code for exchange.
1540  */
1541 static void emit_be_Perm(ia32_emit_env_t *env, const ir_node *node) {
1542         const arch_register_t *in1, *in2;
1543         const arch_register_class_t *cls1, *cls2;
1544
1545         in1 = arch_get_irn_register(env->arch_env, get_irn_n(node, 0));
1546         in2 = arch_get_irn_register(env->arch_env, get_irn_n(node, 1));
1547
1548         cls1 = arch_register_get_class(in1);
1549         cls2 = arch_register_get_class(in2);
1550
1551         assert(cls1 == cls2 && "Register class mismatch at Perm");
1552
1553         if (cls1 == &ia32_reg_classes[CLASS_ia32_gp]) {
1554 #if 0
1555                 if(emit_env->isa->opt_arch == arch_athlon) {
1556                         // xchg commands are Vector path on athlons and therefore stall the DirectPath pipeline
1557                         // it is often beneficial to use the 3 xor trick instead of an xchg
1558                         cmnt_buf[0] = 0;
1559                         lc_esnprintf(ia32_get_arg_env(), cmd_buf, SNPRINTF_BUF_LEN, "xor %1S, %2S", irn, irn);
1560                         IA32_DO_EMIT(irn);
1561                         lc_esnprintf(ia32_get_arg_env(), cmd_buf, SNPRINTF_BUF_LEN, "xor %2S, %1S", irn, irn);
1562                         IA32_DO_EMIT(irn);
1563                         lc_esnprintf(ia32_get_arg_env(), cmd_buf, SNPRINTF_BUF_LEN, "xor %1S, %2S", irn, irn);
1564                 } else {
1565 #endif
1566                         be_emit_cstring(env, "\txchg ");
1567                         ia32_emit_source_register(env, node, 1);
1568                         be_emit_cstring(env, ", ");
1569                         ia32_emit_source_register(env, node, 0);
1570                         be_emit_finish_line_gas(env, node);
1571 #if 0
1572                 }
1573 #endif
1574         } else if (cls1 == &ia32_reg_classes[CLASS_ia32_xmm]) {
1575                 be_emit_cstring(env, "\txorpd ");
1576                 ia32_emit_source_register(env, node, 1);
1577                 be_emit_cstring(env, ", ");
1578                 ia32_emit_source_register(env, node, 0);
1579                 be_emit_finish_line_gas(env, NULL);
1580
1581                 be_emit_cstring(env, "\txorpd ");
1582                 ia32_emit_source_register(env, node, 0);
1583                 be_emit_cstring(env, ", ");
1584                 ia32_emit_source_register(env, node, 1);
1585                 be_emit_finish_line_gas(env, NULL);
1586
1587                 be_emit_cstring(env, "\txorpd ");
1588                 ia32_emit_source_register(env, node, 1);
1589                 be_emit_cstring(env, ", ");
1590                 ia32_emit_source_register(env, node, 0);
1591                 be_emit_finish_line_gas(env, node);
1592         } else if (cls1 == &ia32_reg_classes[CLASS_ia32_vfp]) {
1593                 /* is a NOP */
1594         } else if (cls1 == &ia32_reg_classes[CLASS_ia32_st]) {
1595                 /* is a NOP */
1596         }
1597 }
1598
1599 /**
1600  * Emits code for Constant loading.
1601  */
1602 static void emit_ia32_Const(ia32_emit_env_t *env, const ir_node *node) {
1603         ia32_immop_type_t imm_tp = get_ia32_immop_type(node);
1604
1605         if (imm_tp == ia32_ImmSymConst) {
1606                 be_emit_cstring(env, "\tmovl $");
1607                 ia32_emit_immediate(env, node);
1608                 be_emit_cstring(env, ", ");
1609                 ia32_emit_dest_register(env, node, 0);
1610         } else {
1611                 tarval *tv = get_ia32_Immop_tarval(node);
1612                 assert(get_irn_mode(node) == mode_Iu);
1613                 /* beware: in some rare cases mode is mode_b which has no tarval_null() */
1614                 if (tarval_is_null(tv)) {
1615                         if (env->isa->opt_arch == arch_pentium_4) {
1616                                 /* P4 prefers sub r, r, others xor r, r */
1617                                 be_emit_cstring(env, "\tsubl ");
1618                         } else {
1619                                 be_emit_cstring(env, "\txorl ");
1620                         }
1621                         ia32_emit_dest_register(env, node, 0);
1622                         be_emit_cstring(env, ", ");
1623                         ia32_emit_dest_register(env, node, 0);
1624                 } else {
1625                         be_emit_cstring(env, "\tmovl $");
1626                         ia32_emit_immediate(env, node);
1627                         be_emit_cstring(env, ", ");
1628                         ia32_emit_dest_register(env, node, 0);
1629                 }
1630         }
1631         be_emit_finish_line_gas(env, node);
1632 }
1633
1634 /**
1635  * Emits code to load the TLS base
1636  */
1637 static void emit_ia32_LdTls(ia32_emit_env_t *env, const ir_node *node) {
1638         be_emit_cstring(env, "\tmovl %gs:0, ");
1639         ia32_emit_dest_register(env, node, 0);
1640         be_emit_finish_line_gas(env, node);
1641 }
1642
1643 static void emit_be_Return(ia32_emit_env_t *env, const ir_node *node) {
1644         be_emit_cstring(env, "\tret");
1645         be_emit_finish_line_gas(env, node);
1646 }
1647
1648 static void emit_Nothing(ia32_emit_env_t *env, const ir_node *node) {
1649 }
1650
1651
1652 /***********************************************************************************
1653  *                  _          __                                             _
1654  *                 (_)        / _|                                           | |
1655  *  _ __ ___   __ _ _ _ __   | |_ _ __ __ _ _ __ ___   _____      _____  _ __| | __
1656  * | '_ ` _ \ / _` | | '_ \  |  _| '__/ _` | '_ ` _ \ / _ \ \ /\ / / _ \| '__| |/ /
1657  * | | | | | | (_| | | | | | | | | | | (_| | | | | | |  __/\ V  V / (_) | |  |   <
1658  * |_| |_| |_|\__,_|_|_| |_| |_| |_|  \__,_|_| |_| |_|\___| \_/\_/ \___/|_|  |_|\_\
1659  *
1660  ***********************************************************************************/
1661
1662 /**
1663  * Enters the emitter functions for handled nodes into the generic
1664  * pointer of an opcode.
1665  */
1666 static void ia32_register_emitters(void) {
1667
1668 #define IA32_EMIT2(a,b) op_ia32_##a->ops.generic = (op_func)emit_ia32_##b
1669 #define IA32_EMIT(a)    IA32_EMIT2(a,a)
1670 #define EMIT(a)         op_##a->ops.generic = (op_func)emit_##a
1671 #define IGN(a)                  op_##a->ops.generic = (op_func)emit_Nothing
1672 #define BE_EMIT(a)      op_be_##a->ops.generic = (op_func)emit_be_##a
1673 #define BE_IGN(a)               op_be_##a->ops.generic = (op_func)emit_Nothing
1674
1675         /* first clear the generic function pointer for all ops */
1676         clear_irp_opcodes_generic_func();
1677
1678         /* register all emitter functions defined in spec */
1679         ia32_register_spec_emitters();
1680
1681         /* other ia32 emitter functions */
1682         IA32_EMIT(CondJmp);
1683         IA32_EMIT(TestJmp);
1684         IA32_EMIT(CJmp);
1685         IA32_EMIT(CJmpAM);
1686         IA32_EMIT(CmpCMov);
1687         IA32_EMIT(PsiCondCMov);
1688         IA32_EMIT(CmpSet);
1689         IA32_EMIT(PsiCondSet);
1690         IA32_EMIT(SwitchJmp);
1691         IA32_EMIT(CopyB);
1692         IA32_EMIT(CopyB_i);
1693         IA32_EMIT(Conv_I2FP);
1694         IA32_EMIT(Conv_FP2I);
1695         IA32_EMIT(Conv_FP2FP);
1696         IA32_EMIT(Conv_I2I);
1697         IA32_EMIT(Conv_I2I8Bit);
1698         IA32_EMIT(Const);
1699         IA32_EMIT(LdTls);
1700         IA32_EMIT(xCmp);
1701         IA32_EMIT(xCmpSet);
1702         IA32_EMIT(xCmpCMov);
1703         IA32_EMIT(xCondJmp);
1704         IA32_EMIT2(fcomJmp, x87CondJmp);
1705         IA32_EMIT2(fcompJmp, x87CondJmp);
1706         IA32_EMIT2(fcomppJmp, x87CondJmp);
1707         IA32_EMIT2(fcomrJmp, x87CondJmp);
1708         IA32_EMIT2(fcomrpJmp, x87CondJmp);
1709         IA32_EMIT2(fcomrppJmp, x87CondJmp);
1710
1711         /* benode emitter */
1712         BE_EMIT(Call);
1713         BE_EMIT(IncSP);
1714         BE_EMIT(SetSP);
1715         BE_EMIT(Copy);
1716         BE_EMIT(CopyKeep);
1717         BE_EMIT(Perm);
1718         BE_EMIT(Return);
1719
1720         BE_IGN(RegParams);
1721         BE_IGN(Barrier);
1722         BE_IGN(Keep);
1723
1724         /* firm emitter */
1725         EMIT(Jmp);
1726         IGN(Proj);
1727         IGN(Phi);
1728         IGN(Start);
1729
1730 #undef BE_EMIT
1731 #undef EMIT
1732 #undef IGN
1733 #undef IA32_EMIT2
1734 #undef IA32_EMIT
1735 }
1736
1737 static const char *last_name = NULL;
1738 static unsigned last_line = -1;
1739 static unsigned num = -1;
1740
1741 /**
1742  * Emit the debug support for node node.
1743  */
1744 static void ia32_emit_dbg(ia32_emit_env_t *env, const ir_node *node) {
1745         dbg_info *db = get_irn_dbg_info(node);
1746         unsigned lineno;
1747         const char *fname = be_retrieve_dbg_info(db, &lineno);
1748
1749         if (! env->cg->birg->main_env->options->stabs_debug_support)
1750                 return;
1751
1752         if (fname) {
1753                 if (last_name != fname) {
1754                         last_line = -1;
1755                         be_dbg_include_begin(env->cg->birg->main_env->db_handle, fname);
1756                         last_name = fname;
1757                 }
1758                 if (last_line != lineno) {
1759                         char name[64];
1760
1761                         snprintf(name, sizeof(name), ".LM%u", ++num);
1762                         last_line = lineno;
1763                         be_dbg_line(env->cg->birg->main_env->db_handle, lineno, name);
1764                         be_emit_string(env, name);
1765                         be_emit_cstring(env, ":\n");
1766                         be_emit_write_line(env);
1767                 }
1768         }
1769 }
1770
1771 typedef void (*emit_func_ptr) (ia32_emit_env_t *, const ir_node *);
1772
1773 /**
1774  * Emits code for a node.
1775  */
1776 static void ia32_emit_node(ia32_emit_env_t *env, const ir_node *node) {
1777         ir_op *op = get_irn_op(node);
1778         DEBUG_ONLY(firm_dbg_module_t *mod = env->mod;)
1779
1780         DBG((mod, LEVEL_1, "emitting code for %+F\n", node));
1781
1782         if (op->ops.generic) {
1783                 emit_func_ptr func = (emit_func_ptr) op->ops.generic;
1784                 ia32_emit_dbg(env, node);
1785                 (*func) (env, node);
1786         } else {
1787                 emit_Nothing(env, node);
1788                 ir_fprintf(stderr, "Warning: No emit handler for node %+F (%+G)\n", node, node);
1789         }
1790 }
1791
1792 /**
1793  * Emits gas alignment directives
1794  */
1795 static void ia32_emit_alignment(ia32_emit_env_t *env, unsigned align, unsigned skip) {
1796         be_emit_cstring(env, "\t.p2align ");
1797         be_emit_irprintf(env->emit, "%u,,%u\n", align, skip);
1798         be_emit_write_line(env);
1799 }
1800
1801 /**
1802  * Emits gas alignment directives for Functions depended on cpu architecture.
1803  */
1804 static void ia32_emit_align_func(ia32_emit_env_t *env, cpu_support cpu) {
1805         unsigned align;
1806         unsigned maximum_skip;
1807
1808         switch (cpu) {
1809                 case arch_i386:
1810                         align = 2;
1811                         break;
1812                 case arch_i486:
1813                         align = 4;
1814                         break;
1815                 case arch_k6:
1816                         align = 5;
1817                         break;
1818                 default:
1819                         align = 4;
1820         }
1821         maximum_skip = (1 << align) - 1;
1822         ia32_emit_alignment(env, align, maximum_skip);
1823 }
1824
1825 /**
1826  * Emits gas alignment directives for Labels depended on cpu architecture.
1827  */
1828 static void ia32_emit_align_label(ia32_emit_env_t *env, cpu_support cpu) {
1829         unsigned align; unsigned maximum_skip;
1830
1831         switch (cpu) {
1832                 case arch_i386:
1833                         align = 2;
1834                         break;
1835                 case arch_i486:
1836                         align = 4;
1837                         break;
1838                 case arch_k6:
1839                         align = 5;
1840                         break;
1841                 default:
1842                         align = 4;
1843         }
1844         maximum_skip = (1 << align) - 1;
1845         ia32_emit_alignment(env, align, maximum_skip);
1846 }
1847
1848 static int is_first_loop_block(ia32_emit_env_t *env, ir_node *block, ir_node *prev_block) {
1849         ir_exec_freq *exec_freq = env->cg->birg->exec_freq;
1850         double block_freq, prev_freq;
1851         static const double DELTA = .0001;
1852         cpu_support cpu = env->isa->opt_arch;
1853
1854         if(exec_freq == NULL)
1855                 return 0;
1856         if(cpu == arch_i386 || cpu == arch_i486)
1857                 return 0;
1858
1859         block_freq = get_block_execfreq(exec_freq, block);
1860         prev_freq = get_block_execfreq(exec_freq, prev_block);
1861
1862         if(block_freq < DELTA || prev_freq < DELTA)
1863                 return 0;
1864
1865         block_freq /= prev_freq;
1866
1867         switch (cpu) {
1868                 case arch_athlon:
1869                 case arch_athlon_64:
1870                 case arch_k6:
1871                         return block_freq > 3;
1872                 default:
1873                         break;
1874         }
1875
1876         return block_freq > 2;
1877 }
1878
1879 /**
1880  * Walks over the nodes in a block connected by scheduling edges
1881  * and emits code for each node.
1882  */
1883 static void ia32_gen_block(ia32_emit_env_t *env, ir_node *block, ir_node *last_block) {
1884         ir_graph      *irg         = get_irn_irg(block);
1885         ir_node       *start_block = get_irg_start_block(irg);
1886         int           need_label   = 1;
1887         const ir_node *node;
1888         int           i;
1889
1890         assert(is_Block(block));
1891
1892         if (block == start_block)
1893                 need_label = 0;
1894
1895         if (need_label && get_irn_arity(block) == 1) {
1896                 ir_node *pred_block = get_Block_cfgpred_block(block, 0);
1897
1898                 if (pred_block == last_block && get_irn_n_edges_kind(pred_block, EDGE_KIND_BLOCK) <= 2)
1899                         need_label = 0;
1900         }
1901
1902         /* special case: if one of our cfg preds is a switch-jmp we need a label, */
1903         /*               otherwise there might be jump table entries jumping to   */
1904         /*               non-existent (omitted) labels                            */
1905         for (i = get_Block_n_cfgpreds(block) - 1; i >= 0; --i) {
1906                 ir_node *pred = get_Block_cfgpred(block, i);
1907
1908                 if (is_Proj(pred)) {
1909                         assert(get_irn_mode(pred) == mode_X);
1910                         if (is_ia32_SwitchJmp(get_Proj_pred(pred))) {
1911                                 need_label = 1;
1912                                 break;
1913                         }
1914                 }
1915         }
1916
1917         if (need_label) {
1918                 int i, arity;
1919                 int align = 1;
1920                 ir_exec_freq *exec_freq = env->cg->birg->exec_freq;
1921
1922                 /* align the loop headers */
1923                 if (! is_first_loop_block(env, block, last_block)) {
1924                         /* align blocks where the previous block has no fallthrough */
1925                         arity = get_irn_arity(block);
1926
1927                         for (i = 0; i < arity; ++i) {
1928                                 ir_node *predblock = get_Block_cfgpred_block(block, i);
1929
1930                                 if (predblock == last_block) {
1931                                         align = 0;
1932                                         break;
1933                                 }
1934                         }
1935                 }
1936
1937                 if (align)
1938                         ia32_emit_align_label(env, env->isa->opt_arch);
1939
1940                 be_emit_cstring(env, BLOCK_PREFIX);
1941                 be_emit_irprintf(env->emit, "%d:", get_irn_node_nr(block));
1942                 be_emit_pad_comment(env);
1943                 be_emit_cstring(env, "   /* preds:");
1944
1945                 /* emit list of pred blocks in comment */
1946                 arity = get_irn_arity(block);
1947                 for (i = 0; i < arity; ++i) {
1948                         ir_node *predblock = get_Block_cfgpred_block(block, i);
1949                         be_emit_irprintf(env->emit, " %d", get_irn_node_nr(predblock));
1950                 }
1951
1952                 if (exec_freq != NULL) {
1953                         be_emit_irprintf(env->emit, " freq: %f", get_block_execfreq(exec_freq, block));
1954                 }
1955                 be_emit_cstring(env, " */\n");
1956                 be_emit_write_line(env);
1957         }
1958
1959         /* emit the contents of the block */
1960         ia32_emit_dbg(env, block);
1961         sched_foreach(block, node) {
1962                 ia32_emit_node(env, node);
1963         }
1964 }
1965
1966 /**
1967  * Emits code for function start.
1968  */
1969 static void ia32_emit_func_prolog(ia32_emit_env_t *env, ir_graph *irg) {
1970         ir_entity  *irg_ent  = get_irg_entity(irg);
1971         const char *irg_name = get_entity_ld_name(irg_ent);
1972         cpu_support cpu      = env->isa->opt_arch;
1973         const be_irg_t *birg = env->cg->birg;
1974
1975         be_emit_write_line(env);
1976         be_gas_emit_switch_section(env->emit, GAS_SECTION_TEXT);
1977         be_dbg_method_begin(birg->main_env->db_handle, irg_ent, be_abi_get_stack_layout(birg->abi));
1978         ia32_emit_align_func(env, cpu);
1979         if (get_entity_visibility(irg_ent) == visibility_external_visible) {
1980                 be_emit_cstring(env, ".global ");
1981                 be_emit_string(env, irg_name);
1982                 be_emit_char(env, '\n');
1983                 be_emit_write_line(env);
1984         }
1985         ia32_emit_function_object(env, irg_name);
1986         be_emit_string(env, irg_name);
1987         be_emit_cstring(env, ":\n");
1988         be_emit_write_line(env);
1989 }
1990
1991 /**
1992  * Emits code for function end
1993  */
1994 static void ia32_emit_func_epilog(ia32_emit_env_t *env, ir_graph *irg) {
1995         const char *irg_name = get_entity_ld_name(get_irg_entity(irg));
1996         const be_irg_t *birg = env->cg->birg;
1997
1998         ia32_emit_function_size(env, irg_name);
1999         be_dbg_method_end(birg->main_env->db_handle);
2000         be_emit_char(env, '\n');
2001         be_emit_write_line(env);
2002 }
2003
2004 /**
2005  * Block-walker:
2006  * Sets labels for control flow nodes (jump target)
2007  */
2008 static void ia32_gen_labels(ir_node *block, void *data) {
2009         ir_node *pred;
2010         int n = get_Block_n_cfgpreds(block);
2011
2012         for (n--; n >= 0; n--) {
2013                 pred = get_Block_cfgpred(block, n);
2014                 set_irn_link(pred, block);
2015         }
2016 }
2017
2018 /**
2019  * Main driver. Emits the code for one routine.
2020  */
2021 void ia32_gen_routine(ia32_code_gen_t *cg, ir_graph *irg) {
2022         ia32_emit_env_t env;
2023         ir_node *block;
2024         ir_node *last_block = NULL;
2025         int i, n;
2026
2027         env.isa      = (ia32_isa_t *)cg->arch_env->isa;
2028         env.emit     = &env.isa->emit;
2029         env.arch_env = cg->arch_env;
2030         env.cg       = cg;
2031         FIRM_DBG_REGISTER(env.mod, "firm.be.ia32.emitter");
2032
2033         /* set the global arch_env (needed by print hooks) */
2034         arch_env = cg->arch_env;
2035
2036         ia32_register_emitters();
2037
2038         ia32_emit_func_prolog(&env, irg);
2039         irg_block_walk_graph(irg, ia32_gen_labels, NULL, &env);
2040
2041         n = ARR_LEN(cg->blk_sched);
2042         for (i = 0; i < n;) {
2043                 ir_node *next_bl;
2044
2045                 block   = cg->blk_sched[i];
2046                 ++i;
2047                 next_bl = i < n ? cg->blk_sched[i] : NULL;
2048
2049                 /* set here the link. the emitter expects to find the next block here */
2050                 set_irn_link(block, next_bl);
2051                 ia32_gen_block(&env, block, last_block);
2052                 last_block = block;
2053         }
2054
2055         ia32_emit_func_epilog(&env, irg);
2056 }