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

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