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