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