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

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