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

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