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

   1 /**
   2  * This is the main ia32 firm backend driver.
   3  * @author Christian Wuerdig
   4  * $Id$
   5  */
   6
   7 #ifdef HAVE_CONFIG_H
   8 #include "config.h"
   9 #endif
  10
  11 #ifdef HAVE_MALLOC_H
  12 #include <malloc.h>
  13 #endif
  14
  15 #ifdef HAVE_ALLOCA_H
  16 #include <alloca.h>
  17 #endif
  18
  19 #ifdef WITH_LIBCORE
  20 #include <libcore/lc_opts.h>
  21 #include <libcore/lc_opts_enum.h>
  22 #endif /* WITH_LIBCORE */
  23
  24 #include <math.h>
  25
  26 #include "pseudo_irg.h"
  27 #include "irgwalk.h"
  28 #include "irprog.h"
  29 #include "irprintf.h"
  30 #include "iredges_t.h"
  31 #include "ircons.h"
  32 #include "irgmod.h"
  33 #include "irgopt.h"
  34 #include "irbitset.h"
  35 #include "pdeq.h"
  36 #include "pset.h"
  37 #include "debug.h"
  38
  39 #include "../beabi.h"                 /* the general register allocator interface */
  40 #include "../benode_t.h"
  41 #include "../belower.h"
  42 #include "../besched_t.h"
  43 #include "../be.h"
  44 #include "../be_t.h"
  45 #include "../beirgmod.h"
  46 #include "../be_dbgout.h"
  47 #include "../beblocksched.h"
  48 #include "../bemachine.h"
  49
  50 #include "bearch_ia32_t.h"
  51
  52 #include "ia32_new_nodes.h"           /* ia32 nodes interface */
  53 #include "gen_ia32_regalloc_if.h"     /* the generated interface (register type and class defenitions) */
  54 #include "gen_ia32_machine.h"
  55 #include "ia32_gen_decls.h"           /* interface declaration emitter */
  56 #include "ia32_transform.h"
  57 #include "ia32_emitter.h"
  58 #include "ia32_map_regs.h"
  59 #include "ia32_optimize.h"
  60 #include "ia32_x87.h"
  61 #include "ia32_dbg_stat.h"
  62 #include "ia32_finish.h"
  63 #include "ia32_util.h"
  64
  65 #define DEBUG_MODULE "firm.be.ia32.isa"
  66
  67 /* TODO: ugly */
  68 static set *cur_reg_set = NULL;
  69
  70 /* Creates the unique per irg GP NoReg node. */
  71 ir_node *ia32_new_NoReg_gp(ia32_code_gen_t *cg) {
  72         return be_abi_get_callee_save_irn(cg->birg->abi, &ia32_gp_regs[REG_GP_NOREG]);
  73 }
  74
  75 /* Creates the unique per irg FP NoReg node. */
  76 ir_node *ia32_new_NoReg_fp(ia32_code_gen_t *cg) {
  77         return be_abi_get_callee_save_irn(cg->birg->abi,
  78                 USE_SSE2(cg) ? &ia32_xmm_regs[REG_XMM_NOREG] : &ia32_vfp_regs[REG_VFP_NOREG]);
  79 }
  80
  81 /**
  82  * Returns gp_noreg or fp_noreg, depending in input requirements.
  83  */
  84 ir_node *ia32_get_admissible_noreg(ia32_code_gen_t *cg, ir_node *irn, int pos) {
  85         arch_register_req_t       req;
  86         const arch_register_req_t *p_req;
  87
  88         p_req = arch_get_register_req(cg->arch_env, &req, irn, pos);
  89         assert(p_req && "Missing register requirements");
  90         if (p_req->cls == &ia32_reg_classes[CLASS_ia32_gp])
  91                 return ia32_new_NoReg_gp(cg);
  92         else
  93                 return ia32_new_NoReg_fp(cg);
  94 }
  95
  96 /**************************************************
  97  *                         _ _              _  __
  98  *                        | | |            (_)/ _|
  99  *  _ __ ___  __ _    __ _| | | ___   ___   _| |_
 100  * | '__/ _ \/ _` |  / _` | | |/ _ \ / __| | |  _|
 101  * | | |  __/ (_| | | (_| | | | (_) | (__  | | |
 102  * |_|  \___|\__, |  \__,_|_|_|\___/ \___| |_|_|
 103  *            __/ |
 104  *           |___/
 105  **************************************************/
 106
 107 /**
 108  * Return register requirements for an ia32 node.
 109  * If the node returns a tuple (mode_T) then the proj's
 110  * will be asked for this information.
 111  */
 112 static const arch_register_req_t *ia32_get_irn_reg_req(const void *self, arch_register_req_t *req, const ir_node *irn, int pos) {
 113         const ia32_irn_ops_t      *ops = self;
 114         const ia32_register_req_t *irn_req;
 115         long                       node_pos = pos == -1 ? 0 : pos;
 116         ir_mode                   *mode     = is_Block(irn) ? NULL : get_irn_mode(irn);
 117         FIRM_DBG_REGISTER(firm_dbg_module_t *mod, DEBUG_MODULE);
 118
 119         if (is_Block(irn) || mode == mode_M || mode == mode_X) {
 120                 DBG((mod, LEVEL_1, "ignoring Block, mode_M, mode_X node %+F\n", irn));
 121                 return NULL;
 122         }
 123
 124         if (mode == mode_T && pos < 0) {
 125                 DBG((mod, LEVEL_1, "ignoring request OUT requirements for node %+F\n", irn));
 126                 return NULL;
 127         }
 128
 129         DBG((mod, LEVEL_1, "get requirements at pos %d for %+F ... ", pos, irn));
 130
 131         if (is_Proj(irn)) {
 132                 if(pos >= 0) {
 133                         DBG((mod, LEVEL_1, "ignoring request IN requirements for node %+F\n", irn));
 134                         return NULL;
 135                 }
 136
 137                 node_pos = (pos == -1) ? get_Proj_proj(irn) : pos;
 138                 irn      = skip_Proj(irn);
 139
 140                 DB((mod, LEVEL_1, "skipping Proj, going to %+F at pos %d ... ", irn, node_pos));
 141         }
 142
 143         if (is_ia32_irn(irn)) {
 144                 irn_req = (pos >= 0) ? get_ia32_in_req(irn, pos) : get_ia32_out_req(irn, node_pos);
 145                 if (irn_req == NULL) {
 146                         /* no requirements */
 147                         return NULL;
 148                 }
 149
 150                 DB((mod, LEVEL_1, "returning reqs for %+F at pos %d\n", irn, pos));
 151
 152                 memcpy(req, &(irn_req->req), sizeof(*req));
 153
 154                 if (arch_register_req_is(&(irn_req->req), should_be_same)) {
 155                         assert(irn_req->same_pos >= 0 && "should be same constraint for in -> out NYI");
 156                         req->other_same = get_irn_n(irn, irn_req->same_pos);
 157                 }
 158
 159                 if (arch_register_req_is(&(irn_req->req), should_be_different)) {
 160                         assert(irn_req->different_pos >= 0 && "should be different constraint for in -> out NYI");
 161                         req->other_different = get_irn_n(irn, irn_req->different_pos);
 162                 }
 163         }
 164         else {
 165                 /* treat Unknowns like Const with default requirements */
 166                 if (is_Unknown(irn)) {
 167                         DB((mod, LEVEL_1, "returning UKNWN reqs for %+F\n", irn));
 168                         if (mode_is_float(mode)) {
 169                                 if (USE_SSE2(ops->cg))
 170                                         memcpy(req, &(ia32_default_req_ia32_xmm_xmm_UKNWN), sizeof(*req));
 171                                 else
 172                                         memcpy(req, &(ia32_default_req_ia32_vfp_vfp_UKNWN), sizeof(*req));
 173                         }
 174                         else if (mode_is_int(mode) || mode_is_reference(mode))
 175                                 memcpy(req, &(ia32_default_req_ia32_gp_gp_UKNWN), sizeof(*req));
 176                         else if (mode == mode_T || mode == mode_M) {
 177                                 DBG((mod, LEVEL_1, "ignoring Unknown node %+F\n", irn));
 178                                 return NULL;
 179                         }
 180                         else
 181                                 assert(0 && "unsupported Unknown-Mode");
 182                 }
 183                 else {
 184                         DB((mod, LEVEL_1, "returning NULL for %+F (not ia32)\n", irn));
 185                         req = NULL;
 186                 }
 187         }
 188
 189         return req;
 190 }
 191
 192 static void ia32_set_irn_reg(const void *self, ir_node *irn, const arch_register_t *reg) {
 193         int                   pos = 0;
 194         const ia32_irn_ops_t *ops = self;
 195
 196         if (get_irn_mode(irn) == mode_X) {
 197                 return;
 198         }
 199
 200         DBG((ops->cg->mod, LEVEL_1, "ia32 assigned register %s to node %+F\n", reg->name, irn));
 201
 202         if (is_Proj(irn)) {
 203                 pos = get_Proj_proj(irn);
 204                 irn = skip_Proj(irn);
 205         }
 206
 207         if (is_ia32_irn(irn)) {
 208                 const arch_register_t **slots;
 209
 210                 slots      = get_ia32_slots(irn);
 211                 slots[pos] = reg;
 212         }
 213         else {
 214                 ia32_set_firm_reg(irn, reg, cur_reg_set);
 215         }
 216 }
 217
 218 static const arch_register_t *ia32_get_irn_reg(const void *self, const ir_node *irn) {
 219         int pos = 0;
 220         const arch_register_t *reg = NULL;
 221
 222         if (is_Proj(irn)) {
 223
 224                 if (get_irn_mode(irn) == mode_X) {
 225                         return NULL;
 226                 }
 227
 228                 pos = get_Proj_proj(irn);
 229                 irn = skip_Proj(irn);
 230         }
 231
 232         if (is_ia32_irn(irn)) {
 233                 const arch_register_t **slots;
 234                 slots = get_ia32_slots(irn);
 235                 reg   = slots[pos];
 236         }
 237         else {
 238                 reg = ia32_get_firm_reg(irn, cur_reg_set);
 239         }
 240
 241         return reg;
 242 }
 243
 244 static arch_irn_class_t ia32_classify(const void *self, const ir_node *irn) {
 245         arch_irn_class_t classification = arch_irn_class_normal;
 246
 247         irn = skip_Proj(irn);
 248
 249         if (is_cfop(irn))
 250                 classification |= arch_irn_class_branch;
 251
 252         if (! is_ia32_irn(irn))
 253                 return classification & ~arch_irn_class_normal;
 254
 255         if (is_ia32_Cnst(irn))
 256                 classification |= arch_irn_class_const;
 257
 258         if (is_ia32_Ld(irn))
 259                 classification |= arch_irn_class_load;
 260
 261         if (is_ia32_St(irn) || is_ia32_Store8Bit(irn))
 262                 classification |= arch_irn_class_store;
 263
 264         if (is_ia32_got_reload(irn))
 265                 classification |= arch_irn_class_reload;
 266
 267         return classification;
 268 }
 269
 270 static arch_irn_flags_t ia32_get_flags(const void *self, const ir_node *irn) {
 271         arch_irn_flags_t flags;
 272         ir_node          *pred = is_Proj(irn) && mode_is_datab(get_irn_mode(irn)) ? get_Proj_pred(irn) : NULL;
 273
 274         if (is_Unknown(irn))
 275                 flags = arch_irn_flags_ignore;
 276         else {
 277             /* pred is only set, if we have a Proj */
 278                 flags = pred && is_ia32_irn(pred) ? get_ia32_out_flags(pred, get_Proj_proj(irn)) : arch_irn_flags_none;
 279
 280                 irn = skip_Proj(irn);
 281                 if (is_ia32_irn(irn))
 282                         flags |= get_ia32_flags(irn);
 283         }
 284
 285         return flags;
 286 }
 287
 288 /**
 289  * The IA32 ABI callback object.
 290  */
 291 typedef struct {
 292         be_abi_call_flags_bits_t flags;  /**< The call flags. */
 293         const arch_isa_t *isa;           /**< The ISA handle. */
 294         const arch_env_t *aenv;          /**< The architecture environment. */
 295         ir_graph *irg;                   /**< The associated graph. */
 296 } ia32_abi_env_t;
 297
 298 static entity *ia32_get_frame_entity(const void *self, const ir_node *irn) {
 299         return is_ia32_irn(irn) ? get_ia32_frame_ent(irn) : NULL;
 300 }
 301
 302 static void ia32_set_frame_entity(const void *self, ir_node *irn, entity *ent) {
 303         set_ia32_frame_ent(irn, ent);
 304 }
 305
 306 static void ia32_set_frame_offset(const void *self, ir_node *irn, int bias) {
 307         char buf[64];
 308         const ia32_irn_ops_t *ops = self;
 309
 310         if (get_ia32_frame_ent(irn)) {
 311                 ia32_am_flavour_t am_flav = get_ia32_am_flavour(irn);
 312
 313                 if(is_ia32_Pop(irn)) {
 314                         int omit_fp = be_abi_omit_fp(ops->cg->birg->abi);
 315                         if (omit_fp) {
 316                                 /* Pop nodes modify the stack pointer before calculating the destination
 317                                  * address, so fix this here
 318                                  */
 319                                 bias -= 4;
 320                         }
 321                 }
 322
 323                 DBG((ops->cg->mod, LEVEL_1, "stack biased %+F with %d\n", irn, bias));
 324
 325                 snprintf(buf, sizeof(buf), "%d", bias);
 326
 327                 if (get_ia32_op_type(irn) == ia32_Normal) {
 328                         set_ia32_cnst(irn, buf);
 329                 } else {
 330                         add_ia32_am_offs(irn, buf);
 331                         am_flav |= ia32_O;
 332                         set_ia32_am_flavour(irn, am_flav);
 333                 }
 334         }
 335 }
 336
 337 static int ia32_get_sp_bias(const void *self, const ir_node *irn) {
 338         if(is_Proj(irn)) {
 339                 long proj = get_Proj_proj(irn);
 340                 ir_node *pred = get_Proj_pred(irn);
 341
 342                 if (proj == pn_ia32_Push_stack && is_ia32_Push(pred))
 343                         return 4;
 344                 if (proj == pn_ia32_Pop_stack && is_ia32_Pop(pred))
 345                         return -4;
 346         }
 347
 348         return 0;
 349 }
 350
 351 /**
 352  * Put all registers which are saved by the prologue/epilogue in a set.
 353  *
 354  * @param self  The callback object.
 355  * @param s     The result set.
 356  */
 357 static void ia32_abi_dont_save_regs(void *self, pset *s)
 358 {
 359         ia32_abi_env_t *env = self;
 360         if(env->flags.try_omit_fp)
 361                 pset_insert_ptr(s, env->isa->bp);
 362 }
 363
 364 /**
 365  * Generate the routine prologue.
 366  *
 367  * @param self    The callback object.
 368  * @param mem     A pointer to the mem node. Update this if you define new memory.
 369  * @param reg_map A map mapping all callee_save/ignore/parameter registers to their defining nodes.
 370  *
 371  * @return        The register which shall be used as a stack frame base.
 372  *
 373  * All nodes which define registers in @p reg_map must keep @p reg_map current.
 374  */
 375 static const arch_register_t *ia32_abi_prologue(void *self, ir_node **mem, pmap *reg_map)
 376 {
 377         ia32_abi_env_t *env = self;
 378
 379         if (! env->flags.try_omit_fp) {
 380                 ir_node *bl      = get_irg_start_block(env->irg);
 381                 ir_node *curr_sp = be_abi_reg_map_get(reg_map, env->isa->sp);
 382                 ir_node *curr_bp = be_abi_reg_map_get(reg_map, env->isa->bp);
 383                 ir_node *noreg = be_abi_reg_map_get(reg_map, &ia32_gp_regs[REG_GP_NOREG]);
 384                 ir_node *push;
 385
 386                 /* push ebp */
 387                 push    = new_rd_ia32_Push(NULL, env->irg, bl, noreg, noreg, curr_bp, curr_sp, *mem);
 388                 curr_sp = new_r_Proj(env->irg, bl, push, get_irn_mode(curr_sp), pn_ia32_Push_stack);
 389                 *mem    = new_r_Proj(env->irg, bl, push, mode_M, pn_ia32_Push_M);
 390
 391                 /* the push must have SP out register */
 392                 arch_set_irn_register(env->aenv, curr_sp, env->isa->sp);
 393                 set_ia32_flags(push, arch_irn_flags_ignore);
 394
 395                 /* move esp to ebp */
 396                 curr_bp  = be_new_Copy(env->isa->bp->reg_class, env->irg, bl, curr_sp);
 397                 be_set_constr_single_reg(curr_bp, BE_OUT_POS(0), env->isa->bp);
 398                 arch_set_irn_register(env->aenv, curr_bp, env->isa->bp);
 399                 be_node_set_flags(curr_bp, BE_OUT_POS(0), arch_irn_flags_ignore);
 400
 401                 /* beware: the copy must be done before any other sp use */
 402                 curr_sp = be_new_CopyKeep_single(env->isa->sp->reg_class, env->irg, bl, curr_sp, curr_bp, get_irn_mode(curr_sp));
 403                 be_set_constr_single_reg(curr_sp, BE_OUT_POS(0), env->isa->sp);
 404                 arch_set_irn_register(env->aenv, curr_sp, env->isa->sp);
 405                 be_node_set_flags(curr_sp, BE_OUT_POS(0), arch_irn_flags_ignore);
 406
 407                 be_abi_reg_map_set(reg_map, env->isa->sp, curr_sp);
 408                 be_abi_reg_map_set(reg_map, env->isa->bp, curr_bp);
 409
 410                 return env->isa->bp;
 411         }
 412
 413         return env->isa->sp;
 414 }
 415
 416 /**
 417  * Generate the routine epilogue.
 418  * @param self    The callback object.
 419  * @param bl      The block for the epilog
 420  * @param mem     A pointer to the mem node. Update this if you define new memory.
 421  * @param reg_map A map mapping all callee_save/ignore/parameter registers to their defining nodes.
 422  * @return        The register which shall be used as a stack frame base.
 423  *
 424  * All nodes which define registers in @p reg_map must keep @p reg_map current.
 425  */
 426 static void ia32_abi_epilogue(void *self, ir_node *bl, ir_node **mem, pmap *reg_map)
 427 {
 428         ia32_abi_env_t *env     = self;
 429         ir_node        *curr_sp = be_abi_reg_map_get(reg_map, env->isa->sp);
 430         ir_node        *curr_bp = be_abi_reg_map_get(reg_map, env->isa->bp);
 431
 432         if (env->flags.try_omit_fp) {
 433                 /* simply remove the stack frame here */
 434                 curr_sp = be_new_IncSP(env->isa->sp, env->irg, bl, curr_sp, BE_STACK_FRAME_SIZE_SHRINK);
 435                 add_irn_dep(curr_sp, *mem);
 436         }
 437         else {
 438                 const ia32_isa_t *isa     = (ia32_isa_t *)env->isa;
 439                 ir_mode          *mode_bp = env->isa->bp->reg_class->mode;
 440
 441                 /* gcc always emits a leave at the end of a routine */
 442                 if (1 || ARCH_AMD(isa->opt_arch)) {
 443                         ir_node *leave;
 444
 445                         /* leave */
 446                         leave   = new_rd_ia32_Leave(NULL, env->irg, bl, curr_sp, curr_bp);
 447                         set_ia32_flags(leave, arch_irn_flags_ignore);
 448                         curr_bp = new_r_Proj(current_ir_graph, bl, leave, mode_bp, pn_ia32_Leave_frame);
 449                         curr_sp = new_r_Proj(current_ir_graph, bl, leave, get_irn_mode(curr_sp), pn_ia32_Leave_stack);
 450                         *mem    = new_r_Proj(current_ir_graph, bl, leave, mode_M, pn_ia32_Leave_M);
 451                 }
 452                 else {
 453                         ir_node *noreg = be_abi_reg_map_get(reg_map, &ia32_gp_regs[REG_GP_NOREG]);
 454                         ir_node *pop;
 455
 456                         /* copy ebp to esp */
 457                         curr_sp = be_new_SetSP(env->isa->sp, env->irg, bl, curr_sp, curr_bp, *mem);
 458
 459                         /* pop ebp */
 460                         pop     = new_rd_ia32_Pop(NULL, env->irg, bl, noreg, noreg, curr_sp, *mem);
 461                         set_ia32_flags(pop, arch_irn_flags_ignore);
 462                         curr_bp = new_r_Proj(current_ir_graph, bl, pop, mode_bp, pn_ia32_Pop_res);
 463                         curr_sp = new_r_Proj(current_ir_graph, bl, pop, get_irn_mode(curr_sp), pn_ia32_Pop_stack);
 464                         *mem    = new_r_Proj(current_ir_graph, bl, pop, mode_M, pn_ia32_Pop_M);
 465                 }
 466                 arch_set_irn_register(env->aenv, curr_sp, env->isa->sp);
 467                 arch_set_irn_register(env->aenv, curr_bp, env->isa->bp);
 468         }
 469
 470         be_abi_reg_map_set(reg_map, env->isa->sp, curr_sp);
 471         be_abi_reg_map_set(reg_map, env->isa->bp, curr_bp);
 472 }
 473
 474 /**
 475  * Initialize the callback object.
 476  * @param call The call object.
 477  * @param aenv The architecture environment.
 478  * @param irg  The graph with the method.
 479  * @return     Some pointer. This pointer is passed to all other callback functions as self object.
 480  */
 481 static void *ia32_abi_init(const be_abi_call_t *call, const arch_env_t *aenv, ir_graph *irg)
 482 {
 483         ia32_abi_env_t *env    = xmalloc(sizeof(env[0]));
 484         be_abi_call_flags_t fl = be_abi_call_get_flags(call);
 485         env->flags = fl.bits;
 486         env->irg   = irg;
 487         env->aenv  = aenv;
 488         env->isa   = aenv->isa;
 489         return env;
 490 }
 491
 492 /**
 493  * Destroy the callback object.
 494  * @param self The callback object.
 495  */
 496 static void ia32_abi_done(void *self) {
 497         free(self);
 498 }
 499
 500 /**
 501  * Produces the type which sits between the stack args and the locals on the stack.
 502  * it will contain the return address and space to store the old base pointer.
 503  * @return The Firm type modeling the ABI between type.
 504  */
 505 static ir_type *ia32_abi_get_between_type(void *self)
 506 {
 507 #define IDENT(s) new_id_from_chars(s, sizeof(s)-1)
 508         static ir_type *omit_fp_between_type = NULL;
 509         static ir_type *between_type         = NULL;
 510
 511         ia32_abi_env_t *env = self;
 512
 513         if ( !between_type) {
 514                 entity *old_bp_ent;
 515                 entity *ret_addr_ent;
 516                 entity *omit_fp_ret_addr_ent;
 517
 518                 ir_type *old_bp_type   = new_type_primitive(IDENT("bp"), mode_P);
 519                 ir_type *ret_addr_type = new_type_primitive(IDENT("return_addr"), mode_P);
 520
 521                 between_type           = new_type_struct(IDENT("ia32_between_type"));
 522                 old_bp_ent             = new_entity(between_type, IDENT("old_bp"), old_bp_type);
 523                 ret_addr_ent           = new_entity(between_type, IDENT("ret_addr"), ret_addr_type);
 524
 525                 set_entity_offset_bytes(old_bp_ent, 0);
 526                 set_entity_offset_bytes(ret_addr_ent, get_type_size_bytes(old_bp_type));
 527                 set_type_size_bytes(between_type, get_type_size_bytes(old_bp_type) + get_type_size_bytes(ret_addr_type));
 528                 set_type_state(between_type, layout_fixed);
 529
 530                 omit_fp_between_type = new_type_struct(IDENT("ia32_between_type_omit_fp"));
 531                 omit_fp_ret_addr_ent = new_entity(omit_fp_between_type, IDENT("ret_addr"), ret_addr_type);
 532
 533                 set_entity_offset_bytes(omit_fp_ret_addr_ent, 0);
 534                 set_type_size_bytes(omit_fp_between_type, get_type_size_bytes(ret_addr_type));
 535                 set_type_state(omit_fp_between_type, layout_fixed);
 536         }
 537
 538         return env->flags.try_omit_fp ? omit_fp_between_type : between_type;
 539 #undef IDENT
 540 }
 541
 542 /**
 543  * Get the estimated cycle count for @p irn.
 544  *
 545  * @param self The this pointer.
 546  * @param irn  The node.
 547  *
 548  * @return     The estimated cycle count for this operation
 549  */
 550 static int ia32_get_op_estimated_cost(const void *self, const ir_node *irn)
 551 {
 552         int cost;
 553         ia32_op_type_t op_tp;
 554         const ia32_irn_ops_t *ops = self;
 555
 556         if (is_Proj(irn))
 557                 return 0;
 558         if (!is_ia32_irn(irn))
 559                 return 0;
 560
 561         assert(is_ia32_irn(irn));
 562
 563         cost  = get_ia32_latency(irn);
 564         op_tp = get_ia32_op_type(irn);
 565
 566         if (is_ia32_CopyB(irn)) {
 567                 cost = 250;
 568                 if (ARCH_INTEL(ops->cg->arch))
 569                         cost += 150;
 570         }
 571         else if (is_ia32_CopyB_i(irn)) {
 572                 int size = get_tarval_long(get_ia32_Immop_tarval(irn));
 573                 cost     = 20 + (int)ceil((4/3) * size);
 574                 if (ARCH_INTEL(ops->cg->arch))
 575                         cost += 150;
 576         }
 577         /* in case of address mode operations add additional cycles */
 578         else if (op_tp == ia32_AddrModeD || op_tp == ia32_AddrModeS) {
 579                 /*
 580                         In case of stack access add 5 cycles (we assume stack is in cache),
 581                         other memory operations cost 20 cycles.
 582                 */
 583                 cost += is_ia32_use_frame(irn) ? 5 : 20;
 584         }
 585
 586         return cost;
 587 }
 588
 589 /**
 590  * Returns the inverse operation if @p irn, recalculating the argument at position @p i.
 591  *
 592  * @param irn       The original operation
 593  * @param i         Index of the argument we want the inverse operation to yield
 594  * @param inverse   struct to be filled with the resulting inverse op
 595  * @param obstack   The obstack to use for allocation of the returned nodes array
 596  * @return          The inverse operation or NULL if operation invertible
 597  */
 598 static arch_inverse_t *ia32_get_inverse(const void *self, const ir_node *irn, int i, arch_inverse_t *inverse, struct obstack *obst) {
 599         ir_graph *irg;
 600         ir_mode  *mode;
 601         ir_node  *block, *noreg, *nomem;
 602         int      pnc;
 603
 604         /* we cannot invert non-ia32 irns */
 605         if (! is_ia32_irn(irn))
 606                 return NULL;
 607
 608         /* operand must always be a real operand (not base, index or mem) */
 609         if (i != 2 && i != 3)
 610                 return NULL;
 611
 612         /* we don't invert address mode operations */
 613         if (get_ia32_op_type(irn) != ia32_Normal)
 614                 return NULL;
 615
 616         irg   = get_irn_irg(irn);
 617         block = get_nodes_block(irn);
 618         mode  = get_ia32_res_mode(irn);
 619         noreg = get_irn_n(irn, 0);
 620         nomem = new_r_NoMem(irg);
 621
 622         /* initialize structure */
 623         inverse->nodes = obstack_alloc(obst, 2 * sizeof(inverse->nodes[0]));
 624         inverse->costs = 0;
 625         inverse->n     = 2;
 626
 627         switch (get_ia32_irn_opcode(irn)) {
 628                 case iro_ia32_Add:
 629                         if (get_ia32_immop_type(irn) == ia32_ImmConst) {
 630                                 /* we have an add with a const here */
 631                                 /* invers == add with negated const */
 632                                 inverse->nodes[0] = new_rd_ia32_Add(NULL, irg, block, noreg, noreg, get_irn_n(irn, i), noreg, nomem);
 633                                 pnc               = pn_ia32_Add_res;
 634                                 inverse->costs   += 1;
 635                                 copy_ia32_Immop_attr(inverse->nodes[0], (ir_node *)irn);
 636                                 set_ia32_Immop_tarval(inverse->nodes[0], tarval_neg(get_ia32_Immop_tarval(irn)));
 637                                 set_ia32_commutative(inverse->nodes[0]);
 638                         }
 639                         else if (get_ia32_immop_type(irn) == ia32_ImmSymConst) {
 640                                 /* we have an add with a symconst here */
 641                                 /* invers == sub with const */
 642                                 inverse->nodes[0] = new_rd_ia32_Sub(NULL, irg, block, noreg, noreg, get_irn_n(irn, i), noreg, nomem);
 643                                 pnc               = pn_ia32_Sub_res;
 644                                 inverse->costs   += 2;
 645                                 copy_ia32_Immop_attr(inverse->nodes[0], (ir_node *)irn);
 646                         }
 647                         else {
 648                                 /* normal add: inverse == sub */
 649                                 ir_node *proj = ia32_get_res_proj(irn);
 650                                 assert(proj);
 651
 652                                 inverse->nodes[0] = new_rd_ia32_Sub(NULL, irg, block, noreg, noreg, proj, get_irn_n(irn, i ^ 1), nomem);
 653                                 pnc               = pn_ia32_Sub_res;
 654                                 inverse->costs   += 2;
 655                         }
 656                         break;
 657                 case iro_ia32_Sub:
 658                         if (get_ia32_immop_type(irn) != ia32_ImmNone) {
 659                                 /* we have a sub with a const/symconst here */
 660                                 /* invers == add with this const */
 661                                 inverse->nodes[0] = new_rd_ia32_Add(NULL, irg, block, noreg, noreg, get_irn_n(irn, i), noreg, nomem);
 662                                 pnc               = pn_ia32_Add_res;
 663                                 inverse->costs   += (get_ia32_immop_type(irn) == ia32_ImmSymConst) ? 5 : 1;
 664                                 copy_ia32_Immop_attr(inverse->nodes[0], (ir_node *)irn);
 665                         }
 666                         else {
 667                                 /* normal sub */
 668                                 ir_node *proj = ia32_get_res_proj(irn);
 669                                 assert(proj);
 670
 671                                 if (i == 2) {
 672                                         inverse->nodes[0] = new_rd_ia32_Add(NULL, irg, block, noreg, noreg, proj, get_irn_n(irn, 3), nomem);
 673                                 }
 674                                 else {
 675                                         inverse->nodes[0] = new_rd_ia32_Sub(NULL, irg, block, noreg, noreg, get_irn_n(irn, 2), proj, nomem);
 676                                 }
 677                                 pnc             = pn_ia32_Sub_res;
 678                                 inverse->costs += 1;
 679                         }
 680                         break;
 681                 case iro_ia32_Eor:
 682                         if (get_ia32_immop_type(irn) != ia32_ImmNone) {
 683                                 /* xor with const: inverse = xor */
 684                                 inverse->nodes[0] = new_rd_ia32_Eor(NULL, irg, block, noreg, noreg, get_irn_n(irn, i), noreg, nomem);
 685                                 pnc               = pn_ia32_Eor_res;
 686                                 inverse->costs   += (get_ia32_immop_type(irn) == ia32_ImmSymConst) ? 5 : 1;
 687                                 copy_ia32_Immop_attr(inverse->nodes[0], (ir_node *)irn);
 688                         }
 689                         else {
 690                                 /* normal xor */
 691                                 inverse->nodes[0] = new_rd_ia32_Eor(NULL, irg, block, noreg, noreg, (ir_node *)irn, get_irn_n(irn, i), nomem);
 692                                 pnc               = pn_ia32_Eor_res;
 693                                 inverse->costs   += 1;
 694                         }
 695                         break;
 696                 case iro_ia32_Not: {
 697                         ir_node *proj = ia32_get_res_proj(irn);
 698                         assert(proj);
 699
 700                         inverse->nodes[0] = new_rd_ia32_Not(NULL, irg, block, noreg, noreg, proj, nomem);
 701                         pnc = pn_ia32_Not_res;
 702                         inverse->costs   += 1;
 703                         break;
 704                 }
 705                 case iro_ia32_Minus: {
 706                         ir_node *proj = ia32_get_res_proj(irn);
 707                         assert(proj);
 708
 709                         inverse->nodes[0] = new_rd_ia32_Minus(NULL, irg, block, noreg, noreg, proj, nomem);
 710                         pnc               = pn_ia32_Minus_res;
 711                         inverse->costs   += 1;
 712                         break;
 713                 }
 714                 default:
 715                         /* inverse operation not supported */
 716                         return NULL;
 717         }
 718
 719         set_ia32_res_mode(inverse->nodes[0], mode);
 720         inverse->nodes[1] = new_r_Proj(irg, block, inverse->nodes[0], mode, pnc);
 721
 722         return inverse;
 723 }
 724
 725 /**
 726  * Check if irn can load it's operand at position i from memory (source addressmode).
 727  * @param self   Pointer to irn ops itself
 728  * @param irn    The irn to be checked
 729  * @param i      The operands position
 730  * @return Non-Zero if operand can be loaded
 731  */
 732 static int ia32_possible_memory_operand(const void *self, const ir_node *irn, unsigned int i) {
 733         if (! is_ia32_irn(irn)                            ||  /* must be an ia32 irn */
 734                 get_irn_arity(irn) != 5                       ||  /* must be a binary operation */
 735                 get_ia32_op_type(irn) != ia32_Normal          ||  /* must not already be a addressmode irn */
 736                 ! (get_ia32_am_support(irn) & ia32_am_Source) ||  /* must be capable of source addressmode */
 737                 (i != 2 && i != 3)                            ||  /* a "real" operand position must be requested */
 738                 (i == 2 && ! is_ia32_commutative(irn))        ||  /* if first operand requested irn must be commutative */
 739                 is_ia32_use_frame(irn))                           /* must not already use frame */
 740                 return 0;
 741
 742         return 1;
 743 }
 744
 745 static void ia32_perform_memory_operand(const void *self, ir_node *irn, ir_node *spill, unsigned int i) {
 746         const ia32_irn_ops_t *ops = self;
 747         ia32_code_gen_t      *cg  = ops->cg;
 748
 749         assert(ia32_possible_memory_operand(self, irn, i) && "Cannot perform memory operand change");
 750
 751         if (i == 2) {
 752                 ir_node *tmp = get_irn_n(irn, 3);
 753                 set_irn_n(irn, 3, get_irn_n(irn, 2));
 754                 set_irn_n(irn, 2, tmp);
 755         }
 756
 757         set_ia32_am_support(irn, ia32_am_Source);
 758         set_ia32_op_type(irn, ia32_AddrModeS);
 759         set_ia32_am_flavour(irn, ia32_B);
 760         set_ia32_ls_mode(irn, get_irn_mode(get_irn_n(irn, i)));
 761         set_ia32_use_frame(irn);
 762         set_ia32_got_reload(irn);
 763
 764         set_irn_n(irn, 0, get_irg_frame(get_irn_irg(irn)));
 765         set_irn_n(irn, 4, spill);
 766
 767         /*
 768                 Input at position one is index register, which is NoReg.
 769                 We would need cg object to get a real noreg, but we cannot
 770                 access it from here.
 771          */
 772         set_irn_n(irn, 3, ia32_get_admissible_noreg(cg, irn, 3));
 773
 774         //FIXME DBG_OPT_AM_S(reload, irn);
 775 }
 776
 777 static const be_abi_callbacks_t ia32_abi_callbacks = {
 778         ia32_abi_init,
 779         ia32_abi_done,
 780         ia32_abi_get_between_type,
 781         ia32_abi_dont_save_regs,
 782         ia32_abi_prologue,
 783         ia32_abi_epilogue,
 784 };
 785
 786 /* fill register allocator interface */
 787
 788 static const arch_irn_ops_if_t ia32_irn_ops_if = {
 789         ia32_get_irn_reg_req,
 790         ia32_set_irn_reg,
 791         ia32_get_irn_reg,
 792         ia32_classify,
 793         ia32_get_flags,
 794         ia32_get_frame_entity,
 795         ia32_set_frame_entity,
 796         ia32_set_frame_offset,
 797         ia32_get_sp_bias,
 798         ia32_get_inverse,
 799         ia32_get_op_estimated_cost,
 800         ia32_possible_memory_operand,
 801         ia32_perform_memory_operand,
 802 };
 803
 804 ia32_irn_ops_t ia32_irn_ops = {
 805         &ia32_irn_ops_if,
 806         NULL
 807 };
 808
 809
 810
 811 /**************************************************
 812  *                _                         _  __
 813  *               | |                       (_)/ _|
 814  *   ___ ___   __| | ___  __ _  ___ _ __    _| |_
 815  *  / __/ _ \ / _` |/ _ \/ _` |/ _ \ '_ \  | |  _|
 816  * | (_| (_) | (_| |  __/ (_| |  __/ | | | | | |
 817  *  \___\___/ \__,_|\___|\__, |\___|_| |_| |_|_|
 818  *                        __/ |
 819  *                       |___/
 820  **************************************************/
 821
 822 static void ia32_kill_convs(ia32_code_gen_t *cg) {
 823         ir_node *irn;
 824
 825         /* BEWARE: the Projs are inserted in the set */
 826         foreach_nodeset(cg->kill_conv, irn) {
 827                 ir_node *in = get_irn_n(get_Proj_pred(irn), 2);
 828                 edges_reroute(irn, in, cg->birg->irg);
 829         }
 830 }
 831
 832 /**
 833  * Transform the Thread Local Store base.
 834  */
 835 static void transform_tls(ir_graph *irg) {
 836         ir_node *irn = get_irg_tls(irg);
 837
 838         if (irn) {
 839                 dbg_info *dbg = get_irn_dbg_info(irn);
 840                 ir_node  *blk = get_nodes_block(irn);
 841                 ir_node  *newn;
 842                 newn = new_rd_ia32_LdTls(dbg, irg, blk, get_irn_mode(irn));
 843
 844                 exchange(irn, newn);
 845         }
 846 }
 847
 848 /**
 849  * Transforms the standard firm graph into
 850  * an ia32 firm graph
 851  */
 852 static void ia32_prepare_graph(void *self) {
 853         ia32_code_gen_t *cg = self;
 854         dom_front_info_t *dom;
 855         DEBUG_ONLY(firm_dbg_module_t *old_mod = cg->mod;)
 856
 857         FIRM_DBG_REGISTER(cg->mod, "firm.be.ia32.transform");
 858
 859         /* 1st: transform constants and psi condition trees */
 860         ia32_pre_transform_phase(cg);
 861
 862         /* 2nd: transform all remaining nodes */
 863         ia32_register_transformers();
 864         dom = be_compute_dominance_frontiers(cg->irg);
 865
 866         cg->kill_conv = new_nodeset(5);
 867         transform_tls(cg->irg);
 868         edges_deactivate(cg->irg);
 869         edges_activate(cg->irg);
 870         irg_walk_blkwise_graph(cg->irg, NULL, ia32_transform_node, cg);
 871         ia32_kill_convs(cg);
 872         del_nodeset(cg->kill_conv);
 873
 874         be_free_dominance_frontiers(dom);
 875
 876         if (cg->dump)
 877                 be_dump(cg->irg, "-transformed", dump_ir_block_graph_sched);
 878
 879         /* 3rd: optimize address mode */
 880         FIRM_DBG_REGISTER(cg->mod, "firm.be.ia32.am");
 881         ia32_optimize_addressmode(cg);
 882
 883         if (cg->dump)
 884                 be_dump(cg->irg, "-am", dump_ir_block_graph_sched);
 885
 886         DEBUG_ONLY(cg->mod = old_mod;)
 887 }
 888
 889 /**
 890  * Dummy functions for hooks we don't need but which must be filled.
 891  */
 892 static void ia32_before_sched(void *self) {
 893 }
 894
 895 static void remove_unused_nodes(ir_node *irn, bitset_t *already_visited) {
 896         int i, arity;
 897         ir_mode *mode;
 898         ir_node *mem_proj = NULL;
 899
 900         if (is_Block(irn))
 901                 return;
 902
 903         mode = get_irn_mode(irn);
 904
 905         /* check if we already saw this node or the node has more than one user */
 906         if (bitset_contains_irn(already_visited, irn) || get_irn_n_edges(irn) > 1) {
 907                 return;
 908         };
 909
 910         /* mark irn visited */
 911         bitset_add_irn(already_visited, irn);
 912
 913         /* non-Tuple nodes with one user: ok, return */
 914         if (get_irn_n_edges(irn) >= 1 && mode != mode_T) {
 915                 return;
 916         }
 917
 918         /* tuple node has one user which is not the mem proj-> ok */
 919         if (mode == mode_T && get_irn_n_edges(irn) == 1) {
 920                 mem_proj = ia32_get_proj_for_mode(irn, mode_M);
 921                 if (mem_proj == NULL) {
 922                         return;
 923                 }
 924         }
 925
 926         arity = get_irn_arity(irn);
 927         for (i = 0; i < arity; ++i) {
 928                 ir_node *pred = get_irn_n(irn, i);
 929
 930                 /* do not follow memory edges or we will accidentally remove stores */
 931                 if (get_irn_mode(pred) == mode_M) {
 932                         if(mem_proj != NULL) {
 933                                 edges_reroute(mem_proj, pred, get_irn_irg(mem_proj));
 934                                 mem_proj = NULL;
 935                         }
 936                         continue;
 937                 }
 938
 939                 set_irn_n(irn, i, new_Bad());
 940
 941                 /*
 942                         The current node is about to be removed: if the predecessor
 943                         has only this node as user, it need to be removed as well.
 944                 */
 945                 if (get_irn_n_edges(pred) <= 1)
 946                         remove_unused_nodes(pred, already_visited);
 947         }
 948
 949         // we need to set the presd to Bad again to also get the memory edges
 950         arity = get_irn_arity(irn);
 951         for (i = 0; i < arity; ++i) {
 952                 set_irn_n(irn, i, new_Bad());
 953         }
 954
 955         if (sched_is_scheduled(irn)) {
 956                 sched_remove(irn);
 957         }
 958 }
 959
 960 static void remove_unused_loads_walker(ir_node *irn, void *env) {
 961         bitset_t *already_visited = env;
 962         if (is_ia32_Ld(irn) && ! bitset_contains_irn(already_visited, irn))
 963                 remove_unused_nodes(irn, env);
 964 }
 965
 966 /**
 967  * Called before the register allocator.
 968  * Calculate a block schedule here. We need it for the x87
 969  * simulator and the emitter.
 970  */
 971 static void ia32_before_ra(void *self) {
 972         ia32_code_gen_t *cg              = self;
 973         bitset_t        *already_visited = bitset_irg_alloca(cg->irg);
 974
 975         /*
 976                 Handle special case:
 977                 There are sometimes unused loads, only pinned by memory.
 978                 We need to remove those Loads and all other nodes which won't be used
 979                 after removing the Load from schedule.
 980         */
 981         irg_walk_graph(cg->irg, NULL, remove_unused_loads_walker, already_visited);
 982 }
 983
 984
 985 /**
 986  * Transforms a be node into a Load.
 987  */
 988 static void transform_to_Load(ia32_transform_env_t *env) {
 989         ir_node *irn         = env->irn;
 990         entity  *ent         = be_get_frame_entity(irn);
 991         ir_mode *mode        = env->mode;
 992         ir_node *noreg       = ia32_new_NoReg_gp(env->cg);
 993         ir_node *nomem       = new_rd_NoMem(env->irg);
 994         ir_node *sched_point = NULL;
 995         ir_node *ptr         = get_irn_n(irn, 0);
 996         ir_node *mem         = be_is_Reload(irn) ? get_irn_n(irn, 1) : nomem;
 997         ir_node *new_op, *proj;
 998         const arch_register_t *reg;
 999
1000         if (sched_is_scheduled(irn)) {
1001                 sched_point = sched_prev(irn);
1002         }
1003
1004         if (mode_is_float(mode)) {
1005                 if (USE_SSE2(env->cg))
1006                         new_op = new_rd_ia32_xLoad(env->dbg, env->irg, env->block, ptr, noreg, mem);
1007                 else
1008                         new_op = new_rd_ia32_vfld(env->dbg, env->irg, env->block, ptr, noreg, mem);
1009         }
1010         else
1011                 new_op = new_rd_ia32_Load(env->dbg, env->irg, env->block, ptr, noreg, mem);
1012
1013         set_ia32_am_support(new_op, ia32_am_Source);
1014         set_ia32_op_type(new_op, ia32_AddrModeS);
1015         set_ia32_am_flavour(new_op, ia32_B);
1016         set_ia32_ls_mode(new_op, mode);
1017         set_ia32_frame_ent(new_op, ent);
1018         set_ia32_use_frame(new_op);
1019
1020         DBG_OPT_RELOAD2LD(irn, new_op);
1021
1022         proj = new_rd_Proj(env->dbg, env->irg, env->block, new_op, mode, pn_ia32_Load_res);
1023
1024         if (sched_point) {
1025                 sched_add_after(sched_point, new_op);
1026                 sched_add_after(new_op, proj);
1027
1028                 sched_remove(irn);
1029         }
1030
1031         /* copy the register from the old node to the new Load */
1032         reg = arch_get_irn_register(env->cg->arch_env, irn);
1033         arch_set_irn_register(env->cg->arch_env, new_op, reg);
1034
1035         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, irn));
1036
1037         exchange(irn, proj);
1038 }
1039
1040 /**
1041  * Transforms a be node into a Store.
1042  */
1043 static void transform_to_Store(ia32_transform_env_t *env) {
1044         ir_node *irn   = env->irn;
1045         entity  *ent   = be_get_frame_entity(irn);
1046         ir_mode *mode  = env->mode;
1047         ir_node *noreg = ia32_new_NoReg_gp(env->cg);
1048         ir_node *nomem = new_rd_NoMem(env->irg);
1049         ir_node *ptr   = get_irn_n(irn, 0);
1050         ir_node *val   = get_irn_n(irn, 1);
1051         ir_node *new_op, *proj;
1052         ir_node *sched_point = NULL;
1053
1054         if (sched_is_scheduled(irn)) {
1055                 sched_point = sched_prev(irn);
1056         }
1057
1058         if (mode_is_float(mode)) {
1059                 if (USE_SSE2(env->cg))
1060                         new_op = new_rd_ia32_xStore(env->dbg, env->irg, env->block, ptr, noreg, val, nomem);
1061                 else
1062                         new_op = new_rd_ia32_vfst(env->dbg, env->irg, env->block, ptr, noreg, val, nomem);
1063         }
1064         else if (get_mode_size_bits(mode) == 8) {
1065                 new_op = new_rd_ia32_Store8Bit(env->dbg, env->irg, env->block, ptr, noreg, val, nomem);
1066         }
1067         else {
1068                 new_op = new_rd_ia32_Store(env->dbg, env->irg, env->block, ptr, noreg, val, nomem);
1069         }
1070
1071         set_ia32_am_support(new_op, ia32_am_Dest);
1072         set_ia32_op_type(new_op, ia32_AddrModeD);
1073         set_ia32_am_flavour(new_op, ia32_B);
1074         set_ia32_ls_mode(new_op, mode);
1075         set_ia32_frame_ent(new_op, ent);
1076         set_ia32_use_frame(new_op);
1077
1078         DBG_OPT_SPILL2ST(irn, new_op);
1079
1080         proj = new_rd_Proj(env->dbg, env->irg, env->block, new_op, mode_M, pn_ia32_Store_M);
1081
1082         if (sched_point) {
1083                 sched_add_after(sched_point, new_op);
1084                 sched_remove(irn);
1085         }
1086
1087         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, irn));
1088
1089         exchange(irn, proj);
1090 }
1091
1092 static ir_node *create_push(ia32_transform_env_t *env, ir_node *schedpoint, ir_node *sp, ir_node *mem, entity *ent) {
1093         ir_node *noreg = ia32_new_NoReg_gp(env->cg);
1094         ir_node *frame = get_irg_frame(env->irg);
1095
1096         ir_node *push = new_rd_ia32_Push(env->dbg, env->irg, env->block, frame, noreg, noreg, sp, mem);
1097
1098         set_ia32_frame_ent(push, ent);
1099         set_ia32_use_frame(push);
1100         set_ia32_op_type(push, ia32_AddrModeS);
1101         set_ia32_am_flavour(push, ia32_B);
1102         set_ia32_ls_mode(push, mode_Is);
1103
1104         sched_add_before(schedpoint, push);
1105         return push;
1106 }
1107
1108 static ir_node *create_pop(ia32_transform_env_t *env, ir_node *schedpoint, ir_node *sp, entity *ent) {
1109         ir_node *noreg = ia32_new_NoReg_gp(env->cg);
1110         ir_node *frame = get_irg_frame(env->irg);
1111
1112         ir_node *pop = new_rd_ia32_Pop(env->dbg, env->irg, env->block, frame, noreg, sp, new_NoMem());
1113
1114         set_ia32_frame_ent(pop, ent);
1115         set_ia32_use_frame(pop);
1116         set_ia32_op_type(pop, ia32_AddrModeD);
1117         set_ia32_am_flavour(pop, ia32_B);
1118         set_ia32_ls_mode(pop, mode_Is);
1119
1120         sched_add_before(schedpoint, pop);
1121
1122         return pop;
1123 }
1124
1125 static ir_node* create_spproj(ia32_transform_env_t *env, ir_node *pred, int pos, ir_node *schedpoint) {
1126         ir_mode *spmode = mode_Iu;
1127         const arch_register_t *spreg = &ia32_gp_regs[REG_ESP];
1128         ir_node *sp;
1129
1130         sp = new_rd_Proj(env->dbg, env->irg, env->block, pred, spmode, pos);
1131         arch_set_irn_register(env->cg->arch_env, sp, spreg);
1132         sched_add_before(schedpoint, sp);
1133
1134         return sp;
1135 }
1136
1137 /**
1138  * Transform memperm, currently we do this the ugly way and produce
1139  * push/pop into/from memory cascades. This is possible without using
1140  * any registers.
1141  */
1142 static void transform_MemPerm(ia32_transform_env_t *env) {
1143         ir_node *node = env->irn;
1144         int i, arity;
1145         ir_node *sp = be_abi_get_ignore_irn(env->cg->birg->abi, &ia32_gp_regs[REG_ESP]);
1146         const ir_edge_t *edge;
1147         const ir_edge_t *next;
1148         ir_node **pops;
1149
1150         arity = be_get_MemPerm_entity_arity(node);
1151         pops = alloca(arity * sizeof(pops[0]));
1152
1153         // create pushs
1154         for(i = 0; i < arity; ++i) {
1155                 entity *ent = be_get_MemPerm_in_entity(node, i);
1156                 ir_type *enttype = get_entity_type(ent);
1157                 int entbits = get_type_size_bits(enttype);
1158                 ir_node *mem = get_irn_n(node, i + 1);
1159                 ir_node *push;
1160
1161                 assert( (entbits == 32 || entbits == 64) && "spillslot on x86 should be 32 or 64 bit");
1162
1163                 push = create_push(env, node, sp, mem, ent);
1164                 sp = create_spproj(env, push, 0, node);
1165                 if(entbits == 64) {
1166                         // add another push after the first one
1167                         push = create_push(env, node, sp, mem, ent);
1168                         add_ia32_am_offs_int(push, 4);
1169                         sp = create_spproj(env, push, 0, node);
1170                 }
1171
1172                 set_irn_n(node, i, new_Bad());
1173         }
1174
1175         // create pops
1176         for(i = arity - 1; i >= 0; --i) {
1177                 entity *ent = be_get_MemPerm_out_entity(node, i);
1178                 ir_type *enttype = get_entity_type(ent);
1179                 int entbits = get_type_size_bits(enttype);
1180
1181                 ir_node *pop;
1182
1183                 assert( (entbits == 32 || entbits == 64) && "spillslot on x86 should be 32 or 64 bit");
1184
1185                 pop = create_pop(env, node, sp, ent);
1186                 if(entbits == 64) {
1187                         // add another pop after the first one
1188                         sp = create_spproj(env, pop, 1, node);
1189                         pop = create_pop(env, node, sp, ent);
1190                         add_ia32_am_offs_int(pop, 4);
1191                 }
1192                 sp = create_spproj(env, pop, 1, node);
1193
1194                 pops[i] = pop;
1195         }
1196
1197         // exchange memprojs
1198         foreach_out_edge_safe(node, edge, next) {
1199                 ir_node *proj = get_edge_src_irn(edge);
1200                 int p = get_Proj_proj(proj);
1201
1202                 assert(p < arity);
1203
1204                 set_Proj_pred(proj, pops[p]);
1205                 set_Proj_proj(proj, 3);
1206         }
1207
1208         // remove memperm
1209         arity = get_irn_arity(node);
1210         for(i = 0; i < arity; ++i) {
1211                 set_irn_n(node, i, new_Bad());
1212         }
1213         sched_remove(node);
1214 }
1215
1216 /**
1217  * Fix the mode of Spill/Reload
1218  */
1219 static ir_mode *fix_spill_mode(ia32_code_gen_t *cg, ir_mode *mode)
1220 {
1221         if (mode_is_float(mode)) {
1222                 if (USE_SSE2(cg))
1223                         mode = mode_D;
1224                 else
1225                         mode = mode_E;
1226         }
1227         else
1228                 mode = mode_Is;
1229         return mode;
1230 }
1231
1232 /**
1233  * Block-Walker: Calls the transform functions Spill and Reload.
1234  */
1235 static void ia32_after_ra_walker(ir_node *block, void *env) {
1236         ir_node *node, *prev;
1237         ia32_code_gen_t *cg = env;
1238         ia32_transform_env_t tenv;
1239
1240         tenv.block = block;
1241         tenv.irg   = current_ir_graph;
1242         tenv.cg    = cg;
1243         DEBUG_ONLY(tenv.mod = cg->mod;)
1244
1245         /* beware: the schedule is changed here */
1246         for (node = sched_last(block); !sched_is_begin(node); node = prev) {
1247                 prev = sched_prev(node);
1248                 if (be_is_Reload(node)) {
1249                         /* we always reload the whole register  */
1250                         tenv.dbg  = get_irn_dbg_info(node);
1251                         tenv.irn  = node;
1252                         tenv.mode = fix_spill_mode(cg, get_irn_mode(node));
1253                         transform_to_Load(&tenv);
1254                 }
1255                 else if (be_is_Spill(node)) {
1256                         ir_node *spillval = get_irn_n(node, be_pos_Spill_val);
1257                         /* we always spill the whole register  */
1258                         tenv.dbg  = get_irn_dbg_info(node);
1259                         tenv.irn  = node;
1260                         tenv.mode = fix_spill_mode(cg, get_irn_mode(spillval));
1261                         transform_to_Store(&tenv);
1262                 }
1263                 else if(be_is_MemPerm(node)) {
1264                         tenv.dbg = get_irn_dbg_info(node);
1265                         tenv.irn = node;
1266                         transform_MemPerm(&tenv);
1267                 }
1268         }
1269 }
1270
1271 /**
1272  * We transform Spill and Reload here. This needs to be done before
1273  * stack biasing otherwise we would miss the corrected offset for these nodes.
1274  *
1275  * If x87 instruction should be emitted, run the x87 simulator and patch
1276  * the virtual instructions. This must obviously be done after register allocation.
1277  */
1278 static void ia32_after_ra(void *self) {
1279         ia32_code_gen_t *cg = self;
1280         ir_graph *irg = cg->irg;
1281
1282         irg_block_walk_graph(irg, NULL, ia32_after_ra_walker, cg);
1283
1284         ia32_finish_irg(irg, cg);
1285 }
1286
1287 /**
1288  * Last touchups for the graph before emit
1289  */
1290 static void ia32_finish(void *self) {
1291         ia32_code_gen_t *cg = self;
1292         ir_graph        *irg = cg->irg;
1293
1294         //be_remove_empty_blocks(irg);
1295         cg->blk_sched = be_create_block_schedule(irg, cg->birg->execfreqs);
1296
1297         //cg->blk_sched = sched_create_block_schedule(cg->irg, cg->birg->execfreqs);
1298
1299         /* if we do x87 code generation, rewrite all the virtual instructions and registers */
1300         if (cg->used_fp == fp_x87 || cg->force_sim) {
1301                 x87_simulate_graph(cg->arch_env, irg, cg->blk_sched);
1302         }
1303
1304         ia32_peephole_optimization(irg, cg);
1305 }
1306
1307 /**
1308  * Emits the code, closes the output file and frees
1309  * the code generator interface.
1310  */
1311 static void ia32_codegen(void *self) {
1312         ia32_code_gen_t *cg = self;
1313         ir_graph        *irg = cg->irg;
1314
1315         ia32_gen_routine(cg->isa->out, irg, cg);
1316
1317         cur_reg_set = NULL;
1318
1319         /* remove it from the isa */
1320         cg->isa->cg = NULL;
1321
1322         /* de-allocate code generator */
1323         del_set(cg->reg_set);
1324         free(cg);
1325 }
1326
1327 static void *ia32_cg_init(const be_irg_t *birg);
1328
1329 static const arch_code_generator_if_t ia32_code_gen_if = {
1330         ia32_cg_init,
1331         NULL,                /* before abi introduce hook */
1332         ia32_prepare_graph,
1333         ia32_before_sched,   /* before scheduling hook */
1334         ia32_before_ra,      /* before register allocation hook */
1335         ia32_after_ra,       /* after register allocation hook */
1336         ia32_finish,         /* called before codegen */
1337         ia32_codegen         /* emit && done */
1338 };
1339
1340 /**
1341  * Initializes a IA32 code generator.
1342  */
1343 static void *ia32_cg_init(const be_irg_t *birg) {
1344         ia32_isa_t      *isa = (ia32_isa_t *)birg->main_env->arch_env->isa;
1345         ia32_code_gen_t *cg  = xcalloc(1, sizeof(*cg));
1346
1347         cg->impl      = &ia32_code_gen_if;
1348         cg->irg       = birg->irg;
1349         cg->reg_set   = new_set(ia32_cmp_irn_reg_assoc, 1024);
1350         cg->arch_env  = birg->main_env->arch_env;
1351         cg->isa       = isa;
1352         cg->birg      = birg;
1353         cg->blk_sched = NULL;
1354         cg->fp_to_gp  = NULL;
1355         cg->gp_to_fp  = NULL;
1356         cg->fp_kind   = isa->fp_kind;
1357         cg->used_fp   = fp_none;
1358         cg->dump      = (birg->main_env->options->dump_flags & DUMP_BE) ? 1 : 0;
1359
1360         FIRM_DBG_REGISTER(cg->mod, "firm.be.ia32.cg");
1361
1362         /* copy optimizations from isa for easier access */
1363         cg->opt      = isa->opt;
1364         cg->arch     = isa->arch;
1365         cg->opt_arch = isa->opt_arch;
1366
1367         /* enter it */
1368         isa->cg = cg;
1369
1370 #ifndef NDEBUG
1371         if (isa->name_obst_size) {
1372                 //printf("freed %d bytes from name obst\n", isa->name_obst_size);
1373                 isa->name_obst_size = 0;
1374                 obstack_free(isa->name_obst, NULL);
1375                 obstack_init(isa->name_obst);
1376         }
1377 #endif /* NDEBUG */
1378
1379         cur_reg_set = cg->reg_set;
1380
1381         ia32_irn_ops.cg = cg;
1382
1383         return (arch_code_generator_t *)cg;
1384 }
1385
1386
1387
1388 /*****************************************************************
1389  *  ____             _                  _   _____  _____
1390  * |  _ \           | |                | | |_   _|/ ____|  /\
1391  * | |_) | __ _  ___| | _____ _ __   __| |   | | | (___   /  \
1392  * |  _ < / _` |/ __| |/ / _ \ '_ \ / _` |   | |  \___ \ / /\ \
1393  * | |_) | (_| | (__|   <  __/ | | | (_| |  _| |_ ____) / ____ \
1394  * |____/ \__,_|\___|_|\_\___|_| |_|\__,_| |_____|_____/_/    \_\
1395  *
1396  *****************************************************************/
1397
1398 /**
1399  * Set output modes for GCC
1400  */
1401 static const tarval_mode_info mo_integer = {
1402         TVO_DECIMAL,
1403         NULL,
1404         NULL,
1405 };
1406
1407 /*
1408  * set the tarval output mode of all integer modes to decimal
1409  */
1410 static void set_tarval_output_modes(void)
1411 {
1412         int i;
1413
1414         for (i = get_irp_n_modes() - 1; i >= 0; --i) {
1415                 ir_mode *mode = get_irp_mode(i);
1416
1417                 if (mode_is_int(mode))
1418                         set_tarval_mode_output_option(mode, &mo_integer);
1419         }
1420 }
1421
1422
1423 /**
1424  * The template that generates a new ISA object.
1425  * Note that this template can be changed by command line
1426  * arguments.
1427  */
1428 static ia32_isa_t ia32_isa_template = {
1429         {
1430                 &ia32_isa_if,            /* isa interface implementation */
1431                 &ia32_gp_regs[REG_ESP],  /* stack pointer register */
1432                 &ia32_gp_regs[REG_EBP],  /* base pointer register */
1433                 -1,                      /* stack direction */
1434                 NULL,                    /* main environment */
1435         },
1436         NULL,                    /* 16bit register names */
1437         NULL,                    /* 8bit register names */
1438         NULL,                    /* types */
1439         NULL,                    /* tv_ents */
1440         (0                 |
1441         IA32_OPT_INCDEC    |     /* optimize add 1, sub 1 into inc/dec               default: on */
1442         IA32_OPT_DOAM      |     /* optimize address mode                            default: on */
1443         IA32_OPT_LEA       |     /* optimize for LEAs                                default: on */
1444         IA32_OPT_PLACECNST |     /* place constants immediately before instructions, default: on */
1445         IA32_OPT_IMMOPS    |     /* operations can use immediates,                   default: on */
1446         IA32_OPT_EXTBB     |     /* use extended basic block scheduling,             default: on */
1447         IA32_OPT_PUSHARGS),      /* create pushs for function argument passing,      default: on */
1448         arch_pentium_4,          /* instruction architecture */
1449         arch_pentium_4,          /* optimize for architecture */
1450         fp_sse2,                 /* use sse2 unit */
1451         NULL,                    /* current code generator */
1452         NULL,                    /* output file */
1453 #ifndef NDEBUG
1454         NULL,                    /* name obstack */
1455         0                        /* name obst size */
1456 #endif
1457 };
1458
1459 /**
1460  * Initializes the backend ISA.
1461  */
1462 static void *ia32_init(FILE *file_handle) {
1463         static int inited = 0;
1464         ia32_isa_t *isa;
1465
1466         if (inited)
1467                 return NULL;
1468
1469         set_tarval_output_modes();
1470
1471         isa = xmalloc(sizeof(*isa));
1472         memcpy(isa, &ia32_isa_template, sizeof(*isa));
1473
1474         ia32_register_init(isa);
1475         ia32_create_opcodes();
1476
1477         if ((ARCH_INTEL(isa->arch) && isa->arch < arch_pentium_4) ||
1478             (ARCH_AMD(isa->arch) && isa->arch < arch_athlon))
1479                 /* no SSE2 for these cpu's */
1480                 isa->fp_kind = fp_x87;
1481
1482         if (ARCH_INTEL(isa->opt_arch) && isa->opt_arch >= arch_pentium_4) {
1483                 /* Pentium 4 don't like inc and dec instructions */
1484                 isa->opt &= ~IA32_OPT_INCDEC;
1485         }
1486
1487         isa->regs_16bit = pmap_create();
1488         isa->regs_8bit  = pmap_create();
1489         isa->types      = pmap_create();
1490         isa->tv_ent     = pmap_create();
1491         isa->out        = file_handle;
1492         isa->cpu        = ia32_init_machine_description();
1493
1494         ia32_build_16bit_reg_map(isa->regs_16bit);
1495         ia32_build_8bit_reg_map(isa->regs_8bit);
1496
1497         /* patch register names of x87 registers */
1498         ia32_st_regs[0].name = "st";
1499         ia32_st_regs[1].name = "st(1)";
1500         ia32_st_regs[2].name = "st(2)";
1501         ia32_st_regs[3].name = "st(3)";
1502         ia32_st_regs[4].name = "st(4)";
1503         ia32_st_regs[5].name = "st(5)";
1504         ia32_st_regs[6].name = "st(6)";
1505         ia32_st_regs[7].name = "st(7)";
1506
1507 #ifndef NDEBUG
1508         isa->name_obst = xmalloc(sizeof(*isa->name_obst));
1509         obstack_init(isa->name_obst);
1510         isa->name_obst_size = 0;
1511 #endif /* NDEBUG */
1512
1513         ia32_handle_intrinsics();
1514         ia32_switch_section(isa->out, NO_SECTION);
1515         fprintf(isa->out, "\t.intel_syntax\n");
1516
1517         /* needed for the debug support */
1518         ia32_switch_section(isa->out, SECTION_TEXT);
1519         fprintf(isa->out, ".Ltext0:\n");
1520
1521         inited = 1;
1522
1523         return isa;
1524 }
1525
1526
1527
1528 /**
1529  * Closes the output file and frees the ISA structure.
1530  */
1531 static void ia32_done(void *self) {
1532         ia32_isa_t *isa = self;
1533
1534         /* emit now all global declarations */
1535         ia32_gen_decls(isa->out, isa->arch_isa.main_env);
1536
1537         pmap_destroy(isa->regs_16bit);
1538         pmap_destroy(isa->regs_8bit);
1539         pmap_destroy(isa->tv_ent);
1540         pmap_destroy(isa->types);
1541
1542 #ifndef NDEBUG
1543         //printf("name obst size = %d bytes\n", isa->name_obst_size);
1544         obstack_free(isa->name_obst, NULL);
1545 #endif /* NDEBUG */
1546
1547         free(self);
1548 }
1549
1550
1551 /**
1552  * Return the number of register classes for this architecture.
1553  * We report always these:
1554  *  - the general purpose registers
1555  *  - the SSE floating point register set
1556  *  - the virtual floating point registers
1557  */
1558 static int ia32_get_n_reg_class(const void *self) {
1559         return 3;
1560 }
1561
1562 /**
1563  * Return the register class for index i.
1564  */
1565 static const arch_register_class_t *ia32_get_reg_class(const void *self, int i) {
1566         assert(i >= 0 && i < 3 && "Invalid ia32 register class requested.");
1567         if (i == 0)
1568                 return &ia32_reg_classes[CLASS_ia32_gp];
1569         else if (i == 1)
1570                 return &ia32_reg_classes[CLASS_ia32_xmm];
1571         else
1572                 return &ia32_reg_classes[CLASS_ia32_vfp];
1573 }
1574
1575 /**
1576  * Get the register class which shall be used to store a value of a given mode.
1577  * @param self The this pointer.
1578  * @param mode The mode in question.
1579  * @return A register class which can hold values of the given mode.
1580  */
1581 const arch_register_class_t *ia32_get_reg_class_for_mode(const void *self, const ir_mode *mode) {
1582         const ia32_isa_t *isa = self;
1583         if (mode_is_float(mode)) {
1584                 return USE_SSE2(isa) ? &ia32_reg_classes[CLASS_ia32_xmm] : &ia32_reg_classes[CLASS_ia32_vfp];
1585         }
1586         else
1587                 return &ia32_reg_classes[CLASS_ia32_gp];
1588 }
1589
1590 /**
1591  * Get the ABI restrictions for procedure calls.
1592  * @param self        The this pointer.
1593  * @param method_type The type of the method (procedure) in question.
1594  * @param abi         The abi object to be modified
1595  */
1596 static void ia32_get_call_abi(const void *self, ir_type *method_type, be_abi_call_t *abi) {
1597         const ia32_isa_t *isa = self;
1598         ir_type  *tp;
1599         ir_mode  *mode;
1600         unsigned  cc        = get_method_calling_convention(method_type);
1601         int       n         = get_method_n_params(method_type);
1602         int       biggest_n = -1;
1603         int       stack_idx = 0;
1604         int       i, ignore_1, ignore_2;
1605         ir_mode **modes;
1606         const arch_register_t *reg;
1607         be_abi_call_flags_t call_flags = be_abi_call_get_flags(abi);
1608
1609         unsigned use_push = !IS_P6_ARCH(isa->opt_arch);
1610
1611         /* set abi flags for calls */
1612         call_flags.bits.left_to_right         = 0;  /* always last arg first on stack */
1613         call_flags.bits.store_args_sequential = use_push;
1614         /* call_flags.bits.try_omit_fp                 not changed: can handle both settings */
1615         call_flags.bits.fp_free               = 0;  /* the frame pointer is fixed in IA32 */
1616         call_flags.bits.call_has_imm          = 1;  /* IA32 calls can have immediate address */
1617
1618         /* set stack parameter passing style */
1619         be_abi_call_set_flags(abi, call_flags, &ia32_abi_callbacks);
1620
1621         /* collect the mode for each type */
1622         modes = alloca(n * sizeof(modes[0]));
1623
1624         for (i = 0; i < n; i++) {
1625                 tp       = get_method_param_type(method_type, i);
1626                 modes[i] = get_type_mode(tp);
1627         }
1628
1629         /* set register parameters  */
1630         if (cc & cc_reg_param) {
1631                 /* determine the number of parameters passed via registers */
1632                 biggest_n = ia32_get_n_regparam_class(n, modes, &ignore_1, &ignore_2);
1633
1634                 /* loop over all parameters and set the register requirements */
1635                 for (i = 0; i <= biggest_n; i++) {
1636                         reg = ia32_get_RegParam_reg(n, modes, i, cc);
1637                         assert(reg && "kaputt");
1638                         be_abi_call_param_reg(abi, i, reg);
1639                 }
1640
1641                 stack_idx = i;
1642         }
1643
1644
1645         /* set stack parameters */
1646         for (i = stack_idx; i < n; i++) {
1647                 /* parameters on the stack are 32 bit aligned */
1648                 be_abi_call_param_stack(abi, i, 4, 0, 0);
1649         }
1650
1651
1652         /* set return registers */
1653         n = get_method_n_ress(method_type);
1654
1655         assert(n <= 2 && "more than two results not supported");
1656
1657         /* In case of 64bit returns, we will have two 32bit values */
1658         if (n == 2) {
1659                 tp   = get_method_res_type(method_type, 0);
1660                 mode = get_type_mode(tp);
1661
1662                 assert(!mode_is_float(mode) && "two FP results not supported");
1663
1664                 tp   = get_method_res_type(method_type, 1);
1665                 mode = get_type_mode(tp);
1666
1667                 assert(!mode_is_float(mode) && "mixed INT, FP results not supported");
1668
1669                 be_abi_call_res_reg(abi, 0, &ia32_gp_regs[REG_EAX]);
1670                 be_abi_call_res_reg(abi, 1, &ia32_gp_regs[REG_EDX]);
1671         }
1672         else if (n == 1) {
1673                 const arch_register_t *reg;
1674
1675                 tp   = get_method_res_type(method_type, 0);
1676                 assert(is_atomic_type(tp));
1677                 mode = get_type_mode(tp);
1678
1679                 reg = mode_is_float(mode) ? &ia32_vfp_regs[REG_VF0] : &ia32_gp_regs[REG_EAX];
1680
1681                 be_abi_call_res_reg(abi, 0, reg);
1682         }
1683 }
1684
1685
1686 static const void *ia32_get_irn_ops(const arch_irn_handler_t *self, const ir_node *irn) {
1687         return &ia32_irn_ops;
1688 }
1689
1690 const arch_irn_handler_t ia32_irn_handler = {
1691         ia32_get_irn_ops
1692 };
1693
1694 const arch_irn_handler_t *ia32_get_irn_handler(const void *self) {
1695         return &ia32_irn_handler;
1696 }
1697
1698 int ia32_to_appear_in_schedule(void *block_env, const ir_node *irn) {
1699         return is_ia32_irn(irn) ? 1 : -1;
1700 }
1701
1702 /**
1703  * Initializes the code generator interface.
1704  */
1705 static const arch_code_generator_if_t *ia32_get_code_generator_if(void *self) {
1706         return &ia32_code_gen_if;
1707 }
1708
1709 /**
1710  * Returns the estimated execution time of an ia32 irn.
1711  */
1712 static sched_timestep_t ia32_sched_exectime(void *env, const ir_node *irn) {
1713         const arch_env_t *arch_env = env;
1714         return is_ia32_irn(irn) ? ia32_get_op_estimated_cost(arch_get_irn_ops(arch_env, irn), irn) : 1;
1715 }
1716
1717 list_sched_selector_t ia32_sched_selector;
1718
1719 /**
1720  * Returns the reg_pressure scheduler with to_appear_in_schedule() overloaded
1721  */
1722 static const list_sched_selector_t *ia32_get_list_sched_selector(const void *self, list_sched_selector_t *selector) {
1723         memcpy(&ia32_sched_selector, selector, sizeof(ia32_sched_selector));
1724         ia32_sched_selector.exectime              = ia32_sched_exectime;
1725         ia32_sched_selector.to_appear_in_schedule = ia32_to_appear_in_schedule;
1726         return &ia32_sched_selector;
1727 }
1728
1729 /**
1730  * Returns the necessary byte alignment for storing a register of given class.
1731  */
1732 static int ia32_get_reg_class_alignment(const void *self, const arch_register_class_t *cls) {
1733         ir_mode *mode = arch_register_class_mode(cls);
1734         int bytes     = get_mode_size_bytes(mode);
1735
1736         if (mode_is_float(mode) && bytes > 8)
1737                 return 16;
1738         return bytes;
1739 }
1740
1741 static const be_execution_unit_t ***ia32_get_allowed_execution_units(const void *self, const ir_node *irn) {
1742         static const be_execution_unit_t *_allowed_units_BRANCH[] = {
1743                 &ia32_execution_units_BRANCH[IA32_EXECUNIT_TP_BRANCH_BRANCH1],
1744                 &ia32_execution_units_BRANCH[IA32_EXECUNIT_TP_BRANCH_BRANCH2],
1745                 NULL,
1746         };
1747         static const be_execution_unit_t *_allowed_units_ALU[] = {
1748                 &ia32_execution_units_ALU[IA32_EXECUNIT_TP_ALU_ALU1],
1749                 &ia32_execution_units_ALU[IA32_EXECUNIT_TP_ALU_ALU2],
1750                 &ia32_execution_units_ALU[IA32_EXECUNIT_TP_ALU_ALU3],
1751                 &ia32_execution_units_ALU[IA32_EXECUNIT_TP_ALU_ALU4],
1752                 NULL,
1753         };
1754         static const be_execution_unit_t *_allowed_units_DUMMY[] = {
1755                 &ia32_execution_units_DUMMY[IA32_EXECUNIT_TP_DUMMY_DUMMY1],
1756                 &ia32_execution_units_DUMMY[IA32_EXECUNIT_TP_DUMMY_DUMMY2],
1757                 &ia32_execution_units_DUMMY[IA32_EXECUNIT_TP_DUMMY_DUMMY3],
1758                 &ia32_execution_units_DUMMY[IA32_EXECUNIT_TP_DUMMY_DUMMY4],
1759                 NULL,
1760         };
1761         static const be_execution_unit_t **_units_callret[] = {
1762                 _allowed_units_BRANCH,
1763                 NULL
1764         };
1765         static const be_execution_unit_t **_units_other[] = {
1766                 _allowed_units_ALU,
1767                 NULL
1768         };
1769         static const be_execution_unit_t **_units_dummy[] = {
1770                 _allowed_units_DUMMY,
1771                 NULL
1772         };
1773         const be_execution_unit_t ***ret;
1774
1775         if (is_ia32_irn(irn)) {
1776                 ret = get_ia32_exec_units(irn);
1777         }
1778         else if (is_be_node(irn)) {
1779                 if (be_is_Call(irn) || be_is_Return(irn)) {
1780                         ret = _units_callret;
1781                 }
1782                 else if (be_is_Barrier(irn)) {
1783                         ret = _units_dummy;
1784                 }
1785                 else {
1786                          ret = _units_other;
1787                 }
1788         }
1789         else {
1790                 ret = _units_dummy;
1791         }
1792
1793         return ret;
1794 }
1795
1796 /**
1797  * Return the abstract ia32 machine.
1798  */
1799 static const be_machine_t *ia32_get_machine(const void *self) {
1800         const ia32_isa_t *isa = self;
1801         return isa->cpu;
1802 }
1803
1804 /**
1805  * Allows or disallows the creation of Psi nodes for the given Phi nodes.
1806  * @return 1 if allowed, 0 otherwise
1807  */
1808 static int ia32_is_psi_allowed(ir_node *sel, ir_node *phi_list, int i, int j)
1809 {
1810         ir_node *cmp, *cmp_a, *phi;
1811         ir_mode *mode;
1812
1813 /* we don't want long long an floating point Psi */
1814 #define IS_BAD_PSI_MODE(mode) (mode_is_float(mode) || get_mode_size_bits(mode) > 32)
1815
1816         if (get_irn_mode(sel) != mode_b)
1817                 return 0;
1818
1819         cmp   = get_Proj_pred(sel);
1820         cmp_a = get_Cmp_left(cmp);
1821         mode  = get_irn_mode(cmp_a);
1822
1823         if (IS_BAD_PSI_MODE(mode))
1824                 return 0;
1825
1826         /* check the Phi nodes */
1827         for (phi = phi_list; phi; phi = get_irn_link(phi)) {
1828                 ir_node *pred_i = get_irn_n(phi, i);
1829                 ir_node *pred_j = get_irn_n(phi, j);
1830                 ir_mode *mode_i = get_irn_mode(pred_i);
1831                 ir_mode *mode_j = get_irn_mode(pred_j);
1832
1833                 if (IS_BAD_PSI_MODE(mode_i) || IS_BAD_PSI_MODE(mode_j))
1834                         return 0;
1835         }
1836
1837 #undef IS_BAD_PSI_MODE
1838
1839         return 1;
1840 }
1841
1842 static ia32_intrinsic_env_t intrinsic_env = {
1843         NULL,    /**< the irg, these entities belong to */
1844         NULL,    /**< entity for first div operand (move into FPU) */
1845         NULL,    /**< entity for second div operand (move into FPU) */
1846         NULL,    /**< entity for converts ll -> d */
1847         NULL,    /**< entity for converts d -> ll */
1848 };
1849
1850 /**
1851  * Returns the libFirm configuration parameter for this backend.
1852  */
1853 static const backend_params *ia32_get_libfirm_params(void) {
1854         static const opt_if_conv_info_t ifconv = {
1855                 4,                    /* maxdepth, doesn't matter for Psi-conversion */
1856                 ia32_is_psi_allowed   /* allows or disallows Psi creation for given selector */
1857         };
1858         static const arch_dep_params_t ad = {
1859                 1,  /* also use subs */
1860                 4,  /* maximum shifts */
1861                 31, /* maximum shift amount */
1862
1863                 1,  /* allow Mulhs */
1864                 1,  /* allow Mulus */
1865                 32  /* Mulh allowed up to 32 bit */
1866         };
1867         static backend_params p = {
1868                 NULL,  /* no additional opcodes */
1869                 NULL,  /* will be set later */
1870                 1,     /* need dword lowering */
1871                 ia32_create_intrinsic_fkt,
1872                 &intrinsic_env,  /* context for ia32_create_intrinsic_fkt */
1873                 NULL,  /* will be set later */
1874         };
1875
1876         p.dep_param    = &ad;
1877         p.if_conv_info = &ifconv;
1878         return &p;
1879 }
1880 #ifdef WITH_LIBCORE
1881
1882 /* instruction set architectures. */
1883 static const lc_opt_enum_int_items_t arch_items[] = {
1884         { "386",        arch_i386, },
1885         { "486",        arch_i486, },
1886         { "pentium",    arch_pentium, },
1887         { "586",        arch_pentium, },
1888         { "pentiumpro", arch_pentium_pro, },
1889         { "686",        arch_pentium_pro, },
1890         { "pentiummmx", arch_pentium_mmx, },
1891         { "pentium2",   arch_pentium_2, },
1892         { "p2",         arch_pentium_2, },
1893         { "pentium3",   arch_pentium_3, },
1894         { "p3",         arch_pentium_3, },
1895         { "pentium4",   arch_pentium_4, },
1896         { "p4",         arch_pentium_4, },
1897         { "pentiumm",   arch_pentium_m, },
1898         { "pm",         arch_pentium_m, },
1899         { "core",       arch_core, },
1900         { "k6",         arch_k6, },
1901         { "athlon",     arch_athlon, },
1902         { "athlon64",   arch_athlon_64, },
1903         { "opteron",    arch_opteron, },
1904         { NULL,         0 }
1905 };
1906
1907 static lc_opt_enum_int_var_t arch_var = {
1908         &ia32_isa_template.arch, arch_items
1909 };
1910
1911 static lc_opt_enum_int_var_t opt_arch_var = {
1912         &ia32_isa_template.opt_arch, arch_items
1913 };
1914
1915 static const lc_opt_enum_int_items_t fp_unit_items[] = {
1916         { "x87" ,    fp_x87 },
1917         { "sse2",    fp_sse2 },
1918         { NULL,      0 }
1919 };
1920
1921 static lc_opt_enum_int_var_t fp_unit_var = {
1922         &ia32_isa_template.fp_kind, fp_unit_items
1923 };
1924
1925 static const lc_opt_enum_int_items_t gas_items[] = {
1926         { "linux",   ASM_LINUX_GAS },
1927         { "mingw",   ASM_MINGW_GAS },
1928         { NULL,      0 }
1929 };
1930
1931 static lc_opt_enum_int_var_t gas_var = {
1932         (int *)&asm_flavour, gas_items
1933 };
1934
1935 static const lc_opt_table_entry_t ia32_options[] = {
1936         LC_OPT_ENT_ENUM_INT("arch",      "select the instruction architecture", &arch_var),
1937         LC_OPT_ENT_ENUM_INT("opt",       "optimize for instruction architecture", &opt_arch_var),
1938         LC_OPT_ENT_ENUM_INT("fpunit",    "select the floating point unit", &fp_unit_var),
1939         LC_OPT_ENT_NEGBIT("noaddrmode",  "do not use address mode", &ia32_isa_template.opt, IA32_OPT_DOAM),
1940         LC_OPT_ENT_NEGBIT("nolea",       "do not optimize for LEAs", &ia32_isa_template.opt, IA32_OPT_LEA),
1941         LC_OPT_ENT_NEGBIT("noplacecnst", "do not place constants", &ia32_isa_template.opt, IA32_OPT_PLACECNST),
1942         LC_OPT_ENT_NEGBIT("noimmop",     "no operations with immediates", &ia32_isa_template.opt, IA32_OPT_IMMOPS),
1943         LC_OPT_ENT_NEGBIT("noextbb",     "do not use extended basic block scheduling", &ia32_isa_template.opt, IA32_OPT_EXTBB),
1944         LC_OPT_ENT_NEGBIT("nopushargs",  "do not create pushs for function arguments", &ia32_isa_template.opt, IA32_OPT_PUSHARGS),
1945         LC_OPT_ENT_ENUM_INT("gasmode",   "set the GAS compatibility mode", &gas_var),
1946         { NULL }
1947 };
1948
1949 /**
1950  * Register command line options for the ia32 backend.
1951  *
1952  * Options so far:
1953  *
1954  * ia32-arch=arch    create instruction for arch
1955  * ia32-opt=arch     optimize for run on arch
1956  * ia32-fpunit=unit  select floating point unit (x87 or SSE2)
1957  * ia32-incdec       optimize for inc/dec
1958  * ia32-noaddrmode   do not use address mode
1959  * ia32-nolea        do not optimize for LEAs
1960  * ia32-noplacecnst  do not place constants,
1961  * ia32-noimmop      no operations with immediates
1962  * ia32-noextbb      do not use extended basic block scheduling
1963  * ia32-nopushargs   do not create pushs for function argument passing
1964  * ia32-gasmode      set the GAS compatibility mode
1965  */
1966 static void ia32_register_options(lc_opt_entry_t *ent)
1967 {
1968         lc_opt_entry_t *be_grp_ia32 = lc_opt_get_grp(ent, "ia32");
1969         lc_opt_add_table(be_grp_ia32, ia32_options);
1970 }
1971 #endif /* WITH_LIBCORE */
1972
1973 const arch_isa_if_t ia32_isa_if = {
1974         ia32_init,
1975         ia32_done,
1976         ia32_get_n_reg_class,
1977         ia32_get_reg_class,
1978         ia32_get_reg_class_for_mode,
1979         ia32_get_call_abi,
1980         ia32_get_irn_handler,
1981         ia32_get_code_generator_if,
1982         ia32_get_list_sched_selector,
1983         ia32_get_reg_class_alignment,
1984         ia32_get_libfirm_params,
1985         ia32_get_allowed_execution_units,
1986         ia32_get_machine,
1987 #ifdef WITH_LIBCORE
1988         ia32_register_options
1989 #endif
1990 };