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