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

   1 /**
   2  * This file implements the IR transformation from firm into
   3  * ia32-Firm.
   4  *
   5  * $Id$
   6  */
   7
   8 #ifdef HAVE_CONFIG_H
   9 #include "config.h"
  10 #endif
  11
  12 #include <limits.h>
  13
  14 #include "irargs_t.h"
  15 #include "irnode_t.h"
  16 #include "irgraph_t.h"
  17 #include "irmode_t.h"
  18 #include "iropt_t.h"
  19 #include "irop_t.h"
  20 #include "irprog_t.h"
  21 #include "iredges_t.h"
  22 #include "irgmod.h"
  23 #include "irvrfy.h"
  24 #include "ircons.h"
  25 #include "dbginfo.h"
  26 #include "irprintf.h"
  27 #include "debug.h"
  28
  29 #include "../benode_t.h"
  30 #include "../besched.h"
  31 #include "../beabi.h"
  32
  33 #include "bearch_ia32_t.h"
  34
  35 #include "ia32_nodes_attr.h"
  36 #include "../arch/archop.h"     /* we need this for Min and Max nodes */
  37 #include "ia32_transform.h"
  38 #include "ia32_new_nodes.h"
  39 #include "ia32_map_regs.h"
  40 #include "ia32_dbg_stat.h"
  41
  42 #include "gen_ia32_regalloc_if.h"
  43
  44 #define SFP_SIGN "0x80000000"
  45 #define DFP_SIGN "0x8000000000000000"
  46 #define SFP_ABS  "0x7FFFFFFF"
  47 #define DFP_ABS  "0x7FFFFFFFFFFFFFFF"
  48
  49 #define TP_SFP_SIGN "ia32_sfp_sign"
  50 #define TP_DFP_SIGN "ia32_dfp_sign"
  51 #define TP_SFP_ABS  "ia32_sfp_abs"
  52 #define TP_DFP_ABS  "ia32_dfp_abs"
  53
  54 #define ENT_SFP_SIGN "IA32_SFP_SIGN"
  55 #define ENT_DFP_SIGN "IA32_DFP_SIGN"
  56 #define ENT_SFP_ABS  "IA32_SFP_ABS"
  57 #define ENT_DFP_ABS  "IA32_DFP_ABS"
  58
  59 extern ir_op *get_op_Mulh(void);
  60
  61 typedef ir_node *construct_binop_func(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *base, ir_node *index, \
  62                                                                           ir_node *op1, ir_node *op2, ir_node *mem);
  63
  64 typedef ir_node *construct_unop_func(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *base, ir_node *index, \
  65                                                                          ir_node *op, ir_node *mem);
  66
  67 typedef enum {
  68         ia32_SSIGN, ia32_DSIGN, ia32_SABS, ia32_DABS, ia32_known_const_max
  69 } ia32_known_const_t;
  70
  71 /****************************************************************************************************
  72  *                  _        _                        __                           _   _
  73  *                 | |      | |                      / _|                         | | (_)
  74  *  _ __   ___   __| | ___  | |_ _ __ __ _ _ __  ___| |_ ___  _ __ _ __ ___   __ _| |_ _  ___  _ __
  75  * | '_ \ / _ \ / _` |/ _ \ | __| '__/ _` | '_ \/ __|  _/ _ \| '__| '_ ` _ \ / _` | __| |/ _ \| '_ \
  76  * | | | | (_) | (_| |  __/ | |_| | | (_| | | | \__ \ || (_) | |  | | | | | | (_| | |_| | (_) | | | |
  77  * |_| |_|\___/ \__,_|\___|  \__|_|  \__,_|_| |_|___/_| \___/|_|  |_| |_| |_|\__,_|\__|_|\___/|_| |_|
  78  *
  79  ****************************************************************************************************/
  80
  81 /**
  82  * Returns 1 if irn is a Const representing 0, 0 otherwise
  83  */
  84 static INLINE int is_ia32_Const_0(ir_node *irn) {
  85         return is_ia32_Const(irn) ? classify_tarval(get_ia32_Immop_tarval(irn)) == TV_CLASSIFY_NULL : 0;
  86 }
  87
  88 /**
  89  * Returns 1 if irn is a Const representing 1, 0 otherwise
  90  */
  91 static INLINE int is_ia32_Const_1(ir_node *irn) {
  92         return is_ia32_Const(irn) ? classify_tarval(get_ia32_Immop_tarval(irn)) == TV_CLASSIFY_ONE : 0;
  93 }
  94
  95 /**
  96  * Returns the Proj representing the UNKNOWN register for given mode.
  97  */
  98 static ir_node *be_get_unknown_for_mode(ia32_code_gen_t *cg, ir_mode *mode) {
  99         be_abi_irg_t          *babi       = cg->birg->abi;
 100         const arch_register_t *unknwn_reg = NULL;
 101
 102         if (mode_is_float(mode)) {
 103                 unknwn_reg = USE_SSE2(cg) ? &ia32_xmm_regs[REG_XMM_UKNWN] : &ia32_vfp_regs[REG_VFP_UKNWN];
 104         }
 105         else {
 106                 unknwn_reg = &ia32_gp_regs[REG_GP_UKNWN];
 107         }
 108
 109         return be_abi_get_callee_save_irn(babi, unknwn_reg);
 110 }
 111
 112 /**
 113  * Gets the Proj with number pn from irn.
 114  */
 115 static ir_node *get_proj_for_pn(const ir_node *irn, long pn) {
 116         const ir_edge_t *edge;
 117         ir_node   *proj;
 118         assert(get_irn_mode(irn) == mode_T && "need mode_T");
 119
 120         foreach_out_edge(irn, edge) {
 121                 proj = get_edge_src_irn(edge);
 122
 123                 if (get_Proj_proj(proj) == pn)
 124                         return proj;
 125         }
 126
 127         return NULL;
 128 }
 129
 130 /* Generates an entity for a known FP const (used for FP Neg + Abs) */
 131 static ident *gen_fp_known_const(ir_mode *mode, ia32_known_const_t kct) {
 132         static const struct {
 133                 const char *tp_name;
 134                 const char *ent_name;
 135                 const char *cnst_str;
 136         } names [ia32_known_const_max] = {
 137                 { TP_SFP_SIGN, ENT_SFP_SIGN, SFP_SIGN },        /* ia32_SSIGN */
 138                 { TP_DFP_SIGN, ENT_DFP_SIGN, DFP_SIGN },        /* ia32_DSIGN */
 139                 { TP_SFP_ABS,  ENT_SFP_ABS,  SFP_ABS },         /* ia32_SABS */
 140                 { TP_DFP_ABS,  ENT_DFP_ABS,  DFP_ABS }          /* ia32_DABS */
 141         };
 142         static struct entity *ent_cache[ia32_known_const_max];
 143
 144         const char    *tp_name, *ent_name, *cnst_str;
 145         ir_type       *tp;
 146         ir_node       *cnst;
 147         ir_graph      *rem;
 148         entity        *ent;
 149         tarval        *tv;
 150
 151         ent_name = names[kct].ent_name;
 152         if (! ent_cache[kct]) {
 153                 tp_name  = names[kct].tp_name;
 154                 cnst_str = names[kct].cnst_str;
 155
 156                 tv  = new_tarval_from_str(cnst_str, strlen(cnst_str), mode);
 157                 tp  = new_type_primitive(new_id_from_str(tp_name), mode);
 158                 ent = new_entity(get_glob_type(), new_id_from_str(ent_name), tp);
 159
 160                 set_entity_ld_ident(ent, get_entity_ident(ent));
 161                 set_entity_visibility(ent, visibility_local);
 162                 set_entity_variability(ent, variability_constant);
 163                 set_entity_allocation(ent, allocation_static);
 164
 165                 /* we create a new entity here: It's initialization must resist on the
 166                     const code irg */
 167                 rem = current_ir_graph;
 168                 current_ir_graph = get_const_code_irg();
 169                 cnst = new_Const(mode, tv);
 170                 current_ir_graph = rem;
 171
 172                 set_atomic_ent_value(ent, cnst);
 173
 174                 /* cache the entry */
 175                 ent_cache[kct] = ent;
 176         }
 177
 178         return get_entity_ident(ent_cache[kct]);
 179 }
 180
 181 #ifndef NDEBUG
 182 /**
 183  * Prints the old node name on cg obst and returns a pointer to it.
 184  */
 185 const char *ia32_get_old_node_name(ia32_code_gen_t *cg, ir_node *irn) {
 186         ia32_isa_t *isa = (ia32_isa_t *)cg->arch_env->isa;
 187
 188         lc_eoprintf(firm_get_arg_env(), isa->name_obst, "%+F", irn);
 189         obstack_1grow(isa->name_obst, 0);
 190         isa->name_obst_size += obstack_object_size(isa->name_obst);
 191         return obstack_finish(isa->name_obst);
 192 }
 193 #endif /* NDEBUG */
 194
 195 /* determine if one operator is an Imm */
 196 static ir_node *get_immediate_op(ir_node *op1, ir_node *op2) {
 197         if (op1)
 198                 return is_ia32_Cnst(op1) ? op1 : (is_ia32_Cnst(op2) ? op2 : NULL);
 199         else return is_ia32_Cnst(op2) ? op2 : NULL;
 200 }
 201
 202 /* determine if one operator is not an Imm */
 203 static ir_node *get_expr_op(ir_node *op1, ir_node *op2) {
 204         return !is_ia32_Cnst(op1) ? op1 : (!is_ia32_Cnst(op2) ? op2 : NULL);
 205 }
 206
 207
 208 /**
 209  * Construct a standard binary operation, set AM and immediate if required.
 210  *
 211  * @param env   The transformation environment
 212  * @param op1   The first operand
 213  * @param op2   The second operand
 214  * @param func  The node constructor function
 215  * @return The constructed ia32 node.
 216  */
 217 static ir_node *gen_binop(ia32_transform_env_t *env, ir_node *op1, ir_node *op2, construct_binop_func *func) {
 218         ir_node           *new_op   = NULL;
 219         ir_mode           *mode     = env->mode;
 220         dbg_info          *dbg      = env->dbg;
 221         ir_graph          *irg      = env->irg;
 222         ir_node           *block    = env->block;
 223         ir_node           *noreg_gp = ia32_new_NoReg_gp(env->cg);
 224         ir_node           *noreg_fp = ia32_new_NoReg_fp(env->cg);
 225         ir_node           *nomem    = new_NoMem();
 226         ir_node           *expr_op, *imm_op;
 227         DEBUG_ONLY(firm_dbg_module_t *mod = env->mod;)
 228
 229         /* Check if immediate optimization is on and */
 230         /* if it's an operation with immediate.      */
 231         if (! (env->cg->opt & IA32_OPT_IMMOPS)) {
 232                 expr_op = op1;
 233                 imm_op  = NULL;
 234         }
 235         else if (is_op_commutative(get_irn_op(env->irn))) {
 236                 imm_op  = get_immediate_op(op1, op2);
 237                 expr_op = get_expr_op(op1, op2);
 238         }
 239         else {
 240                 imm_op  = get_immediate_op(NULL, op2);
 241                 expr_op = get_expr_op(op1, op2);
 242         }
 243
 244         assert((expr_op || imm_op) && "invalid operands");
 245
 246         if (!expr_op) {
 247                 /* We have two consts here: not yet supported */
 248                 imm_op = NULL;
 249         }
 250
 251         if (mode_is_float(mode)) {
 252                 /* floating point operations */
 253                 if (imm_op) {
 254                         DB((mod, LEVEL_1, "FP with immediate ..."));
 255                         new_op = func(dbg, irg, block, noreg_gp, noreg_gp, expr_op, noreg_fp, nomem);
 256                         set_ia32_Immop_attr(new_op, imm_op);
 257                         set_ia32_am_support(new_op, ia32_am_None);
 258                 }
 259                 else {
 260                         DB((mod, LEVEL_1, "FP binop ..."));
 261                         new_op = func(dbg, irg, block, noreg_gp, noreg_gp, op1, op2, nomem);
 262                         set_ia32_am_support(new_op, ia32_am_Source);
 263                 }
 264                 set_ia32_ls_mode(new_op, mode);
 265         }
 266         else {
 267                 /* integer operations */
 268                 if (imm_op) {
 269                         /* This is expr + const */
 270                         DB((mod, LEVEL_1, "INT with immediate ..."));
 271                         new_op = func(dbg, irg, block, noreg_gp, noreg_gp, expr_op, noreg_gp, nomem);
 272                         set_ia32_Immop_attr(new_op, imm_op);
 273
 274                         /* set AM support */
 275                         set_ia32_am_support(new_op, ia32_am_Dest);
 276                 }
 277                 else {
 278                         DB((mod, LEVEL_1, "INT binop ..."));
 279                         /* This is a normal operation */
 280                         new_op = func(dbg, irg, block, noreg_gp, noreg_gp, op1, op2, nomem);
 281
 282                         /* set AM support */
 283                         set_ia32_am_support(new_op, ia32_am_Full);
 284                 }
 285         }
 286
 287         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, env->irn));
 288
 289         set_ia32_res_mode(new_op, mode);
 290
 291         if (is_op_commutative(get_irn_op(env->irn))) {
 292                 set_ia32_commutative(new_op);
 293         }
 294
 295         return new_rd_Proj(dbg, irg, block, new_op, mode, 0);
 296 }
 297
 298
 299
 300 /**
 301  * Construct a shift/rotate binary operation, sets AM and immediate if required.
 302  *
 303  * @param env   The transformation environment
 304  * @param op1   The first operand
 305  * @param op2   The second operand
 306  * @param func  The node constructor function
 307  * @return The constructed ia32 node.
 308  */
 309 static ir_node *gen_shift_binop(ia32_transform_env_t *env, ir_node *op1, ir_node *op2, construct_binop_func *func) {
 310         ir_node           *new_op = NULL;
 311         ir_mode           *mode   = env->mode;
 312         dbg_info          *dbg    = env->dbg;
 313         ir_graph          *irg    = env->irg;
 314         ir_node           *block  = env->block;
 315         ir_node           *noreg  = ia32_new_NoReg_gp(env->cg);
 316         ir_node           *nomem  = new_NoMem();
 317         ir_node           *expr_op, *imm_op;
 318         tarval            *tv;
 319         DEBUG_ONLY(firm_dbg_module_t *mod = env->mod;)
 320
 321         assert(! mode_is_float(mode) && "Shift/Rotate with float not supported");
 322
 323         /* Check if immediate optimization is on and */
 324         /* if it's an operation with immediate.      */
 325         imm_op  = (env->cg->opt & IA32_OPT_IMMOPS) ? get_immediate_op(NULL, op2) : NULL;
 326         expr_op = get_expr_op(op1, op2);
 327
 328         assert((expr_op || imm_op) && "invalid operands");
 329
 330         if (!expr_op) {
 331                 /* We have two consts here: not yet supported */
 332                 imm_op = NULL;
 333         }
 334
 335         /* Limit imm_op within range imm8 */
 336         if (imm_op) {
 337                 tv = get_ia32_Immop_tarval(imm_op);
 338
 339                 if (tv) {
 340                         tv = tarval_mod(tv, new_tarval_from_long(32, mode_Iu));
 341                 }
 342                 else {
 343                         imm_op = NULL;
 344                 }
 345         }
 346
 347         /* integer operations */
 348         if (imm_op) {
 349                 /* This is shift/rot with const */
 350                 DB((mod, LEVEL_1, "Shift/Rot with immediate ..."));
 351
 352                 new_op = func(dbg, irg, block, noreg, noreg, expr_op, noreg, nomem);
 353                 set_ia32_Immop_attr(new_op, imm_op);
 354         }
 355         else {
 356                 /* This is a normal shift/rot */
 357                 DB((mod, LEVEL_1, "Shift/Rot binop ..."));
 358                 new_op = func(dbg, irg, block, noreg, noreg, op1, op2, nomem);
 359         }
 360
 361         /* set AM support */
 362         set_ia32_am_support(new_op, ia32_am_Dest);
 363
 364         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, env->irn));
 365
 366         set_ia32_res_mode(new_op, mode);
 367         set_ia32_emit_cl(new_op);
 368
 369         return new_rd_Proj(dbg, irg, block, new_op, mode, 0);
 370 }
 371
 372
 373 /**
 374  * Construct a standard unary operation, set AM and immediate if required.
 375  *
 376  * @param env   The transformation environment
 377  * @param op    The operand
 378  * @param func  The node constructor function
 379  * @return The constructed ia32 node.
 380  */
 381 static ir_node *gen_unop(ia32_transform_env_t *env, ir_node *op, construct_unop_func *func) {
 382         ir_node           *new_op = NULL;
 383         ir_mode           *mode   = env->mode;
 384         dbg_info          *dbg    = env->dbg;
 385         ir_graph          *irg    = env->irg;
 386         ir_node           *block  = env->block;
 387         ir_node           *noreg  = ia32_new_NoReg_gp(env->cg);
 388         ir_node           *nomem  = new_NoMem();
 389         DEBUG_ONLY(firm_dbg_module_t *mod = env->mod;)
 390
 391         new_op = func(dbg, irg, block, noreg, noreg, op, nomem);
 392
 393         if (mode_is_float(mode)) {
 394                 DB((mod, LEVEL_1, "FP unop ..."));
 395                 /* floating point operations don't support implicit store */
 396                 set_ia32_am_support(new_op, ia32_am_None);
 397         }
 398         else {
 399                 DB((mod, LEVEL_1, "INT unop ..."));
 400                 set_ia32_am_support(new_op, ia32_am_Dest);
 401         }
 402
 403         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, env->irn));
 404
 405         set_ia32_res_mode(new_op, mode);
 406
 407         return new_rd_Proj(dbg, irg, block, new_op, mode, 0);
 408 }
 409
 410
 411
 412 /**
 413  * Creates an ia32 Add with immediate.
 414  *
 415  * @param env       The transformation environment
 416  * @param expr_op   The expression operator
 417  * @param const_op  The constant
 418  * @return the created ia32 Add node
 419  */
 420 static ir_node *gen_imm_Add(ia32_transform_env_t *env, ir_node *expr_op, ir_node *const_op) {
 421         ir_node                *new_op     = NULL;
 422         tarval                 *tv         = get_ia32_Immop_tarval(const_op);
 423         dbg_info               *dbg        = env->dbg;
 424         ir_graph               *irg        = env->irg;
 425         ir_node                *block      = env->block;
 426         ir_node                *noreg      = ia32_new_NoReg_gp(env->cg);
 427         ir_node                *nomem      = new_NoMem();
 428         int                     normal_add = 1;
 429         tarval_classification_t class_tv, class_negtv;
 430         DEBUG_ONLY(firm_dbg_module_t *mod = env->mod;)
 431
 432         /* try to optimize to inc/dec  */
 433         if ((env->cg->opt & IA32_OPT_INCDEC) && (get_ia32_op_type(const_op) == ia32_Const)) {
 434                 /* optimize tarvals */
 435                 class_tv    = classify_tarval(tv);
 436                 class_negtv = classify_tarval(tarval_neg(tv));
 437
 438                 if (class_tv == TV_CLASSIFY_ONE) { /* + 1 == INC */
 439                         DB((env->mod, LEVEL_2, "Add(1) to Inc ... "));
 440                         new_op     = new_rd_ia32_Inc(dbg, irg, block, noreg, noreg, expr_op, nomem);
 441                         normal_add = 0;
 442                 }
 443                 else if (class_tv == TV_CLASSIFY_ALL_ONE || class_negtv == TV_CLASSIFY_ONE) { /* + (-1) == DEC */
 444                         DB((mod, LEVEL_2, "Add(-1) to Dec ... "));
 445                         new_op     = new_rd_ia32_Dec(dbg, irg, block, noreg, noreg, expr_op, nomem);
 446                         normal_add = 0;
 447                 }
 448         }
 449
 450         if (normal_add) {
 451                 new_op = new_rd_ia32_Add(dbg, irg, block, noreg, noreg, expr_op, noreg, nomem);
 452                 set_ia32_Immop_attr(new_op, const_op);
 453                 set_ia32_commutative(new_op);
 454         }
 455
 456         return new_op;
 457 }
 458
 459 /**
 460  * Creates an ia32 Add.
 461  *
 462  * @param env   The transformation environment
 463  * @return the created ia32 Add node
 464  */
 465 static ir_node *gen_Add(ia32_transform_env_t *env) {
 466         ir_node  *new_op = NULL;
 467         dbg_info *dbg    = env->dbg;
 468         ir_mode  *mode   = env->mode;
 469         ir_graph *irg    = env->irg;
 470         ir_node  *block  = env->block;
 471         ir_node  *noreg  = ia32_new_NoReg_gp(env->cg);
 472         ir_node  *nomem  = new_NoMem();
 473         ir_node  *expr_op, *imm_op;
 474         ir_node  *op1    = get_Add_left(env->irn);
 475         ir_node  *op2    = get_Add_right(env->irn);
 476
 477         /* Check if immediate optimization is on and */
 478         /* if it's an operation with immediate.      */
 479         imm_op  = (env->cg->opt & IA32_OPT_IMMOPS) ? get_immediate_op(op1, op2) : NULL;
 480         expr_op = get_expr_op(op1, op2);
 481
 482         assert((expr_op || imm_op) && "invalid operands");
 483
 484         if (mode_is_float(mode)) {
 485                 FP_USED(env->cg);
 486                 if (USE_SSE2(env->cg))
 487                         return gen_binop(env, op1, op2, new_rd_ia32_xAdd);
 488                 else
 489                         return gen_binop(env, op1, op2, new_rd_ia32_vfadd);
 490         }
 491         else {
 492                 /* integer ADD */
 493                 if (!expr_op) {
 494                         /* No expr_op means, that we have two const - one symconst and */
 495                         /* one tarval or another symconst - because this case is not   */
 496                         /* covered by constant folding                                 */
 497                         /* We need to check for:                                       */
 498                         /*  1) symconst + const    -> becomes a LEA                    */
 499                         /*  2) symconst + symconst -> becomes a const + LEA as the elf */
 500                         /*        linker doesn't support two symconsts                 */
 501
 502                         if (get_ia32_op_type(op1) == ia32_SymConst && get_ia32_op_type(op2) == ia32_SymConst) {
 503                                 /* this is the 2nd case */
 504                                 new_op = new_rd_ia32_Lea(dbg, irg, block, op1, noreg, mode);
 505                                 set_ia32_am_sc(new_op, get_ia32_id_cnst(op2));
 506                                 set_ia32_am_flavour(new_op, ia32_am_OB);
 507
 508                                 DBG_OPT_LEA1(op2, new_op);
 509                         }
 510                         else {
 511                                 /* this is the 1st case */
 512                                 new_op = new_rd_ia32_Lea(dbg, irg, block, noreg, noreg, mode);
 513
 514                                 DBG_OPT_LEA2(op1, op2, new_op);
 515
 516                                 if (get_ia32_op_type(op1) == ia32_SymConst) {
 517                                         set_ia32_am_sc(new_op, get_ia32_id_cnst(op1));
 518                                         add_ia32_am_offs(new_op, get_ia32_cnst(op2));
 519                                 }
 520                                 else {
 521                                         add_ia32_am_offs(new_op, get_ia32_cnst(op1));
 522                                         set_ia32_am_sc(new_op, get_ia32_id_cnst(op2));
 523                                 }
 524                                 set_ia32_am_flavour(new_op, ia32_am_O);
 525                         }
 526
 527                         /* set AM support */
 528                         set_ia32_am_support(new_op, ia32_am_Source);
 529                         set_ia32_op_type(new_op, ia32_AddrModeS);
 530
 531                         /* Lea doesn't need a Proj */
 532                         return new_op;
 533                 }
 534                 else if (imm_op) {
 535                         /* This is expr + const */
 536                         new_op = gen_imm_Add(env, expr_op, imm_op);
 537
 538                         /* set AM support */
 539                         set_ia32_am_support(new_op, ia32_am_Dest);
 540                 }
 541                 else {
 542                         /* This is a normal add */
 543                         new_op = new_rd_ia32_Add(dbg, irg, block, noreg, noreg, op1, op2, nomem);
 544
 545                         /* set AM support */
 546                         set_ia32_am_support(new_op, ia32_am_Full);
 547                         set_ia32_commutative(new_op);
 548                 }
 549         }
 550
 551         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, env->irn));
 552
 553         set_ia32_res_mode(new_op, mode);
 554
 555         return new_rd_Proj(dbg, irg, block, new_op, mode, pn_ia32_Add_res);
 556 }
 557
 558
 559
 560 /**
 561  * Creates an ia32 Mul.
 562  *
 563  * @param env   The transformation environment
 564  * @return the created ia32 Mul node
 565  */
 566 static ir_node *gen_Mul(ia32_transform_env_t *env) {
 567         ir_node *op1 = get_Mul_left(env->irn);
 568         ir_node *op2 = get_Mul_right(env->irn);
 569         ir_node *new_op;
 570
 571         if (mode_is_float(env->mode)) {
 572                 FP_USED(env->cg);
 573                 if (USE_SSE2(env->cg))
 574                         new_op = gen_binop(env, op1, op2, new_rd_ia32_xMul);
 575                 else
 576                         new_op = gen_binop(env, op1, op2, new_rd_ia32_vfmul);
 577         }
 578         else {
 579                 new_op = gen_binop(env, op1, op2, new_rd_ia32_Mul);
 580         }
 581
 582         return new_op;
 583 }
 584
 585
 586
 587 /**
 588  * Creates an ia32 Mulh.
 589  * Note: Mul produces a 64Bit result and Mulh returns the upper 32 bit of
 590  * this result while Mul returns the lower 32 bit.
 591  *
 592  * @param env   The transformation environment
 593  * @return the created ia32 Mulh node
 594  */
 595 static ir_node *gen_Mulh(ia32_transform_env_t *env) {
 596         ir_node *op1 = get_irn_n(env->irn, 0);
 597         ir_node *op2 = get_irn_n(env->irn, 1);
 598         ir_node *proj_EAX, *proj_EDX, *mulh;
 599         ir_node *in[1];
 600
 601         assert(!mode_is_float(env->mode) && "Mulh with float not supported");
 602         proj_EAX = gen_binop(env, op1, op2, new_rd_ia32_Mulh);
 603         mulh     = get_Proj_pred(proj_EAX);
 604         proj_EDX = new_rd_Proj(env->dbg, env->irg, env->block, mulh, env->mode, pn_EDX);
 605
 606         /* to be on the save side */
 607         set_Proj_proj(proj_EAX, pn_EAX);
 608
 609         if (is_ia32_ImmConst(mulh) || is_ia32_ImmSymConst(mulh)) {
 610                 /* Mulh with const cannot have AM */
 611                 set_ia32_am_support(mulh, ia32_am_None);
 612         }
 613         else {
 614                 /* Mulh cannot have AM for destination */
 615                 set_ia32_am_support(mulh, ia32_am_Source);
 616         }
 617
 618         in[0] = proj_EAX;
 619
 620         /* keep EAX */
 621         be_new_Keep(&ia32_reg_classes[CLASS_ia32_gp], env->irg, env->block, 1, in);
 622
 623         return proj_EDX;
 624 }
 625
 626
 627
 628 /**
 629  * Creates an ia32 And.
 630  *
 631  * @param env   The transformation environment
 632  * @return The created ia32 And node
 633  */
 634 static ir_node *gen_And(ia32_transform_env_t *env) {
 635         ir_node *op1 = get_And_left(env->irn);
 636         ir_node *op2 = get_And_right(env->irn);
 637
 638         assert (! mode_is_float(env->mode));
 639         return gen_binop(env, op1, op2, new_rd_ia32_And);
 640 }
 641
 642
 643
 644 /**
 645  * Creates an ia32 Or.
 646  *
 647  * @param env   The transformation environment
 648  * @return The created ia32 Or node
 649  */
 650 static ir_node *gen_Or(ia32_transform_env_t *env) {
 651         ir_node *op1 = get_Or_left(env->irn);
 652         ir_node *op2 = get_Or_right(env->irn);
 653
 654         assert (! mode_is_float(env->mode));
 655         return gen_binop(env, op1, op2, new_rd_ia32_Or);
 656 }
 657
 658
 659
 660 /**
 661  * Creates an ia32 Eor.
 662  *
 663  * @param env   The transformation environment
 664  * @return The created ia32 Eor node
 665  */
 666 static ir_node *gen_Eor(ia32_transform_env_t *env) {
 667         ir_node *op1 = get_Eor_left(env->irn);
 668         ir_node *op2 = get_Eor_right(env->irn);
 669
 670         assert(! mode_is_float(env->mode));
 671         return gen_binop(env, op1, op2, new_rd_ia32_Eor);
 672 }
 673
 674
 675
 676 /**
 677  * Creates an ia32 Max.
 678  *
 679  * @param env      The transformation environment
 680  * @return the created ia32 Max node
 681  */
 682 static ir_node *gen_Max(ia32_transform_env_t *env) {
 683         ir_node *op1 = get_irn_n(env->irn, 0);
 684         ir_node *op2 = get_irn_n(env->irn, 1);
 685         ir_node *new_op;
 686
 687         if (mode_is_float(env->mode)) {
 688                 FP_USED(env->cg);
 689                 if (USE_SSE2(env->cg))
 690                         new_op = gen_binop(env, op1, op2, new_rd_ia32_xMax);
 691                 else {
 692                         assert(0);
 693                 }
 694         }
 695         else {
 696                 new_op = new_rd_ia32_Max(env->dbg, env->irg, env->block, op1, op2, env->mode);
 697                 set_ia32_am_support(new_op, ia32_am_None);
 698                 SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, env->irn));
 699         }
 700
 701         return new_op;
 702 }
 703
 704
 705
 706 /**
 707  * Creates an ia32 Min.
 708  *
 709  * @param env      The transformation environment
 710  * @return the created ia32 Min node
 711  */
 712 static ir_node *gen_Min(ia32_transform_env_t *env) {
 713         ir_node *op1 = get_irn_n(env->irn, 0);
 714         ir_node *op2 = get_irn_n(env->irn, 1);
 715         ir_node *new_op;
 716
 717         if (mode_is_float(env->mode)) {
 718                 FP_USED(env->cg);
 719                 if (USE_SSE2(env->cg))
 720                         new_op = gen_binop(env, op1, op2, new_rd_ia32_xMin);
 721                 else {
 722                         assert(0);
 723                 }
 724         }
 725         else {
 726                 new_op = new_rd_ia32_Min(env->dbg, env->irg, env->block, op1, op2, env->mode);
 727                 set_ia32_am_support(new_op, ia32_am_None);
 728                 SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, env->irn));
 729         }
 730
 731         return new_op;
 732 }
 733
 734
 735
 736 /**
 737  * Creates an ia32 Sub with immediate.
 738  *
 739  * @param env        The transformation environment
 740  * @param expr_op    The first operator
 741  * @param const_op   The constant operator
 742  * @return The created ia32 Sub node
 743  */
 744 static ir_node *gen_imm_Sub(ia32_transform_env_t *env, ir_node *expr_op, ir_node *const_op) {
 745         ir_node                *new_op     = NULL;
 746         tarval                 *tv         = get_ia32_Immop_tarval(const_op);
 747         dbg_info               *dbg        = env->dbg;
 748         ir_graph               *irg        = env->irg;
 749         ir_node                *block      = env->block;
 750         ir_node                *noreg      = ia32_new_NoReg_gp(env->cg);
 751         ir_node                *nomem      = new_NoMem();
 752         int                     normal_sub = 1;
 753         tarval_classification_t class_tv, class_negtv;
 754         DEBUG_ONLY(firm_dbg_module_t *mod = env->mod;)
 755
 756         /* try to optimize to inc/dec  */
 757         if ((env->cg->opt & IA32_OPT_INCDEC) && tv) {
 758                 /* optimize tarvals */
 759                 class_tv    = classify_tarval(tv);
 760                 class_negtv = classify_tarval(tarval_neg(tv));
 761
 762                 if (class_tv == TV_CLASSIFY_ONE) { /* - 1 == DEC */
 763                         DB((mod, LEVEL_2, "Sub(1) to Dec ... "));
 764                         new_op     = new_rd_ia32_Dec(dbg, irg, block, noreg, noreg, expr_op, nomem);
 765                         normal_sub = 0;
 766                 }
 767                 else if (class_negtv == TV_CLASSIFY_ONE) { /* - (-1) == Sub */
 768                         DB((mod, LEVEL_2, "Sub(-1) to Inc ... "));
 769                         new_op     = new_rd_ia32_Inc(dbg, irg, block, noreg, noreg, expr_op, nomem);
 770                         normal_sub = 0;
 771                 }
 772         }
 773
 774         if (normal_sub) {
 775                 new_op = new_rd_ia32_Sub(dbg, irg, block, noreg, noreg, expr_op, noreg, nomem);
 776                 set_ia32_Immop_attr(new_op, const_op);
 777         }
 778
 779         return new_op;
 780 }
 781
 782 /**
 783  * Creates an ia32 Sub.
 784  *
 785  * @param env   The transformation environment
 786  * @return The created ia32 Sub node
 787  */
 788 static ir_node *gen_Sub(ia32_transform_env_t *env) {
 789         ir_node  *new_op = NULL;
 790         dbg_info *dbg    = env->dbg;
 791         ir_mode  *mode   = env->mode;
 792         ir_graph *irg    = env->irg;
 793         ir_node  *block  = env->block;
 794         ir_node  *noreg  = ia32_new_NoReg_gp(env->cg);
 795         ir_node  *nomem  = new_NoMem();
 796         ir_node  *op1    = get_Sub_left(env->irn);
 797         ir_node  *op2    = get_Sub_right(env->irn);
 798         ir_node  *expr_op, *imm_op;
 799
 800         /* Check if immediate optimization is on and */
 801         /* if it's an operation with immediate.      */
 802         imm_op  = (env->cg->opt & IA32_OPT_IMMOPS) ? get_immediate_op(NULL, op2) : NULL;
 803         expr_op = get_expr_op(op1, op2);
 804
 805         assert((expr_op || imm_op) && "invalid operands");
 806
 807         if (mode_is_float(mode)) {
 808                 FP_USED(env->cg);
 809                 if (USE_SSE2(env->cg))
 810                         return gen_binop(env, op1, op2, new_rd_ia32_xSub);
 811                 else
 812                         return gen_binop(env, op1, op2, new_rd_ia32_vfsub);
 813         }
 814         else {
 815                 /* integer SUB */
 816                 if (!expr_op) {
 817                         /* No expr_op means, that we have two const - one symconst and */
 818                         /* one tarval or another symconst - because this case is not   */
 819                         /* covered by constant folding                                 */
 820                         /* We need to check for:                                       */
 821                         /*  1) symconst + const    -> becomes a LEA                    */
 822                         /*  2) symconst + symconst -> becomes a const + LEA as the elf */
 823                         /*        linker doesn't support two symconsts                 */
 824
 825                         if (get_ia32_op_type(op1) == ia32_SymConst && get_ia32_op_type(op2) == ia32_SymConst) {
 826                                 /* this is the 2nd case */
 827                                 new_op = new_rd_ia32_Lea(dbg, irg, block, op1, noreg, mode);
 828                                 set_ia32_am_sc(new_op, get_ia32_id_cnst(op2));
 829                                 set_ia32_am_sc_sign(new_op);
 830                                 set_ia32_am_flavour(new_op, ia32_am_OB);
 831
 832                                 DBG_OPT_LEA1(op2, new_op);
 833                         }
 834                         else {
 835                                 /* this is the 1st case */
 836                                 new_op = new_rd_ia32_Lea(dbg, irg, block, noreg, noreg, mode);
 837
 838                                 DBG_OPT_LEA2(op1, op2, new_op);
 839
 840                                 if (get_ia32_op_type(op1) == ia32_SymConst) {
 841                                         set_ia32_am_sc(new_op, get_ia32_id_cnst(op1));
 842                                         sub_ia32_am_offs(new_op, get_ia32_cnst(op2));
 843                                 }
 844                                 else {
 845                                         add_ia32_am_offs(new_op, get_ia32_cnst(op1));
 846                                         set_ia32_am_sc(new_op, get_ia32_id_cnst(op2));
 847                                         set_ia32_am_sc_sign(new_op);
 848                                 }
 849                                 set_ia32_am_flavour(new_op, ia32_am_O);
 850                         }
 851
 852                         /* set AM support */
 853                         set_ia32_am_support(new_op, ia32_am_Source);
 854                         set_ia32_op_type(new_op, ia32_AddrModeS);
 855
 856                         /* Lea doesn't need a Proj */
 857                         return new_op;
 858                 }
 859                 else if (imm_op) {
 860                         /* This is expr - const */
 861                         new_op = gen_imm_Sub(env, expr_op, imm_op);
 862
 863                         /* set AM support */
 864                         set_ia32_am_support(new_op, ia32_am_Dest);
 865                 }
 866                 else {
 867                         /* This is a normal sub */
 868                         new_op = new_rd_ia32_Sub(dbg, irg, block, noreg, noreg, op1, op2, nomem);
 869
 870                         /* set AM support */
 871                         set_ia32_am_support(new_op, ia32_am_Full);
 872                 }
 873         }
 874
 875         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, env->irn));
 876
 877         set_ia32_res_mode(new_op, mode);
 878
 879         return new_rd_Proj(dbg, irg, block, new_op, mode, pn_ia32_Sub_res);
 880 }
 881
 882
 883
 884 /**
 885  * Generates an ia32 DivMod with additional infrastructure for the
 886  * register allocator if needed.
 887  *
 888  * @param env      The transformation environment
 889  * @param dividend -no comment- :)
 890  * @param divisor  -no comment- :)
 891  * @param dm_flav  flavour_Div/Mod/DivMod
 892  * @return The created ia32 DivMod node
 893  */
 894 static ir_node *generate_DivMod(ia32_transform_env_t *env, ir_node *dividend, ir_node *divisor, ia32_op_flavour_t dm_flav) {
 895         ir_node  *res, *proj;
 896         ir_node  *edx_node, *cltd;
 897         ir_node  *in_keep[1];
 898         dbg_info *dbg   = env->dbg;
 899         ir_graph *irg   = env->irg;
 900         ir_node  *block = env->block;
 901         ir_mode  *mode  = env->mode;
 902         ir_node  *irn   = env->irn;
 903         ir_node  *mem;
 904
 905         switch (dm_flav) {
 906                 case flavour_Div:
 907                         mem  = get_Div_mem(irn);
 908                         mode = get_irn_mode(get_proj_for_pn(irn, pn_Div_res));
 909                         break;
 910                 case flavour_Mod:
 911                         mem  = get_Mod_mem(irn);
 912                         mode = get_irn_mode(get_proj_for_pn(irn, pn_Mod_res));
 913                         break;
 914                 case flavour_DivMod:
 915                         mem  = get_DivMod_mem(irn);
 916                         mode = get_irn_mode(get_proj_for_pn(irn, pn_DivMod_res_div));
 917                         break;
 918                 default:
 919                         assert(0);
 920         }
 921
 922         if (mode_is_signed(mode)) {
 923                 /* in signed mode, we need to sign extend the dividend */
 924                 cltd     = new_rd_ia32_Cdq(dbg, irg, block, dividend);
 925                 dividend = new_rd_Proj(dbg, irg, block, cltd, mode_Is, pn_ia32_Cdq_EAX);
 926                 edx_node = new_rd_Proj(dbg, irg, block, cltd, mode_Is, pn_ia32_Cdq_EDX);
 927         }
 928         else {
 929                 edx_node = new_rd_ia32_Const(dbg, irg, block, get_irg_no_mem(irg), mode_Iu);
 930                 set_ia32_Const_type(edx_node, ia32_Const);
 931                 set_ia32_Immop_tarval(edx_node, get_tarval_null(mode_Iu));
 932         }
 933
 934         res = new_rd_ia32_DivMod(dbg, irg, block, dividend, divisor, edx_node, mem, dm_flav);
 935
 936         set_ia32_n_res(res, 2);
 937
 938         /* Only one proj is used -> We must add a second proj and */
 939         /* connect this one to a Keep node to eat up the second   */
 940         /* destroyed register.                                    */
 941         if (get_irn_n_edges(irn) == 1) {
 942                 proj = get_edge_src_irn(get_irn_out_edge_first(irn));
 943                 assert(is_Proj(proj) && "non-Proj to Div/Mod node");
 944
 945                 if (get_irn_op(irn) == op_Div) {
 946                         set_Proj_proj(proj, pn_DivMod_res_div);
 947                         in_keep[0] = new_rd_Proj(dbg, irg, block, res, mode_Is, pn_DivMod_res_mod);
 948                 }
 949                 else {
 950                         set_Proj_proj(proj, pn_DivMod_res_mod);
 951                         in_keep[0] = new_rd_Proj(dbg, irg, block, res, mode_Is, pn_DivMod_res_div);
 952                 }
 953
 954                 be_new_Keep(&ia32_reg_classes[CLASS_ia32_gp], irg, block, 1, in_keep);
 955         }
 956
 957         SET_IA32_ORIG_NODE(res, ia32_get_old_node_name(env->cg, env->irn));
 958
 959         set_ia32_res_mode(res, mode_Is);
 960
 961         return res;
 962 }
 963
 964
 965 /**
 966  * Wrapper for generate_DivMod. Sets flavour_Mod.
 967  *
 968  * @param env      The transformation environment
 969  */
 970 static ir_node *gen_Mod(ia32_transform_env_t *env) {
 971         return generate_DivMod(env, get_Mod_left(env->irn), get_Mod_right(env->irn), flavour_Mod);
 972 }
 973
 974 /**
 975  * Wrapper for generate_DivMod. Sets flavour_Div.
 976  *
 977  * @param env      The transformation environment
 978  */
 979 static ir_node *gen_Div(ia32_transform_env_t *env) {
 980         return generate_DivMod(env, get_Div_left(env->irn), get_Div_right(env->irn), flavour_Div);
 981 }
 982
 983 /**
 984  * Wrapper for generate_DivMod. Sets flavour_DivMod.
 985  */
 986 static ir_node *gen_DivMod(ia32_transform_env_t *env) {
 987         return generate_DivMod(env, get_DivMod_left(env->irn), get_DivMod_right(env->irn), flavour_DivMod);
 988 }
 989
 990
 991
 992 /**
 993  * Creates an ia32 floating Div.
 994  *
 995  * @param env   The transformation environment
 996  * @return The created ia32 xDiv node
 997  */
 998 static ir_node *gen_Quot(ia32_transform_env_t *env) {
 999         ir_node *noreg = ia32_new_NoReg_gp(env->cg);
1000         ir_node *new_op;
1001         ir_node *nomem = new_rd_NoMem(env->irg);
1002         ir_node *op1   = get_Quot_left(env->irn);
1003         ir_node *op2   = get_Quot_right(env->irn);
1004
1005         FP_USED(env->cg);
1006         if (USE_SSE2(env->cg)) {
1007                 if (is_ia32_xConst(op2)) {
1008                         new_op = new_rd_ia32_xDiv(env->dbg, env->irg, env->block, noreg, noreg, op1, noreg, nomem);
1009                         set_ia32_am_support(new_op, ia32_am_None);
1010                         set_ia32_Immop_attr(new_op, op2);
1011                 }
1012                 else {
1013                         new_op = new_rd_ia32_xDiv(env->dbg, env->irg, env->block, noreg, noreg, op1, op2, nomem);
1014                         set_ia32_am_support(new_op, ia32_am_Source);
1015                 }
1016         }
1017         else {
1018                 new_op = new_rd_ia32_vfdiv(env->dbg, env->irg, env->block, noreg, noreg, op1, op2, nomem);
1019                 set_ia32_am_support(new_op, ia32_am_Source);
1020         }
1021         set_ia32_res_mode(new_op, get_irn_mode(get_proj_for_pn(env->irn, pn_Quot_res)));
1022         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, env->irn));
1023
1024         return new_op;
1025 }
1026
1027
1028
1029 /**
1030  * Creates an ia32 Shl.
1031  *
1032  * @param env   The transformation environment
1033  * @return The created ia32 Shl node
1034  */
1035 static ir_node *gen_Shl(ia32_transform_env_t *env) {
1036         return gen_shift_binop(env, get_Shl_left(env->irn), get_Shl_right(env->irn), new_rd_ia32_Shl);
1037 }
1038
1039
1040
1041 /**
1042  * Creates an ia32 Shr.
1043  *
1044  * @param env   The transformation environment
1045  * @return The created ia32 Shr node
1046  */
1047 static ir_node *gen_Shr(ia32_transform_env_t *env) {
1048         return gen_shift_binop(env, get_Shr_left(env->irn), get_Shr_right(env->irn), new_rd_ia32_Shr);
1049 }
1050
1051
1052
1053 /**
1054  * Creates an ia32 Shrs.
1055  *
1056  * @param env   The transformation environment
1057  * @return The created ia32 Shrs node
1058  */
1059 static ir_node *gen_Shrs(ia32_transform_env_t *env) {
1060         return gen_shift_binop(env, get_Shrs_left(env->irn), get_Shrs_right(env->irn), new_rd_ia32_Shrs);
1061 }
1062
1063
1064
1065 /**
1066  * Creates an ia32 RotL.
1067  *
1068  * @param env   The transformation environment
1069  * @param op1   The first operator
1070  * @param op2   The second operator
1071  * @return The created ia32 RotL node
1072  */
1073 static ir_node *gen_RotL(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
1074         return gen_shift_binop(env, op1, op2, new_rd_ia32_RotL);
1075 }
1076
1077
1078
1079 /**
1080  * Creates an ia32 RotR.
1081  * NOTE: There is no RotR with immediate because this would always be a RotL
1082  *       "imm-mode_size_bits" which can be pre-calculated.
1083  *
1084  * @param env   The transformation environment
1085  * @param op1   The first operator
1086  * @param op2   The second operator
1087  * @return The created ia32 RotR node
1088  */
1089 static ir_node *gen_RotR(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
1090         return gen_shift_binop(env, op1, op2, new_rd_ia32_RotR);
1091 }
1092
1093
1094
1095 /**
1096  * Creates an ia32 RotR or RotL (depending on the found pattern).
1097  *
1098  * @param env   The transformation environment
1099  * @return The created ia32 RotL or RotR node
1100  */
1101 static ir_node *gen_Rot(ia32_transform_env_t *env) {
1102         ir_node *rotate = NULL;
1103         ir_node *op1    = get_Rot_left(env->irn);
1104         ir_node *op2    = get_Rot_right(env->irn);
1105
1106         /* Firm has only Rot (which is a RotL), so we are looking for a right (op2)
1107                  operand "-e+mode_size_bits" (it's an already modified "mode_size_bits-e",
1108                  that means we can create a RotR instead of an Add and a RotL */
1109
1110         if (is_Proj(op2)) {
1111                 ir_node *pred = get_Proj_pred(op2);
1112
1113                 if (is_ia32_Add(pred)) {
1114                         ir_node *pred_pred = get_irn_n(pred, 2);
1115                         tarval  *tv        = get_ia32_Immop_tarval(pred);
1116                         long     bits      = get_mode_size_bits(env->mode);
1117
1118                         if (is_Proj(pred_pred)) {
1119                                 pred_pred = get_Proj_pred(pred_pred);
1120                         }
1121
1122                         if (is_ia32_Minus(pred_pred) &&
1123                                 tarval_is_long(tv)       &&
1124                                 get_tarval_long(tv) == bits)
1125                         {
1126                                 DB((env->mod, LEVEL_1, "RotL into RotR ... "));
1127                                 rotate = gen_RotR(env, op1, get_irn_n(pred_pred, 2));
1128                         }
1129
1130                 }
1131         }
1132
1133         if (!rotate) {
1134                 rotate = gen_RotL(env, op1, op2);
1135         }
1136
1137         return rotate;
1138 }
1139
1140
1141
1142 /**
1143  * Transforms a Minus node.
1144  *
1145  * @param env   The transformation environment
1146  * @param op    The Minus operand
1147  * @return The created ia32 Minus node
1148  */
1149 static ir_node *gen_Minus_ex(ia32_transform_env_t *env, ir_node *op) {
1150         ident   *name;
1151         ir_node *new_op;
1152         int      size;
1153
1154         if (mode_is_float(env->mode)) {
1155                 FP_USED(env->cg);
1156                 if (USE_SSE2(env->cg)) {
1157                         ir_node *noreg_gp = ia32_new_NoReg_gp(env->cg);
1158                         ir_node *noreg_fp = ia32_new_NoReg_fp(env->cg);
1159                         ir_node *nomem    = new_rd_NoMem(env->irg);
1160
1161                         new_op = new_rd_ia32_xEor(env->dbg, env->irg, env->block, noreg_gp, noreg_gp, op, noreg_fp, nomem);
1162
1163                         size   = get_mode_size_bits(env->mode);
1164                         name   = gen_fp_known_const(env->mode, size == 32 ? ia32_SSIGN : ia32_DSIGN);
1165
1166                         set_ia32_sc(new_op, name);
1167
1168                         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, env->irn));
1169
1170                         set_ia32_res_mode(new_op, env->mode);
1171                         set_ia32_immop_type(new_op, ia32_ImmSymConst);
1172
1173                         new_op = new_rd_Proj(env->dbg, env->irg, env->block, new_op, env->mode, pn_ia32_xEor_res);
1174                 }
1175                 else {
1176                         new_op = new_rd_ia32_vfchs(env->dbg, env->irg, env->block, op, env->mode);
1177                         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, env->irn));
1178                 }
1179         }
1180         else {
1181                 new_op = gen_unop(env, op, new_rd_ia32_Minus);
1182         }
1183
1184         return new_op;
1185 }
1186
1187 /**
1188  * Transforms a Minus node.
1189  *
1190  * @param env   The transformation environment
1191  * @return The created ia32 Minus node
1192  */
1193 static ir_node *gen_Minus(ia32_transform_env_t *env) {
1194         return gen_Minus_ex(env, get_Minus_op(env->irn));
1195 }
1196
1197
1198 /**
1199  * Transforms a Not node.
1200  *
1201  * @param env   The transformation environment
1202  * @return The created ia32 Not node
1203  */
1204 static ir_node *gen_Not(ia32_transform_env_t *env) {
1205         assert (! mode_is_float(env->mode));
1206         return gen_unop(env, get_Not_op(env->irn), new_rd_ia32_Not);
1207 }
1208
1209
1210
1211 /**
1212  * Transforms an Abs node.
1213  *
1214  * @param env   The transformation environment
1215  * @return The created ia32 Abs node
1216  */
1217 static ir_node *gen_Abs(ia32_transform_env_t *env) {
1218         ir_node  *res, *p_eax, *p_edx;
1219         dbg_info *dbg      = env->dbg;
1220         ir_mode  *mode     = env->mode;
1221         ir_graph *irg      = env->irg;
1222         ir_node  *block    = env->block;
1223         ir_node  *noreg_gp = ia32_new_NoReg_gp(env->cg);
1224         ir_node  *noreg_fp = ia32_new_NoReg_fp(env->cg);
1225         ir_node  *nomem    = new_NoMem();
1226         ir_node  *op       = get_Abs_op(env->irn);
1227         int       size;
1228         ident    *name;
1229
1230         if (mode_is_float(mode)) {
1231                 FP_USED(env->cg);
1232                 if (USE_SSE2(env->cg)) {
1233                         res = new_rd_ia32_xAnd(dbg,irg, block, noreg_gp, noreg_gp, op, noreg_fp, nomem);
1234
1235                         size   = get_mode_size_bits(mode);
1236                         name   = gen_fp_known_const(mode, size == 32 ? ia32_SABS : ia32_DABS);
1237
1238                         set_ia32_sc(res, name);
1239
1240                         SET_IA32_ORIG_NODE(res, ia32_get_old_node_name(env->cg, env->irn));
1241
1242                         set_ia32_res_mode(res, mode);
1243                         set_ia32_immop_type(res, ia32_ImmSymConst);
1244
1245                         res = new_rd_Proj(dbg, irg, block, res, mode, pn_ia32_xAnd_res);
1246                 }
1247                 else {
1248                         res = new_rd_ia32_vfabs(dbg, irg, block, op, mode);
1249                         SET_IA32_ORIG_NODE(res, ia32_get_old_node_name(env->cg, env->irn));
1250                 }
1251         }
1252         else {
1253                 res   = new_rd_ia32_Cdq(dbg, irg, block, op);
1254                 SET_IA32_ORIG_NODE(res, ia32_get_old_node_name(env->cg, env->irn));
1255                 set_ia32_res_mode(res, mode);
1256
1257                 p_eax = new_rd_Proj(dbg, irg, block, res, mode, pn_ia32_Cdq_EAX);
1258                 p_edx = new_rd_Proj(dbg, irg, block, res, mode, pn_ia32_Cdq_EDX);
1259
1260                 res   = new_rd_ia32_Eor(dbg, irg, block, noreg_gp, noreg_gp, p_eax, p_edx, nomem);
1261                 SET_IA32_ORIG_NODE(res, ia32_get_old_node_name(env->cg, env->irn));
1262                 set_ia32_res_mode(res, mode);
1263
1264                 res   = new_rd_Proj(dbg, irg, block, res, mode, pn_ia32_Eor_res);
1265
1266                 res   = new_rd_ia32_Sub(dbg, irg, block, noreg_gp, noreg_gp, res, p_edx, nomem);
1267                 SET_IA32_ORIG_NODE(res, ia32_get_old_node_name(env->cg, env->irn));
1268                 set_ia32_res_mode(res, mode);
1269
1270                 res   = new_rd_Proj(dbg, irg, block, res, mode, pn_ia32_Sub_res);
1271         }
1272
1273         return res;
1274 }
1275
1276
1277
1278 /**
1279  * Transforms a Load.
1280  *
1281  * @param env   The transformation environment
1282  * @return the created ia32 Load node
1283  */
1284 static ir_node *gen_Load(ia32_transform_env_t *env) {
1285         ir_node    *node  = env->irn;
1286         ir_node    *noreg = ia32_new_NoReg_gp(env->cg);
1287         ir_node    *ptr   = get_Load_ptr(node);
1288         ir_node    *lptr  = ptr;
1289         ir_mode    *mode  = get_Load_mode(node);
1290         int        is_imm = 0;
1291         ir_node *new_op;
1292         ia32_am_flavour_t am_flav = ia32_B;
1293
1294         /* address might be a constant (symconst or absolute address) */
1295         if (is_ia32_Const(ptr)) {
1296                 lptr   = noreg;
1297                 is_imm = 1;
1298         }
1299
1300         if (mode_is_float(mode)) {
1301                 FP_USED(env->cg);
1302                 if (USE_SSE2(env->cg))
1303                         new_op = new_rd_ia32_xLoad(env->dbg, env->irg, env->block, lptr, noreg, get_Load_mem(node));
1304                 else
1305                         new_op = new_rd_ia32_vfld(env->dbg, env->irg, env->block, lptr, noreg, get_Load_mem(node));
1306         }
1307         else {
1308                 new_op = new_rd_ia32_Load(env->dbg, env->irg, env->block, lptr, noreg, get_Load_mem(node));
1309         }
1310
1311         /* base is an constant address */
1312         if (is_imm) {
1313                 if (get_ia32_immop_type(ptr) == ia32_ImmSymConst) {
1314                         set_ia32_am_sc(new_op, get_ia32_id_cnst(ptr));
1315                 }
1316                 else {
1317                         add_ia32_am_offs(new_op, get_ia32_cnst(ptr));
1318                 }
1319
1320                 am_flav = ia32_O;
1321         }
1322
1323         set_ia32_am_support(new_op, ia32_am_Source);
1324         set_ia32_op_type(new_op, ia32_AddrModeS);
1325         set_ia32_am_flavour(new_op, am_flav);
1326         set_ia32_ls_mode(new_op, mode);
1327
1328         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, env->irn));
1329
1330         return new_op;
1331 }
1332
1333
1334
1335 /**
1336  * Transforms a Store.
1337  *
1338  * @param env   The transformation environment
1339  * @return the created ia32 Store node
1340  */
1341 static ir_node *gen_Store(ia32_transform_env_t *env) {
1342         ir_node *node    = env->irn;
1343         ir_node *noreg   = ia32_new_NoReg_gp(env->cg);
1344         ir_node *val     = get_Store_value(node);
1345         ir_node *ptr     = get_Store_ptr(node);
1346         ir_node *sptr    = ptr;
1347         ir_node *mem     = get_Store_mem(node);
1348         ir_mode *mode    = get_irn_mode(val);
1349         ir_node *sval    = val;
1350         int      is_imm  = 0;
1351         ir_node *new_op;
1352         ia32_am_flavour_t am_flav = ia32_B;
1353         ia32_immop_type_t immop   = ia32_ImmNone;
1354
1355         if (! mode_is_float(mode)) {
1356                 /* in case of storing a const (but not a symconst) -> make it an attribute */
1357                 if (is_ia32_Cnst(val)) {
1358                         switch (get_ia32_op_type(val)) {
1359                         case ia32_Const:
1360                                 immop = ia32_ImmConst;
1361                                 break;
1362                         case ia32_SymConst:
1363                                 immop = ia32_ImmSymConst;
1364                                 break;
1365                         default:
1366                                 assert(0 && "unsupported Const type");
1367                         }
1368                         sval = noreg;
1369                 }
1370         }
1371
1372         /* address might be a constant (symconst or absolute address) */
1373         if (is_ia32_Const(ptr)) {
1374                 sptr   = noreg;
1375                 is_imm = 1;
1376         }
1377
1378         if (mode_is_float(mode)) {
1379                 FP_USED(env->cg);
1380                 if (USE_SSE2(env->cg))
1381                         new_op = new_rd_ia32_xStore(env->dbg, env->irg, env->block, sptr, noreg, sval, mem);
1382                 else
1383                         new_op = new_rd_ia32_vfst(env->dbg, env->irg, env->block, sptr, noreg, sval, mem);
1384         }
1385         else if (get_mode_size_bits(mode) == 8) {
1386                 new_op = new_rd_ia32_Store8Bit(env->dbg, env->irg, env->block, sptr, noreg, sval, mem);
1387         }
1388         else {
1389                 new_op = new_rd_ia32_Store(env->dbg, env->irg, env->block, sptr, noreg, sval, mem);
1390         }
1391
1392         /* stored const is an attribute (saves a register) */
1393         if (! mode_is_float(mode) && is_ia32_Cnst(val)) {
1394                 set_ia32_Immop_attr(new_op, val);
1395         }
1396
1397         /* base is an constant address */
1398         if (is_imm) {
1399                 if (get_ia32_immop_type(ptr) == ia32_ImmSymConst) {
1400                         set_ia32_am_sc(new_op, get_ia32_id_cnst(ptr));
1401                 }
1402                 else {
1403                         add_ia32_am_offs(new_op, get_ia32_cnst(ptr));
1404                 }
1405
1406                 am_flav = ia32_O;
1407         }
1408
1409         set_ia32_am_support(new_op, ia32_am_Dest);
1410         set_ia32_op_type(new_op, ia32_AddrModeD);
1411         set_ia32_am_flavour(new_op, am_flav);
1412         set_ia32_ls_mode(new_op, get_irn_mode(val));
1413         set_ia32_immop_type(new_op, immop);
1414
1415         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, env->irn));
1416
1417         return new_op;
1418 }
1419
1420
1421
1422 /**
1423  * Transforms a Cond -> Proj[b] -> Cmp into a CondJmp, CondJmp_i or TestJmp
1424  *
1425  * @param env   The transformation environment
1426  * @return The transformed node.
1427  */
1428 static ir_node *gen_Cond(ia32_transform_env_t *env) {
1429         dbg_info *dbg      = env->dbg;
1430         ir_graph *irg      = env->irg;
1431         ir_node  *block    = env->block;
1432         ir_node  *node     = env->irn;
1433         ir_node  *sel      = get_Cond_selector(node);
1434         ir_mode  *sel_mode = get_irn_mode(sel);
1435         ir_node  *res      = NULL;
1436         ir_node  *pred     = NULL;
1437         ir_node  *noreg    = ia32_new_NoReg_gp(env->cg);
1438         ir_node  *cmp_a, *cmp_b, *cnst, *expr;
1439
1440         if (is_Proj(sel) && sel_mode == mode_b) {
1441                 ir_node  *nomem = new_NoMem();
1442
1443                 pred  = get_Proj_pred(sel);
1444
1445                 /* get both compare operators */
1446                 cmp_a = get_Cmp_left(pred);
1447                 cmp_b = get_Cmp_right(pred);
1448
1449                 /* check if we can use a CondJmp with immediate */
1450                 cnst = (env->cg->opt & IA32_OPT_IMMOPS) ? get_immediate_op(cmp_a, cmp_b) : NULL;
1451                 expr = get_expr_op(cmp_a, cmp_b);
1452
1453                 if (cnst && expr) {
1454                         pn_Cmp pnc = get_Proj_proj(sel);
1455
1456                         if ((pnc == pn_Cmp_Eq || pnc == pn_Cmp_Lg) && mode_is_int(get_irn_mode(expr))) {
1457                                 if (classify_tarval(get_ia32_Immop_tarval(cnst)) == TV_CLASSIFY_NULL) {
1458                                         /* a Cmp A =/!= 0 */
1459                                         ir_node    *op1  = expr;
1460                                         ir_node    *op2  = expr;
1461                                         ir_node    *and  = skip_Proj(expr);
1462                                         const char *cnst = NULL;
1463
1464                                         /* check, if expr is an only once used And operation */
1465                                         if (get_irn_n_edges(expr) == 1 && is_ia32_And(and)) {
1466                                                 op1 = get_irn_n(and, 2);
1467                                                 op2 = get_irn_n(and, 3);
1468
1469                                                 cnst = (is_ia32_ImmConst(and) || is_ia32_ImmSymConst(and)) ? get_ia32_cnst(and) : NULL;
1470                                         }
1471                                         res = new_rd_ia32_TestJmp(dbg, irg, block, op1, op2);
1472                                         set_ia32_pncode(res, get_Proj_proj(sel));
1473                                         set_ia32_res_mode(res, get_irn_mode(op1));
1474
1475                                         if (cnst) {
1476                                                 copy_ia32_Immop_attr(res, and);
1477                                         }
1478
1479                                         SET_IA32_ORIG_NODE(res, ia32_get_old_node_name(env->cg, env->irn));
1480                                         return res;
1481                                 }
1482                         }
1483
1484                         if (mode_is_float(get_irn_mode(expr))) {
1485                                 FP_USED(env->cg);
1486                                 if (USE_SSE2(env->cg))
1487                                         res = new_rd_ia32_xCondJmp(dbg, irg, block, noreg, noreg, expr, noreg, nomem);
1488                                 else {
1489                                         assert(0);
1490                                 }
1491                         }
1492                         else {
1493                                 res = new_rd_ia32_CondJmp(dbg, irg, block, noreg, noreg, expr, noreg, nomem);
1494                         }
1495                         set_ia32_Immop_attr(res, cnst);
1496                         set_ia32_res_mode(res, get_irn_mode(expr));
1497                 }
1498                 else {
1499                         if (mode_is_float(get_irn_mode(cmp_a))) {
1500                                 FP_USED(env->cg);
1501                                 if (USE_SSE2(env->cg))
1502                                         res = new_rd_ia32_xCondJmp(dbg, irg, block, noreg, noreg, cmp_a, cmp_b, nomem);
1503                                 else {
1504                                         ir_node *proj_eax;
1505                                         res = new_rd_ia32_vfCondJmp(dbg, irg, block, noreg, noreg, cmp_a, cmp_b, nomem);
1506                                         proj_eax = new_r_Proj(irg, block, res, mode_Is, pn_ia32_vfCondJmp_temp_reg_eax);
1507                                         be_new_Keep(&ia32_reg_classes[CLASS_ia32_gp], irg, block, 1, &proj_eax);
1508                                 }
1509                         }
1510                         else {
1511                                 res = new_rd_ia32_CondJmp(dbg, irg, block, noreg, noreg, cmp_a, cmp_b, nomem);
1512                                 set_ia32_commutative(res);
1513                         }
1514                         set_ia32_res_mode(res, get_irn_mode(cmp_a));
1515                 }
1516
1517                 set_ia32_pncode(res, get_Proj_proj(sel));
1518                 //set_ia32_am_support(res, ia32_am_Source);
1519         }
1520         else {
1521                 /* determine the smallest switch case value */
1522                 int switch_min = INT_MAX;
1523                 const ir_edge_t *edge;
1524                 char buf[64];
1525
1526                 foreach_out_edge(node, edge) {
1527                         int pn = get_Proj_proj(get_edge_src_irn(edge));
1528                         switch_min = pn < switch_min ? pn : switch_min;
1529                 }
1530
1531                 if (switch_min) {
1532                         /* if smallest switch case is not 0 we need an additional sub */
1533                         snprintf(buf, sizeof(buf), "%d", switch_min);
1534                         res = new_rd_ia32_Lea(dbg, irg, block, sel, noreg, mode_Is);
1535                         SET_IA32_ORIG_NODE(res, ia32_get_old_node_name(env->cg, env->irn));
1536                         sub_ia32_am_offs(res, buf);
1537                         set_ia32_am_flavour(res, ia32_am_OB);
1538                         set_ia32_am_support(res, ia32_am_Source);
1539                         set_ia32_op_type(res, ia32_AddrModeS);
1540                 }
1541
1542                 res = new_rd_ia32_SwitchJmp(dbg, irg, block, switch_min ? res : sel, mode_T);
1543                 set_ia32_pncode(res, get_Cond_defaultProj(node));
1544                 set_ia32_res_mode(res, get_irn_mode(sel));
1545         }
1546
1547         SET_IA32_ORIG_NODE(res, ia32_get_old_node_name(env->cg, env->irn));
1548         return res;
1549 }
1550
1551
1552
1553 /**
1554  * Transforms a CopyB node.
1555  *
1556  * @param env   The transformation environment
1557  * @return The transformed node.
1558  */
1559 static ir_node *gen_CopyB(ia32_transform_env_t *env) {
1560         ir_node  *res   = NULL;
1561         dbg_info *dbg   = env->dbg;
1562         ir_graph *irg   = env->irg;
1563         ir_mode  *mode  = env->mode;
1564         ir_node  *block = env->block;
1565         ir_node  *node  = env->irn;
1566         ir_node  *src   = get_CopyB_src(node);
1567         ir_node  *dst   = get_CopyB_dst(node);
1568         ir_node  *mem   = get_CopyB_mem(node);
1569         int       size  = get_type_size_bytes(get_CopyB_type(node));
1570         int       rem;
1571
1572         /* If we have to copy more than 16 bytes, we use REP MOVSx and */
1573         /* then we need the size explicitly in ECX.                    */
1574         if (size >= 16 * 4) {
1575                 rem = size & 0x3; /* size % 4 */
1576                 size >>= 2;
1577
1578                 res = new_rd_ia32_Const(dbg, irg, block, get_irg_no_mem(irg), mode_Is);
1579                 set_ia32_op_type(res, ia32_Const);
1580                 set_ia32_Immop_tarval(res, new_tarval_from_long(size, mode_Is));
1581
1582                 res = new_rd_ia32_CopyB(dbg, irg, block, dst, src, res, mem, mode);
1583                 set_ia32_Immop_tarval(res, new_tarval_from_long(rem, mode_Is));
1584         }
1585         else {
1586                 res = new_rd_ia32_CopyB_i(dbg, irg, block, dst, src, mem, mode);
1587                 set_ia32_Immop_tarval(res, new_tarval_from_long(size, mode_Is));
1588                 set_ia32_immop_type(res, ia32_ImmConst);
1589         }
1590
1591         SET_IA32_ORIG_NODE(res, ia32_get_old_node_name(env->cg, env->irn));
1592
1593         return res;
1594 }
1595
1596
1597
1598 /**
1599  * Transforms a Mux node into CMov.
1600  *
1601  * @param env   The transformation environment
1602  * @return The transformed node.
1603  */
1604 static ir_node *gen_Mux(ia32_transform_env_t *env) {
1605 #if 0
1606         ir_node *node   = env->irn;
1607         ir_node *new_op = new_rd_ia32_CMov(env->dbg, env->irg, env->block, \
1608                 get_Mux_sel(node), get_Mux_false(node), get_Mux_true(node), env->mode);
1609
1610         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, env->irn));
1611
1612         return new_op;
1613 #endif
1614         return NULL;
1615 }
1616
1617 typedef ir_node *set_func_t(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *cmp_a, ir_node *cmp_b, ir_mode *mode);
1618 typedef ir_node *cmov_func_t(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *cmp_a, ir_node *cmp_b, \
1619                              ir_node *psi_true, ir_node *psi_default, ir_mode *mode);
1620
1621 /**
1622  * Transforms a Psi node into CMov.
1623  *
1624  * @param env   The transformation environment
1625  * @return The transformed node.
1626  */
1627 static ir_node *gen_Psi(ia32_transform_env_t *env) {
1628         ia32_code_gen_t *cg   = env->cg;
1629         dbg_info *dbg         = env->dbg;
1630         ir_graph *irg         = env->irg;
1631         ir_mode  *mode        = env->mode;
1632         ir_node  *block       = env->block;
1633         ir_node  *node        = env->irn;
1634         ir_node  *cmp_proj    = get_Mux_sel(node);
1635         ir_node  *psi_true    = get_Psi_val(node, 0);
1636         ir_node  *psi_default = get_Psi_default(node);
1637         ir_node  *noreg       = ia32_new_NoReg_gp(cg);
1638         ir_node  *nomem       = new_rd_NoMem(irg);
1639         ir_node  *cmp, *cmp_a, *cmp_b, *and1, *and2, *new_op, *c1, *c2 = NULL;
1640         int      pnc;
1641
1642
1643         assert(get_irn_mode(cmp_proj) == mode_b && "Condition for Psi must have mode_b");
1644
1645         cmp   = get_Proj_pred(cmp_proj);
1646         cmp_a = get_Cmp_left(cmp);
1647         cmp_b = get_Cmp_right(cmp);
1648         pnc   = get_Proj_proj(cmp_proj);
1649
1650         if (mode_is_float(mode)) {
1651                 /* floating point psi */
1652                 FP_USED(cg);
1653
1654                 /* 1st case: compare operands are float too */
1655                 if (USE_SSE2(cg)) {
1656                         /* psi(cmp(a, b), t, f) can be done as: */
1657                         /* tmp = cmp a, b                       */
1658                         /* tmp2 = t and tmp                     */
1659                         /* tmp3 = f and not tmp                 */
1660                         /* res  = tmp2 or tmp3                  */
1661
1662                         /* in case the compare operands are int, we move them into xmm register */
1663                         if (! mode_is_float(get_irn_mode(cmp_a))) {
1664                                 c1 = new_rd_ia32_Conv_I2FP(dbg, irg, block, noreg, noreg, cmp_a, nomem);
1665                                 set_ia32_src_mode(c1, get_irn_mode(cmp_a));
1666                                 set_ia32_tgt_mode(c1, mode_D);
1667                                 set_ia32_am_support(c1, ia32_am_Source);
1668                                 SET_IA32_ORIG_NODE(c1, ia32_get_old_node_name(cg, node));
1669                                 c2 = new_rd_ia32_Conv_I2FP(dbg, irg, block, noreg, noreg, cmp_b, nomem);
1670                                 set_ia32_src_mode(c2, get_irn_mode(cmp_b));
1671                                 set_ia32_tgt_mode(c2, mode_D);
1672                                 set_ia32_am_support(c2, ia32_am_Source);
1673                                 SET_IA32_ORIG_NODE(c2, ia32_get_old_node_name(cg, node));
1674
1675                                 cmp_a = new_rd_Proj(dbg, irg, block, c1, mode_D, pn_ia32_Conv_I2FP_res);
1676                                 cmp_b = new_rd_Proj(dbg, irg, block, c2, mode_D, pn_ia32_Conv_I2FP_res);
1677
1678                                 pnc += pn_Cmp_Uo;  /* transform integer compare to fp compare */
1679                         }
1680
1681                         new_op = new_rd_ia32_xCmp(dbg, irg, block, noreg, noreg, cmp_a, cmp_b, nomem);
1682                         set_ia32_pncode(new_op, pnc);
1683                         set_ia32_am_support(new_op, ia32_am_Source);
1684                         set_ia32_res_mode(new_op, mode);
1685                         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(cg, node));
1686                         new_op = new_rd_Proj(dbg, irg, block, new_op, mode, pn_ia32_xCmp_res);
1687
1688                         and1 = new_rd_ia32_xAnd(dbg, irg, block, noreg, noreg, psi_true, new_op, nomem);
1689                         set_ia32_am_support(and1, ia32_am_Source);
1690                         set_ia32_res_mode(and1, mode);
1691                         SET_IA32_ORIG_NODE(and1, ia32_get_old_node_name(cg, node));
1692                         and1 = new_rd_Proj(dbg, irg, block, and1, mode, pn_ia32_xAnd_res);
1693
1694                         and2 = new_rd_ia32_xAndNot(dbg, irg, block, noreg, noreg, psi_default, new_op, nomem);
1695                         set_ia32_am_support(and2, ia32_am_Source);
1696                         set_ia32_res_mode(and2, mode);
1697                         SET_IA32_ORIG_NODE(and2, ia32_get_old_node_name(cg, node));
1698                         and2 = new_rd_Proj(dbg, irg, block, and2, mode, pn_ia32_xAndNot_res);
1699
1700                         new_op = new_rd_ia32_xOr(dbg, irg, block, noreg, noreg, and1, and2, nomem);
1701                         set_ia32_am_support(new_op, ia32_am_Source);
1702                         set_ia32_res_mode(new_op, mode);
1703                         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(cg, node));
1704                         new_op = new_rd_Proj(dbg, irg, block, new_op, mode, pn_ia32_xOr_res);
1705                 }
1706                 else {
1707                         /* x87 FPU */
1708                         new_op = new_rd_ia32_vfCMov(dbg, irg, block, cmp_a, cmp_b, psi_true, psi_default, mode);
1709                         set_ia32_pncode(new_op, pnc);
1710                         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, node));
1711                 }
1712         }
1713         else {
1714                 /* integer psi */
1715                 set_func_t  *set_func  = NULL;
1716                 cmov_func_t *cmov_func = NULL;
1717
1718                 if (mode_is_float(get_irn_mode(cmp_a))) {
1719                         /* 1st case: compare operands are floats */
1720                         FP_USED(cg);
1721
1722                         if (USE_SSE2(cg)) {
1723                                 /* SSE FPU */
1724                                 set_func  = new_rd_ia32_xCmpSet;
1725                                 cmov_func = new_rd_ia32_xCmpCMov;
1726                         }
1727                         else {
1728                                 /* x87 FPU */
1729                                 set_func  = new_rd_ia32_vfCmpSet;
1730                                 cmov_func = new_rd_ia32_vfCmpCMov;
1731                         }
1732                 }
1733                 else {
1734                         /* 2nd case: compare operand are integer too */
1735                         set_func  = new_rd_ia32_Set;
1736                         cmov_func = new_rd_ia32_CMov;
1737                 }
1738
1739                 /* create the nodes */
1740
1741                 if (is_ia32_Const_1(psi_true) && is_ia32_Const_0(psi_default)) {
1742                         /* first case for SETcc: default is 0, set to 1 iff condition is true */
1743                         new_op = set_func(dbg, irg, block, cmp_a, cmp_b, mode);
1744                         set_ia32_pncode(new_op, pnc);
1745                 }
1746                 else if (is_ia32_Const_0(psi_true) && is_ia32_Const_1(psi_default)) {
1747                         /* second case for SETcc: default is 1, set to 0 iff condition is true: */
1748                         /*                        we invert condition and set default to 0      */
1749                         new_op = set_func(dbg, irg, block, cmp_a, cmp_b, mode);
1750                         set_ia32_pncode(new_op, get_negated_pnc(pnc, mode));
1751                 }
1752                 else {
1753                         /* otherwise: use CMOVcc */
1754                         new_op = cmov_func(dbg, irg, block, cmp_a, cmp_b, psi_true, psi_default, mode);
1755                         set_ia32_pncode(new_op, pnc);
1756                 }
1757
1758                 SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(cg, node));
1759         }
1760
1761         return new_op;
1762 }
1763
1764
1765 /**
1766  * Following conversion rules apply:
1767  *
1768  *  INT -> INT
1769  * ============
1770  *  1) n bit -> m bit   n > m (downscale)
1771  *     a) target is signed:    movsx
1772  *     b) target is unsigned:  and with lower bits sets
1773  *  2) n bit -> m bit   n == m   (sign change)
1774  *     always ignored
1775  *  3) n bit -> m bit   n < m (upscale)
1776  *     a) source is signed:    movsx
1777  *     b) source is unsigned:  and with lower bits sets
1778  *
1779  *  INT -> FLOAT
1780  * ==============
1781  *  SSE(1/2) convert to float or double (cvtsi2ss/sd)
1782  *
1783  *  FLOAT -> INT
1784  * ==============
1785  *  SSE(1/2) convert from float or double to 32bit int (cvtss/sd2si)
1786  *  if target mode < 32bit: additional INT -> INT conversion (see above)
1787  *
1788  *  FLOAT -> FLOAT
1789  * ================
1790  *  SSE(1/2) convert from float or double to double or float (cvtss/sd2sd/ss)
1791  *  x87 is mode_E internally, conversions happen only at load and store
1792  *  in non-strict semantic
1793  */
1794
1795 /**
1796  * Create a conversion from x87 state register to general purpose.
1797  */
1798 static ir_node *gen_x87_fp_to_gp(ia32_transform_env_t *env, ir_mode *tgt_mode) {
1799         ia32_code_gen_t *cg = env->cg;
1800         entity   *ent = cg->fp_to_gp;
1801         ir_graph *irg = env->irg;
1802         ir_node  *block = env->block;
1803         ir_node  *noreg = ia32_new_NoReg_gp(env->cg);
1804         ir_node  *op = get_Conv_op(env->irn);
1805         ir_node  *fist, *mem, *load;
1806
1807         if (! ent) {
1808                 int size = get_mode_size_bytes(ia32_reg_classes[CLASS_ia32_vfp].mode);
1809                 ent = cg->fp_to_gp =
1810                         frame_alloc_area(get_irg_frame_type(env->irg), size, 16, 0);
1811         }
1812
1813         /* do a fist */
1814         fist = new_rd_ia32_vfist(env->dbg, irg, block, get_irg_frame(irg), noreg, op, get_irg_no_mem(irg));
1815
1816         set_ia32_frame_ent(fist, ent);
1817         set_ia32_use_frame(fist);
1818         set_ia32_am_support(fist, ia32_am_Dest);
1819         set_ia32_op_type(fist, ia32_AddrModeD);
1820         set_ia32_am_flavour(fist, ia32_B);
1821         set_ia32_ls_mode(fist, mode_E);
1822
1823         mem  = new_r_Proj(irg, block, fist, mode_M, pn_ia32_vfist_M);
1824
1825         /* do a Load */
1826         load = new_rd_ia32_Load(env->dbg, irg, block, get_irg_frame(irg), noreg, mem);
1827
1828         set_ia32_frame_ent(load, ent);
1829         set_ia32_use_frame(load);
1830         set_ia32_am_support(load, ia32_am_Source);
1831         set_ia32_op_type(load, ia32_AddrModeS);
1832         set_ia32_am_flavour(load, ia32_B);
1833         set_ia32_ls_mode(load, tgt_mode);
1834
1835         return new_r_Proj(irg, block, load, tgt_mode, pn_ia32_Load_res);
1836 }
1837
1838 /**
1839  * Create a conversion from x87 state register to general purpose.
1840  */
1841 static ir_node *gen_x87_gp_to_fp(ia32_transform_env_t *env, ir_mode *src_mode) {
1842         ia32_code_gen_t *cg = env->cg;
1843         entity   *ent = cg->gp_to_fp;
1844         ir_graph *irg = env->irg;
1845         ir_node  *block = env->block;
1846         ir_node  *noreg = ia32_new_NoReg_gp(env->cg);
1847         ir_node  *nomem = get_irg_no_mem(irg);
1848         ir_node  *op = get_Conv_op(env->irn);
1849         ir_node  *fild, *store, *mem;
1850         int src_bits;
1851
1852         if (! ent) {
1853                 int size = get_mode_size_bytes(ia32_reg_classes[CLASS_ia32_gp].mode);
1854                 ent = cg->gp_to_fp =
1855                         frame_alloc_area(get_irg_frame_type(env->irg), size, size, 0);
1856         }
1857
1858         /* first convert to 32 bit */
1859         src_bits = get_mode_size_bits(src_mode);
1860         if (src_bits == 8) {
1861                 op = new_rd_ia32_Conv_I2I8Bit(env->dbg, irg, block, noreg, noreg, op, nomem);
1862                 op = new_r_Proj(irg, block, op, mode_Is, 0);
1863         }
1864         else if (src_bits < 32) {
1865                 op = new_rd_ia32_Conv_I2I(env->dbg, irg, block, noreg, noreg, op, nomem);
1866                 op = new_r_Proj(irg, block, op, mode_Is, 0);
1867         }
1868
1869         /* do a store */
1870         store = new_rd_ia32_Store(env->dbg, irg, block, get_irg_frame(irg), noreg, op, nomem);
1871
1872         set_ia32_frame_ent(store, ent);
1873         set_ia32_use_frame(store);
1874
1875         set_ia32_am_support(store, ia32_am_Dest);
1876         set_ia32_op_type(store, ia32_AddrModeD);
1877         set_ia32_am_flavour(store, ia32_B);
1878         set_ia32_ls_mode(store, mode_Is);
1879
1880         mem = new_r_Proj(irg, block, store, mode_M, 0);
1881
1882         /* do a fild */
1883         fild = new_rd_ia32_vfild(env->dbg, irg, block, get_irg_frame(irg), noreg, mem);
1884
1885         set_ia32_frame_ent(fild, ent);
1886         set_ia32_use_frame(fild);
1887         set_ia32_am_support(fild, ia32_am_Source);
1888         set_ia32_op_type(fild, ia32_AddrModeS);
1889         set_ia32_am_flavour(fild, ia32_B);
1890         set_ia32_ls_mode(fild, mode_E);
1891
1892         return new_r_Proj(irg, block, fild, mode_E, 0);
1893 }
1894
1895 /**
1896  * Transforms a Conv node.
1897  *
1898  * @param env   The transformation environment
1899  * @return The created ia32 Conv node
1900  */
1901 static ir_node *gen_Conv(ia32_transform_env_t *env) {
1902         dbg_info *dbg      = env->dbg;
1903         ir_graph *irg      = env->irg;
1904         ir_node  *op       = get_Conv_op(env->irn);
1905         ir_mode  *src_mode = get_irn_mode(op);
1906         ir_mode  *tgt_mode = env->mode;
1907         int      src_bits  = get_mode_size_bits(src_mode);
1908         int      tgt_bits  = get_mode_size_bits(tgt_mode);
1909         int      pn        = -1;
1910         ir_node  *block    = env->block;
1911         ir_node  *new_op   = NULL;
1912         ir_node  *noreg    = ia32_new_NoReg_gp(env->cg);
1913         ir_node  *nomem    = new_rd_NoMem(irg);
1914         ir_node  *proj;
1915         DEBUG_ONLY(firm_dbg_module_t *mod = env->mod;)
1916
1917         if (src_mode == tgt_mode) {
1918                 /* this can happen when changing mode_P to mode_Is */
1919                 DB((mod, LEVEL_1, "killed Conv(mode, mode) ..."));
1920                 edges_reroute(env->irn, op, irg);
1921         }
1922         else if (mode_is_float(src_mode)) {
1923                 /* we convert from float ... */
1924                 if (mode_is_float(tgt_mode)) {
1925                         /* ... to float */
1926                         if (USE_SSE2(env->cg)) {
1927                                 DB((mod, LEVEL_1, "create Conv(float, float) ..."));
1928                                 new_op = new_rd_ia32_Conv_FP2FP(dbg, irg, block, noreg, noreg, op, nomem);
1929                                 pn     = pn_ia32_Conv_FP2FP_res;
1930                         }
1931                         else {
1932                                 DB((mod, LEVEL_1, "killed Conv(float, float) ..."));
1933                                 edges_reroute(env->irn, op, irg);
1934                         }
1935                 }
1936                 else {
1937                         /* ... to int */
1938                         DB((mod, LEVEL_1, "create Conv(float, int) ..."));
1939                         if (USE_SSE2(env->cg)) {
1940                                 new_op = new_rd_ia32_Conv_FP2I(dbg, irg, block, noreg, noreg, op, nomem);
1941                                 pn     = pn_ia32_Conv_FP2I_res;
1942                         }
1943                         else
1944                                 return gen_x87_fp_to_gp(env, tgt_mode);
1945
1946                         /* if target mode is not int: add an additional downscale convert */
1947                         if (tgt_bits < 32) {
1948                                 SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, env->irn));
1949                                 set_ia32_am_support(new_op, ia32_am_Source);
1950                                 set_ia32_tgt_mode(new_op, tgt_mode);
1951                                 set_ia32_src_mode(new_op, src_mode);
1952
1953                                 proj = new_rd_Proj(dbg, irg, block, new_op, mode_Is, pn_ia32_Conv_FP2I_res);
1954
1955                                 if (tgt_bits == 8 || src_bits == 8) {
1956                                         new_op = new_rd_ia32_Conv_I2I8Bit(dbg, irg, block, noreg, noreg, proj, nomem);
1957                                         pn     = pn_ia32_Conv_I2I8Bit_res;
1958                                 }
1959                                 else {
1960                                         new_op = new_rd_ia32_Conv_I2I(dbg, irg, block, noreg, noreg, proj, nomem);
1961                                         pn     = pn_ia32_Conv_I2I_res;
1962                                 }
1963                         }
1964                 }
1965         }
1966         else {
1967                 /* we convert from int ... */
1968                 if (mode_is_float(tgt_mode)) {
1969                         FP_USED(env->cg);
1970                         /* ... to float */
1971                         DB((mod, LEVEL_1, "create Conv(int, float) ..."));
1972                         if (USE_SSE2(env->cg)) {
1973                                 new_op = new_rd_ia32_Conv_I2FP(dbg, irg, block, noreg, noreg, op, nomem);
1974                                 pn     = pn_ia32_Conv_I2FP_res;
1975                         }
1976                         else
1977                                 return gen_x87_gp_to_fp(env, src_mode);
1978                 }
1979                 else {
1980                         /* ... to int */
1981                         if (get_mode_size_bits(src_mode) == tgt_bits) {
1982                                 DB((mod, LEVEL_1, "omitting equal size Conv(%+F, %+F) ...", src_mode, tgt_mode));
1983                                 edges_reroute(env->irn, op, irg);
1984                         }
1985                         else {
1986                                 DB((mod, LEVEL_1, "create Conv(int, int) ...", src_mode, tgt_mode));
1987                                 if (tgt_bits == 8 || src_bits == 8) {
1988                                         new_op = new_rd_ia32_Conv_I2I8Bit(dbg, irg, block, noreg, noreg, op, nomem);
1989                                         pn     = pn_ia32_Conv_I2I8Bit_res;
1990                                 }
1991                                 else {
1992                                         new_op = new_rd_ia32_Conv_I2I(dbg, irg, block, noreg, noreg, op, nomem);
1993                                         pn     = pn_ia32_Conv_I2I_res;
1994                                 }
1995                         }
1996                 }
1997         }
1998
1999         if (new_op) {
2000                 SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, env->irn));
2001                 set_ia32_tgt_mode(new_op, tgt_mode);
2002                 set_ia32_src_mode(new_op, src_mode);
2003
2004                 set_ia32_am_support(new_op, ia32_am_Source);
2005
2006                 new_op = new_rd_Proj(dbg, irg, block, new_op, tgt_mode, pn);
2007         }
2008
2009         return new_op;
2010 }
2011
2012
2013
2014 /********************************************
2015  *  _                          _
2016  * | |                        | |
2017  * | |__   ___ _ __   ___   __| | ___  ___
2018  * | '_ \ / _ \ '_ \ / _ \ / _` |/ _ \/ __|
2019  * | |_) |  __/ | | | (_) | (_| |  __/\__ \
2020  * |_.__/ \___|_| |_|\___/ \__,_|\___||___/
2021  *
2022  ********************************************/
2023
2024 static ir_node *gen_be_StackParam(ia32_transform_env_t *env) {
2025         ir_node *new_op = NULL;
2026         ir_node *node   = env->irn;
2027         ir_node *noreg  = ia32_new_NoReg_gp(env->cg);
2028         ir_node *mem    = new_rd_NoMem(env->irg);
2029         ir_node *ptr    = get_irn_n(node, 0);
2030         entity  *ent    = be_get_frame_entity(node);
2031         ir_mode *mode   = env->mode;
2032
2033 //      /* If the StackParam has only one user ->     */
2034 //      /* put it in the Block where the user resides */
2035 //      if (get_irn_n_edges(node) == 1) {
2036 //              env->block = get_nodes_block(get_edge_src_irn(get_irn_out_edge_first(node)));
2037 //      }
2038
2039         if (mode_is_float(mode)) {
2040                 FP_USED(env->cg);
2041                 if (USE_SSE2(env->cg))
2042                         new_op = new_rd_ia32_xLoad(env->dbg, env->irg, env->block, ptr, noreg, mem);
2043                 else
2044                         new_op = new_rd_ia32_vfld(env->dbg, env->irg, env->block, ptr, noreg, mem);
2045         }
2046         else {
2047                 new_op = new_rd_ia32_Load(env->dbg, env->irg, env->block, ptr, noreg, mem);
2048         }
2049
2050         set_ia32_frame_ent(new_op, ent);
2051         set_ia32_use_frame(new_op);
2052
2053         set_ia32_am_support(new_op, ia32_am_Source);
2054         set_ia32_op_type(new_op, ia32_AddrModeS);
2055         set_ia32_am_flavour(new_op, ia32_B);
2056         set_ia32_ls_mode(new_op, mode);
2057
2058         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, env->irn));
2059
2060         return new_rd_Proj(env->dbg, env->irg, env->block, new_op, mode, pn_ia32_Load_res);
2061 }
2062
2063 /**
2064  * Transforms a FrameAddr into an ia32 Add.
2065  */
2066 static ir_node *gen_be_FrameAddr(ia32_transform_env_t *env) {
2067         ir_node *new_op = NULL;
2068         ir_node *node   = env->irn;
2069         ir_node *op     = get_irn_n(node, 0);
2070         ir_node *noreg  = ia32_new_NoReg_gp(env->cg);
2071         ir_node *nomem  = new_rd_NoMem(env->irg);
2072
2073         new_op = new_rd_ia32_Add(env->dbg, env->irg, env->block, noreg, noreg, op, noreg, nomem);
2074         set_ia32_frame_ent(new_op, be_get_frame_entity(node));
2075         set_ia32_am_support(new_op, ia32_am_Full);
2076         set_ia32_use_frame(new_op);
2077         set_ia32_immop_type(new_op, ia32_ImmConst);
2078         set_ia32_commutative(new_op);
2079
2080         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, env->irn));
2081
2082         return new_rd_Proj(env->dbg, env->irg, env->block, new_op, env->mode, pn_ia32_Add_res);
2083 }
2084
2085 /**
2086  * Transforms a FrameLoad into an ia32 Load.
2087  */
2088 static ir_node *gen_be_FrameLoad(ia32_transform_env_t *env) {
2089         ir_node *new_op = NULL;
2090         ir_node *node   = env->irn;
2091         ir_node *noreg  = ia32_new_NoReg_gp(env->cg);
2092         ir_node *mem    = get_irn_n(node, 0);
2093         ir_node *ptr    = get_irn_n(node, 1);
2094         entity  *ent    = be_get_frame_entity(node);
2095         ir_mode *mode   = get_type_mode(get_entity_type(ent));
2096
2097         if (mode_is_float(mode)) {
2098                 FP_USED(env->cg);
2099                 if (USE_SSE2(env->cg))
2100                         new_op = new_rd_ia32_xLoad(env->dbg, env->irg, env->block, ptr, noreg, mem);
2101                 else
2102                         new_op = new_rd_ia32_vfld(env->dbg, env->irg, env->block, ptr, noreg, mem);
2103         }
2104         else
2105                 new_op = new_rd_ia32_Load(env->dbg, env->irg, env->block, ptr, noreg, mem);
2106
2107         set_ia32_frame_ent(new_op, ent);
2108         set_ia32_use_frame(new_op);
2109
2110         set_ia32_am_support(new_op, ia32_am_Source);
2111         set_ia32_op_type(new_op, ia32_AddrModeS);
2112         set_ia32_am_flavour(new_op, ia32_B);
2113         set_ia32_ls_mode(new_op, mode);
2114
2115         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, env->irn));
2116
2117         return new_op;
2118 }
2119
2120
2121 /**
2122  * Transforms a FrameStore into an ia32 Store.
2123  */
2124 static ir_node *gen_be_FrameStore(ia32_transform_env_t *env) {
2125         ir_node *new_op = NULL;
2126         ir_node *node   = env->irn;
2127         ir_node *noreg  = ia32_new_NoReg_gp(env->cg);
2128         ir_node *mem    = get_irn_n(node, 0);
2129         ir_node *ptr    = get_irn_n(node, 1);
2130         ir_node *val    = get_irn_n(node, 2);
2131         entity  *ent    = be_get_frame_entity(node);
2132         ir_mode *mode   = get_irn_mode(val);
2133
2134         if (mode_is_float(mode)) {
2135                 FP_USED(env->cg);
2136                 if (USE_SSE2(env->cg))
2137                         new_op = new_rd_ia32_xStore(env->dbg, env->irg, env->block, ptr, noreg, val, mem);
2138                 else
2139                         new_op = new_rd_ia32_vfst(env->dbg, env->irg, env->block, ptr, noreg, val, mem);
2140         }
2141         else if (get_mode_size_bits(mode) == 8) {
2142                 new_op = new_rd_ia32_Store8Bit(env->dbg, env->irg, env->block, ptr, noreg, val, mem);
2143         }
2144         else {
2145                 new_op = new_rd_ia32_Store(env->dbg, env->irg, env->block, ptr, noreg, val, mem);
2146         }
2147
2148         set_ia32_frame_ent(new_op, ent);
2149         set_ia32_use_frame(new_op);
2150
2151         set_ia32_am_support(new_op, ia32_am_Dest);
2152         set_ia32_op_type(new_op, ia32_AddrModeD);
2153         set_ia32_am_flavour(new_op, ia32_B);
2154         set_ia32_ls_mode(new_op, mode);
2155
2156         SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env->cg, env->irn));
2157
2158         return new_op;
2159 }
2160
2161 /**
2162  * This function just sets the register for the Unknown node
2163  * as this is not done during register allocation because Unknown
2164  * is an "ignore" node.
2165  */
2166 static ir_node *gen_Unknown(ia32_transform_env_t *env) {
2167         ir_mode *mode = env->mode;
2168         ir_node *irn  = env->irn;
2169
2170         if (mode_is_float(mode)) {
2171                 if (USE_SSE2(env->cg))
2172                         arch_set_irn_register(env->cg->arch_env, irn, &ia32_xmm_regs[REG_XMM_UKNWN]);
2173                 else
2174                         arch_set_irn_register(env->cg->arch_env, irn, &ia32_vfp_regs[REG_VFP_UKNWN]);
2175         }
2176         else if (mode_is_int(mode) || mode_is_reference(mode)) {
2177                 arch_set_irn_register(env->cg->arch_env, irn, &ia32_gp_regs[REG_GP_UKNWN]);
2178         }
2179         else {
2180                 assert(0 && "unsupported Unknown-Mode");
2181         }
2182
2183         return NULL;
2184 }
2185
2186
2187 /*********************************************************
2188  *                  _             _      _
2189  *                 (_)           | |    (_)
2190  *  _ __ ___   __ _ _ _ __     __| |_ __ ___   _____ _ __
2191  * | '_ ` _ \ / _` | | '_ \   / _` | '__| \ \ / / _ \ '__|
2192  * | | | | | | (_| | | | | | | (_| | |  | |\ V /  __/ |
2193  * |_| |_| |_|\__,_|_|_| |_|  \__,_|_|  |_| \_/ \___|_|
2194  *
2195  *********************************************************/
2196
2197 /**
2198  * Transforms a Sub or xSub into Neg--Add iff OUT_REG == SRC2_REG.
2199  * THIS FUNCTIONS MUST BE CALLED AFTER REGISTER ALLOCATION.
2200  */
2201 void ia32_transform_sub_to_neg_add(ir_node *irn, ia32_code_gen_t *cg) {
2202         ia32_transform_env_t tenv;
2203         ir_node *in1, *in2, *noreg, *nomem, *res;
2204         const arch_register_t *in1_reg, *in2_reg, *out_reg, **slots;
2205
2206         /* Return if AM node or not a Sub or xSub */
2207         if (get_ia32_op_type(irn) != ia32_Normal || !(is_ia32_Sub(irn) || is_ia32_xSub(irn)))
2208                 return;
2209
2210         noreg   = ia32_new_NoReg_gp(cg);
2211         nomem   = new_rd_NoMem(cg->irg);
2212         in1     = get_irn_n(irn, 2);
2213         in2     = get_irn_n(irn, 3);
2214         in1_reg = arch_get_irn_register(cg->arch_env, in1);
2215         in2_reg = arch_get_irn_register(cg->arch_env, in2);
2216         out_reg = get_ia32_out_reg(irn, 0);
2217
2218         tenv.block    = get_nodes_block(irn);
2219         tenv.dbg      = get_irn_dbg_info(irn);
2220         tenv.irg      = cg->irg;
2221         tenv.irn      = irn;
2222         tenv.mode     = get_ia32_res_mode(irn);
2223         tenv.cg       = cg;
2224         DEBUG_ONLY(tenv.mod      = cg->mod;)
2225
2226         /* in case of sub and OUT == SRC2 we can transform the sequence into neg src2 -- add */
2227         if (REGS_ARE_EQUAL(out_reg, in2_reg)) {
2228                 /* generate the neg src2 */
2229                 res = gen_Minus_ex(&tenv, in2);
2230                 arch_set_irn_register(cg->arch_env, res, in2_reg);
2231
2232                 /* add to schedule */
2233                 sched_add_before(irn, res);
2234
2235                 /* generate the add */
2236                 if (mode_is_float(tenv.mode)) {
2237                         res = new_rd_ia32_xAdd(tenv.dbg, tenv.irg, tenv.block, noreg, noreg, res, in1, nomem);
2238                         set_ia32_am_support(res, ia32_am_Source);
2239                 }
2240                 else {
2241                         res = new_rd_ia32_Add(tenv.dbg, tenv.irg, tenv.block, noreg, noreg, res, in1, nomem);
2242                         set_ia32_am_support(res, ia32_am_Full);
2243                         set_ia32_commutative(res);
2244                 }
2245             set_ia32_res_mode(res, tenv.mode);
2246
2247                 SET_IA32_ORIG_NODE(res, ia32_get_old_node_name(tenv.cg, irn));
2248                 /* copy register */
2249                 slots    = get_ia32_slots(res);
2250                 slots[0] = in2_reg;
2251
2252                 /* add to schedule */
2253                 sched_add_before(irn, res);
2254
2255                 /* remove the old sub */
2256                 sched_remove(irn);
2257
2258                 DBG_OPT_SUB2NEGADD(irn, res);
2259
2260                 /* exchange the add and the sub */
2261                 exchange(irn, res);
2262         }
2263 }
2264
2265 /**
2266  * Transforms a LEA into an Add if possible
2267  * THIS FUNCTIONS MUST BE CALLED AFTER REGISTER ALLOCATION.
2268  */
2269 void ia32_transform_lea_to_add(ir_node *irn, ia32_code_gen_t *cg) {
2270         ia32_am_flavour_t am_flav;
2271         int               imm = 0;
2272         ir_node          *res = NULL;
2273         ir_node          *nomem, *noreg, *base, *index, *op1, *op2;
2274         char             *offs;
2275         ia32_transform_env_t tenv;
2276         const arch_register_t *out_reg, *base_reg, *index_reg;
2277
2278         /* must be a LEA */
2279         if (! is_ia32_Lea(irn))
2280                 return;
2281
2282         am_flav = get_ia32_am_flavour(irn);
2283
2284         /* only some LEAs can be transformed to an Add */
2285         if (am_flav != ia32_am_B && am_flav != ia32_am_OB && am_flav != ia32_am_OI && am_flav != ia32_am_BI)
2286                 return;
2287
2288         noreg = ia32_new_NoReg_gp(cg);
2289         nomem = new_rd_NoMem(cg->irg);
2290         op1   = noreg;
2291         op2   = noreg;
2292         base  = get_irn_n(irn, 0);
2293         index = get_irn_n(irn,1);
2294
2295         offs  = get_ia32_am_offs(irn);
2296
2297         /* offset has a explicit sign -> we need to skip + */
2298         if (offs && offs[0] == '+')
2299                 offs++;
2300
2301         out_reg   = arch_get_irn_register(cg->arch_env, irn);
2302         base_reg  = arch_get_irn_register(cg->arch_env, base);
2303         index_reg = arch_get_irn_register(cg->arch_env, index);
2304
2305         tenv.block = get_nodes_block(irn);
2306         tenv.dbg   = get_irn_dbg_info(irn);
2307         tenv.irg   = cg->irg;
2308         tenv.irn   = irn;
2309         DEBUG_ONLY(tenv.mod   = cg->mod;)
2310         tenv.mode  = get_irn_mode(irn);
2311         tenv.cg    = cg;
2312
2313         switch(get_ia32_am_flavour(irn)) {
2314                 case ia32_am_B:
2315                         /* out register must be same as base register */
2316                         if (! REGS_ARE_EQUAL(out_reg, base_reg))
2317                                 return;
2318
2319                         op1 = base;
2320                         break;
2321                 case ia32_am_OB:
2322                         /* out register must be same as base register */
2323                         if (! REGS_ARE_EQUAL(out_reg, base_reg))
2324                                 return;
2325
2326                         op1 = base;
2327                         imm = 1;
2328                         break;
2329                 case ia32_am_OI:
2330                         /* out register must be same as index register */
2331                         if (! REGS_ARE_EQUAL(out_reg, index_reg))
2332                                 return;
2333
2334                         op1 = index;
2335                         imm = 1;
2336                         break;
2337                 case ia32_am_BI:
2338                         /* out register must be same as one in register */
2339                         if (REGS_ARE_EQUAL(out_reg, base_reg)) {
2340                                 op1 = base;
2341                                 op2 = index;
2342                         }
2343                         else if (REGS_ARE_EQUAL(out_reg, index_reg)) {
2344                                 op1 = index;
2345                                 op2 = base;
2346                         }
2347                         else {
2348                                 /* in registers a different from out -> no Add possible */
2349                                 return;
2350                         }
2351                 default:
2352                         break;
2353         }
2354
2355         res = new_rd_ia32_Add(tenv.dbg, tenv.irg, tenv.block, noreg, noreg, op1, op2, nomem);
2356         arch_set_irn_register(cg->arch_env, res, out_reg);
2357         set_ia32_op_type(res, ia32_Normal);
2358         set_ia32_commutative(res);
2359         set_ia32_res_mode(res, tenv.mode);
2360
2361         if (imm) {
2362                 set_ia32_cnst(res, offs);
2363                 set_ia32_immop_type(res, ia32_ImmConst);
2364         }
2365
2366         SET_IA32_ORIG_NODE(res, ia32_get_old_node_name(cg, irn));
2367
2368         /* add Add to schedule */
2369         sched_add_before(irn, res);
2370
2371         DBG_OPT_LEA2ADD(irn, res);
2372
2373         res = new_rd_Proj(tenv.dbg, tenv.irg, tenv.block, res, tenv.mode, pn_ia32_Add_res);
2374
2375         /* add result Proj to schedule */
2376         sched_add_before(irn, res);
2377
2378         /* remove the old LEA */
2379         sched_remove(irn);
2380
2381         /* exchange the Add and the LEA */
2382         exchange(irn, res);
2383 }
2384
2385 /**
2386  * the BAD transformer.
2387  */
2388 static ir_node *bad_transform(ia32_transform_env_t *env) {
2389         ir_fprintf(stderr, "Not implemented: %+F\n", env->irn);
2390         assert(0);
2391         return NULL;
2392 }
2393
2394 /**
2395  * Enters all transform functions into the generic pointer
2396  */
2397 void ia32_register_transformers(void) {
2398         ir_op *op_Max, *op_Min, *op_Mulh;
2399
2400         /* first clear the generic function pointer for all ops */
2401         clear_irp_opcodes_generic_func();
2402
2403 #define GEN(a)   op_##a->ops.generic = (op_func)gen_##a
2404 #define BAD(a)   op_##a->ops.generic = (op_func)bad_transform
2405 #define IGN(a)
2406
2407         GEN(Add);
2408         GEN(Sub);
2409         GEN(Mul);
2410         GEN(And);
2411         GEN(Or);
2412         GEN(Eor);
2413
2414         GEN(Shl);
2415         GEN(Shr);
2416         GEN(Shrs);
2417         GEN(Rot);
2418
2419         GEN(Quot);
2420
2421         GEN(Div);
2422         GEN(Mod);
2423         GEN(DivMod);
2424
2425         GEN(Minus);
2426         GEN(Conv);
2427         GEN(Abs);
2428         GEN(Not);
2429
2430         GEN(Load);
2431         GEN(Store);
2432         GEN(Cond);
2433
2434         GEN(CopyB);
2435         GEN(Mux);
2436         GEN(Psi);
2437
2438         IGN(Call);
2439         IGN(Alloc);
2440
2441         IGN(Proj);
2442         IGN(Block);
2443         IGN(Start);
2444         IGN(End);
2445         IGN(NoMem);
2446         IGN(Phi);
2447         IGN(IJmp);
2448         IGN(Break);
2449         IGN(Cmp);
2450
2451         /* constant transformation happens earlier */
2452         IGN(Const);
2453         IGN(SymConst);
2454         IGN(Sync);
2455
2456         BAD(Raise);
2457         BAD(Sel);
2458         BAD(InstOf);
2459         BAD(Cast);
2460         BAD(Free);
2461         BAD(Tuple);
2462         BAD(Id);
2463         BAD(Bad);
2464         BAD(Confirm);
2465         BAD(Filter);
2466         BAD(CallBegin);
2467         BAD(EndReg);
2468         BAD(EndExcept);
2469
2470         GEN(be_FrameAddr);
2471         GEN(be_FrameLoad);
2472         GEN(be_FrameStore);
2473         GEN(be_StackParam);
2474
2475         /* set the register for all Unknown nodes */
2476         GEN(Unknown);
2477
2478         op_Max = get_op_Max();
2479         if (op_Max)
2480                 GEN(Max);
2481         op_Min = get_op_Min();
2482         if (op_Min)
2483                 GEN(Min);
2484         op_Mulh = get_op_Mulh();
2485         if (op_Mulh)
2486                 GEN(Mulh);
2487
2488 #undef GEN
2489 #undef BAD
2490 #undef IGN
2491 }
2492
2493 typedef ir_node *(transform_func)(ia32_transform_env_t *env);
2494
2495 /**
2496  * Transforms the given firm node (and maybe some other related nodes)
2497  * into one or more assembler nodes.
2498  *
2499  * @param node    the firm node
2500  * @param env     the debug module
2501  */
2502 void ia32_transform_node(ir_node *node, void *env) {
2503         ia32_code_gen_t *cg = (ia32_code_gen_t *)env;
2504         ir_op *op           = get_irn_op(node);
2505         ir_node *asm_node   = NULL;
2506         int i;
2507
2508         if (is_Block(node))
2509                 return;
2510
2511         /* link arguments pointing to Unknown to the UNKNOWN Proj */
2512         for (i = get_irn_arity(node) - 1; i >= 0; i--) {
2513                 if (is_Unknown(get_irn_n(node, i)))
2514                         set_irn_n(node, i, be_get_unknown_for_mode(cg, get_irn_mode(get_irn_n(node, i))));
2515         }
2516
2517         DBG((cg->mod, LEVEL_1, "check %+F ... ", node));
2518         if (op->ops.generic) {
2519                 ia32_transform_env_t  tenv;
2520                 transform_func *transform = (transform_func *)op->ops.generic;
2521
2522                 tenv.block    = get_nodes_block(node);
2523                 tenv.dbg      = get_irn_dbg_info(node);
2524                 tenv.irg      = current_ir_graph;
2525                 tenv.irn      = node;
2526                 tenv.mode     = get_irn_mode(node);
2527                 tenv.cg       = cg;
2528                 DEBUG_ONLY(tenv.mod = cg->mod;)
2529
2530                 asm_node = (*transform)(&tenv);
2531         }
2532
2533         /* exchange nodes if a new one was generated */
2534         if (asm_node) {
2535                 exchange(node, asm_node);
2536                 DB((cg->mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node));
2537         }
2538         else {
2539                 DB((cg->mod, LEVEL_1, "ignored\n"));
2540         }
2541 }