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