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