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

   1 /*
   2  * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   6  * This file may be distributed and/or modified under the terms of the
   7  * GNU General Public License version 2 as published by the Free Software
   8  * Foundation and appearing in the file LICENSE.GPL included in the
   9  * packaging of this file.
  10  *
  11  * Licensees holding valid libFirm Professional Edition licenses may use
  12  * this file in accordance with the libFirm Commercial License.
  13  * Agreement provided with the Software.
  14  *
  15  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief       This file implements the IR transformation from firm into
  23  *              ia32-Firm.
  24  * @author      Christian Wuerdig, Matthias Braun
  25  * @version     $Id$
  26  */
  27 #include "config.h"
  28
  29 #include <limits.h>
  30 #include <stdbool.h>
  31
  32 #include "irargs_t.h"
  33 #include "irnode_t.h"
  34 #include "irgraph_t.h"
  35 #include "irmode_t.h"
  36 #include "iropt_t.h"
  37 #include "irop_t.h"
  38 #include "irprog_t.h"
  39 #include "iredges_t.h"
  40 #include "irgmod.h"
  41 #include "irvrfy.h"
  42 #include "ircons.h"
  43 #include "irgwalk.h"
  44 #include "irprintf.h"
  45 #include "debug.h"
  46 #include "irdom.h"
  47 #include "archop.h"
  48 #include "error.h"
  49 #include "array_t.h"
  50 #include "height.h"
  51
  52 #include "../benode_t.h"
  53 #include "../besched.h"
  54 #include "../beabi.h"
  55 #include "../beutil.h"
  56 #include "../beirg_t.h"
  57 #include "../betranshlp.h"
  58 #include "../be_t.h"
  59
  60 #include "bearch_ia32_t.h"
  61 #include "ia32_common_transform.h"
  62 #include "ia32_nodes_attr.h"
  63 #include "ia32_transform.h"
  64 #include "ia32_new_nodes.h"
  65 #include "ia32_map_regs.h"
  66 #include "ia32_dbg_stat.h"
  67 #include "ia32_optimize.h"
  68 #include "ia32_util.h"
  69 #include "ia32_address_mode.h"
  70 #include "ia32_architecture.h"
  71
  72 #include "gen_ia32_regalloc_if.h"
  73
  74 #define SFP_SIGN   "0x80000000"
  75 #define DFP_SIGN   "0x8000000000000000"
  76 #define SFP_ABS    "0x7FFFFFFF"
  77 #define DFP_ABS    "0x7FFFFFFFFFFFFFFF"
  78 #define DFP_INTMAX "9223372036854775807"
  79
  80 #define TP_SFP_SIGN "ia32_sfp_sign"
  81 #define TP_DFP_SIGN "ia32_dfp_sign"
  82 #define TP_SFP_ABS  "ia32_sfp_abs"
  83 #define TP_DFP_ABS  "ia32_dfp_abs"
  84 #define TP_INT_MAX  "ia32_int_max"
  85
  86 #define ENT_SFP_SIGN "IA32_SFP_SIGN"
  87 #define ENT_DFP_SIGN "IA32_DFP_SIGN"
  88 #define ENT_SFP_ABS  "IA32_SFP_ABS"
  89 #define ENT_DFP_ABS  "IA32_DFP_ABS"
  90 #define ENT_INT_MAX  "IA32_INT_MAX"
  91
  92 #define mode_vfp        (ia32_reg_classes[CLASS_ia32_vfp].mode)
  93 #define mode_xmm    (ia32_reg_classes[CLASS_ia32_xmm].mode)
  94
  95 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
  96
  97 static ir_node         *initial_fpcw = NULL;
  98
  99 extern ir_op *get_op_Mulh(void);
 100
 101 typedef ir_node *construct_binop_func(dbg_info *db, ir_graph *irg,
 102         ir_node *block, ir_node *base, ir_node *index, ir_node *mem,
 103         ir_node *op1, ir_node *op2);
 104
 105 typedef ir_node *construct_binop_flags_func(dbg_info *db, ir_graph *irg,
 106         ir_node *block, ir_node *base, ir_node *index, ir_node *mem,
 107         ir_node *op1, ir_node *op2, ir_node *flags);
 108
 109 typedef ir_node *construct_shift_func(dbg_info *db, ir_graph *irg,
 110         ir_node *block, ir_node *op1, ir_node *op2);
 111
 112 typedef ir_node *construct_binop_dest_func(dbg_info *db, ir_graph *irg,
 113         ir_node *block, ir_node *base, ir_node *index, ir_node *mem,
 114         ir_node *op);
 115
 116 typedef ir_node *construct_unop_dest_func(dbg_info *db, ir_graph *irg,
 117         ir_node *block, ir_node *base, ir_node *index, ir_node *mem);
 118
 119 typedef ir_node *construct_binop_float_func(dbg_info *db, ir_graph *irg,
 120         ir_node *block, ir_node *base, ir_node *index, ir_node *mem,
 121         ir_node *op1, ir_node *op2, ir_node *fpcw);
 122
 123 typedef ir_node *construct_unop_func(dbg_info *db, ir_graph *irg,
 124         ir_node *block, ir_node *op);
 125
 126 static ir_node *create_immediate_or_transform(ir_node *node,
 127                                               char immediate_constraint_type);
 128
 129 static ir_node *create_I2I_Conv(ir_mode *src_mode, ir_mode *tgt_mode,
 130                                 dbg_info *dbgi, ir_node *block,
 131                                 ir_node *op, ir_node *orig_node);
 132
 133 /** Return non-zero is a node represents the 0 constant. */
 134 static bool is_Const_0(ir_node *node)
 135 {
 136         return is_Const(node) && is_Const_null(node);
 137 }
 138
 139 /** Return non-zero is a node represents the 1 constant. */
 140 static bool is_Const_1(ir_node *node)
 141 {
 142         return is_Const(node) && is_Const_one(node);
 143 }
 144
 145 /** Return non-zero is a node represents the -1 constant. */
 146 static bool is_Const_Minus_1(ir_node *node)
 147 {
 148         return is_Const(node) && is_Const_all_one(node);
 149 }
 150
 151 /**
 152  * returns true if constant can be created with a simple float command
 153  */
 154 static bool is_simple_x87_Const(ir_node *node)
 155 {
 156         tarval *tv = get_Const_tarval(node);
 157         if (tarval_is_null(tv) || tarval_is_one(tv))
 158                 return true;
 159
 160         /* TODO: match all the other float constants */
 161         return false;
 162 }
 163
 164 /**
 165  * returns true if constant can be created with a simple float command
 166  */
 167 static bool is_simple_sse_Const(ir_node *node)
 168 {
 169         tarval  *tv   = get_Const_tarval(node);
 170         ir_mode *mode = get_tarval_mode(tv);
 171
 172         if (mode == mode_F)
 173                 return true;
 174
 175         if (tarval_is_null(tv) || tarval_is_one(tv))
 176                 return true;
 177
 178         if (mode == mode_D) {
 179                 unsigned val = get_tarval_sub_bits(tv, 0) |
 180                         (get_tarval_sub_bits(tv, 1) << 8) |
 181                         (get_tarval_sub_bits(tv, 2) << 16) |
 182                         (get_tarval_sub_bits(tv, 3) << 24);
 183                 if (val == 0)
 184                         /* lower 32bit are zero, really a 32bit constant */
 185                         return true;
 186         }
 187
 188         /* TODO: match all the other float constants */
 189         return false;
 190 }
 191
 192 /**
 193  * Transforms a Const.
 194  */
 195 static ir_node *gen_Const(ir_node *node)
 196 {
 197         ir_graph        *irg   = current_ir_graph;
 198         ir_node         *old_block = get_nodes_block(node);
 199         ir_node         *block = be_transform_node(old_block);
 200         dbg_info        *dbgi  = get_irn_dbg_info(node);
 201         ir_mode         *mode  = get_irn_mode(node);
 202
 203         assert(is_Const(node));
 204
 205         if (mode_is_float(mode)) {
 206                 ir_node   *res   = NULL;
 207                 ir_node   *noreg = ia32_new_NoReg_gp(env_cg);
 208                 ir_node   *nomem = new_NoMem();
 209                 ir_node   *load;
 210                 ir_entity *floatent;
 211
 212                 if (ia32_cg_config.use_sse2) {
 213                         tarval *tv = get_Const_tarval(node);
 214                         if (tarval_is_null(tv)) {
 215                                 load = new_rd_ia32_xZero(dbgi, irg, block);
 216                                 set_ia32_ls_mode(load, mode);
 217                                 res  = load;
 218                         } else if (tarval_is_one(tv)) {
 219                                 int     cnst  = mode == mode_F ? 26 : 55;
 220                                 ir_node *imm1 = create_Immediate(NULL, 0, cnst);
 221                                 ir_node *imm2 = create_Immediate(NULL, 0, 2);
 222                                 ir_node *pslld, *psrld;
 223
 224                                 load = new_rd_ia32_xAllOnes(dbgi, irg, block);
 225                                 set_ia32_ls_mode(load, mode);
 226                                 pslld = new_rd_ia32_xPslld(dbgi, irg, block, load, imm1);
 227                                 set_ia32_ls_mode(pslld, mode);
 228                                 psrld = new_rd_ia32_xPsrld(dbgi, irg, block, pslld, imm2);
 229                                 set_ia32_ls_mode(psrld, mode);
 230                                 res = psrld;
 231                         } else if (mode == mode_F) {
 232                                 /* we can place any 32bit constant by using a movd gp, sse */
 233                                 unsigned val = get_tarval_sub_bits(tv, 0) |
 234                                                (get_tarval_sub_bits(tv, 1) << 8) |
 235                                                (get_tarval_sub_bits(tv, 2) << 16) |
 236                                                (get_tarval_sub_bits(tv, 3) << 24);
 237                                 ir_node *cnst = new_rd_ia32_Const(dbgi, irg, block, NULL, 0, val);
 238                                 load = new_rd_ia32_xMovd(dbgi, irg, block, cnst);
 239                                 set_ia32_ls_mode(load, mode);
 240                                 res = load;
 241                         } else {
 242                                 if (mode == mode_D) {
 243                                         unsigned val = get_tarval_sub_bits(tv, 0) |
 244                                                 (get_tarval_sub_bits(tv, 1) << 8) |
 245                                                 (get_tarval_sub_bits(tv, 2) << 16) |
 246                                                 (get_tarval_sub_bits(tv, 3) << 24);
 247                                         if (val == 0) {
 248                                                 ir_node *imm32 = create_Immediate(NULL, 0, 32);
 249                                                 ir_node *cnst, *psllq;
 250
 251                                                 /* fine, lower 32bit are zero, produce 32bit value */
 252                                                 val = get_tarval_sub_bits(tv, 4) |
 253                                                         (get_tarval_sub_bits(tv, 5) << 8) |
 254                                                         (get_tarval_sub_bits(tv, 6) << 16) |
 255                                                         (get_tarval_sub_bits(tv, 7) << 24);
 256                                                 cnst = new_rd_ia32_Const(dbgi, irg, block, NULL, 0, val);
 257                                                 load = new_rd_ia32_xMovd(dbgi, irg, block, cnst);
 258                                                 set_ia32_ls_mode(load, mode);
 259                                                 psllq = new_rd_ia32_xPsllq(dbgi, irg, block, load, imm32);
 260                                                 set_ia32_ls_mode(psllq, mode);
 261                                                 res = psllq;
 262                                                 goto end;
 263                                         }
 264                                 }
 265                                 floatent = create_float_const_entity(node);
 266
 267                                 load     = new_rd_ia32_xLoad(dbgi, irg, block, noreg, noreg, nomem,
 268                                                              mode);
 269                                 set_ia32_op_type(load, ia32_AddrModeS);
 270                                 set_ia32_am_sc(load, floatent);
 271                                 set_ia32_flags(load, get_ia32_flags(load) | arch_irn_flags_rematerializable);
 272                                 res = new_r_Proj(irg, block, load, mode_xmm, pn_ia32_xLoad_res);
 273                         }
 274                 } else {
 275                         if (is_Const_null(node)) {
 276                                 load = new_rd_ia32_vfldz(dbgi, irg, block);
 277                                 res  = load;
 278                                 set_ia32_ls_mode(load, mode);
 279                         } else if (is_Const_one(node)) {
 280                                 load = new_rd_ia32_vfld1(dbgi, irg, block);
 281                                 res  = load;
 282                                 set_ia32_ls_mode(load, mode);
 283                         } else {
 284                                 floatent = create_float_const_entity(node);
 285
 286                                 load     = new_rd_ia32_vfld(dbgi, irg, block, noreg, noreg, nomem, mode);
 287                                 set_ia32_op_type(load, ia32_AddrModeS);
 288                                 set_ia32_am_sc(load, floatent);
 289                                 set_ia32_flags(load, get_ia32_flags(load) | arch_irn_flags_rematerializable);
 290                                 res = new_r_Proj(irg, block, load, mode_vfp, pn_ia32_vfld_res);
 291                                 /* take the mode from the entity */
 292                                 set_ia32_ls_mode(load, get_type_mode(get_entity_type(floatent)));
 293                         }
 294                 }
 295 end:
 296                 SET_IA32_ORIG_NODE(load, ia32_get_old_node_name(env_cg, node));
 297
 298                 be_dep_on_frame(load);
 299                 return res;
 300         } else { /* non-float mode */
 301                 ir_node *cnst;
 302                 tarval  *tv = get_Const_tarval(node);
 303                 long     val;
 304
 305                 tv = tarval_convert_to(tv, mode_Iu);
 306
 307                 if (tv == get_tarval_bad() || tv == get_tarval_undefined() ||
 308                     tv == NULL) {
 309                         panic("couldn't convert constant tarval (%+F)", node);
 310                 }
 311                 val = get_tarval_long(tv);
 312
 313                 cnst = new_rd_ia32_Const(dbgi, irg, block, NULL, 0, val);
 314                 SET_IA32_ORIG_NODE(cnst, ia32_get_old_node_name(env_cg, node));
 315
 316                 be_dep_on_frame(cnst);
 317                 return cnst;
 318         }
 319 }
 320
 321 /**
 322  * Transforms a SymConst.
 323  */
 324 static ir_node *gen_SymConst(ir_node *node)
 325 {
 326         ir_graph *irg   = current_ir_graph;
 327         ir_node  *old_block = get_nodes_block(node);
 328         ir_node  *block = be_transform_node(old_block);
 329         dbg_info *dbgi  = get_irn_dbg_info(node);
 330         ir_mode  *mode  = get_irn_mode(node);
 331         ir_node  *cnst;
 332
 333         if (mode_is_float(mode)) {
 334                 ir_node *noreg = ia32_new_NoReg_gp(env_cg);
 335                 ir_node *nomem = new_NoMem();
 336
 337                 if (ia32_cg_config.use_sse2)
 338                         cnst = new_rd_ia32_xLoad(dbgi, irg, block, noreg, noreg, nomem, mode_E);
 339                 else
 340                         cnst = new_rd_ia32_vfld(dbgi, irg, block, noreg, noreg, nomem, mode_E);
 341                 set_ia32_am_sc(cnst, get_SymConst_entity(node));
 342                 set_ia32_use_frame(cnst);
 343         } else {
 344                 ir_entity *entity;
 345
 346                 if (get_SymConst_kind(node) != symconst_addr_ent) {
 347                         panic("backend only support symconst_addr_ent (at %+F)", node);
 348                 }
 349                 entity = get_SymConst_entity(node);
 350                 cnst = new_rd_ia32_Const(dbgi, irg, block, entity, 0, 0);
 351         }
 352
 353         SET_IA32_ORIG_NODE(cnst, ia32_get_old_node_name(env_cg, node));
 354
 355         be_dep_on_frame(cnst);
 356         return cnst;
 357 }
 358
 359 /* Generates an entity for a known FP const (used for FP Neg + Abs) */
 360 ir_entity *ia32_gen_fp_known_const(ia32_known_const_t kct)
 361 {
 362         static const struct {
 363                 const char *tp_name;
 364                 const char *ent_name;
 365                 const char *cnst_str;
 366                 char mode;
 367                 char align;
 368         } names [ia32_known_const_max] = {
 369                 { TP_SFP_SIGN, ENT_SFP_SIGN, SFP_SIGN,   0, 16 },       /* ia32_SSIGN */
 370                 { TP_DFP_SIGN, ENT_DFP_SIGN, DFP_SIGN,   1, 16 },       /* ia32_DSIGN */
 371                 { TP_SFP_ABS,  ENT_SFP_ABS,  SFP_ABS,    0, 16 },       /* ia32_SABS */
 372                 { TP_DFP_ABS,  ENT_DFP_ABS,  DFP_ABS,    1, 16 },       /* ia32_DABS */
 373                 { TP_INT_MAX,  ENT_INT_MAX,  DFP_INTMAX, 2, 4 }         /* ia32_INTMAX */
 374         };
 375         static ir_entity *ent_cache[ia32_known_const_max];
 376
 377         const char    *tp_name, *ent_name, *cnst_str;
 378         ir_type       *tp;
 379         ir_node       *cnst;
 380         ir_graph      *rem;
 381         ir_entity     *ent;
 382         tarval        *tv;
 383         ir_mode       *mode;
 384
 385         ent_name = names[kct].ent_name;
 386         if (! ent_cache[kct]) {
 387                 tp_name  = names[kct].tp_name;
 388                 cnst_str = names[kct].cnst_str;
 389
 390                 switch (names[kct].mode) {
 391                 case 0:  mode = mode_Iu; break;
 392                 case 1:  mode = mode_Lu; break;
 393                 default: mode = mode_F; break;
 394                 }
 395                 tv  = new_tarval_from_str(cnst_str, strlen(cnst_str), mode);
 396                 tp  = new_type_primitive(new_id_from_str(tp_name), mode);
 397                 /* set the specified alignment */
 398                 set_type_alignment_bytes(tp, names[kct].align);
 399
 400                 ent = new_entity(get_glob_type(), new_id_from_str(ent_name), tp);
 401
 402                 set_entity_ld_ident(ent, get_entity_ident(ent));
 403                 set_entity_visibility(ent, visibility_local);
 404                 set_entity_variability(ent, variability_constant);
 405                 set_entity_allocation(ent, allocation_static);
 406
 407                 /* we create a new entity here: It's initialization must resist on the
 408                     const code irg */
 409                 rem = current_ir_graph;
 410                 current_ir_graph = get_const_code_irg();
 411                 cnst = new_Const(mode, tv);
 412                 current_ir_graph = rem;
 413
 414                 set_atomic_ent_value(ent, cnst);
 415
 416                 /* cache the entry */
 417                 ent_cache[kct] = ent;
 418         }
 419
 420         return ent_cache[kct];
 421 }
 422
 423 /**
 424  * return true if the node is a Proj(Load) and could be used in source address
 425  * mode for another node. Will return only true if the @p other node is not
 426  * dependent on the memory of the Load (for binary operations use the other
 427  * input here, for unary operations use NULL).
 428  */
 429 static int ia32_use_source_address_mode(ir_node *block, ir_node *node,
 430                                         ir_node *other, ir_node *other2, match_flags_t flags)
 431 {
 432         ir_node *load;
 433         long     pn;
 434
 435         /* float constants are always available */
 436         if (is_Const(node)) {
 437                 ir_mode *mode = get_irn_mode(node);
 438                 if (mode_is_float(mode)) {
 439                         if (ia32_cg_config.use_sse2) {
 440                                 if (is_simple_sse_Const(node))
 441                                         return 0;
 442                         } else {
 443                                 if (is_simple_x87_Const(node))
 444                                         return 0;
 445                         }
 446                         if (get_irn_n_edges(node) > 1)
 447                                 return 0;
 448                         return 1;
 449                 }
 450         }
 451
 452         if (!is_Proj(node))
 453                 return 0;
 454         load = get_Proj_pred(node);
 455         pn   = get_Proj_proj(node);
 456         if (!is_Load(load) || pn != pn_Load_res)
 457                 return 0;
 458         if (get_nodes_block(load) != block)
 459                 return 0;
 460         /* we only use address mode if we're the only user of the load */
 461         if (get_irn_n_edges(node) != (flags & match_two_users ? 2 : 1))
 462                 return 0;
 463         /* in some edge cases with address mode we might reach the load normally
 464          * and through some AM sequence, if it is already materialized then we
 465          * can't create an AM node from it */
 466         if (be_is_transformed(node))
 467                 return 0;
 468
 469         /* don't do AM if other node inputs depend on the load (via mem-proj) */
 470         if (other != NULL && prevents_AM(block, load, other))
 471                 return 0;
 472
 473         if (other2 != NULL && prevents_AM(block, load, other2))
 474                 return 0;
 475
 476         return 1;
 477 }
 478
 479 typedef struct ia32_address_mode_t ia32_address_mode_t;
 480 struct ia32_address_mode_t {
 481         ia32_address_t  addr;
 482         ir_mode        *ls_mode;
 483         ir_node        *mem_proj;
 484         ir_node        *am_node;
 485         ia32_op_type_t  op_type;
 486         ir_node        *new_op1;
 487         ir_node        *new_op2;
 488         op_pin_state    pinned;
 489         unsigned        commutative  : 1;
 490         unsigned        ins_permuted : 1;
 491 };
 492
 493 static void build_address_ptr(ia32_address_t *addr, ir_node *ptr, ir_node *mem)
 494 {
 495         ir_node *noreg_gp;
 496
 497         /* construct load address */
 498         memset(addr, 0, sizeof(addr[0]));
 499         ia32_create_address_mode(addr, ptr, /*force=*/0);
 500
 501         noreg_gp    = ia32_new_NoReg_gp(env_cg);
 502         addr->base  = addr->base  ? be_transform_node(addr->base)  : noreg_gp;
 503         addr->index = addr->index ? be_transform_node(addr->index) : noreg_gp;
 504         addr->mem   = be_transform_node(mem);
 505 }
 506
 507 static void build_address(ia32_address_mode_t *am, ir_node *node)
 508 {
 509         ir_node        *noreg_gp = ia32_new_NoReg_gp(env_cg);
 510         ia32_address_t *addr     = &am->addr;
 511         ir_node        *load;
 512         ir_node        *ptr;
 513         ir_node        *mem;
 514         ir_node        *new_mem;
 515
 516         if (is_Const(node)) {
 517                 ir_entity *entity  = create_float_const_entity(node);
 518                 addr->base         = noreg_gp;
 519                 addr->index        = noreg_gp;
 520                 addr->mem          = new_NoMem();
 521                 addr->symconst_ent = entity;
 522                 addr->use_frame    = 1;
 523                 am->ls_mode        = get_type_mode(get_entity_type(entity));
 524                 am->pinned         = op_pin_state_floats;
 525                 return;
 526         }
 527
 528         load         = get_Proj_pred(node);
 529         ptr          = get_Load_ptr(load);
 530         mem          = get_Load_mem(load);
 531         new_mem      = be_transform_node(mem);
 532         am->pinned   = get_irn_pinned(load);
 533         am->ls_mode  = get_Load_mode(load);
 534         am->mem_proj = be_get_Proj_for_pn(load, pn_Load_M);
 535         am->am_node  = node;
 536
 537         /* construct load address */
 538         ia32_create_address_mode(addr, ptr, /*force=*/0);
 539
 540         addr->base  = addr->base  ? be_transform_node(addr->base)  : noreg_gp;
 541         addr->index = addr->index ? be_transform_node(addr->index) : noreg_gp;
 542         addr->mem   = new_mem;
 543 }
 544
 545 static void set_address(ir_node *node, const ia32_address_t *addr)
 546 {
 547         set_ia32_am_scale(node, addr->scale);
 548         set_ia32_am_sc(node, addr->symconst_ent);
 549         set_ia32_am_offs_int(node, addr->offset);
 550         if (addr->symconst_sign)
 551                 set_ia32_am_sc_sign(node);
 552         if (addr->use_frame)
 553                 set_ia32_use_frame(node);
 554         set_ia32_frame_ent(node, addr->frame_entity);
 555 }
 556
 557 /**
 558  * Apply attributes of a given address mode to a node.
 559  */
 560 static void set_am_attributes(ir_node *node, const ia32_address_mode_t *am)
 561 {
 562         set_address(node, &am->addr);
 563
 564         set_ia32_op_type(node, am->op_type);
 565         set_ia32_ls_mode(node, am->ls_mode);
 566         if (am->pinned == op_pin_state_pinned) {
 567                 /* beware: some nodes are already pinned and did not allow to change the state */
 568                 if (get_irn_pinned(node) != op_pin_state_pinned)
 569                         set_irn_pinned(node, op_pin_state_pinned);
 570         }
 571         if (am->commutative)
 572                 set_ia32_commutative(node);
 573 }
 574
 575 /**
 576  * Check, if a given node is a Down-Conv, ie. a integer Conv
 577  * from a mode with a mode with more bits to a mode with lesser bits.
 578  * Moreover, we return only true if the node has not more than 1 user.
 579  *
 580  * @param node   the node
 581  * @return non-zero if node is a Down-Conv
 582  */
 583 static int is_downconv(const ir_node *node)
 584 {
 585         ir_mode *src_mode;
 586         ir_mode *dest_mode;
 587
 588         if (!is_Conv(node))
 589                 return 0;
 590
 591         /* we only want to skip the conv when we're the only user
 592          * (not optimal but for now...)
 593          */
 594         if (get_irn_n_edges(node) > 1)
 595                 return 0;
 596
 597         src_mode  = get_irn_mode(get_Conv_op(node));
 598         dest_mode = get_irn_mode(node);
 599         return ia32_mode_needs_gp_reg(src_mode)
 600                 && ia32_mode_needs_gp_reg(dest_mode)
 601                 && get_mode_size_bits(dest_mode) < get_mode_size_bits(src_mode);
 602 }
 603
 604 /* Skip all Down-Conv's on a given node and return the resulting node. */
 605 ir_node *ia32_skip_downconv(ir_node *node)
 606 {
 607         while (is_downconv(node))
 608                 node = get_Conv_op(node);
 609
 610         return node;
 611 }
 612
 613 static ir_node *create_upconv(ir_node *node, ir_node *orig_node)
 614 {
 615         ir_mode  *mode = get_irn_mode(node);
 616         ir_node  *block;
 617         ir_mode  *tgt_mode;
 618         dbg_info *dbgi;
 619
 620         if (mode_is_signed(mode)) {
 621                 tgt_mode = mode_Is;
 622         } else {
 623                 tgt_mode = mode_Iu;
 624         }
 625         block = get_nodes_block(node);
 626         dbgi  = get_irn_dbg_info(node);
 627
 628         return create_I2I_Conv(mode, tgt_mode, dbgi, block, node, orig_node);
 629 }
 630
 631 /**
 632  * matches operands of a node into ia32 addressing/operand modes. This covers
 633  * usage of source address mode, immediates, operations with non 32-bit modes,
 634  * ...
 635  * The resulting data is filled into the @p am struct. block is the block
 636  * of the node whose arguments are matched. op1, op2 are the first and second
 637  * input that are matched (op1 may be NULL). other_op is another unrelated
 638  * input that is not matched! but which is needed sometimes to check if AM
 639  * for op1/op2 is legal.
 640  * @p flags describes the supported modes of the operation in detail.
 641  */
 642 static void match_arguments(ia32_address_mode_t *am, ir_node *block,
 643                             ir_node *op1, ir_node *op2, ir_node *other_op,
 644                             match_flags_t flags)
 645 {
 646         ia32_address_t *addr      = &am->addr;
 647         ir_mode        *mode      = get_irn_mode(op2);
 648         int             mode_bits = get_mode_size_bits(mode);
 649         ir_node        *noreg_gp, *new_op1, *new_op2;
 650         int             use_am;
 651         unsigned        commutative;
 652         int             use_am_and_immediates;
 653         int             use_immediate;
 654
 655         memset(am, 0, sizeof(am[0]));
 656
 657         commutative           = (flags & match_commutative) != 0;
 658         use_am_and_immediates = (flags & match_am_and_immediates) != 0;
 659         use_am                = (flags & match_am) != 0;
 660         use_immediate         = (flags & match_immediate) != 0;
 661         assert(!use_am_and_immediates || use_immediate);
 662
 663         assert(op2 != NULL);
 664         assert(!commutative || op1 != NULL);
 665         assert(use_am || !(flags & match_8bit_am));
 666         assert(use_am || !(flags & match_16bit_am));
 667
 668         if (mode_bits == 8) {
 669                 if (!(flags & match_8bit_am))
 670                         use_am = 0;
 671                 /* we don't automatically add upconvs yet */
 672                 assert((flags & match_mode_neutral) || (flags & match_8bit));
 673         } else if (mode_bits == 16) {
 674                 if (!(flags & match_16bit_am))
 675                         use_am = 0;
 676                 /* we don't automatically add upconvs yet */
 677                 assert((flags & match_mode_neutral) || (flags & match_16bit));
 678         }
 679
 680         /* we can simply skip downconvs for mode neutral nodes: the upper bits
 681          * can be random for these operations */
 682         if (flags & match_mode_neutral) {
 683                 op2 = ia32_skip_downconv(op2);
 684                 if (op1 != NULL) {
 685                         op1 = ia32_skip_downconv(op1);
 686                 }
 687         }
 688
 689         /* match immediates. firm nodes are normalized: constants are always on the
 690          * op2 input */
 691         new_op2 = NULL;
 692         if (!(flags & match_try_am) && use_immediate) {
 693                 new_op2 = try_create_Immediate(op2, 0);
 694         }
 695
 696         noreg_gp = ia32_new_NoReg_gp(env_cg);
 697         if (new_op2 == NULL &&
 698             use_am && ia32_use_source_address_mode(block, op2, op1, other_op, flags)) {
 699                 build_address(am, op2);
 700                 new_op1     = (op1 == NULL ? NULL : be_transform_node(op1));
 701                 if (mode_is_float(mode)) {
 702                         new_op2 = ia32_new_NoReg_vfp(env_cg);
 703                 } else {
 704                         new_op2 = noreg_gp;
 705                 }
 706                 am->op_type = ia32_AddrModeS;
 707         } else if (commutative && (new_op2 == NULL || use_am_and_immediates) &&
 708                        use_am &&
 709                        ia32_use_source_address_mode(block, op1, op2, other_op, flags)) {
 710                 ir_node *noreg;
 711                 build_address(am, op1);
 712
 713                 if (mode_is_float(mode)) {
 714                         noreg = ia32_new_NoReg_vfp(env_cg);
 715                 } else {
 716                         noreg = noreg_gp;
 717                 }
 718
 719                 if (new_op2 != NULL) {
 720                         new_op1 = noreg;
 721                 } else {
 722                         new_op1 = be_transform_node(op2);
 723                         new_op2 = noreg;
 724                         am->ins_permuted = 1;
 725                 }
 726                 am->op_type = ia32_AddrModeS;
 727         } else {
 728                 am->op_type = ia32_Normal;
 729
 730                 if (flags & match_try_am) {
 731                         am->new_op1 = NULL;
 732                         am->new_op2 = NULL;
 733                         return;
 734                 }
 735
 736                 new_op1 = (op1 == NULL ? NULL : be_transform_node(op1));
 737                 if (new_op2 == NULL)
 738                         new_op2 = be_transform_node(op2);
 739                 am->ls_mode =
 740                         (flags & match_mode_neutral ? mode_Iu : get_irn_mode(op2));
 741         }
 742         if (addr->base == NULL)
 743                 addr->base = noreg_gp;
 744         if (addr->index == NULL)
 745                 addr->index = noreg_gp;
 746         if (addr->mem == NULL)
 747                 addr->mem = new_NoMem();
 748
 749         am->new_op1     = new_op1;
 750         am->new_op2     = new_op2;
 751         am->commutative = commutative;
 752 }
 753
 754 static ir_node *fix_mem_proj(ir_node *node, ia32_address_mode_t *am)
 755 {
 756         ir_mode  *mode;
 757         ir_node  *load;
 758
 759         if (am->mem_proj == NULL)
 760                 return node;
 761
 762         /* we have to create a mode_T so the old MemProj can attach to us */
 763         mode = get_irn_mode(node);
 764         load = get_Proj_pred(am->mem_proj);
 765
 766         be_set_transformed_node(load, node);
 767
 768         if (mode != mode_T) {
 769                 set_irn_mode(node, mode_T);
 770                 return new_rd_Proj(NULL, current_ir_graph, get_nodes_block(node), node, mode, pn_ia32_res);
 771         } else {
 772                 return node;
 773         }
 774 }
 775
 776 /**
 777  * Construct a standard binary operation, set AM and immediate if required.
 778  *
 779  * @param node  The original node for which the binop is created
 780  * @param op1   The first operand
 781  * @param op2   The second operand
 782  * @param func  The node constructor function
 783  * @return The constructed ia32 node.
 784  */
 785 static ir_node *gen_binop(ir_node *node, ir_node *op1, ir_node *op2,
 786                           construct_binop_func *func, match_flags_t flags)
 787 {
 788         dbg_info            *dbgi;
 789         ir_node             *block, *new_block, *new_node;
 790         ia32_address_mode_t  am;
 791         ia32_address_t      *addr = &am.addr;
 792
 793         block = get_nodes_block(node);
 794         match_arguments(&am, block, op1, op2, NULL, flags);
 795
 796         dbgi      = get_irn_dbg_info(node);
 797         new_block = be_transform_node(block);
 798         new_node  = func(dbgi, current_ir_graph, new_block,
 799                          addr->base, addr->index, addr->mem,
 800                          am.new_op1, am.new_op2);
 801         set_am_attributes(new_node, &am);
 802         /* we can't use source address mode anymore when using immediates */
 803         if (!(flags & match_am_and_immediates) &&
 804             (is_ia32_Immediate(am.new_op1) || is_ia32_Immediate(am.new_op2)))
 805                 set_ia32_am_support(new_node, ia32_am_none);
 806         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
 807
 808         new_node = fix_mem_proj(new_node, &am);
 809
 810         return new_node;
 811 }
 812
 813 enum {
 814         n_ia32_l_binop_left,
 815         n_ia32_l_binop_right,
 816         n_ia32_l_binop_eflags
 817 };
 818 COMPILETIME_ASSERT(n_ia32_l_binop_left   == n_ia32_l_Adc_left,       n_Adc_left)
 819 COMPILETIME_ASSERT(n_ia32_l_binop_right  == n_ia32_l_Adc_right,      n_Adc_right)
 820 COMPILETIME_ASSERT(n_ia32_l_binop_eflags == n_ia32_l_Adc_eflags,     n_Adc_eflags)
 821 COMPILETIME_ASSERT(n_ia32_l_binop_left   == n_ia32_l_Sbb_minuend,    n_Sbb_minuend)
 822 COMPILETIME_ASSERT(n_ia32_l_binop_right  == n_ia32_l_Sbb_subtrahend, n_Sbb_subtrahend)
 823 COMPILETIME_ASSERT(n_ia32_l_binop_eflags == n_ia32_l_Sbb_eflags,     n_Sbb_eflags)
 824
 825 /**
 826  * Construct a binary operation which also consumes the eflags.
 827  *
 828  * @param node  The node to transform
 829  * @param func  The node constructor function
 830  * @param flags The match flags
 831  * @return      The constructor ia32 node
 832  */
 833 static ir_node *gen_binop_flags(ir_node *node, construct_binop_flags_func *func,
 834                                 match_flags_t flags)
 835 {
 836         ir_node             *src_block  = get_nodes_block(node);
 837         ir_node             *op1        = get_irn_n(node, n_ia32_l_binop_left);
 838         ir_node             *op2        = get_irn_n(node, n_ia32_l_binop_right);
 839         ir_node             *eflags     = get_irn_n(node, n_ia32_l_binop_eflags);
 840         dbg_info            *dbgi;
 841         ir_node             *block, *new_node, *new_eflags;
 842         ia32_address_mode_t  am;
 843         ia32_address_t      *addr       = &am.addr;
 844
 845         match_arguments(&am, src_block, op1, op2, eflags, flags);
 846
 847         dbgi       = get_irn_dbg_info(node);
 848         block      = be_transform_node(src_block);
 849         new_eflags = be_transform_node(eflags);
 850         new_node   = func(dbgi, current_ir_graph, block, addr->base, addr->index,
 851                         addr->mem, am.new_op1, am.new_op2, new_eflags);
 852         set_am_attributes(new_node, &am);
 853         /* we can't use source address mode anymore when using immediates */
 854         if (!(flags & match_am_and_immediates) &&
 855             (is_ia32_Immediate(am.new_op1) || is_ia32_Immediate(am.new_op2)))
 856                 set_ia32_am_support(new_node, ia32_am_none);
 857         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
 858
 859         new_node = fix_mem_proj(new_node, &am);
 860
 861         return new_node;
 862 }
 863
 864 static ir_node *get_fpcw(void)
 865 {
 866         ir_node *fpcw;
 867         if (initial_fpcw != NULL)
 868                 return initial_fpcw;
 869
 870         fpcw         = be_abi_get_ignore_irn(env_cg->birg->abi,
 871                                              &ia32_fp_cw_regs[REG_FPCW]);
 872         initial_fpcw = be_transform_node(fpcw);
 873
 874         return initial_fpcw;
 875 }
 876
 877 /**
 878  * Construct a standard binary operation, set AM and immediate if required.
 879  *
 880  * @param op1   The first operand
 881  * @param op2   The second operand
 882  * @param func  The node constructor function
 883  * @return The constructed ia32 node.
 884  */
 885 static ir_node *gen_binop_x87_float(ir_node *node, ir_node *op1, ir_node *op2,
 886                                     construct_binop_float_func *func)
 887 {
 888         ir_mode             *mode  = get_irn_mode(node);
 889         dbg_info            *dbgi;
 890         ir_node             *block, *new_block, *new_node;
 891         ia32_address_mode_t  am;
 892         ia32_address_t      *addr = &am.addr;
 893         ia32_x87_attr_t     *attr;
 894         /* All operations are considered commutative, because there are reverse
 895          * variants */
 896         match_flags_t        flags = match_commutative;
 897
 898         /* cannot use address mode with long double on x87 */
 899         if (get_mode_size_bits(mode) <= 64)
 900                 flags |= match_am;
 901
 902         block = get_nodes_block(node);
 903         match_arguments(&am, block, op1, op2, NULL, flags);
 904
 905         dbgi      = get_irn_dbg_info(node);
 906         new_block = be_transform_node(block);
 907         new_node  = func(dbgi, current_ir_graph, new_block,
 908                          addr->base, addr->index, addr->mem,
 909                          am.new_op1, am.new_op2, get_fpcw());
 910         set_am_attributes(new_node, &am);
 911
 912         attr = get_ia32_x87_attr(new_node);
 913         attr->attr.data.ins_permuted = am.ins_permuted;
 914
 915         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
 916
 917         new_node = fix_mem_proj(new_node, &am);
 918
 919         return new_node;
 920 }
 921
 922 /**
 923  * Construct a shift/rotate binary operation, sets AM and immediate if required.
 924  *
 925  * @param op1   The first operand
 926  * @param op2   The second operand
 927  * @param func  The node constructor function
 928  * @return The constructed ia32 node.
 929  */
 930 static ir_node *gen_shift_binop(ir_node *node, ir_node *op1, ir_node *op2,
 931                                 construct_shift_func *func,
 932                                 match_flags_t flags)
 933 {
 934         dbg_info *dbgi;
 935         ir_node  *block, *new_block, *new_op1, *new_op2, *new_node;
 936
 937         assert(! mode_is_float(get_irn_mode(node)));
 938         assert(flags & match_immediate);
 939         assert((flags & ~(match_mode_neutral | match_immediate)) == 0);
 940
 941         if (flags & match_mode_neutral) {
 942                 op1     = ia32_skip_downconv(op1);
 943                 new_op1 = be_transform_node(op1);
 944         } else if (get_mode_size_bits(get_irn_mode(node)) != 32) {
 945                 new_op1 = create_upconv(op1, node);
 946         } else {
 947                 new_op1 = be_transform_node(op1);
 948         }
 949
 950         /* the shift amount can be any mode that is bigger than 5 bits, since all
 951          * other bits are ignored anyway */
 952         while (is_Conv(op2) && get_irn_n_edges(op2) == 1) {
 953                 ir_node *const op = get_Conv_op(op2);
 954                 if (mode_is_float(get_irn_mode(op)))
 955                         break;
 956                 op2 = op;
 957                 assert(get_mode_size_bits(get_irn_mode(op2)) >= 5);
 958         }
 959         new_op2 = create_immediate_or_transform(op2, 0);
 960
 961         dbgi      = get_irn_dbg_info(node);
 962         block     = get_nodes_block(node);
 963         new_block = be_transform_node(block);
 964         new_node  = func(dbgi, current_ir_graph, new_block, new_op1, new_op2);
 965         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
 966
 967         /* lowered shift instruction may have a dependency operand, handle it here */
 968         if (get_irn_arity(node) == 3) {
 969                 /* we have a dependency */
 970                 ir_node *new_dep = be_transform_node(get_irn_n(node, 2));
 971                 add_irn_dep(new_node, new_dep);
 972         }
 973
 974         return new_node;
 975 }
 976
 977
 978 /**
 979  * Construct a standard unary operation, set AM and immediate if required.
 980  *
 981  * @param op    The operand
 982  * @param func  The node constructor function
 983  * @return The constructed ia32 node.
 984  */
 985 static ir_node *gen_unop(ir_node *node, ir_node *op, construct_unop_func *func,
 986                          match_flags_t flags)
 987 {
 988         dbg_info *dbgi;
 989         ir_node  *block, *new_block, *new_op, *new_node;
 990
 991         assert(flags == 0 || flags == match_mode_neutral);
 992         if (flags & match_mode_neutral) {
 993                 op = ia32_skip_downconv(op);
 994         }
 995
 996         new_op    = be_transform_node(op);
 997         dbgi      = get_irn_dbg_info(node);
 998         block     = get_nodes_block(node);
 999         new_block = be_transform_node(block);
1000         new_node  = func(dbgi, current_ir_graph, new_block, new_op);
1001
1002         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
1003
1004         return new_node;
1005 }
1006
1007 static ir_node *create_lea_from_address(dbg_info *dbgi, ir_node *block,
1008                                         ia32_address_t *addr)
1009 {
1010         ir_node *base, *index, *res;
1011
1012         base = addr->base;
1013         if (base == NULL) {
1014                 base = ia32_new_NoReg_gp(env_cg);
1015         } else {
1016                 base = be_transform_node(base);
1017         }
1018
1019         index = addr->index;
1020         if (index == NULL) {
1021                 index = ia32_new_NoReg_gp(env_cg);
1022         } else {
1023                 index = be_transform_node(index);
1024         }
1025
1026         res = new_rd_ia32_Lea(dbgi, current_ir_graph, block, base, index);
1027         set_address(res, addr);
1028
1029         return res;
1030 }
1031
1032 /**
1033  * Returns non-zero if a given address mode has a symbolic or
1034  * numerical offset != 0.
1035  */
1036 static int am_has_immediates(const ia32_address_t *addr)
1037 {
1038         return addr->offset != 0 || addr->symconst_ent != NULL
1039                 || addr->frame_entity || addr->use_frame;
1040 }
1041
1042 /**
1043  * Creates an ia32 Add.
1044  *
1045  * @return the created ia32 Add node
1046  */
1047 static ir_node *gen_Add(ir_node *node)
1048 {
1049         ir_mode  *mode = get_irn_mode(node);
1050         ir_node  *op1  = get_Add_left(node);
1051         ir_node  *op2  = get_Add_right(node);
1052         dbg_info *dbgi;
1053         ir_node  *block, *new_block, *new_node, *add_immediate_op;
1054         ia32_address_t       addr;
1055         ia32_address_mode_t  am;
1056
1057         if (mode_is_float(mode)) {
1058                 if (ia32_cg_config.use_sse2)
1059                         return gen_binop(node, op1, op2, new_rd_ia32_xAdd,
1060                                          match_commutative | match_am);
1061                 else
1062                         return gen_binop_x87_float(node, op1, op2, new_rd_ia32_vfadd);
1063         }
1064
1065         ia32_mark_non_am(node);
1066
1067         op2 = ia32_skip_downconv(op2);
1068         op1 = ia32_skip_downconv(op1);
1069
1070         /**
1071          * Rules for an Add:
1072          *   0. Immediate Trees (example Add(Symconst, Const) -> Const)
1073          *   1. Add with immediate -> Lea
1074          *   2. Add with possible source address mode -> Add
1075          *   3. Otherwise -> Lea
1076          */
1077         memset(&addr, 0, sizeof(addr));
1078         ia32_create_address_mode(&addr, node, /*force=*/1);
1079         add_immediate_op = NULL;
1080
1081         dbgi      = get_irn_dbg_info(node);
1082         block     = get_nodes_block(node);
1083         new_block = be_transform_node(block);
1084
1085         /* a constant? */
1086         if (addr.base == NULL && addr.index == NULL) {
1087                 ir_graph *irg = current_ir_graph;
1088                 new_node = new_rd_ia32_Const(dbgi, irg, new_block, addr.symconst_ent,
1089                                              addr.symconst_sign, addr.offset);
1090                 be_dep_on_frame(new_node);
1091                 SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
1092                 return new_node;
1093         }
1094         /* add with immediate? */
1095         if (addr.index == NULL) {
1096                 add_immediate_op = addr.base;
1097         } else if (addr.base == NULL && addr.scale == 0) {
1098                 add_immediate_op = addr.index;
1099         }
1100
1101         if (add_immediate_op != NULL) {
1102                 if (!am_has_immediates(&addr)) {
1103 #ifdef DEBUG_libfirm
1104                         ir_fprintf(stderr, "Optimisation warning Add x,0 (%+F) found\n",
1105                                            node);
1106 #endif
1107                         return be_transform_node(add_immediate_op);
1108                 }
1109
1110                 new_node = create_lea_from_address(dbgi, new_block, &addr);
1111                 SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
1112                 return new_node;
1113         }
1114
1115         /* test if we can use source address mode */
1116         match_arguments(&am, block, op1, op2, NULL, match_commutative
1117                         | match_mode_neutral | match_am | match_immediate | match_try_am);
1118
1119         /* construct an Add with source address mode */
1120         if (am.op_type == ia32_AddrModeS) {
1121                 ir_graph *irg = current_ir_graph;
1122                 ia32_address_t *am_addr = &am.addr;
1123                 new_node = new_rd_ia32_Add(dbgi, irg, new_block, am_addr->base,
1124                                          am_addr->index, am_addr->mem, am.new_op1,
1125                                          am.new_op2);
1126                 set_am_attributes(new_node, &am);
1127                 SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
1128
1129                 new_node = fix_mem_proj(new_node, &am);
1130
1131                 return new_node;
1132         }
1133
1134         /* otherwise construct a lea */
1135         new_node = create_lea_from_address(dbgi, new_block, &addr);
1136         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
1137         return new_node;
1138 }
1139
1140 /**
1141  * Creates an ia32 Mul.
1142  *
1143  * @return the created ia32 Mul node
1144  */
1145 static ir_node *gen_Mul(ir_node *node)
1146 {
1147         ir_node *op1  = get_Mul_left(node);
1148         ir_node *op2  = get_Mul_right(node);
1149         ir_mode *mode = get_irn_mode(node);
1150
1151         if (mode_is_float(mode)) {
1152                 if (ia32_cg_config.use_sse2)
1153                         return gen_binop(node, op1, op2, new_rd_ia32_xMul,
1154                                          match_commutative | match_am);
1155                 else
1156                         return gen_binop_x87_float(node, op1, op2, new_rd_ia32_vfmul);
1157         }
1158         return gen_binop(node, op1, op2, new_rd_ia32_IMul,
1159                          match_commutative | match_am | match_mode_neutral |
1160                          match_immediate | match_am_and_immediates);
1161 }
1162
1163 /**
1164  * Creates an ia32 Mulh.
1165  * Note: Mul produces a 64Bit result and Mulh returns the upper 32 bit of
1166  * this result while Mul returns the lower 32 bit.
1167  *
1168  * @return the created ia32 Mulh node
1169  */
1170 static ir_node *gen_Mulh(ir_node *node)
1171 {
1172         ir_node              *block     = get_nodes_block(node);
1173         ir_node              *new_block = be_transform_node(block);
1174         dbg_info             *dbgi      = get_irn_dbg_info(node);
1175         ir_node              *op1       = get_Mulh_left(node);
1176         ir_node              *op2       = get_Mulh_right(node);
1177         ir_mode              *mode      = get_irn_mode(node);
1178         ir_node              *new_node;
1179         ir_node              *proj_res_high;
1180
1181         if (mode_is_signed(mode)) {
1182                 new_node = gen_binop(node, op1, op2, new_rd_ia32_IMul1OP, match_commutative | match_am);
1183                 proj_res_high = new_rd_Proj(dbgi, current_ir_graph, new_block, new_node,
1184                                     mode_Iu, pn_ia32_IMul1OP_res_high);
1185         } else {
1186                 new_node = gen_binop(node, op1, op2, new_rd_ia32_Mul, match_commutative | match_am);
1187                 proj_res_high = new_rd_Proj(dbgi, current_ir_graph, new_block, new_node,
1188                                     mode_Iu, pn_ia32_Mul_res_high);
1189         }
1190         return proj_res_high;
1191 }
1192
1193 /**
1194  * Creates an ia32 And.
1195  *
1196  * @return The created ia32 And node
1197  */
1198 static ir_node *gen_And(ir_node *node)
1199 {
1200         ir_node *op1 = get_And_left(node);
1201         ir_node *op2 = get_And_right(node);
1202         assert(! mode_is_float(get_irn_mode(node)));
1203
1204         /* is it a zero extension? */
1205         if (is_Const(op2)) {
1206                 tarval   *tv    = get_Const_tarval(op2);
1207                 long      v     = get_tarval_long(tv);
1208
1209                 if (v == 0xFF || v == 0xFFFF) {
1210                         dbg_info *dbgi   = get_irn_dbg_info(node);
1211                         ir_node  *block  = get_nodes_block(node);
1212                         ir_mode  *src_mode;
1213                         ir_node  *res;
1214
1215                         if (v == 0xFF) {
1216                                 src_mode = mode_Bu;
1217                         } else {
1218                                 assert(v == 0xFFFF);
1219                                 src_mode = mode_Hu;
1220                         }
1221                         res = create_I2I_Conv(src_mode, mode_Iu, dbgi, block, op1, node);
1222
1223                         return res;
1224                 }
1225         }
1226         return gen_binop(node, op1, op2, new_rd_ia32_And,
1227                          match_commutative | match_mode_neutral | match_am
1228                                          | match_immediate);
1229 }
1230
1231
1232
1233 /**
1234  * Creates an ia32 Or.
1235  *
1236  * @return The created ia32 Or node
1237  */
1238 static ir_node *gen_Or(ir_node *node)
1239 {
1240         ir_node *op1 = get_Or_left(node);
1241         ir_node *op2 = get_Or_right(node);
1242
1243         assert (! mode_is_float(get_irn_mode(node)));
1244         return gen_binop(node, op1, op2, new_rd_ia32_Or, match_commutative
1245                         | match_mode_neutral | match_am | match_immediate);
1246 }
1247
1248
1249
1250 /**
1251  * Creates an ia32 Eor.
1252  *
1253  * @return The created ia32 Eor node
1254  */
1255 static ir_node *gen_Eor(ir_node *node)
1256 {
1257         ir_node *op1 = get_Eor_left(node);
1258         ir_node *op2 = get_Eor_right(node);
1259
1260         assert(! mode_is_float(get_irn_mode(node)));
1261         return gen_binop(node, op1, op2, new_rd_ia32_Xor, match_commutative
1262                         | match_mode_neutral | match_am | match_immediate);
1263 }
1264
1265
1266 /**
1267  * Creates an ia32 Sub.
1268  *
1269  * @return The created ia32 Sub node
1270  */
1271 static ir_node *gen_Sub(ir_node *node)
1272 {
1273         ir_node  *op1  = get_Sub_left(node);
1274         ir_node  *op2  = get_Sub_right(node);
1275         ir_mode  *mode = get_irn_mode(node);
1276
1277         if (mode_is_float(mode)) {
1278                 if (ia32_cg_config.use_sse2)
1279                         return gen_binop(node, op1, op2, new_rd_ia32_xSub, match_am);
1280                 else
1281                         return gen_binop_x87_float(node, op1, op2, new_rd_ia32_vfsub);
1282         }
1283
1284         if (is_Const(op2)) {
1285                 ir_fprintf(stderr, "Optimisation warning: found sub with const (%+F)\n",
1286                            node);
1287         }
1288
1289         return gen_binop(node, op1, op2, new_rd_ia32_Sub, match_mode_neutral
1290                         | match_am | match_immediate);
1291 }
1292
1293 static ir_node *transform_AM_mem(ir_graph *const irg, ir_node *const block,
1294                                  ir_node  *const src_val,
1295                                  ir_node  *const src_mem,
1296                                  ir_node  *const am_mem)
1297 {
1298         if (is_NoMem(am_mem)) {
1299                 return be_transform_node(src_mem);
1300         } else if (is_Proj(src_val) &&
1301                    is_Proj(src_mem) &&
1302                    get_Proj_pred(src_val) == get_Proj_pred(src_mem)) {
1303                 /* avoid memory loop */
1304                 return am_mem;
1305         } else if (is_Proj(src_val) && is_Sync(src_mem)) {
1306                 ir_node  *const ptr_pred = get_Proj_pred(src_val);
1307                 int       const arity    = get_Sync_n_preds(src_mem);
1308                 int             n        = 0;
1309                 ir_node **      ins;
1310                 int             i;
1311
1312                 NEW_ARR_A(ir_node*, ins, arity + 1);
1313
1314                 for (i = arity - 1; i >= 0; --i) {
1315                         ir_node *const pred = get_Sync_pred(src_mem, i);
1316
1317                         /* avoid memory loop */
1318                         if (is_Proj(pred) && get_Proj_pred(pred) == ptr_pred)
1319                                 continue;
1320
1321                         ins[n++] = be_transform_node(pred);
1322                 }
1323
1324                 ins[n++] = am_mem;
1325
1326                 return new_r_Sync(irg, block, n, ins);
1327         } else {
1328                 ir_node *ins[2];
1329
1330                 ins[0] = be_transform_node(src_mem);
1331                 ins[1] = am_mem;
1332                 return new_r_Sync(irg, block, 2, ins);
1333         }
1334 }
1335
1336 /**
1337  * Generates an ia32 DivMod with additional infrastructure for the
1338  * register allocator if needed.
1339  */
1340 static ir_node *create_Div(ir_node *node)
1341 {
1342         ir_graph *irg       = current_ir_graph;
1343         dbg_info *dbgi      = get_irn_dbg_info(node);
1344         ir_node  *block     = get_nodes_block(node);
1345         ir_node  *new_block = be_transform_node(block);
1346         ir_node  *mem;
1347         ir_node  *new_mem;
1348         ir_node  *op1;
1349         ir_node  *op2;
1350         ir_node  *new_node;
1351         ir_mode  *mode;
1352         ir_node  *sign_extension;
1353         ia32_address_mode_t  am;
1354         ia32_address_t      *addr = &am.addr;
1355
1356         /* the upper bits have random contents for smaller modes */
1357         switch (get_irn_opcode(node)) {
1358         case iro_Div:
1359                 op1     = get_Div_left(node);
1360                 op2     = get_Div_right(node);
1361                 mem     = get_Div_mem(node);
1362                 mode    = get_Div_resmode(node);
1363                 break;
1364         case iro_Mod:
1365                 op1     = get_Mod_left(node);
1366                 op2     = get_Mod_right(node);
1367                 mem     = get_Mod_mem(node);
1368                 mode    = get_Mod_resmode(node);
1369                 break;
1370         case iro_DivMod:
1371                 op1     = get_DivMod_left(node);
1372                 op2     = get_DivMod_right(node);
1373                 mem     = get_DivMod_mem(node);
1374                 mode    = get_DivMod_resmode(node);
1375                 break;
1376         default:
1377                 panic("invalid divmod node %+F", node);
1378         }
1379
1380         match_arguments(&am, block, op1, op2, NULL, match_am);
1381
1382         /* Beware: We don't need a Sync, if the memory predecessor of the Div node
1383            is the memory of the consumed address. We can have only the second op as address
1384            in Div nodes, so check only op2. */
1385         new_mem = transform_AM_mem(irg, block, op2, mem, addr->mem);
1386
1387         if (mode_is_signed(mode)) {
1388                 ir_node *produceval = new_rd_ia32_ProduceVal(dbgi, irg, new_block);
1389                 be_dep_on_frame(produceval);
1390                 sign_extension = new_rd_ia32_Cltd(dbgi, irg, new_block, am.new_op1,
1391                                                   produceval);
1392
1393                 new_node = new_rd_ia32_IDiv(dbgi, irg, new_block, addr->base,
1394                                             addr->index, new_mem, am.new_op2,
1395                                             am.new_op1, sign_extension);
1396         } else {
1397                 sign_extension = new_rd_ia32_Const(dbgi, irg, new_block, NULL, 0, 0);
1398                 be_dep_on_frame(sign_extension);
1399
1400                 new_node = new_rd_ia32_Div(dbgi, irg, new_block, addr->base,
1401                                            addr->index, new_mem, am.new_op2,
1402                                            am.new_op1, sign_extension);
1403         }
1404
1405         set_irn_pinned(new_node, get_irn_pinned(node));
1406
1407         set_am_attributes(new_node, &am);
1408         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
1409
1410         new_node = fix_mem_proj(new_node, &am);
1411
1412         return new_node;
1413 }
1414
1415
1416 static ir_node *gen_Mod(ir_node *node)
1417 {
1418         return create_Div(node);
1419 }
1420
1421 static ir_node *gen_Div(ir_node *node)
1422 {
1423         return create_Div(node);
1424 }
1425
1426 static ir_node *gen_DivMod(ir_node *node)
1427 {
1428         return create_Div(node);
1429 }
1430
1431
1432
1433 /**
1434  * Creates an ia32 floating Div.
1435  *
1436  * @return The created ia32 xDiv node
1437  */
1438 static ir_node *gen_Quot(ir_node *node)
1439 {
1440         ir_node *op1 = get_Quot_left(node);
1441         ir_node *op2 = get_Quot_right(node);
1442
1443         if (ia32_cg_config.use_sse2) {
1444                 return gen_binop(node, op1, op2, new_rd_ia32_xDiv, match_am);
1445         } else {
1446                 return gen_binop_x87_float(node, op1, op2, new_rd_ia32_vfdiv);
1447         }
1448 }
1449
1450
1451 /**
1452  * Creates an ia32 Shl.
1453  *
1454  * @return The created ia32 Shl node
1455  */
1456 static ir_node *gen_Shl(ir_node *node)
1457 {
1458         ir_node *left  = get_Shl_left(node);
1459         ir_node *right = get_Shl_right(node);
1460
1461         return gen_shift_binop(node, left, right, new_rd_ia32_Shl,
1462                                match_mode_neutral | match_immediate);
1463 }
1464
1465 /**
1466  * Creates an ia32 Shr.
1467  *
1468  * @return The created ia32 Shr node
1469  */
1470 static ir_node *gen_Shr(ir_node *node)
1471 {
1472         ir_node *left  = get_Shr_left(node);
1473         ir_node *right = get_Shr_right(node);
1474
1475         return gen_shift_binop(node, left, right, new_rd_ia32_Shr, match_immediate);
1476 }
1477
1478
1479
1480 /**
1481  * Creates an ia32 Sar.
1482  *
1483  * @return The created ia32 Shrs node
1484  */
1485 static ir_node *gen_Shrs(ir_node *node)
1486 {
1487         ir_node *left  = get_Shrs_left(node);
1488         ir_node *right = get_Shrs_right(node);
1489         ir_mode *mode  = get_irn_mode(node);
1490
1491         if (is_Const(right) && mode == mode_Is) {
1492                 tarval *tv = get_Const_tarval(right);
1493                 long val = get_tarval_long(tv);
1494                 if (val == 31) {
1495                         /* this is a sign extension */
1496                         ir_graph *irg    = current_ir_graph;
1497                         dbg_info *dbgi   = get_irn_dbg_info(node);
1498                         ir_node  *block  = be_transform_node(get_nodes_block(node));
1499                         ir_node  *op     = left;
1500                         ir_node  *new_op = be_transform_node(op);
1501                         ir_node  *pval   = new_rd_ia32_ProduceVal(dbgi, irg, block);
1502
1503                         be_dep_on_frame(pval);
1504                         return new_rd_ia32_Cltd(dbgi, irg, block, new_op, pval);
1505                 }
1506         }
1507
1508         /* 8 or 16 bit sign extension? */
1509         if (is_Const(right) && is_Shl(left) && mode == mode_Is) {
1510                 ir_node *shl_left  = get_Shl_left(left);
1511                 ir_node *shl_right = get_Shl_right(left);
1512                 if (is_Const(shl_right)) {
1513                         tarval *tv1 = get_Const_tarval(right);
1514                         tarval *tv2 = get_Const_tarval(shl_right);
1515                         if (tv1 == tv2 && tarval_is_long(tv1)) {
1516                                 long val = get_tarval_long(tv1);
1517                                 if (val == 16 || val == 24) {
1518                                         dbg_info *dbgi   = get_irn_dbg_info(node);
1519                                         ir_node  *block  = get_nodes_block(node);
1520                                         ir_mode  *src_mode;
1521                                         ir_node  *res;
1522
1523                                         if (val == 24) {
1524                                                 src_mode = mode_Bs;
1525                                         } else {
1526                                                 assert(val == 16);
1527                                                 src_mode = mode_Hs;
1528                                         }
1529                                         res = create_I2I_Conv(src_mode, mode_Is, dbgi, block,
1530                                                               shl_left, node);
1531
1532                                         return res;
1533                                 }
1534                         }
1535                 }
1536         }
1537
1538         return gen_shift_binop(node, left, right, new_rd_ia32_Sar, match_immediate);
1539 }
1540
1541
1542
1543 /**
1544  * Creates an ia32 Rol.
1545  *
1546  * @param op1   The first operator
1547  * @param op2   The second operator
1548  * @return The created ia32 RotL node
1549  */
1550 static ir_node *gen_Rol(ir_node *node, ir_node *op1, ir_node *op2)
1551 {
1552         return gen_shift_binop(node, op1, op2, new_rd_ia32_Rol, match_immediate);
1553 }
1554
1555
1556
1557 /**
1558  * Creates an ia32 Ror.
1559  * NOTE: There is no RotR with immediate because this would always be a RotL
1560  *       "imm-mode_size_bits" which can be pre-calculated.
1561  *
1562  * @param op1   The first operator
1563  * @param op2   The second operator
1564  * @return The created ia32 RotR node
1565  */
1566 static ir_node *gen_Ror(ir_node *node, ir_node *op1, ir_node *op2)
1567 {
1568         return gen_shift_binop(node, op1, op2, new_rd_ia32_Ror, match_immediate);
1569 }
1570
1571
1572
1573 /**
1574  * Creates an ia32 RotR or RotL (depending on the found pattern).
1575  *
1576  * @return The created ia32 RotL or RotR node
1577  */
1578 static ir_node *gen_Rotl(ir_node *node)
1579 {
1580         ir_node *rotate = NULL;
1581         ir_node *op1    = get_Rotl_left(node);
1582         ir_node *op2    = get_Rotl_right(node);
1583
1584         /* Firm has only RotL, so we are looking for a right (op2)
1585                  operand "-e+mode_size_bits" (it's an already modified "mode_size_bits-e",
1586                  that means we can create a RotR instead of an Add and a RotL */
1587
1588         if (is_Add(op2)) {
1589                 ir_node *add = op2;
1590                 ir_node *left = get_Add_left(add);
1591                 ir_node *right = get_Add_right(add);
1592                 if (is_Const(right)) {
1593                         tarval  *tv   = get_Const_tarval(right);
1594                         ir_mode *mode = get_irn_mode(node);
1595                         long     bits = get_mode_size_bits(mode);
1596
1597                         if (is_Minus(left) &&
1598                             tarval_is_long(tv)       &&
1599                             get_tarval_long(tv) == bits &&
1600                             bits                == 32)
1601                         {
1602                                 DB((dbg, LEVEL_1, "RotL into RotR ... "));
1603                                 rotate = gen_Ror(node, op1, get_Minus_op(left));
1604                         }
1605                 }
1606         }
1607
1608         if (rotate == NULL) {
1609                 rotate = gen_Rol(node, op1, op2);
1610         }
1611
1612         return rotate;
1613 }
1614
1615
1616
1617 /**
1618  * Transforms a Minus node.
1619  *
1620  * @return The created ia32 Minus node
1621  */
1622 static ir_node *gen_Minus(ir_node *node)
1623 {
1624         ir_node   *op    = get_Minus_op(node);
1625         ir_node   *block = be_transform_node(get_nodes_block(node));
1626         ir_graph  *irg   = current_ir_graph;
1627         dbg_info  *dbgi  = get_irn_dbg_info(node);
1628         ir_mode   *mode  = get_irn_mode(node);
1629         ir_entity *ent;
1630         ir_node   *new_node;
1631         int        size;
1632
1633         if (mode_is_float(mode)) {
1634                 ir_node *new_op = be_transform_node(op);
1635                 if (ia32_cg_config.use_sse2) {
1636                         /* TODO: non-optimal... if we have many xXors, then we should
1637                          * rather create a load for the const and use that instead of
1638                          * several AM nodes... */
1639                         ir_node *noreg_gp  = ia32_new_NoReg_gp(env_cg);
1640                         ir_node *noreg_xmm = ia32_new_NoReg_xmm(env_cg);
1641                         ir_node *nomem     = new_rd_NoMem(irg);
1642
1643                         new_node = new_rd_ia32_xXor(dbgi, irg, block, noreg_gp, noreg_gp,
1644                                                     nomem, new_op, noreg_xmm);
1645
1646                         size = get_mode_size_bits(mode);
1647                         ent  = ia32_gen_fp_known_const(size == 32 ? ia32_SSIGN : ia32_DSIGN);
1648
1649                         set_ia32_am_sc(new_node, ent);
1650                         set_ia32_op_type(new_node, ia32_AddrModeS);
1651                         set_ia32_ls_mode(new_node, mode);
1652                 } else {
1653                         new_node = new_rd_ia32_vfchs(dbgi, irg, block, new_op);
1654                 }
1655         } else {
1656                 new_node = gen_unop(node, op, new_rd_ia32_Neg, match_mode_neutral);
1657         }
1658
1659         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
1660
1661         return new_node;
1662 }
1663
1664 /**
1665  * Transforms a Not node.
1666  *
1667  * @return The created ia32 Not node
1668  */
1669 static ir_node *gen_Not(ir_node *node)
1670 {
1671         ir_node *op   = get_Not_op(node);
1672
1673         assert(get_irn_mode(node) != mode_b); /* should be lowered already */
1674         assert (! mode_is_float(get_irn_mode(node)));
1675
1676         return gen_unop(node, op, new_rd_ia32_Not, match_mode_neutral);
1677 }
1678
1679
1680
1681 /**
1682  * Transforms an Abs node.
1683  *
1684  * @return The created ia32 Abs node
1685  */
1686 static ir_node *gen_Abs(ir_node *node)
1687 {
1688         ir_node   *block     = get_nodes_block(node);
1689         ir_node   *new_block = be_transform_node(block);
1690         ir_node   *op        = get_Abs_op(node);
1691         ir_graph  *irg       = current_ir_graph;
1692         dbg_info  *dbgi      = get_irn_dbg_info(node);
1693         ir_mode   *mode      = get_irn_mode(node);
1694         ir_node   *noreg_gp  = ia32_new_NoReg_gp(env_cg);
1695         ir_node   *nomem     = new_NoMem();
1696         ir_node   *new_op;
1697         ir_node   *new_node;
1698         int        size;
1699         ir_entity *ent;
1700
1701         if (mode_is_float(mode)) {
1702                 new_op = be_transform_node(op);
1703
1704                 if (ia32_cg_config.use_sse2) {
1705                         ir_node *noreg_fp = ia32_new_NoReg_xmm(env_cg);
1706                         new_node = new_rd_ia32_xAnd(dbgi,irg, new_block, noreg_gp, noreg_gp,
1707                                                     nomem, new_op, noreg_fp);
1708
1709                         size = get_mode_size_bits(mode);
1710                         ent  = ia32_gen_fp_known_const(size == 32 ? ia32_SABS : ia32_DABS);
1711
1712                         set_ia32_am_sc(new_node, ent);
1713
1714                         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
1715
1716                         set_ia32_op_type(new_node, ia32_AddrModeS);
1717                         set_ia32_ls_mode(new_node, mode);
1718                 } else {
1719                         new_node = new_rd_ia32_vfabs(dbgi, irg, new_block, new_op);
1720                         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
1721                 }
1722         } else {
1723                 ir_node *xor, *pval, *sign_extension;
1724
1725                 if (get_mode_size_bits(mode) == 32) {
1726                         new_op = be_transform_node(op);
1727                 } else {
1728                         new_op = create_I2I_Conv(mode, mode_Is, dbgi, block, op, node);
1729                 }
1730
1731                 pval           = new_rd_ia32_ProduceVal(dbgi, irg, new_block);
1732                 sign_extension = new_rd_ia32_Cltd(dbgi, irg, new_block,
1733                                                            new_op, pval);
1734
1735                 be_dep_on_frame(pval);
1736                 SET_IA32_ORIG_NODE(sign_extension,ia32_get_old_node_name(env_cg, node));
1737
1738                 xor = new_rd_ia32_Xor(dbgi, irg, new_block, noreg_gp, noreg_gp,
1739                                       nomem, new_op, sign_extension);
1740                 SET_IA32_ORIG_NODE(xor, ia32_get_old_node_name(env_cg, node));
1741
1742                 new_node = new_rd_ia32_Sub(dbgi, irg, new_block, noreg_gp, noreg_gp,
1743                                            nomem, xor, sign_extension);
1744                 SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
1745         }
1746
1747         return new_node;
1748 }
1749
1750 /**
1751  * Create a bt instruction for x & (1 << n) and place it into the block of cmp.
1752  */
1753 static ir_node *gen_bt(ir_node *cmp, ir_node *x, ir_node *n)
1754 {
1755         dbg_info *dbgi      = get_irn_dbg_info(cmp);
1756         ir_node  *block     = get_nodes_block(cmp);
1757         ir_node  *new_block = be_transform_node(block);
1758         ir_node  *op1       = be_transform_node(x);
1759         ir_node  *op2       = be_transform_node(n);
1760
1761         return new_rd_ia32_Bt(dbgi, current_ir_graph, new_block, op1, op2);
1762 }
1763
1764 /**
1765  * Transform a node returning a "flag" result.
1766  *
1767  * @param node     the node to transform
1768  * @param pnc_out  the compare mode to use
1769  */
1770 static ir_node *get_flags_node(ir_node *node, pn_Cmp *pnc_out)
1771 {
1772         ir_node  *flags;
1773         ir_node  *new_op;
1774         ir_node  *noreg;
1775         ir_node  *nomem;
1776         ir_node  *new_block;
1777         dbg_info *dbgi;
1778
1779         /* we have a Cmp as input */
1780         if (is_Proj(node)) {
1781                 ir_node *pred = get_Proj_pred(node);
1782                 if (is_Cmp(pred)) {
1783                         pn_Cmp pnc = get_Proj_proj(node);
1784                         if (ia32_cg_config.use_bt && (pnc == pn_Cmp_Lg || pnc == pn_Cmp_Eq)) {
1785                                 ir_node *l = get_Cmp_left(pred);
1786                                 ir_node *r = get_Cmp_right(pred);
1787                                 if (is_And(l)) {
1788                                         ir_node *la = get_And_left(l);
1789                                         ir_node *ra = get_And_right(l);
1790                                         if (is_Shl(la)) {
1791                                                 ir_node *c = get_Shl_left(la);
1792                                                 if (is_Const_1(c) && (is_Const_0(r) || r == la)) {
1793                                                         /* (1 << n) & ra) */
1794                                                         ir_node *n = get_Shl_right(la);
1795                                                         flags    = gen_bt(pred, ra, n);
1796                                                         /* we must generate a Jc/Jnc jump */
1797                                                         pnc = pnc == pn_Cmp_Lg ? pn_Cmp_Lt : pn_Cmp_Ge;
1798                                                         if (r == la)
1799                                                                 pnc ^= pn_Cmp_Leg;
1800                                                         *pnc_out = ia32_pn_Cmp_unsigned | pnc;
1801                                                         return flags;
1802                                                 }
1803                                         }
1804                                         if (is_Shl(ra)) {
1805                                                 ir_node *c = get_Shl_left(ra);
1806                                                 if (is_Const_1(c) && (is_Const_0(r) || r == ra)) {
1807                                                         /* la & (1 << n)) */
1808                                                         ir_node *n = get_Shl_right(ra);
1809                                                         flags    = gen_bt(pred, la, n);
1810                                                         /* we must generate a Jc/Jnc jump */
1811                                                         pnc = pnc == pn_Cmp_Lg ? pn_Cmp_Lt : pn_Cmp_Ge;
1812                                                         if (r == ra)
1813                                                                 pnc ^= pn_Cmp_Leg;
1814                                                         *pnc_out = ia32_pn_Cmp_unsigned | pnc;
1815                                                         return flags;
1816                                                 }
1817                                         }
1818                                 }
1819                         }
1820                         flags    = be_transform_node(pred);
1821                         *pnc_out = pnc;
1822                         return flags;
1823                 }
1824         }
1825
1826         /* a mode_b value, we have to compare it against 0 */
1827         dbgi      = get_irn_dbg_info(node);
1828         new_block = be_transform_node(get_nodes_block(node));
1829         new_op    = be_transform_node(node);
1830         noreg     = ia32_new_NoReg_gp(env_cg);
1831         nomem     = new_NoMem();
1832         flags     = new_rd_ia32_Test(dbgi, current_ir_graph, new_block, noreg, noreg, nomem,
1833                                      new_op, new_op, /*is_permuted=*/0, /*cmp_unsigned=*/0);
1834         *pnc_out  = pn_Cmp_Lg;
1835         return flags;
1836 }
1837
1838 /**
1839  * Transforms a Load.
1840  *
1841  * @return the created ia32 Load node
1842  */
1843 static ir_node *gen_Load(ir_node *node)
1844 {
1845         ir_node  *old_block = get_nodes_block(node);
1846         ir_node  *block   = be_transform_node(old_block);
1847         ir_node  *ptr     = get_Load_ptr(node);
1848         ir_node  *mem     = get_Load_mem(node);
1849         ir_node  *new_mem = be_transform_node(mem);
1850         ir_node  *base;
1851         ir_node  *index;
1852         ir_graph *irg     = current_ir_graph;
1853         dbg_info *dbgi    = get_irn_dbg_info(node);
1854         ir_node  *noreg   = ia32_new_NoReg_gp(env_cg);
1855         ir_mode  *mode    = get_Load_mode(node);
1856         ir_mode  *res_mode;
1857         ir_node  *new_node;
1858         ia32_address_t addr;
1859
1860         /* construct load address */
1861         memset(&addr, 0, sizeof(addr));
1862         ia32_create_address_mode(&addr, ptr, /*force=*/0);
1863         base  = addr.base;
1864         index = addr.index;
1865
1866         if (base == NULL) {
1867                 base = noreg;
1868         } else {
1869                 base = be_transform_node(base);
1870         }
1871
1872         if (index == NULL) {
1873                 index = noreg;
1874         } else {
1875                 index = be_transform_node(index);
1876         }
1877
1878         if (mode_is_float(mode)) {
1879                 if (ia32_cg_config.use_sse2) {
1880                         new_node = new_rd_ia32_xLoad(dbgi, irg, block, base, index, new_mem,
1881                                                      mode);
1882                         res_mode = mode_xmm;
1883                 } else {
1884                         new_node = new_rd_ia32_vfld(dbgi, irg, block, base, index, new_mem,
1885                                                     mode);
1886                         res_mode = mode_vfp;
1887                 }
1888         } else {
1889                 assert(mode != mode_b);
1890
1891                 /* create a conv node with address mode for smaller modes */
1892                 if (get_mode_size_bits(mode) < 32) {
1893                         new_node = new_rd_ia32_Conv_I2I(dbgi, irg, block, base, index,
1894                                                         new_mem, noreg, mode);
1895                 } else {
1896                         new_node = new_rd_ia32_Load(dbgi, irg, block, base, index, new_mem);
1897                 }
1898                 res_mode = mode_Iu;
1899         }
1900
1901         set_irn_pinned(new_node, get_irn_pinned(node));
1902         set_ia32_op_type(new_node, ia32_AddrModeS);
1903         set_ia32_ls_mode(new_node, mode);
1904         set_address(new_node, &addr);
1905
1906         if (get_irn_pinned(node) == op_pin_state_floats) {
1907                 add_ia32_flags(new_node, arch_irn_flags_rematerializable);
1908         }
1909
1910         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
1911
1912         be_dep_on_frame(new_node);
1913         return new_node;
1914 }
1915
1916 static int use_dest_am(ir_node *block, ir_node *node, ir_node *mem,
1917                        ir_node *ptr, ir_node *other)
1918 {
1919         ir_node *load;
1920
1921         if (!is_Proj(node))
1922                 return 0;
1923
1924         /* we only use address mode if we're the only user of the load */
1925         if (get_irn_n_edges(node) > 1)
1926                 return 0;
1927
1928         load = get_Proj_pred(node);
1929         if (!is_Load(load))
1930                 return 0;
1931         if (get_nodes_block(load) != block)
1932                 return 0;
1933
1934         /* store should have the same pointer as the load */
1935         if (get_Load_ptr(load) != ptr)
1936                 return 0;
1937
1938         /* don't do AM if other node inputs depend on the load (via mem-proj) */
1939         if (other != NULL                   &&
1940             get_nodes_block(other) == block &&
1941             heights_reachable_in_block(heights, other, load)) {
1942                 return 0;
1943         }
1944
1945         if (prevents_AM(block, load, mem))
1946                 return 0;
1947         /* Store should be attached to the load via mem */
1948         assert(heights_reachable_in_block(heights, mem, load));
1949
1950         return 1;
1951 }
1952
1953 static ir_node *dest_am_binop(ir_node *node, ir_node *op1, ir_node *op2,
1954                               ir_node *mem, ir_node *ptr, ir_mode *mode,
1955                               construct_binop_dest_func *func,
1956                               construct_binop_dest_func *func8bit,
1957                                                           match_flags_t flags)
1958 {
1959         ir_node  *src_block = get_nodes_block(node);
1960         ir_node  *block;
1961         ir_node  *noreg_gp  = ia32_new_NoReg_gp(env_cg);
1962         ir_graph *irg      = current_ir_graph;
1963         dbg_info *dbgi;
1964         ir_node  *new_mem;
1965         ir_node  *new_node;
1966         ir_node  *new_op;
1967         ir_node  *mem_proj;
1968         int       commutative;
1969         ia32_address_mode_t  am;
1970         ia32_address_t      *addr = &am.addr;
1971         memset(&am, 0, sizeof(am));
1972
1973         assert(flags & match_dest_am);
1974         assert(flags & match_immediate); /* there is no destam node without... */
1975         commutative = (flags & match_commutative) != 0;
1976
1977         if (use_dest_am(src_block, op1, mem, ptr, op2)) {
1978                 build_address(&am, op1);
1979                 new_op = create_immediate_or_transform(op2, 0);
1980         } else if (commutative && use_dest_am(src_block, op2, mem, ptr, op1)) {
1981                 build_address(&am, op2);
1982                 new_op = create_immediate_or_transform(op1, 0);
1983         } else {
1984                 return NULL;
1985         }
1986
1987         if (addr->base == NULL)
1988                 addr->base = noreg_gp;
1989         if (addr->index == NULL)
1990                 addr->index = noreg_gp;
1991         if (addr->mem == NULL)
1992                 addr->mem = new_NoMem();
1993
1994         dbgi    = get_irn_dbg_info(node);
1995         block   = be_transform_node(src_block);
1996         new_mem = transform_AM_mem(irg, block, am.am_node, mem, addr->mem);
1997
1998         if (get_mode_size_bits(mode) == 8) {
1999                 new_node = func8bit(dbgi, irg, block, addr->base, addr->index,
2000                                     new_mem, new_op);
2001         } else {
2002                 new_node = func(dbgi, irg, block, addr->base, addr->index, new_mem,
2003                                 new_op);
2004         }
2005         set_address(new_node, addr);
2006         set_ia32_op_type(new_node, ia32_AddrModeD);
2007         set_ia32_ls_mode(new_node, mode);
2008         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
2009
2010         be_set_transformed_node(get_Proj_pred(am.mem_proj), new_node);
2011         mem_proj = be_transform_node(am.mem_proj);
2012         be_set_transformed_node(mem_proj ? mem_proj : am.mem_proj, new_node);
2013
2014         return new_node;
2015 }
2016
2017 static ir_node *dest_am_unop(ir_node *node, ir_node *op, ir_node *mem,
2018                              ir_node *ptr, ir_mode *mode,
2019                              construct_unop_dest_func *func)
2020 {
2021         ir_graph *irg       = current_ir_graph;
2022         ir_node  *src_block = get_nodes_block(node);
2023         ir_node  *block;
2024         dbg_info *dbgi;
2025         ir_node  *new_mem;
2026         ir_node  *new_node;
2027         ir_node  *mem_proj;
2028         ia32_address_mode_t  am;
2029         ia32_address_t *addr = &am.addr;
2030         memset(&am, 0, sizeof(am));
2031
2032         if (!use_dest_am(src_block, op, mem, ptr, NULL))
2033                 return NULL;
2034
2035         build_address(&am, op);
2036
2037         dbgi     = get_irn_dbg_info(node);
2038         block    = be_transform_node(src_block);
2039         new_mem  = transform_AM_mem(irg, block, am.am_node, mem, addr->mem);
2040         new_node = func(dbgi, irg, block, addr->base, addr->index, new_mem);
2041         set_address(new_node, addr);
2042         set_ia32_op_type(new_node, ia32_AddrModeD);
2043         set_ia32_ls_mode(new_node, mode);
2044         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
2045
2046         be_set_transformed_node(get_Proj_pred(am.mem_proj), new_node);
2047         mem_proj = be_transform_node(am.mem_proj);
2048         be_set_transformed_node(mem_proj ? mem_proj : am.mem_proj, new_node);
2049
2050         return new_node;
2051 }
2052
2053 static ir_node *try_create_SetMem(ir_node *node, ir_node *ptr, ir_node *mem)
2054 {
2055         ir_mode  *mode        = get_irn_mode(node);
2056         ir_node  *mux_true    = get_Mux_true(node);
2057         ir_node  *mux_false   = get_Mux_false(node);
2058         ir_graph *irg;
2059         ir_node  *cond;
2060         ir_node  *new_mem;
2061         dbg_info *dbgi;
2062         ir_node  *block;
2063         ir_node  *new_block;
2064         ir_node  *flags;
2065         ir_node  *new_node;
2066         int       negated;
2067         pn_Cmp    pnc;
2068         ia32_address_t addr;
2069
2070         if (get_mode_size_bits(mode) != 8)
2071                 return NULL;
2072
2073         if (is_Const_1(mux_true) && is_Const_0(mux_false)) {
2074                 negated = 0;
2075         } else if (is_Const_0(mux_true) && is_Const_1(mux_false)) {
2076                 negated = 1;
2077         } else {
2078                 return NULL;
2079         }
2080
2081         build_address_ptr(&addr, ptr, mem);
2082
2083         irg       = current_ir_graph;
2084         dbgi      = get_irn_dbg_info(node);
2085         block     = get_nodes_block(node);
2086         new_block = be_transform_node(block);
2087         cond      = get_Mux_sel(node);
2088         flags     = get_flags_node(cond, &pnc);
2089         new_mem   = be_transform_node(mem);
2090         new_node  = new_rd_ia32_SetMem(dbgi, irg, new_block, addr.base,
2091                                        addr.index, addr.mem, flags, pnc, negated);
2092         set_address(new_node, &addr);
2093         set_ia32_op_type(new_node, ia32_AddrModeD);
2094         set_ia32_ls_mode(new_node, mode);
2095         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
2096
2097         return new_node;
2098 }
2099
2100 static ir_node *try_create_dest_am(ir_node *node)
2101 {
2102         ir_node  *val  = get_Store_value(node);
2103         ir_node  *mem  = get_Store_mem(node);
2104         ir_node  *ptr  = get_Store_ptr(node);
2105         ir_mode  *mode = get_irn_mode(val);
2106         unsigned  bits = get_mode_size_bits(mode);
2107         ir_node  *op1;
2108         ir_node  *op2;
2109         ir_node  *new_node;
2110
2111         /* handle only GP modes for now... */
2112         if (!ia32_mode_needs_gp_reg(mode))
2113                 return NULL;
2114
2115         for (;;) {
2116                 /* store must be the only user of the val node */
2117                 if (get_irn_n_edges(val) > 1)
2118                         return NULL;
2119                 /* skip pointless convs */
2120                 if (is_Conv(val)) {
2121                         ir_node *conv_op   = get_Conv_op(val);
2122                         ir_mode *pred_mode = get_irn_mode(conv_op);
2123                         if (!ia32_mode_needs_gp_reg(pred_mode))
2124                                 break;
2125                         if (pred_mode == mode_b || bits <= get_mode_size_bits(pred_mode)) {
2126                                 val = conv_op;
2127                                 continue;
2128                         }
2129                 }
2130                 break;
2131         }
2132
2133         /* value must be in the same block */
2134         if (get_nodes_block(node) != get_nodes_block(val))
2135                 return NULL;
2136
2137         switch (get_irn_opcode(val)) {
2138         case iro_Add:
2139                 op1      = get_Add_left(val);
2140                 op2      = get_Add_right(val);
2141                 if (ia32_cg_config.use_incdec) {
2142                         if (is_Const_1(op2)) {
2143                                 new_node = dest_am_unop(val, op1, mem, ptr, mode, new_rd_ia32_IncMem);
2144                                 break;
2145                         } else if (is_Const_Minus_1(op2)) {
2146                                 new_node = dest_am_unop(val, op1, mem, ptr, mode, new_rd_ia32_DecMem);
2147                                 break;
2148                         }
2149                 }
2150                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2151                                          new_rd_ia32_AddMem, new_rd_ia32_AddMem8Bit,
2152                                          match_dest_am | match_commutative |
2153                                          match_immediate);
2154                 break;
2155         case iro_Sub:
2156                 op1      = get_Sub_left(val);
2157                 op2      = get_Sub_right(val);
2158                 if (is_Const(op2)) {
2159                         ir_fprintf(stderr, "Optimisation warning: not-normalized sub ,C found\n");
2160                 }
2161                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2162                                          new_rd_ia32_SubMem, new_rd_ia32_SubMem8Bit,
2163                                          match_dest_am | match_immediate |
2164                                          match_immediate);
2165                 break;
2166         case iro_And:
2167                 op1      = get_And_left(val);
2168                 op2      = get_And_right(val);
2169                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2170                                          new_rd_ia32_AndMem, new_rd_ia32_AndMem8Bit,
2171                                          match_dest_am | match_commutative |
2172                                          match_immediate);
2173                 break;
2174         case iro_Or:
2175                 op1      = get_Or_left(val);
2176                 op2      = get_Or_right(val);
2177                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2178                                          new_rd_ia32_OrMem, new_rd_ia32_OrMem8Bit,
2179                                          match_dest_am | match_commutative |
2180                                          match_immediate);
2181                 break;
2182         case iro_Eor:
2183                 op1      = get_Eor_left(val);
2184                 op2      = get_Eor_right(val);
2185                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2186                                          new_rd_ia32_XorMem, new_rd_ia32_XorMem8Bit,
2187                                          match_dest_am | match_commutative |
2188                                          match_immediate);
2189                 break;
2190         case iro_Shl:
2191                 op1      = get_Shl_left(val);
2192                 op2      = get_Shl_right(val);
2193                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2194                                          new_rd_ia32_ShlMem, new_rd_ia32_ShlMem,
2195                                          match_dest_am | match_immediate);
2196                 break;
2197         case iro_Shr:
2198                 op1      = get_Shr_left(val);
2199                 op2      = get_Shr_right(val);
2200                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2201                                          new_rd_ia32_ShrMem, new_rd_ia32_ShrMem,
2202                                          match_dest_am | match_immediate);
2203                 break;
2204         case iro_Shrs:
2205                 op1      = get_Shrs_left(val);
2206                 op2      = get_Shrs_right(val);
2207                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2208                                          new_rd_ia32_SarMem, new_rd_ia32_SarMem,
2209                                          match_dest_am | match_immediate);
2210                 break;
2211         case iro_Rotl:
2212                 op1      = get_Rotl_left(val);
2213                 op2      = get_Rotl_right(val);
2214                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2215                                          new_rd_ia32_RolMem, new_rd_ia32_RolMem,
2216                                          match_dest_am | match_immediate);
2217                 break;
2218         /* TODO: match ROR patterns... */
2219         case iro_Mux:
2220                 new_node = try_create_SetMem(val, ptr, mem);
2221                 break;
2222         case iro_Minus:
2223                 op1      = get_Minus_op(val);
2224                 new_node = dest_am_unop(val, op1, mem, ptr, mode, new_rd_ia32_NegMem);
2225                 break;
2226         case iro_Not:
2227                 /* should be lowered already */
2228                 assert(mode != mode_b);
2229                 op1      = get_Not_op(val);
2230                 new_node = dest_am_unop(val, op1, mem, ptr, mode, new_rd_ia32_NotMem);
2231                 break;
2232         default:
2233                 return NULL;
2234         }
2235
2236         if (new_node != NULL) {
2237                 if (get_irn_pinned(new_node) != op_pin_state_pinned &&
2238                                 get_irn_pinned(node) == op_pin_state_pinned) {
2239                         set_irn_pinned(new_node, op_pin_state_pinned);
2240                 }
2241         }
2242
2243         return new_node;
2244 }
2245
2246 static int is_float_to_int_conv(const ir_node *node)
2247 {
2248         ir_mode  *mode = get_irn_mode(node);
2249         ir_node  *conv_op;
2250         ir_mode  *conv_mode;
2251
2252         if (mode != mode_Is && mode != mode_Hs)
2253                 return 0;
2254
2255         if (!is_Conv(node))
2256                 return 0;
2257         conv_op   = get_Conv_op(node);
2258         conv_mode = get_irn_mode(conv_op);
2259
2260         if (!mode_is_float(conv_mode))
2261                 return 0;
2262
2263         return 1;
2264 }
2265
2266 /**
2267  * Transform a Store(floatConst).
2268  *
2269  * @return the created ia32 Store node
2270  */
2271 static ir_node *gen_float_const_Store(ir_node *node, ir_node *cns)
2272 {
2273         ir_mode        *mode      = get_irn_mode(cns);
2274         unsigned        size      = get_mode_size_bytes(mode);
2275         tarval         *tv        = get_Const_tarval(cns);
2276         ir_node        *block     = get_nodes_block(node);
2277         ir_node        *new_block = be_transform_node(block);
2278         ir_node        *ptr       = get_Store_ptr(node);
2279         ir_node        *mem       = get_Store_mem(node);
2280         ir_graph       *irg       = current_ir_graph;
2281         dbg_info       *dbgi      = get_irn_dbg_info(node);
2282         int             ofs       = 0;
2283         size_t          i         = 0;
2284         ir_node        *ins[4];
2285         ia32_address_t  addr;
2286
2287         assert(size % 4 ==  0);
2288         assert(size     <= 16);
2289
2290         build_address_ptr(&addr, ptr, mem);
2291
2292         do {
2293                 unsigned val =
2294                          get_tarval_sub_bits(tv, ofs)            |
2295                         (get_tarval_sub_bits(tv, ofs + 1) <<  8) |
2296                         (get_tarval_sub_bits(tv, ofs + 2) << 16) |
2297                         (get_tarval_sub_bits(tv, ofs + 3) << 24);
2298                 ir_node *imm = create_Immediate(NULL, 0, val);
2299
2300                 ir_node *new_node = new_rd_ia32_Store(dbgi, irg, new_block, addr.base,
2301                         addr.index, addr.mem, imm);
2302
2303                 set_irn_pinned(new_node, get_irn_pinned(node));
2304                 set_ia32_op_type(new_node, ia32_AddrModeD);
2305                 set_ia32_ls_mode(new_node, mode_Iu);
2306                 set_address(new_node, &addr);
2307                 SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
2308
2309                 ins[i++] = new_node;
2310
2311                 size        -= 4;
2312                 ofs         += 4;
2313                 addr.offset += 4;
2314         } while (size != 0);
2315
2316         return i == 1 ? ins[0] : new_rd_Sync(dbgi, irg, new_block, i, ins);
2317 }
2318
2319 /**
2320  * Generate a vfist or vfisttp instruction.
2321  */
2322 static ir_node *gen_vfist(dbg_info *dbgi, ir_graph *irg, ir_node *block, ir_node *base, ir_node *index,
2323                           ir_node *mem,  ir_node *val, ir_node **fist)
2324 {
2325         ir_node *new_node;
2326
2327         if (ia32_cg_config.use_fisttp) {
2328                 /* Note: fisttp ALWAYS pop the tos. We have to ensure here that the value is copied
2329                 if other users exists */
2330                 const arch_register_class_t *reg_class = &ia32_reg_classes[CLASS_ia32_vfp];
2331                 ir_node *vfisttp = new_rd_ia32_vfisttp(dbgi, irg, block, base, index, mem, val);
2332                 ir_node *value   = new_r_Proj(irg, block, vfisttp, mode_E, pn_ia32_vfisttp_res);
2333                 be_new_Keep(reg_class, irg, block, 1, &value);
2334
2335                 new_node = new_r_Proj(irg, block, vfisttp, mode_M, pn_ia32_vfisttp_M);
2336                 *fist    = vfisttp;
2337         } else {
2338                 ir_node *trunc_mode = ia32_new_Fpu_truncate(env_cg);
2339
2340                 /* do a fist */
2341                 new_node = new_rd_ia32_vfist(dbgi, irg, block, base, index, mem, val, trunc_mode);
2342                 *fist    = new_node;
2343         }
2344         return new_node;
2345 }
2346 /**
2347  * Transforms a normal Store.
2348  *
2349  * @return the created ia32 Store node
2350  */
2351 static ir_node *gen_normal_Store(ir_node *node)
2352 {
2353         ir_node  *val       = get_Store_value(node);
2354         ir_mode  *mode      = get_irn_mode(val);
2355         ir_node  *block     = get_nodes_block(node);
2356         ir_node  *new_block = be_transform_node(block);
2357         ir_node  *ptr       = get_Store_ptr(node);
2358         ir_node  *mem       = get_Store_mem(node);
2359         ir_graph *irg       = current_ir_graph;
2360         dbg_info *dbgi      = get_irn_dbg_info(node);
2361         ir_node  *noreg     = ia32_new_NoReg_gp(env_cg);
2362         ir_node  *new_val, *new_node, *store;
2363         ia32_address_t addr;
2364
2365         /* check for destination address mode */
2366         new_node = try_create_dest_am(node);
2367         if (new_node != NULL)
2368                 return new_node;
2369
2370         /* construct store address */
2371         memset(&addr, 0, sizeof(addr));
2372         ia32_create_address_mode(&addr, ptr, /*force=*/0);
2373
2374         if (addr.base == NULL) {
2375                 addr.base = noreg;
2376         } else {
2377                 addr.base = be_transform_node(addr.base);
2378         }
2379
2380         if (addr.index == NULL) {
2381                 addr.index = noreg;
2382         } else {
2383                 addr.index = be_transform_node(addr.index);
2384         }
2385         addr.mem = be_transform_node(mem);
2386
2387         if (mode_is_float(mode)) {
2388                 /* Convs (and strict-Convs) before stores are unnecessary if the mode
2389                    is the same. */
2390                 while (is_Conv(val) && mode == get_irn_mode(val)) {
2391                         ir_node *op = get_Conv_op(val);
2392                         if (!mode_is_float(get_irn_mode(op)))
2393                                 break;
2394                         val = op;
2395                 }
2396                 new_val = be_transform_node(val);
2397                 if (ia32_cg_config.use_sse2) {
2398                         new_node = new_rd_ia32_xStore(dbgi, irg, new_block, addr.base,
2399                                                       addr.index, addr.mem, new_val);
2400                 } else {
2401                         new_node = new_rd_ia32_vfst(dbgi, irg, new_block, addr.base,
2402                                                     addr.index, addr.mem, new_val, mode);
2403                 }
2404                 store = new_node;
2405         } else if (!ia32_cg_config.use_sse2 && is_float_to_int_conv(val)) {
2406                 val = get_Conv_op(val);
2407
2408                 /* TODO: is this optimisation still necessary at all (middleend)? */
2409                 /* We can skip ALL float->float up-Convs (and strict-up-Convs) before stores. */
2410                 while (is_Conv(val)) {
2411                         ir_node *op = get_Conv_op(val);
2412                         if (!mode_is_float(get_irn_mode(op)))
2413                                 break;
2414                         if (get_mode_size_bits(get_irn_mode(op)) > get_mode_size_bits(get_irn_mode(val)))
2415                                 break;
2416                         val = op;
2417                 }
2418                 new_val  = be_transform_node(val);
2419                 new_node = gen_vfist(dbgi, irg, new_block, addr.base, addr.index, addr.mem, new_val, &store);
2420         } else {
2421                 new_val = create_immediate_or_transform(val, 0);
2422                 assert(mode != mode_b);
2423
2424                 if (get_mode_size_bits(mode) == 8) {
2425                         new_node = new_rd_ia32_Store8Bit(dbgi, irg, new_block, addr.base,
2426                                                          addr.index, addr.mem, new_val);
2427                 } else {
2428                         new_node = new_rd_ia32_Store(dbgi, irg, new_block, addr.base,
2429                                                      addr.index, addr.mem, new_val);
2430                 }
2431                 store = new_node;
2432         }
2433
2434         set_irn_pinned(store, get_irn_pinned(node));
2435         set_ia32_op_type(store, ia32_AddrModeD);
2436         set_ia32_ls_mode(store, mode);
2437
2438         set_address(store, &addr);
2439         SET_IA32_ORIG_NODE(store, ia32_get_old_node_name(env_cg, node));
2440
2441         return new_node;
2442 }
2443
2444 /**
2445  * Transforms a Store.
2446  *
2447  * @return the created ia32 Store node
2448  */
2449 static ir_node *gen_Store(ir_node *node)
2450 {
2451         ir_node  *val  = get_Store_value(node);
2452         ir_mode  *mode = get_irn_mode(val);
2453
2454         if (mode_is_float(mode) && is_Const(val)) {
2455                 int transform;
2456
2457                 /* we are storing a floating point constant */
2458                 if (ia32_cg_config.use_sse2) {
2459                         transform = !is_simple_sse_Const(val);
2460                 } else {
2461                         transform = !is_simple_x87_Const(val);
2462                 }
2463                 if (transform)
2464                         return gen_float_const_Store(node, val);
2465         }
2466         return gen_normal_Store(node);
2467 }
2468
2469 /**
2470  * Transforms a Switch.
2471  *
2472  * @return the created ia32 SwitchJmp node
2473  */
2474 static ir_node *create_Switch(ir_node *node)
2475 {
2476         ir_graph *irg        = current_ir_graph;
2477         dbg_info *dbgi       = get_irn_dbg_info(node);
2478         ir_node  *block      = be_transform_node(get_nodes_block(node));
2479         ir_node  *sel        = get_Cond_selector(node);
2480         ir_node  *new_sel    = be_transform_node(sel);
2481         int       switch_min = INT_MAX;
2482         int       switch_max = INT_MIN;
2483         long      default_pn = get_Cond_defaultProj(node);
2484         ir_node  *new_node;
2485         const ir_edge_t *edge;
2486
2487         assert(get_mode_size_bits(get_irn_mode(sel)) == 32);
2488
2489         /* determine the smallest switch case value */
2490         foreach_out_edge(node, edge) {
2491                 ir_node *proj = get_edge_src_irn(edge);
2492                 long     pn   = get_Proj_proj(proj);
2493                 if (pn == default_pn)
2494                         continue;
2495
2496                 if (pn < switch_min)
2497                         switch_min = pn;
2498                 if (pn > switch_max)
2499                         switch_max = pn;
2500         }
2501
2502         if ((unsigned) (switch_max - switch_min) > 256000) {
2503                 panic("Size of switch %+F bigger than 256000", node);
2504         }
2505
2506         if (switch_min != 0) {
2507                 ir_node *noreg = ia32_new_NoReg_gp(env_cg);
2508
2509                 /* if smallest switch case is not 0 we need an additional sub */
2510                 new_sel = new_rd_ia32_Lea(dbgi, irg, block, new_sel, noreg);
2511                 add_ia32_am_offs_int(new_sel, -switch_min);
2512                 set_ia32_op_type(new_sel, ia32_AddrModeS);
2513
2514                 SET_IA32_ORIG_NODE(new_sel, ia32_get_old_node_name(env_cg, node));
2515         }
2516
2517         new_node = new_rd_ia32_SwitchJmp(dbgi, irg, block, new_sel, default_pn);
2518         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
2519
2520         return new_node;
2521 }
2522
2523 /**
2524  * Transform a Cond node.
2525  */
2526 static ir_node *gen_Cond(ir_node *node)
2527 {
2528         ir_node  *block     = get_nodes_block(node);
2529         ir_node  *new_block = be_transform_node(block);
2530         ir_graph *irg       = current_ir_graph;
2531         dbg_info *dbgi      = get_irn_dbg_info(node);
2532         ir_node  *sel       = get_Cond_selector(node);
2533         ir_mode  *sel_mode  = get_irn_mode(sel);
2534         ir_node  *flags     = NULL;
2535         ir_node  *new_node;
2536         pn_Cmp    pnc;
2537
2538         if (sel_mode != mode_b) {
2539                 return create_Switch(node);
2540         }
2541
2542         /* we get flags from a Cmp */
2543         flags = get_flags_node(sel, &pnc);
2544
2545         new_node = new_rd_ia32_Jcc(dbgi, irg, new_block, flags, pnc);
2546         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
2547
2548         return new_node;
2549 }
2550
2551 static ir_node *gen_be_Copy(ir_node *node)
2552 {
2553         ir_node *new_node = be_duplicate_node(node);
2554         ir_mode *mode     = get_irn_mode(new_node);
2555
2556         if (ia32_mode_needs_gp_reg(mode)) {
2557                 set_irn_mode(new_node, mode_Iu);
2558         }
2559
2560         return new_node;
2561 }
2562
2563 static ir_node *create_Fucom(ir_node *node)
2564 {
2565         ir_graph *irg       = current_ir_graph;
2566         dbg_info *dbgi      = get_irn_dbg_info(node);
2567         ir_node  *block     = get_nodes_block(node);
2568         ir_node  *new_block = be_transform_node(block);
2569         ir_node  *left      = get_Cmp_left(node);
2570         ir_node  *new_left  = be_transform_node(left);
2571         ir_node  *right     = get_Cmp_right(node);
2572         ir_node  *new_right;
2573         ir_node  *new_node;
2574
2575         if (ia32_cg_config.use_fucomi) {
2576                 new_right = be_transform_node(right);
2577                 new_node  = new_rd_ia32_vFucomi(dbgi, irg, new_block, new_left,
2578                                                 new_right, 0);
2579                 set_ia32_commutative(new_node);
2580                 SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
2581         } else {
2582                 if (ia32_cg_config.use_ftst && is_Const_0(right)) {
2583                         new_node = new_rd_ia32_vFtstFnstsw(dbgi, irg, new_block, new_left,
2584                                                            0);
2585                 } else {
2586                         new_right = be_transform_node(right);
2587                         new_node  = new_rd_ia32_vFucomFnstsw(dbgi, irg, new_block, new_left,
2588                                                                                                  new_right, 0);
2589                 }
2590
2591                 set_ia32_commutative(new_node);
2592
2593                 SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
2594
2595                 new_node = new_rd_ia32_Sahf(dbgi, irg, new_block, new_node);
2596                 SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
2597         }
2598
2599         return new_node;
2600 }
2601
2602 static ir_node *create_Ucomi(ir_node *node)
2603 {
2604         ir_graph *irg       = current_ir_graph;
2605         dbg_info *dbgi      = get_irn_dbg_info(node);
2606         ir_node  *src_block = get_nodes_block(node);
2607         ir_node  *new_block = be_transform_node(src_block);
2608         ir_node  *left      = get_Cmp_left(node);
2609         ir_node  *right     = get_Cmp_right(node);
2610         ir_node  *new_node;
2611         ia32_address_mode_t  am;
2612         ia32_address_t      *addr = &am.addr;
2613
2614         match_arguments(&am, src_block, left, right, NULL,
2615                         match_commutative | match_am);
2616
2617         new_node = new_rd_ia32_Ucomi(dbgi, irg, new_block, addr->base, addr->index,
2618                                      addr->mem, am.new_op1, am.new_op2,
2619                                      am.ins_permuted);
2620         set_am_attributes(new_node, &am);
2621
2622         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
2623
2624         new_node = fix_mem_proj(new_node, &am);
2625
2626         return new_node;
2627 }
2628
2629 /**
2630  * helper function: checks whether all Cmp projs are Lg or Eq which is needed
2631  * to fold an and into a test node
2632  */
2633 static bool can_fold_test_and(ir_node *node)
2634 {
2635         const ir_edge_t *edge;
2636
2637         /** we can only have eq and lg projs */
2638         foreach_out_edge(node, edge) {
2639                 ir_node *proj = get_edge_src_irn(edge);
2640                 pn_Cmp   pnc  = get_Proj_proj(proj);
2641                 if (pnc != pn_Cmp_Eq && pnc != pn_Cmp_Lg)
2642                         return false;
2643         }
2644
2645         return true;
2646 }
2647
2648 /**
2649  * returns true if it is assured, that the upper bits of a node are "clean"
2650  * which means for a 16 or 8 bit value, that the upper bits in the register
2651  * are 0 for unsigned and a copy of the last significant bit for signed
2652  * numbers.
2653  */
2654 static bool upper_bits_clean(ir_node *transformed_node, ir_mode *mode)
2655 {
2656         assert(ia32_mode_needs_gp_reg(mode));
2657         if (get_mode_size_bits(mode) >= 32)
2658                 return true;
2659
2660         if (is_Proj(transformed_node))
2661                 return upper_bits_clean(get_Proj_pred(transformed_node), mode);
2662
2663         if (is_ia32_Conv_I2I(transformed_node)
2664                         || is_ia32_Conv_I2I8Bit(transformed_node)) {
2665                 ir_mode *smaller_mode = get_ia32_ls_mode(transformed_node);
2666                 if (mode_is_signed(smaller_mode) != mode_is_signed(mode))
2667                         return false;
2668                 if (get_mode_size_bits(smaller_mode) > get_mode_size_bits(mode))
2669                         return false;
2670
2671                 return true;
2672         }
2673
2674         if (is_ia32_Shr(transformed_node) && !mode_is_signed(mode)) {
2675                 ir_node *right = get_irn_n(transformed_node, n_ia32_Shr_count);
2676                 if (is_ia32_Immediate(right) || is_ia32_Const(right)) {
2677                         const ia32_immediate_attr_t *attr
2678                                 = get_ia32_immediate_attr_const(right);
2679                         if (attr->symconst == 0
2680                                         && (unsigned) attr->offset >= (32 - get_mode_size_bits(mode))) {
2681                                 return true;
2682                         }
2683                 }
2684                 return upper_bits_clean(get_irn_n(transformed_node, n_ia32_Shr_val), mode);
2685         }
2686
2687         if (is_ia32_And(transformed_node) && !mode_is_signed(mode)) {
2688                 ir_node *right = get_irn_n(transformed_node, n_ia32_And_right);
2689                 if (is_ia32_Immediate(right) || is_ia32_Const(right)) {
2690                         const ia32_immediate_attr_t *attr
2691                                 = get_ia32_immediate_attr_const(right);
2692                         if (attr->symconst == 0
2693                                         && (unsigned) attr->offset
2694                                         <= (0xffffffff >> (32 - get_mode_size_bits(mode)))) {
2695                                 return true;
2696                         }
2697                 }
2698                 /* TODO recurse? */
2699         }
2700
2701         /* TODO recurse on Or, Xor, ... if appropriate? */
2702
2703         if (is_ia32_Immediate(transformed_node)
2704                         || is_ia32_Const(transformed_node)) {
2705                 const ia32_immediate_attr_t *attr
2706                         = get_ia32_immediate_attr_const(transformed_node);
2707                 if (mode_is_signed(mode)) {
2708                         long shifted = attr->offset >> (get_mode_size_bits(mode) - 1);
2709                         if (shifted == 0 || shifted == -1)
2710                                 return true;
2711                 } else {
2712                         unsigned long shifted = (unsigned long) attr->offset;
2713                         shifted >>= get_mode_size_bits(mode);
2714                         if (shifted == 0)
2715                                 return true;
2716                 }
2717         }
2718
2719         return false;
2720 }
2721
2722 /**
2723  * Generate code for a Cmp.
2724  */
2725 static ir_node *gen_Cmp(ir_node *node)
2726 {
2727         ir_graph *irg       = current_ir_graph;
2728         dbg_info *dbgi      = get_irn_dbg_info(node);
2729         ir_node  *block     = get_nodes_block(node);
2730         ir_node  *new_block = be_transform_node(block);
2731         ir_node  *left      = get_Cmp_left(node);
2732         ir_node  *right     = get_Cmp_right(node);
2733         ir_mode  *cmp_mode  = get_irn_mode(left);
2734         ir_node  *new_node;
2735         ia32_address_mode_t  am;
2736         ia32_address_t      *addr = &am.addr;
2737         int                  cmp_unsigned;
2738
2739         if (mode_is_float(cmp_mode)) {
2740                 if (ia32_cg_config.use_sse2) {
2741                         return create_Ucomi(node);
2742                 } else {
2743                         return create_Fucom(node);
2744                 }
2745         }
2746
2747         assert(ia32_mode_needs_gp_reg(cmp_mode));
2748
2749         /* Prefer the Test instruction, when encountering (x & y) ==/!= 0 */
2750         cmp_unsigned = !mode_is_signed(cmp_mode);
2751         if (is_Const_0(right)          &&
2752             is_And(left)               &&
2753             get_irn_n_edges(left) == 1 &&
2754             can_fold_test_and(node)) {
2755                 /* Test(and_left, and_right) */
2756                 ir_node *and_left  = get_And_left(left);
2757                 ir_node *and_right = get_And_right(left);
2758
2759                 /* matze: code here used mode instead of cmd_mode, I think it is always
2760                  * the same as cmp_mode, but I leave this here to see if this is really
2761                  * true...
2762                  */
2763                 assert(get_irn_mode(and_left) == cmp_mode);
2764
2765                 match_arguments(&am, block, and_left, and_right, NULL,
2766                                                                                 match_commutative |
2767                                                                                 match_am | match_8bit_am | match_16bit_am |
2768                                                                                 match_am_and_immediates | match_immediate |
2769                                                                                 match_8bit | match_16bit);
2770
2771                 /* use 32bit compare mode if possible since the opcode is smaller */
2772                 if (upper_bits_clean(am.new_op1, cmp_mode) &&
2773                     upper_bits_clean(am.new_op2, cmp_mode)) {
2774                         cmp_mode = mode_is_signed(cmp_mode) ? mode_Is : mode_Iu;
2775                 }
2776
2777                 if (get_mode_size_bits(cmp_mode) == 8) {
2778                         new_node = new_rd_ia32_Test8Bit(dbgi, irg, new_block, addr->base,
2779                                                         addr->index, addr->mem, am.new_op1,
2780                                                         am.new_op2, am.ins_permuted,
2781                                                         cmp_unsigned);
2782                 } else {
2783                         new_node = new_rd_ia32_Test(dbgi, irg, new_block, addr->base,
2784                                                     addr->index, addr->mem, am.new_op1,
2785                                                     am.new_op2, am.ins_permuted,
2786                                                                                 cmp_unsigned);
2787                 }
2788         } else {
2789                 /* Cmp(left, right) */
2790                 match_arguments(&am, block, left, right, NULL,
2791                                 match_commutative | match_am | match_8bit_am |
2792                                 match_16bit_am | match_am_and_immediates |
2793                                 match_immediate | match_8bit | match_16bit);
2794                 /* use 32bit compare mode if possible since the opcode is smaller */
2795                 if (upper_bits_clean(am.new_op1, cmp_mode) &&
2796                     upper_bits_clean(am.new_op2, cmp_mode)) {
2797                         cmp_mode = mode_is_signed(cmp_mode) ? mode_Is : mode_Iu;
2798                 }
2799
2800                 if (get_mode_size_bits(cmp_mode) == 8) {
2801                         new_node = new_rd_ia32_Cmp8Bit(dbgi, irg, new_block, addr->base,
2802                                                        addr->index, addr->mem, am.new_op1,
2803                                                        am.new_op2, am.ins_permuted,
2804                                                        cmp_unsigned);
2805                 } else {
2806                         new_node = new_rd_ia32_Cmp(dbgi, irg, new_block, addr->base,
2807                                                    addr->index, addr->mem, am.new_op1,
2808                                                    am.new_op2, am.ins_permuted, cmp_unsigned);
2809                 }
2810         }
2811         set_am_attributes(new_node, &am);
2812         set_ia32_ls_mode(new_node, cmp_mode);
2813
2814         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
2815
2816         new_node = fix_mem_proj(new_node, &am);
2817
2818         return new_node;
2819 }
2820
2821 static ir_node *create_CMov(ir_node *node, ir_node *flags, ir_node *new_flags,
2822                             pn_Cmp pnc)
2823 {
2824         ir_graph            *irg           = current_ir_graph;
2825         dbg_info            *dbgi          = get_irn_dbg_info(node);
2826         ir_node             *block         = get_nodes_block(node);
2827         ir_node             *new_block     = be_transform_node(block);
2828         ir_node             *val_true      = get_Mux_true(node);
2829         ir_node             *val_false     = get_Mux_false(node);
2830         ir_node             *new_node;
2831         match_flags_t        match_flags;
2832         ia32_address_mode_t  am;
2833         ia32_address_t      *addr;
2834
2835         assert(ia32_cg_config.use_cmov);
2836         assert(ia32_mode_needs_gp_reg(get_irn_mode(val_true)));
2837
2838         addr = &am.addr;
2839
2840         match_flags = match_commutative | match_am | match_16bit_am |
2841                       match_mode_neutral;
2842
2843         match_arguments(&am, block, val_false, val_true, flags, match_flags);
2844
2845         new_node = new_rd_ia32_CMov(dbgi, irg, new_block, addr->base, addr->index,
2846                                     addr->mem, am.new_op1, am.new_op2, new_flags,
2847                                     am.ins_permuted, pnc);
2848         set_am_attributes(new_node, &am);
2849
2850         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
2851
2852         new_node = fix_mem_proj(new_node, &am);
2853
2854         return new_node;
2855 }
2856
2857 /**
2858  * Creates a ia32 Setcc instruction.
2859  */
2860 static ir_node *create_set_32bit(dbg_info *dbgi, ir_node *new_block,
2861                                  ir_node *flags, pn_Cmp pnc, ir_node *orig_node,
2862                                  int ins_permuted)
2863 {
2864         ir_graph *irg   = current_ir_graph;
2865         ir_node  *noreg = ia32_new_NoReg_gp(env_cg);
2866         ir_node  *nomem = new_NoMem();
2867         ir_mode  *mode  = get_irn_mode(orig_node);
2868         ir_node  *new_node;
2869
2870         new_node = new_rd_ia32_Set(dbgi, irg, new_block, flags, pnc, ins_permuted);
2871         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, orig_node));
2872
2873         /* we might need to conv the result up */
2874         if (get_mode_size_bits(mode) > 8) {
2875                 new_node = new_rd_ia32_Conv_I2I8Bit(dbgi, irg, new_block, noreg, noreg,
2876                                                     nomem, new_node, mode_Bu);
2877                 SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, orig_node));
2878         }
2879
2880         return new_node;
2881 }
2882
2883 /**
2884  * Create instruction for an unsigned Difference or Zero.
2885  */
2886 static ir_node *create_Doz(ir_node *psi, ir_node *a, ir_node *b)
2887 {
2888         ir_graph *irg   = current_ir_graph;
2889         ir_mode  *mode  = get_irn_mode(psi);
2890         ir_node  *new_node, *sub, *sbb, *eflags, *block, *noreg, *tmpreg, *nomem;
2891         dbg_info *dbgi;
2892
2893         new_node = gen_binop(psi, a, b, new_rd_ia32_Sub,
2894                 match_mode_neutral | match_am | match_immediate | match_two_users);
2895
2896         block = get_nodes_block(new_node);
2897
2898         if (is_Proj(new_node)) {
2899                 sub = get_Proj_pred(new_node);
2900                 assert(is_ia32_Sub(sub));
2901         } else {
2902                 sub = new_node;
2903                 set_irn_mode(sub, mode_T);
2904                 new_node = new_rd_Proj(NULL, irg, block, sub, mode, pn_ia32_res);
2905         }
2906         eflags = new_rd_Proj(NULL, irg, block, sub, mode_Iu, pn_ia32_Sub_flags);
2907
2908         dbgi   = get_irn_dbg_info(psi);
2909         noreg  = ia32_new_NoReg_gp(env_cg);
2910         tmpreg = new_rd_ia32_ProduceVal(dbgi, irg, block);
2911         nomem  = new_NoMem();
2912         sbb    = new_rd_ia32_Sbb(dbgi, irg, block, noreg, noreg, nomem, tmpreg, tmpreg, eflags);
2913
2914         new_node = new_rd_ia32_And(dbgi, irg, block, noreg, noreg, nomem, new_node, sbb);
2915         set_ia32_commutative(new_node);
2916         return new_node;
2917 }
2918
2919 /**
2920  * Transforms a Mux node into CMov.
2921  *
2922  * @return The transformed node.
2923  */
2924 static ir_node *gen_Mux(ir_node *node)
2925 {
2926         dbg_info *dbgi        = get_irn_dbg_info(node);
2927         ir_node  *block       = get_nodes_block(node);
2928         ir_node  *new_block   = be_transform_node(block);
2929         ir_node  *mux_true    = get_Mux_true(node);
2930         ir_node  *mux_false   = get_Mux_false(node);
2931         ir_node  *cond        = get_Mux_sel(node);
2932         ir_mode  *mode        = get_irn_mode(node);
2933         pn_Cmp   pnc;
2934
2935         assert(get_irn_mode(cond) == mode_b);
2936
2937         /* Note: a Mux node uses a Load two times IFF it's used in the compare AND in the result */
2938         if (mode_is_float(mode)) {
2939                 ir_node  *cmp         = get_Proj_pred(cond);
2940                 ir_node  *cmp_left    = get_Cmp_left(cmp);
2941                 ir_node  *cmp_right   = get_Cmp_right(cmp);
2942                 pn_Cmp   pnc          = get_Proj_proj(cond);
2943
2944                 if (ia32_cg_config.use_sse2) {
2945                         if (pnc == pn_Cmp_Lt || pnc == pn_Cmp_Le) {
2946                                 if (cmp_left == mux_true && cmp_right == mux_false) {
2947                                         /* Mux(a <= b, a, b) => MIN */
2948                                         return gen_binop(node, cmp_left, cmp_right, new_rd_ia32_xMin,
2949                                          match_commutative | match_am | match_two_users);
2950                                 } else if (cmp_left == mux_false && cmp_right == mux_true) {
2951                                         /* Mux(a <= b, b, a) => MAX */
2952                                         return gen_binop(node, cmp_left, cmp_right, new_rd_ia32_xMax,
2953                                          match_commutative | match_am | match_two_users);
2954                                 }
2955                         } else if (pnc == pn_Cmp_Gt || pnc == pn_Cmp_Ge) {
2956                                 if (cmp_left == mux_true && cmp_right == mux_false) {
2957                                         /* Mux(a >= b, a, b) => MAX */
2958                                         return gen_binop(node, cmp_left, cmp_right, new_rd_ia32_xMax,
2959                                          match_commutative | match_am | match_two_users);
2960                                 } else if (cmp_left == mux_false && cmp_right == mux_true) {
2961                                         /* Mux(a >= b, b, a) => MIN */
2962                                         return gen_binop(node, cmp_left, cmp_right, new_rd_ia32_xMin,
2963                                          match_commutative | match_am | match_two_users);
2964                                 }
2965                         }
2966                 }
2967                 panic("cannot transform floating point Mux");
2968
2969         } else {
2970                 ir_node *flags;
2971                 ir_node *new_node;
2972
2973                 assert(ia32_mode_needs_gp_reg(mode));
2974
2975                 if (is_Proj(cond)) {
2976                         ir_node *cmp = get_Proj_pred(cond);
2977                         if (is_Cmp(cmp)) {
2978                                 ir_node  *cmp_left    = get_Cmp_left(cmp);
2979                                 ir_node  *cmp_right   = get_Cmp_right(cmp);
2980                                 pn_Cmp   pnc          = get_Proj_proj(cond);
2981
2982                                 /* check for unsigned Doz first */
2983                                 if ((pnc & pn_Cmp_Gt) && !mode_is_signed(mode) &&
2984                                         is_Const_0(mux_false) && is_Sub(mux_true) &&
2985                                         get_Sub_left(mux_true) == cmp_left && get_Sub_right(mux_true) == cmp_right) {
2986                                         /* Mux(a >=u b, a - b, 0) unsigned Doz */
2987                                         return create_Doz(node, cmp_left, cmp_right);
2988                                 } else if ((pnc & pn_Cmp_Lt) && !mode_is_signed(mode) &&
2989                                         is_Const_0(mux_true) && is_Sub(mux_false) &&
2990                                         get_Sub_left(mux_false) == cmp_left && get_Sub_right(mux_false) == cmp_right) {
2991                                         /* Mux(a <=u b, 0, a - b) unsigned Doz */
2992                                         return create_Doz(node, cmp_left, cmp_right);
2993                                 }
2994                         }
2995                 }
2996
2997                 flags = get_flags_node(cond, &pnc);
2998
2999                 if (is_Const(mux_true) && is_Const(mux_false)) {
3000                         /* both are const, good */
3001                         if (is_Const_1(mux_true) && is_Const_0(mux_false)) {
3002                                 new_node = create_set_32bit(dbgi, new_block, flags, pnc, node, /*is_premuted=*/0);
3003                         } else if (is_Const_0(mux_true) && is_Const_1(mux_false)) {
3004                                 new_node = create_set_32bit(dbgi, new_block, flags, pnc, node, /*is_premuted=*/1);
3005                         } else {
3006                                 /* Not that simple. */
3007                                 goto need_cmov;
3008                         }
3009                 } else {
3010 need_cmov:
3011                         new_node = create_CMov(node, cond, flags, pnc);
3012                 }
3013                 return new_node;
3014         }
3015 }
3016
3017
3018 /**
3019  * Create a conversion from x87 state register to general purpose.
3020  */
3021 static ir_node *gen_x87_fp_to_gp(ir_node *node)
3022 {
3023         ir_node         *block      = be_transform_node(get_nodes_block(node));
3024         ir_node         *op         = get_Conv_op(node);
3025         ir_node         *new_op     = be_transform_node(op);
3026         ia32_code_gen_t *cg         = env_cg;
3027         ir_graph        *irg        = current_ir_graph;
3028         dbg_info        *dbgi       = get_irn_dbg_info(node);
3029         ir_node         *noreg      = ia32_new_NoReg_gp(cg);
3030         ir_mode         *mode       = get_irn_mode(node);
3031         ir_node         *fist, *load, *mem;
3032
3033         mem = gen_vfist(dbgi, irg, block, get_irg_frame(irg), noreg, new_NoMem(), new_op, &fist);
3034         set_irn_pinned(fist, op_pin_state_floats);
3035         set_ia32_use_frame(fist);
3036         set_ia32_op_type(fist, ia32_AddrModeD);
3037
3038         assert(get_mode_size_bits(mode) <= 32);
3039         /* exception we can only store signed 32 bit integers, so for unsigned
3040            we store a 64bit (signed) integer and load the lower bits */
3041         if (get_mode_size_bits(mode) == 32 && !mode_is_signed(mode)) {
3042                 set_ia32_ls_mode(fist, mode_Ls);
3043         } else {
3044                 set_ia32_ls_mode(fist, mode_Is);
3045         }
3046         SET_IA32_ORIG_NODE(fist, ia32_get_old_node_name(cg, node));
3047
3048         /* do a Load */
3049         load = new_rd_ia32_Load(dbgi, irg, block, get_irg_frame(irg), noreg, mem);
3050
3051         set_irn_pinned(load, op_pin_state_floats);
3052         set_ia32_use_frame(load);
3053         set_ia32_op_type(load, ia32_AddrModeS);
3054         set_ia32_ls_mode(load, mode_Is);
3055         if (get_ia32_ls_mode(fist) == mode_Ls) {
3056                 ia32_attr_t *attr = get_ia32_attr(load);
3057                 attr->data.need_64bit_stackent = 1;
3058         } else {
3059                 ia32_attr_t *attr = get_ia32_attr(load);
3060                 attr->data.need_32bit_stackent = 1;
3061         }
3062         SET_IA32_ORIG_NODE(load, ia32_get_old_node_name(cg, node));
3063
3064         return new_r_Proj(irg, block, load, mode_Iu, pn_ia32_Load_res);
3065 }
3066
3067 /**
3068  * Creates a x87 strict Conv by placing a Store and a Load
3069  */
3070 static ir_node *gen_x87_strict_conv(ir_mode *tgt_mode, ir_node *node)
3071 {
3072         ir_node  *block    = get_nodes_block(node);
3073         ir_graph *irg      = current_ir_graph;
3074         dbg_info *dbgi     = get_irn_dbg_info(node);
3075         ir_node  *noreg    = ia32_new_NoReg_gp(env_cg);
3076         ir_node  *nomem    = new_NoMem();
3077         ir_node  *frame    = get_irg_frame(irg);
3078         ir_node  *store, *load;
3079         ir_node  *new_node;
3080
3081         store = new_rd_ia32_vfst(dbgi, irg, block, frame, noreg, nomem, node,
3082                                  tgt_mode);
3083         set_ia32_use_frame(store);
3084         set_ia32_op_type(store, ia32_AddrModeD);
3085         SET_IA32_ORIG_NODE(store, ia32_get_old_node_name(env_cg, node));
3086
3087         load = new_rd_ia32_vfld(dbgi, irg, block, frame, noreg, store,
3088                                 tgt_mode);
3089         set_ia32_use_frame(load);
3090         set_ia32_op_type(load, ia32_AddrModeS);
3091         SET_IA32_ORIG_NODE(load, ia32_get_old_node_name(env_cg, node));
3092
3093         new_node = new_r_Proj(irg, block, load, mode_E, pn_ia32_vfld_res);
3094         return new_node;
3095 }
3096
3097 /**
3098  * Create a conversion from general purpose to x87 register
3099  */
3100 static ir_node *gen_x87_gp_to_fp(ir_node *node, ir_mode *src_mode)
3101 {
3102         ir_node  *src_block = get_nodes_block(node);
3103         ir_node  *block     = be_transform_node(src_block);
3104         ir_graph *irg       = current_ir_graph;
3105         dbg_info *dbgi      = get_irn_dbg_info(node);
3106         ir_node  *op        = get_Conv_op(node);
3107         ir_node  *new_op    = NULL;
3108         ir_node  *noreg;
3109         ir_node  *nomem;
3110         ir_mode  *mode;
3111         ir_mode  *store_mode;
3112         ir_node  *fild;
3113         ir_node  *store;
3114         ir_node  *new_node;
3115         int       src_bits;
3116
3117         /* fild can use source AM if the operand is a signed 16bit or 32bit integer */
3118         if (src_mode == mode_Is || src_mode == mode_Hs) {
3119                 ia32_address_mode_t am;
3120
3121                 match_arguments(&am, src_block, NULL, op, NULL,
3122                                 match_am | match_try_am | match_16bit | match_16bit_am);
3123                 if (am.op_type == ia32_AddrModeS) {
3124                         ia32_address_t *addr = &am.addr;
3125
3126                         fild     = new_rd_ia32_vfild(dbgi, irg, block, addr->base,
3127                                                      addr->index, addr->mem);
3128                         new_node = new_r_Proj(irg, block, fild, mode_vfp,
3129                                               pn_ia32_vfild_res);
3130
3131                         set_am_attributes(fild, &am);
3132                         SET_IA32_ORIG_NODE(fild, ia32_get_old_node_name(env_cg, node));
3133
3134                         fix_mem_proj(fild, &am);
3135
3136                         return new_node;
3137                 }
3138         }
3139         if (new_op == NULL) {
3140                 new_op = be_transform_node(op);
3141         }
3142
3143         noreg  = ia32_new_NoReg_gp(env_cg);
3144         nomem  = new_NoMem();
3145         mode   = get_irn_mode(op);
3146
3147         /* first convert to 32 bit signed if necessary */
3148         src_bits = get_mode_size_bits(src_mode);
3149         if (src_bits == 8) {
3150                 new_op = new_rd_ia32_Conv_I2I8Bit(dbgi, irg, block, noreg, noreg, nomem,
3151                                                   new_op, src_mode);
3152                 SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env_cg, node));
3153                 mode = mode_Is;
3154         } else if (src_bits < 32) {
3155                 new_op = new_rd_ia32_Conv_I2I(dbgi, irg, block, noreg, noreg, nomem,
3156                                               new_op, src_mode);
3157                 SET_IA32_ORIG_NODE(new_op, ia32_get_old_node_name(env_cg, node));
3158                 mode = mode_Is;
3159         }
3160
3161         assert(get_mode_size_bits(mode) == 32);
3162
3163         /* do a store */
3164         store = new_rd_ia32_Store(dbgi, irg, block, get_irg_frame(irg), noreg, nomem,
3165                                   new_op);
3166
3167         set_ia32_use_frame(store);
3168         set_ia32_op_type(store, ia32_AddrModeD);
3169         set_ia32_ls_mode(store, mode_Iu);
3170
3171         /* exception for 32bit unsigned, do a 64bit spill+load */
3172         if (!mode_is_signed(mode)) {
3173                 ir_node *in[2];
3174                 /* store a zero */
3175                 ir_node *zero_const = create_Immediate(NULL, 0, 0);
3176
3177                 ir_node *zero_store = new_rd_ia32_Store(dbgi, irg, block,
3178                                                         get_irg_frame(irg), noreg, nomem,
3179                                                         zero_const);
3180
3181                 set_ia32_use_frame(zero_store);
3182                 set_ia32_op_type(zero_store, ia32_AddrModeD);
3183                 add_ia32_am_offs_int(zero_store, 4);
3184                 set_ia32_ls_mode(zero_store, mode_Iu);
3185
3186                 in[0] = zero_store;
3187                 in[1] = store;
3188
3189                 store      = new_rd_Sync(dbgi, irg, block, 2, in);
3190                 store_mode = mode_Ls;
3191         } else {
3192                 store_mode = mode_Is;
3193         }
3194
3195         /* do a fild */
3196         fild = new_rd_ia32_vfild(dbgi, irg, block, get_irg_frame(irg), noreg, store);
3197
3198         set_ia32_use_frame(fild);
3199         set_ia32_op_type(fild, ia32_AddrModeS);
3200         set_ia32_ls_mode(fild, store_mode);
3201
3202         new_node = new_r_Proj(irg, block, fild, mode_vfp, pn_ia32_vfild_res);
3203
3204         return new_node;
3205 }
3206
3207 /**
3208  * Create a conversion from one integer mode into another one
3209  */
3210 static ir_node *create_I2I_Conv(ir_mode *src_mode, ir_mode *tgt_mode,
3211                                 dbg_info *dbgi, ir_node *block, ir_node *op,
3212                                 ir_node *node)
3213 {
3214         ir_graph *irg       = current_ir_graph;
3215         int       src_bits  = get_mode_size_bits(src_mode);
3216         int       tgt_bits  = get_mode_size_bits(tgt_mode);
3217         ir_node  *new_block = be_transform_node(block);
3218         ir_node  *new_node;
3219         ir_mode  *smaller_mode;
3220         int       smaller_bits;
3221         ia32_address_mode_t  am;
3222         ia32_address_t      *addr = &am.addr;
3223
3224         (void) node;
3225         if (src_bits < tgt_bits) {
3226                 smaller_mode = src_mode;
3227                 smaller_bits = src_bits;
3228         } else {
3229                 smaller_mode = tgt_mode;
3230                 smaller_bits = tgt_bits;
3231         }
3232
3233 #ifdef DEBUG_libfirm
3234         if (is_Const(op)) {
3235                 ir_fprintf(stderr, "Optimisation warning: conv after constant %+F\n",
3236                            op);
3237         }
3238 #endif
3239
3240         match_arguments(&am, block, NULL, op, NULL,
3241                         match_8bit | match_16bit |
3242                         match_am | match_8bit_am | match_16bit_am);
3243
3244         if (upper_bits_clean(am.new_op2, smaller_mode)) {
3245                 /* unnecessary conv. in theory it shouldn't have been AM */
3246                 assert(is_ia32_NoReg_GP(addr->base));
3247                 assert(is_ia32_NoReg_GP(addr->index));
3248                 assert(is_NoMem(addr->mem));
3249                 assert(am.addr.offset == 0);
3250                 assert(am.addr.symconst_ent == NULL);
3251                 return am.new_op2;
3252         }
3253
3254         if (smaller_bits == 8) {
3255                 new_node = new_rd_ia32_Conv_I2I8Bit(dbgi, irg, new_block, addr->base,
3256                                                     addr->index, addr->mem, am.new_op2,
3257                                                     smaller_mode);
3258         } else {
3259                 new_node = new_rd_ia32_Conv_I2I(dbgi, irg, new_block, addr->base,
3260                                                 addr->index, addr->mem, am.new_op2,
3261                                                 smaller_mode);
3262         }
3263         set_am_attributes(new_node, &am);
3264         /* match_arguments assume that out-mode = in-mode, this isn't true here
3265          * so fix it */
3266         set_ia32_ls_mode(new_node, smaller_mode);
3267         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
3268         new_node = fix_mem_proj(new_node, &am);
3269         return new_node;
3270 }
3271
3272 /**
3273  * Transforms a Conv node.
3274  *
3275  * @return The created ia32 Conv node
3276  */
3277 static ir_node *gen_Conv(ir_node *node)
3278 {
3279         ir_node  *block     = get_nodes_block(node);
3280         ir_node  *new_block = be_transform_node(block);
3281         ir_node  *op        = get_Conv_op(node);
3282         ir_node  *new_op    = NULL;
3283         ir_graph *irg       = current_ir_graph;
3284         dbg_info *dbgi      = get_irn_dbg_info(node);
3285         ir_mode  *src_mode  = get_irn_mode(op);
3286         ir_mode  *tgt_mode  = get_irn_mode(node);
3287         int       src_bits  = get_mode_size_bits(src_mode);
3288         int       tgt_bits  = get_mode_size_bits(tgt_mode);
3289         ir_node  *noreg     = ia32_new_NoReg_gp(env_cg);
3290         ir_node  *nomem     = new_rd_NoMem(irg);
3291         ir_node  *res       = NULL;
3292
3293         if (src_mode == mode_b) {
3294                 assert(mode_is_int(tgt_mode) || mode_is_reference(tgt_mode));
3295                 /* nothing to do, we already model bools as 0/1 ints */
3296                 return be_transform_node(op);
3297         }
3298
3299         if (src_mode == tgt_mode) {
3300                 if (get_Conv_strict(node)) {
3301                         if (ia32_cg_config.use_sse2) {
3302                                 /* when we are in SSE mode, we can kill all strict no-op conversion */
3303                                 return be_transform_node(op);
3304                         }
3305                 } else {
3306                         /* this should be optimized already, but who knows... */
3307                         DEBUG_ONLY(ir_fprintf(stderr, "Debug warning: conv %+F is pointless\n", node));
3308                         DB((dbg, LEVEL_1, "killed Conv(mode, mode) ..."));
3309                         return be_transform_node(op);
3310                 }
3311         }
3312
3313         if (mode_is_float(src_mode)) {
3314                 new_op = be_transform_node(op);
3315                 /* we convert from float ... */
3316                 if (mode_is_float(tgt_mode)) {
3317                         if (src_mode == mode_E && tgt_mode == mode_D
3318                                         && !get_Conv_strict(node)) {
3319                                 DB((dbg, LEVEL_1, "killed Conv(mode, mode) ..."));
3320                                 return new_op;
3321                         }
3322
3323                         /* ... to float */
3324                         if (ia32_cg_config.use_sse2) {
3325                                 DB((dbg, LEVEL_1, "create Conv(float, float) ..."));
3326                                 res = new_rd_ia32_Conv_FP2FP(dbgi, irg, new_block, noreg, noreg,
3327                                                              nomem, new_op);
3328                                 set_ia32_ls_mode(res, tgt_mode);
3329                         } else {
3330                                 if (get_Conv_strict(node)) {
3331                                         res = gen_x87_strict_conv(tgt_mode, new_op);
3332                                         SET_IA32_ORIG_NODE(get_Proj_pred(res), ia32_get_old_node_name(env_cg, node));
3333                                         return res;
3334                                 }
3335                                 DB((dbg, LEVEL_1, "killed Conv(float, float) ..."));
3336                                 return new_op;
3337                         }
3338                 } else {
3339                         /* ... to int */
3340                         DB((dbg, LEVEL_1, "create Conv(float, int) ..."));
3341                         if (ia32_cg_config.use_sse2) {
3342                                 res = new_rd_ia32_Conv_FP2I(dbgi, irg, new_block, noreg, noreg,
3343                                                             nomem, new_op);
3344                                 set_ia32_ls_mode(res, src_mode);
3345                         } else {
3346                                 return gen_x87_fp_to_gp(node);
3347                         }
3348                 }
3349         } else {
3350                 /* we convert from int ... */
3351                 if (mode_is_float(tgt_mode)) {
3352                         /* ... to float */
3353                         DB((dbg, LEVEL_1, "create Conv(int, float) ..."));
3354                         if (ia32_cg_config.use_sse2) {
3355                                 new_op = be_transform_node(op);
3356                                 res = new_rd_ia32_Conv_I2FP(dbgi, irg, new_block, noreg, noreg,
3357                                                             nomem, new_op);
3358                                 set_ia32_ls_mode(res, tgt_mode);
3359                         } else {
3360                                 res = gen_x87_gp_to_fp(node, src_mode);
3361                                 if (get_Conv_strict(node)) {
3362                                         /* The strict-Conv is only necessary, if the int mode has more bits
3363                                          * than the float mantissa */
3364                                         size_t int_mantissa = get_mode_size_bits(src_mode) - (mode_is_signed(src_mode) ? 1 : 0);
3365                                         size_t float_mantissa;
3366                                         /* FIXME There is no way to get the mantissa size of a mode */
3367                                         switch (get_mode_size_bits(tgt_mode)) {
3368                                                 case 32: float_mantissa = 23 + 1; break; // + 1 for implicit 1
3369                                                 case 64: float_mantissa = 52 + 1; break;
3370                                                 case 80:
3371                                                 case 96: float_mantissa = 64;     break;
3372                                                 default: float_mantissa = 0;      break;
3373                                         }
3374                                         if (float_mantissa < int_mantissa) {
3375                                                 res = gen_x87_strict_conv(tgt_mode, res);
3376                                                 SET_IA32_ORIG_NODE(get_Proj_pred(res), ia32_get_old_node_name(env_cg, node));
3377                                         }
3378                                 }
3379                                 return res;
3380                         }
3381                 } else if (tgt_mode == mode_b) {
3382                         /* mode_b lowering already took care that we only have 0/1 values */
3383                         DB((dbg, LEVEL_1, "omitting unnecessary Conv(%+F, %+F) ...",
3384                             src_mode, tgt_mode));
3385                         return be_transform_node(op);
3386                 } else {
3387                         /* to int */
3388                         if (src_bits == tgt_bits) {
3389                                 DB((dbg, LEVEL_1, "omitting unnecessary Conv(%+F, %+F) ...",
3390                                     src_mode, tgt_mode));
3391                                 return be_transform_node(op);
3392                         }
3393
3394                         res = create_I2I_Conv(src_mode, tgt_mode, dbgi, block, op, node);
3395                         return res;
3396                 }
3397         }
3398
3399         return res;
3400 }
3401
3402 static ir_node *create_immediate_or_transform(ir_node *node,
3403                                               char immediate_constraint_type)
3404 {
3405         ir_node *new_node = try_create_Immediate(node, immediate_constraint_type);
3406         if (new_node == NULL) {
3407                 new_node = be_transform_node(node);
3408         }
3409         return new_node;
3410 }
3411
3412 /**
3413  * Transforms a FrameAddr into an ia32 Add.
3414  */
3415 static ir_node *gen_be_FrameAddr(ir_node *node)
3416 {
3417         ir_node  *block  = be_transform_node(get_nodes_block(node));
3418         ir_node  *op     = be_get_FrameAddr_frame(node);
3419         ir_node  *new_op = be_transform_node(op);
3420         ir_graph *irg    = current_ir_graph;
3421         dbg_info *dbgi   = get_irn_dbg_info(node);
3422         ir_node  *noreg  = ia32_new_NoReg_gp(env_cg);
3423         ir_node  *new_node;
3424
3425         new_node = new_rd_ia32_Lea(dbgi, irg, block, new_op, noreg);
3426         set_ia32_frame_ent(new_node, arch_get_frame_entity(node));
3427         set_ia32_use_frame(new_node);
3428
3429         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
3430
3431         return new_node;
3432 }
3433
3434 /**
3435  * In case SSE is used we need to copy the result from XMM0 to FPU TOS before return.
3436  */
3437 static ir_node *gen_be_Return(ir_node *node)
3438 {
3439         ir_graph  *irg     = current_ir_graph;
3440         ir_node   *ret_val = get_irn_n(node, be_pos_Return_val);
3441         ir_node   *ret_mem = get_irn_n(node, be_pos_Return_mem);
3442         ir_entity *ent     = get_irg_entity(irg);
3443         ir_type   *tp      = get_entity_type(ent);
3444         dbg_info  *dbgi;
3445         ir_node   *block;
3446         ir_type   *res_type;
3447         ir_mode   *mode;
3448         ir_node   *frame, *sse_store, *fld, *mproj, *barrier;
3449         ir_node   *new_barrier, *new_ret_val, *new_ret_mem;
3450         ir_node   *noreg;
3451         ir_node   **in;
3452         int       pn_ret_val, pn_ret_mem, arity, i;
3453
3454         assert(ret_val != NULL);
3455         if (be_Return_get_n_rets(node) < 1 || ! ia32_cg_config.use_sse2) {
3456                 return be_duplicate_node(node);
3457         }
3458
3459         res_type = get_method_res_type(tp, 0);
3460
3461         if (! is_Primitive_type(res_type)) {
3462                 return be_duplicate_node(node);
3463         }
3464
3465         mode = get_type_mode(res_type);
3466         if (! mode_is_float(mode)) {
3467                 return be_duplicate_node(node);
3468         }
3469
3470         assert(get_method_n_ress(tp) == 1);
3471
3472         pn_ret_val = get_Proj_proj(ret_val);
3473         pn_ret_mem = get_Proj_proj(ret_mem);
3474
3475         /* get the Barrier */
3476         barrier = get_Proj_pred(ret_val);
3477
3478         /* get result input of the Barrier */
3479         ret_val     = get_irn_n(barrier, pn_ret_val);
3480         new_ret_val = be_transform_node(ret_val);
3481
3482         /* get memory input of the Barrier */
3483         ret_mem     = get_irn_n(barrier, pn_ret_mem);
3484         new_ret_mem = be_transform_node(ret_mem);
3485
3486         frame = get_irg_frame(irg);
3487
3488         dbgi  = get_irn_dbg_info(barrier);
3489         block = be_transform_node(get_nodes_block(barrier));
3490
3491         noreg = ia32_new_NoReg_gp(env_cg);
3492
3493         /* store xmm0 onto stack */
3494         sse_store = new_rd_ia32_xStoreSimple(dbgi, irg, block, frame, noreg,
3495                                              new_ret_mem, new_ret_val);
3496         set_ia32_ls_mode(sse_store, mode);
3497         set_ia32_op_type(sse_store, ia32_AddrModeD);
3498         set_ia32_use_frame(sse_store);
3499
3500         /* load into x87 register */
3501         fld = new_rd_ia32_vfld(dbgi, irg, block, frame, noreg, sse_store, mode);
3502         set_ia32_op_type(fld, ia32_AddrModeS);
3503         set_ia32_use_frame(fld);
3504
3505         mproj = new_r_Proj(irg, block, fld, mode_M, pn_ia32_vfld_M);
3506         fld   = new_r_Proj(irg, block, fld, mode_vfp, pn_ia32_vfld_res);
3507
3508         /* create a new barrier */
3509         arity = get_irn_arity(barrier);
3510         in = alloca(arity * sizeof(in[0]));
3511         for (i = 0; i < arity; ++i) {
3512                 ir_node *new_in;
3513
3514                 if (i == pn_ret_val) {
3515                         new_in = fld;
3516                 } else if (i == pn_ret_mem) {
3517                         new_in = mproj;
3518                 } else {
3519                         ir_node *in = get_irn_n(barrier, i);
3520                         new_in = be_transform_node(in);
3521                 }
3522                 in[i] = new_in;
3523         }
3524
3525         new_barrier = new_ir_node(dbgi, irg, block,
3526                                   get_irn_op(barrier), get_irn_mode(barrier),
3527                                   arity, in);
3528         copy_node_attr(barrier, new_barrier);
3529         be_duplicate_deps(barrier, new_barrier);
3530         be_set_transformed_node(barrier, new_barrier);
3531
3532         /* transform normally */
3533         return be_duplicate_node(node);
3534 }
3535
3536 /**
3537  * Transform a be_AddSP into an ia32_SubSP.
3538  */
3539 static ir_node *gen_be_AddSP(ir_node *node)
3540 {
3541         ir_node  *sz = get_irn_n(node, be_pos_AddSP_size);
3542         ir_node  *sp = get_irn_n(node, be_pos_AddSP_old_sp);
3543
3544         return gen_binop(node, sp, sz, new_rd_ia32_SubSP,
3545                          match_am | match_immediate);
3546 }
3547
3548 /**
3549  * Transform a be_SubSP into an ia32_AddSP
3550  */
3551 static ir_node *gen_be_SubSP(ir_node *node)
3552 {
3553         ir_node  *sz = get_irn_n(node, be_pos_SubSP_size);
3554         ir_node  *sp = get_irn_n(node, be_pos_SubSP_old_sp);
3555
3556         return gen_binop(node, sp, sz, new_rd_ia32_AddSP,
3557                          match_am | match_immediate);
3558 }
3559
3560 /**
3561  * Change some phi modes
3562  */
3563 static ir_node *gen_Phi(ir_node *node)
3564 {
3565         ir_node  *block = be_transform_node(get_nodes_block(node));
3566         ir_graph *irg   = current_ir_graph;
3567         dbg_info *dbgi  = get_irn_dbg_info(node);
3568         ir_mode  *mode  = get_irn_mode(node);
3569         ir_node  *phi;
3570
3571         if (ia32_mode_needs_gp_reg(mode)) {
3572                 /* we shouldn't have any 64bit stuff around anymore */
3573                 assert(get_mode_size_bits(mode) <= 32);
3574                 /* all integer operations are on 32bit registers now */
3575                 mode = mode_Iu;
3576         } else if (mode_is_float(mode)) {
3577                 if (ia32_cg_config.use_sse2) {
3578                         mode = mode_xmm;
3579                 } else {
3580                         mode = mode_vfp;
3581                 }
3582         }
3583
3584         /* phi nodes allow loops, so we use the old arguments for now
3585          * and fix this later */
3586         phi = new_ir_node(dbgi, irg, block, op_Phi, mode, get_irn_arity(node),
3587                           get_irn_in(node) + 1);
3588         copy_node_attr(node, phi);
3589         be_duplicate_deps(node, phi);
3590
3591         be_enqueue_preds(node);
3592
3593         return phi;
3594 }
3595
3596 /**
3597  * Transform IJmp
3598  */
3599 static ir_node *gen_IJmp(ir_node *node)
3600 {
3601         ir_node  *block     = get_nodes_block(node);
3602         ir_node  *new_block = be_transform_node(block);
3603         dbg_info *dbgi      = get_irn_dbg_info(node);
3604         ir_node  *op        = get_IJmp_target(node);
3605         ir_node  *new_node;
3606         ia32_address_mode_t  am;
3607         ia32_address_t      *addr = &am.addr;
3608
3609         assert(get_irn_mode(op) == mode_P);
3610
3611         match_arguments(&am, block, NULL, op, NULL,
3612                         match_am | match_8bit_am | match_16bit_am |
3613                         match_immediate | match_8bit | match_16bit);
3614
3615         new_node = new_rd_ia32_IJmp(dbgi, current_ir_graph, new_block,
3616                                     addr->base, addr->index, addr->mem,
3617                                     am.new_op2);
3618         set_am_attributes(new_node, &am);
3619         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
3620
3621         new_node = fix_mem_proj(new_node, &am);
3622
3623         return new_node;
3624 }
3625
3626 /**
3627  * Transform a Bound node.
3628  */
3629 static ir_node *gen_Bound(ir_node *node)
3630 {
3631         ir_node  *new_node;
3632         ir_node  *lower = get_Bound_lower(node);
3633         dbg_info *dbgi  = get_irn_dbg_info(node);
3634
3635         if (is_Const_0(lower)) {
3636                 /* typical case for Java */
3637                 ir_node  *sub, *res, *flags, *block;
3638                 ir_graph *irg  = current_ir_graph;
3639
3640                 res = gen_binop(node, get_Bound_index(node), get_Bound_upper(node),
3641                         new_rd_ia32_Sub, match_mode_neutral     | match_am | match_immediate);
3642
3643                 block = get_nodes_block(res);
3644                 if (! is_Proj(res)) {
3645                         sub = res;
3646                         set_irn_mode(sub, mode_T);
3647                         res = new_rd_Proj(NULL, irg, block, sub, mode_Iu, pn_ia32_res);
3648                 } else {
3649                         sub = get_Proj_pred(res);
3650                 }
3651                 flags = new_rd_Proj(NULL, irg, block, sub, mode_Iu, pn_ia32_Sub_flags);
3652                 new_node = new_rd_ia32_Jcc(dbgi, irg, block, flags, pn_Cmp_Lt | ia32_pn_Cmp_unsigned);
3653                 SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
3654         } else {
3655                 panic("generic Bound not supported in ia32 Backend");
3656         }
3657         return new_node;
3658 }
3659
3660
3661 static ir_node *gen_ia32_l_ShlDep(ir_node *node)
3662 {
3663         ir_node *left  = get_irn_n(node, n_ia32_l_ShlDep_val);
3664         ir_node *right = get_irn_n(node, n_ia32_l_ShlDep_count);
3665
3666         return gen_shift_binop(node, left, right, new_rd_ia32_Shl,
3667                                match_immediate | match_mode_neutral);
3668 }
3669
3670 static ir_node *gen_ia32_l_ShrDep(ir_node *node)
3671 {
3672         ir_node *left  = get_irn_n(node, n_ia32_l_ShrDep_val);
3673         ir_node *right = get_irn_n(node, n_ia32_l_ShrDep_count);
3674         return gen_shift_binop(node, left, right, new_rd_ia32_Shr,
3675                                match_immediate);
3676 }
3677
3678 static ir_node *gen_ia32_l_SarDep(ir_node *node)
3679 {
3680         ir_node *left  = get_irn_n(node, n_ia32_l_SarDep_val);
3681         ir_node *right = get_irn_n(node, n_ia32_l_SarDep_count);
3682         return gen_shift_binop(node, left, right, new_rd_ia32_Sar,
3683                                match_immediate);
3684 }
3685
3686 static ir_node *gen_ia32_l_Add(ir_node *node)
3687 {
3688         ir_node *left    = get_irn_n(node, n_ia32_l_Add_left);
3689         ir_node *right   = get_irn_n(node, n_ia32_l_Add_right);
3690         ir_node *lowered = gen_binop(node, left, right, new_rd_ia32_Add,
3691                         match_commutative | match_am | match_immediate |
3692                         match_mode_neutral);
3693
3694         if (is_Proj(lowered)) {
3695                 lowered = get_Proj_pred(lowered);
3696         } else {
3697                 assert(is_ia32_Add(lowered));
3698                 set_irn_mode(lowered, mode_T);
3699         }
3700
3701         return lowered;
3702 }
3703
3704 static ir_node *gen_ia32_l_Adc(ir_node *node)
3705 {
3706         return gen_binop_flags(node, new_rd_ia32_Adc,
3707                         match_commutative | match_am | match_immediate |
3708                         match_mode_neutral);
3709 }
3710
3711 /**
3712  * Transforms a l_MulS into a "real" MulS node.
3713  *
3714  * @return the created ia32 Mul node
3715  */
3716 static ir_node *gen_ia32_l_Mul(ir_node *node)
3717 {
3718         ir_node *left  = get_binop_left(node);
3719         ir_node *right = get_binop_right(node);
3720
3721         return gen_binop(node, left, right, new_rd_ia32_Mul,
3722                          match_commutative | match_am | match_mode_neutral);
3723 }
3724
3725 /**
3726  * Transforms a l_IMulS into a "real" IMul1OPS node.
3727  *
3728  * @return the created ia32 IMul1OP node
3729  */
3730 static ir_node *gen_ia32_l_IMul(ir_node *node)
3731 {
3732         ir_node  *left  = get_binop_left(node);
3733         ir_node  *right = get_binop_right(node);
3734
3735         return gen_binop(node, left, right, new_rd_ia32_IMul1OP,
3736                          match_commutative | match_am | match_mode_neutral);
3737 }
3738
3739 static ir_node *gen_ia32_l_Sub(ir_node *node)
3740 {
3741         ir_node *left    = get_irn_n(node, n_ia32_l_Sub_minuend);
3742         ir_node *right   = get_irn_n(node, n_ia32_l_Sub_subtrahend);
3743         ir_node *lowered = gen_binop(node, left, right, new_rd_ia32_Sub,
3744                         match_am | match_immediate | match_mode_neutral);
3745
3746         if (is_Proj(lowered)) {
3747                 lowered = get_Proj_pred(lowered);
3748         } else {
3749                 assert(is_ia32_Sub(lowered));
3750                 set_irn_mode(lowered, mode_T);
3751         }
3752
3753         return lowered;
3754 }
3755
3756 static ir_node *gen_ia32_l_Sbb(ir_node *node)
3757 {
3758         return gen_binop_flags(node, new_rd_ia32_Sbb,
3759                         match_am | match_immediate | match_mode_neutral);
3760 }
3761
3762 /**
3763  * Transforms a l_ShlD/l_ShrD into a ShlD/ShrD. Those nodes have 3 data inputs:
3764  * op1 - target to be shifted
3765  * op2 - contains bits to be shifted into target
3766  * op3 - shift count
3767  * Only op3 can be an immediate.
3768  */
3769 static ir_node *gen_lowered_64bit_shifts(ir_node *node, ir_node *high,
3770                                          ir_node *low, ir_node *count)
3771 {
3772         ir_node  *block     = get_nodes_block(node);
3773         ir_node  *new_block = be_transform_node(block);
3774         ir_graph *irg       = current_ir_graph;
3775         dbg_info *dbgi      = get_irn_dbg_info(node);
3776         ir_node  *new_high  = be_transform_node(high);
3777         ir_node  *new_low   = be_transform_node(low);
3778         ir_node  *new_count;
3779         ir_node  *new_node;
3780
3781         /* the shift amount can be any mode that is bigger than 5 bits, since all
3782          * other bits are ignored anyway */
3783         while (is_Conv(count)              &&
3784                get_irn_n_edges(count) == 1 &&
3785                mode_is_int(get_irn_mode(count))) {
3786                 assert(get_mode_size_bits(get_irn_mode(count)) >= 5);
3787                 count = get_Conv_op(count);
3788         }
3789         new_count = create_immediate_or_transform(count, 0);
3790
3791         if (is_ia32_l_ShlD(node)) {
3792                 new_node = new_rd_ia32_ShlD(dbgi, irg, new_block, new_high, new_low,
3793                                             new_count);
3794         } else {
3795                 new_node = new_rd_ia32_ShrD(dbgi, irg, new_block, new_high, new_low,
3796                                             new_count);
3797         }
3798         SET_IA32_ORIG_NODE(new_node, ia32_get_old_node_name(env_cg, node));
3799
3800         return new_node;
3801 }
3802
3803 static ir_node *gen_ia32_l_ShlD(ir_node *node)
3804 {
3805         ir_node *high  = get_irn_n(node, n_ia32_l_ShlD_val_high);
3806         ir_node *low   = get_irn_n(node, n_ia32_l_ShlD_val_low);
3807         ir_node *count = get_irn_n(node, n_ia32_l_ShlD_count);
3808         return gen_lowered_64bit_shifts(node, high, low, count);
3809 }
3810
3811 static ir_node *gen_ia32_l_ShrD(ir_node *node)
3812 {
3813         ir_node *high  = get_irn_n(node, n_ia32_l_ShrD_val_high);
3814         ir_node *low   = get_irn_n(node, n_ia32_l_ShrD_val_low);
3815         ir_node *count = get_irn_n(node, n_ia32_l_ShrD_count);
3816         return gen_lowered_64bit_shifts(node, high, low, count);
3817 }
3818
3819 static ir_node *gen_ia32_l_LLtoFloat(ir_node *node)
3820 {
3821         ir_node  *src_block    = get_nodes_block(node);
3822         ir_node  *block        = be_transform_node(src_block);
3823         ir_graph *irg          = current_ir_graph;
3824         dbg_info *dbgi         = get_irn_dbg_info(node);
3825         ir_node  *frame        = get_irg_frame(irg);
3826         ir_node  *noreg        = ia32_new_NoReg_gp(env_cg);
3827         ir_node  *nomem        = new_NoMem();
3828         ir_node  *val_low      = get_irn_n(node, n_ia32_l_LLtoFloat_val_low);
3829         ir_node  *val_high     = get_irn_n(node, n_ia32_l_LLtoFloat_val_high);
3830         ir_node  *new_val_low  = be_transform_node(val_low);
3831         ir_node  *new_val_high = be_transform_node(val_high);
3832         ir_node  *in[2];
3833         ir_node  *sync;
3834         ir_node  *fild;
3835         ir_node  *store_low;
3836         ir_node  *store_high;
3837
3838         if (!mode_is_signed(get_irn_mode(val_high))) {
3839                 panic("unsigned long long -> float not supported yet (%+F)", node);
3840         }
3841
3842         /* do a store */
3843         store_low = new_rd_ia32_Store(dbgi, irg, block, frame, noreg, nomem,
3844                                       new_val_low);
3845         store_high = new_rd_ia32_Store(dbgi, irg, block, frame, noreg, nomem,
3846                                        new_val_high);
3847         SET_IA32_ORIG_NODE(store_low, ia32_get_old_node_name(env_cg, node));
3848         SET_IA32_ORIG_NODE(store_high, ia32_get_old_node_name(env_cg, node));
3849
3850         set_ia32_use_frame(store_low);
3851         set_ia32_use_frame(store_high);
3852         set_ia32_op_type(store_low, ia32_AddrModeD);
3853         set_ia32_op_type(store_high, ia32_AddrModeD);
3854         set_ia32_ls_mode(store_low, mode_Iu);
3855         set_ia32_ls_mode(store_high, mode_Is);
3856         add_ia32_am_offs_int(store_high, 4);
3857
3858         in[0] = store_low;
3859         in[1] = store_high;
3860         sync  = new_rd_Sync(dbgi, irg, block, 2, in);
3861
3862         /* do a fild */
3863         fild = new_rd_ia32_vfild(dbgi, irg, block, frame, noreg, sync);
3864
3865         set_ia32_use_frame(fild);
3866         set_ia32_op_type(fild, ia32_AddrModeS);
3867         set_ia32_ls_mode(fild, mode_Ls);
3868
3869         SET_IA32_ORIG_NODE(fild, ia32_get_old_node_name(env_cg, node));
3870
3871         return new_r_Proj(irg, block, fild, mode_vfp, pn_ia32_vfild_res);
3872 }
3873
3874 static ir_node *gen_ia32_l_FloattoLL(ir_node *node)
3875 {
3876         ir_node  *src_block  = get_nodes_block(node);
3877         ir_node  *block      = be_transform_node(src_block);
3878         ir_graph *irg        = current_ir_graph;
3879         dbg_info *dbgi       = get_irn_dbg_info(node);
3880         ir_node  *frame      = get_irg_frame(irg);
3881         ir_node  *noreg      = ia32_new_NoReg_gp(env_cg);
3882         ir_node  *nomem      = new_NoMem();
3883         ir_node  *val        = get_irn_n(node, n_ia32_l_FloattoLL_val);
3884         ir_node  *new_val    = be_transform_node(val);
3885         ir_node  *fist, *mem;
3886
3887         mem = gen_vfist(dbgi, irg, block, frame, noreg, nomem, new_val, &fist);
3888         SET_IA32_ORIG_NODE(fist, ia32_get_old_node_name(env_cg, node));
3889         set_ia32_use_frame(fist);
3890         set_ia32_op_type(fist, ia32_AddrModeD);
3891         set_ia32_ls_mode(fist, mode_Ls);
3892
3893         return mem;
3894 }
3895
3896 /**
3897  * the BAD transformer.
3898  */
3899 static ir_node *bad_transform(ir_node *node)
3900 {
3901         panic("No transform function for %+F available.", node);
3902         return NULL;
3903 }
3904
3905 static ir_node *gen_Proj_l_FloattoLL(ir_node *node)
3906 {
3907         ir_graph *irg      = current_ir_graph;
3908         ir_node  *block    = be_transform_node(get_nodes_block(node));
3909         ir_node  *pred     = get_Proj_pred(node);
3910         ir_node  *new_pred = be_transform_node(pred);
3911         ir_node  *frame    = get_irg_frame(irg);
3912         ir_node  *noreg    = ia32_new_NoReg_gp(env_cg);
3913         dbg_info *dbgi     = get_irn_dbg_info(node);
3914         long      pn       = get_Proj_proj(node);
3915         ir_node  *load;
3916         ir_node  *proj;
3917         ia32_attr_t *attr;
3918
3919         load = new_rd_ia32_Load(dbgi, irg, block, frame, noreg, new_pred);
3920         SET_IA32_ORIG_NODE(load, ia32_get_old_node_name(env_cg, node));
3921         set_ia32_use_frame(load);
3922         set_ia32_op_type(load, ia32_AddrModeS);
3923         set_ia32_ls_mode(load, mode_Iu);
3924         /* we need a 64bit stackslot (fist stores 64bit) even though we only load
3925          * 32 bit from it with this particular load */
3926         attr = get_ia32_attr(load);
3927         attr->data.need_64bit_stackent = 1;
3928
3929         if (pn == pn_ia32_l_FloattoLL_res_high) {
3930                 add_ia32_am_offs_int(load, 4);
3931         } else {
3932                 assert(pn == pn_ia32_l_FloattoLL_res_low);
3933         }
3934
3935         proj = new_r_Proj(irg, block, load, mode_Iu, pn_ia32_Load_res);
3936
3937         return proj;
3938 }
3939
3940 /**
3941  * Transform the Projs of an AddSP.
3942  */
3943 static ir_node *gen_Proj_be_AddSP(ir_node *node)
3944 {
3945         ir_node  *block    = be_transform_node(get_nodes_block(node));
3946         ir_node  *pred     = get_Proj_pred(node);
3947         ir_node  *new_pred = be_transform_node(pred);
3948         ir_graph *irg      = current_ir_graph;
3949         dbg_info *dbgi     = get_irn_dbg_info(node);
3950         long     proj      = get_Proj_proj(node);
3951
3952         if (proj == pn_be_AddSP_sp) {
3953                 ir_node *res = new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu,
3954                                            pn_ia32_SubSP_stack);
3955                 arch_set_irn_register(res, &ia32_gp_regs[REG_ESP]);
3956                 return res;
3957         } else if (proj == pn_be_AddSP_res) {
3958                 return new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu,
3959                                    pn_ia32_SubSP_addr);
3960         } else if (proj == pn_be_AddSP_M) {
3961                 return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_SubSP_M);
3962         }
3963
3964         panic("No idea how to transform proj->AddSP");
3965 }
3966
3967 /**
3968  * Transform the Projs of a SubSP.
3969  */
3970 static ir_node *gen_Proj_be_SubSP(ir_node *node)
3971 {
3972         ir_node  *block    = be_transform_node(get_nodes_block(node));
3973         ir_node  *pred     = get_Proj_pred(node);
3974         ir_node  *new_pred = be_transform_node(pred);
3975         ir_graph *irg      = current_ir_graph;
3976         dbg_info *dbgi     = get_irn_dbg_info(node);
3977         long     proj      = get_Proj_proj(node);
3978
3979         if (proj == pn_be_SubSP_sp) {
3980                 ir_node *res = new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu,
3981                                            pn_ia32_AddSP_stack);
3982                 arch_set_irn_register(res, &ia32_gp_regs[REG_ESP]);
3983                 return res;
3984         } else if (proj == pn_be_SubSP_M) {
3985                 return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_AddSP_M);
3986         }
3987
3988         panic("No idea how to transform proj->SubSP");
3989 }
3990
3991 /**
3992  * Transform and renumber the Projs from a Load.
3993  */
3994 static ir_node *gen_Proj_Load(ir_node *node)
3995 {
3996         ir_node  *new_pred;
3997         ir_node  *block    = be_transform_node(get_nodes_block(node));
3998         ir_node  *pred     = get_Proj_pred(node);
3999         ir_graph *irg      = current_ir_graph;
4000         dbg_info *dbgi     = get_irn_dbg_info(node);
4001         long     proj      = get_Proj_proj(node);
4002
4003         /* loads might be part of source address mode matches, so we don't
4004          * transform the ProjMs yet (with the exception of loads whose result is
4005          * not used)
4006          */
4007         if (is_Load(pred) && proj == pn_Load_M && get_irn_n_edges(pred) > 1) {
4008                 ir_node *res;
4009
4010                 /* this is needed, because sometimes we have loops that are only
4011                    reachable through the ProjM */
4012                 be_enqueue_preds(node);
4013                 /* do it in 2 steps, to silence firm verifier */
4014                 res = new_rd_Proj(dbgi, irg, block, pred, mode_M, pn_Load_M);
4015                 set_Proj_proj(res, pn_ia32_mem);
4016                 return res;
4017         }
4018
4019         /* renumber the proj */
4020         new_pred = be_transform_node(pred);
4021         if (is_ia32_Load(new_pred)) {
4022                 switch (proj) {
4023                 case pn_Load_res:
4024                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu, pn_ia32_Load_res);
4025                 case pn_Load_M:
4026                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_Load_M);
4027                 case pn_Load_X_regular:
4028                         return new_rd_Jmp(dbgi, irg, block);
4029                 case pn_Load_X_except:
4030                         /* This Load might raise an exception. Mark it. */
4031                         set_ia32_exc_label(new_pred, 1);
4032                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_X, pn_ia32_Load_X_exc);
4033                 default:
4034                         break;
4035                 }
4036         } else if (is_ia32_Conv_I2I(new_pred) ||
4037                    is_ia32_Conv_I2I8Bit(new_pred)) {
4038                 set_irn_mode(new_pred, mode_T);
4039                 if (proj == pn_Load_res) {
4040                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu, pn_ia32_res);
4041                 } else if (proj == pn_Load_M) {
4042                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_mem);
4043                 }
4044         } else if (is_ia32_xLoad(new_pred)) {
4045                 switch (proj) {
4046                 case pn_Load_res:
4047                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_xmm, pn_ia32_xLoad_res);
4048                 case pn_Load_M:
4049                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_xLoad_M);
4050                 case pn_Load_X_regular:
4051                         return new_rd_Jmp(dbgi, irg, block);
4052                 case pn_Load_X_except:
4053                         /* This Load might raise an exception. Mark it. */
4054                         set_ia32_exc_label(new_pred, 1);
4055                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_X, pn_ia32_xLoad_X_exc);
4056                 default:
4057                         break;
4058                 }
4059         } else if (is_ia32_vfld(new_pred)) {
4060                 switch (proj) {
4061                 case pn_Load_res:
4062                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_vfp, pn_ia32_vfld_res);
4063                 case pn_Load_M:
4064                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_vfld_M);
4065                 case pn_Load_X_regular:
4066                         return new_rd_Jmp(dbgi, irg, block);
4067                 case pn_Load_X_except:
4068                         /* This Load might raise an exception. Mark it. */
4069                         set_ia32_exc_label(new_pred, 1);
4070                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_X, pn_ia32_xLoad_X_exc);
4071                 default:
4072                         break;
4073                 }
4074         } else {
4075                 /* can happen for ProJMs when source address mode happened for the
4076                    node */
4077
4078                 /* however it should not be the result proj, as that would mean the
4079                    load had multiple users and should not have been used for
4080                    SourceAM */
4081                 if (proj != pn_Load_M) {
4082                         panic("internal error: transformed node not a Load");
4083                 }
4084                 return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, 1);
4085         }
4086
4087         panic("No idea how to transform proj");
4088 }
4089
4090 /**
4091  * Transform and renumber the Projs from a DivMod like instruction.
4092  */
4093 static ir_node *gen_Proj_DivMod(ir_node *node)
4094 {
4095         ir_node  *block    = be_transform_node(get_nodes_block(node));
4096         ir_node  *pred     = get_Proj_pred(node);
4097         ir_node  *new_pred = be_transform_node(pred);
4098         ir_graph *irg      = current_ir_graph;
4099         dbg_info *dbgi     = get_irn_dbg_info(node);
4100         long     proj      = get_Proj_proj(node);
4101
4102         assert(is_ia32_Div(new_pred) || is_ia32_IDiv(new_pred));
4103
4104         switch (get_irn_opcode(pred)) {
4105         case iro_Div:
4106                 switch (proj) {
4107                 case pn_Div_M:
4108                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_Div_M);
4109                 case pn_Div_res:
4110                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu, pn_ia32_Div_div_res);
4111                 case pn_Div_X_regular:
4112                         return new_rd_Jmp(dbgi, irg, block);
4113                 case pn_Div_X_except:
4114                         set_ia32_exc_label(new_pred, 1);
4115                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_X, pn_ia32_Div_X_exc);
4116                 default:
4117                         break;
4118                 }
4119                 break;
4120         case iro_Mod:
4121                 switch (proj) {
4122                 case pn_Mod_M:
4123                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_Div_M);
4124                 case pn_Mod_res:
4125                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu, pn_ia32_Div_mod_res);
4126                 case pn_Mod_X_except:
4127                         set_ia32_exc_label(new_pred, 1);
4128                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_X, pn_ia32_Div_X_exc);
4129                 default:
4130                         break;
4131                 }
4132                 break;
4133         case iro_DivMod:
4134                 switch (proj) {
4135                 case pn_DivMod_M:
4136                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_Div_M);
4137                 case pn_DivMod_res_div:
4138                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu, pn_ia32_Div_div_res);
4139                 case pn_DivMod_res_mod:
4140                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu, pn_ia32_Div_mod_res);
4141                 case pn_DivMod_X_regular:
4142                         return new_rd_Jmp(dbgi, irg, block);
4143                 case pn_DivMod_X_except:
4144                         set_ia32_exc_label(new_pred, 1);
4145                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_X, pn_ia32_Div_X_exc);
4146                 default:
4147                         break;
4148                 }
4149                 break;
4150         default:
4151                 break;
4152         }
4153
4154         panic("No idea how to transform proj->DivMod");
4155 }
4156
4157 /**
4158  * Transform and renumber the Projs from a CopyB.
4159  */
4160 static ir_node *gen_Proj_CopyB(ir_node *node)
4161 {
4162         ir_node  *block    = be_transform_node(get_nodes_block(node));
4163         ir_node  *pred     = get_Proj_pred(node);
4164         ir_node  *new_pred = be_transform_node(pred);
4165         ir_graph *irg      = current_ir_graph;
4166         dbg_info *dbgi     = get_irn_dbg_info(node);
4167         long     proj      = get_Proj_proj(node);
4168
4169         switch (proj) {
4170         case pn_CopyB_M_regular:
4171                 if (is_ia32_CopyB_i(new_pred)) {
4172                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_CopyB_i_M);
4173                 } else if (is_ia32_CopyB(new_pred)) {
4174                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_CopyB_M);
4175                 }
4176                 break;
4177         default:
4178                 break;
4179         }
4180
4181         panic("No idea how to transform proj->CopyB");
4182 }
4183
4184 /**
4185  * Transform and renumber the Projs from a Quot.
4186  */
4187 static ir_node *gen_Proj_Quot(ir_node *node)
4188 {
4189         ir_node  *block    = be_transform_node(get_nodes_block(node));
4190         ir_node  *pred     = get_Proj_pred(node);
4191         ir_node  *new_pred = be_transform_node(pred);
4192         ir_graph *irg      = current_ir_graph;
4193         dbg_info *dbgi     = get_irn_dbg_info(node);
4194         long     proj      = get_Proj_proj(node);
4195
4196         switch (proj) {
4197         case pn_Quot_M:
4198                 if (is_ia32_xDiv(new_pred)) {
4199                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_xDiv_M);
4200                 } else if (is_ia32_vfdiv(new_pred)) {
4201                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_vfdiv_M);
4202                 }
4203                 break;
4204         case pn_Quot_res:
4205                 if (is_ia32_xDiv(new_pred)) {
4206                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_xmm, pn_ia32_xDiv_res);
4207                 } else if (is_ia32_vfdiv(new_pred)) {
4208                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_vfp, pn_ia32_vfdiv_res);
4209                 }
4210                 break;
4211         case pn_Quot_X_regular:
4212         case pn_Quot_X_except:
4213         default:
4214                 break;
4215         }
4216
4217         panic("No idea how to transform proj->Quot");
4218 }
4219
4220 static ir_node *gen_be_Call(ir_node *node)
4221 {
4222         dbg_info       *const dbgi      = get_irn_dbg_info(node);
4223         ir_graph       *const irg       = current_ir_graph;
4224         ir_node        *const src_block = get_nodes_block(node);
4225         ir_node        *const block     = be_transform_node(src_block);
4226         ir_node        *const src_mem   = get_irn_n(node, be_pos_Call_mem);
4227         ir_node        *const src_sp    = get_irn_n(node, be_pos_Call_sp);
4228         ir_node        *const sp        = be_transform_node(src_sp);
4229         ir_node        *const src_ptr   = get_irn_n(node, be_pos_Call_ptr);
4230         ir_node        *const noreg     = ia32_new_NoReg_gp(env_cg);
4231         ia32_address_mode_t   am;
4232         ia32_address_t *const addr      = &am.addr;
4233         ir_node        *      mem;
4234         ir_node        *      call;
4235         int                   i;
4236         ir_node        *      fpcw;
4237         ir_node        *      eax       = noreg;
4238         ir_node        *      ecx       = noreg;
4239         ir_node        *      edx       = noreg;
4240         unsigned        const pop       = be_Call_get_pop(node);
4241         ir_type        *const call_tp   = be_Call_get_type(node);
4242
4243         /* Run the x87 simulator if the call returns a float value */
4244         if (get_method_n_ress(call_tp) > 0) {
4245                 ir_type *const res_type = get_method_res_type(call_tp, 0);
4246                 ir_mode *const res_mode = get_type_mode(res_type);
4247
4248                 if (res_mode != NULL && mode_is_float(res_mode)) {
4249                         env_cg->do_x87_sim = 1;
4250                 }
4251         }
4252
4253         /* We do not want be_Call direct calls */
4254         assert(be_Call_get_entity(node) == NULL);
4255
4256         match_arguments(&am, src_block, NULL, src_ptr, src_mem,
4257                         match_am | match_immediate);
4258
4259         i    = get_irn_arity(node) - 1;
4260         fpcw = be_transform_node(get_irn_n(node, i--));
4261         for (; i >= be_pos_Call_first_arg; --i) {
4262                 arch_register_req_t const *const req = arch_get_register_req(node, i);
4263                 ir_node *const reg_parm = be_transform_node(get_irn_n(node, i));
4264
4265                 assert(req->type == arch_register_req_type_limited);
4266                 assert(req->cls == &ia32_reg_classes[CLASS_ia32_gp]);
4267
4268                 switch (*req->limited) {
4269                         case 1 << REG_EAX: assert(eax == noreg); eax = reg_parm; break;
4270                         case 1 << REG_ECX: assert(ecx == noreg); ecx = reg_parm; break;
4271                         case 1 << REG_EDX: assert(edx == noreg); edx = reg_parm; break;
4272                         default: panic("Invalid GP register for register parameter");
4273                 }
4274         }
4275
4276         mem  = transform_AM_mem(irg, block, src_ptr, src_mem, addr->mem);
4277         call = new_rd_ia32_Call(dbgi, irg, block, addr->base, addr->index, mem,
4278                                 am.new_op2, sp, fpcw, eax, ecx, edx, pop, call_tp);
4279         set_am_attributes(call, &am);
4280         call = fix_mem_proj(call, &am);
4281
4282         if (get_irn_pinned(node) == op_pin_state_pinned)
4283                 set_irn_pinned(call, op_pin_state_pinned);
4284
4285         SET_IA32_ORIG_NODE(call, ia32_get_old_node_name(env_cg, node));
4286         return call;
4287 }
4288
4289 static ir_node *gen_be_IncSP(ir_node *node)
4290 {
4291         ir_node *res = be_duplicate_node(node);
4292         be_node_add_flags(res, -1, arch_irn_flags_modify_flags);
4293
4294         return res;
4295 }
4296
4297 /**
4298  * Transform the Projs from a be_Call.
4299  */
4300 static ir_node *gen_Proj_be_Call(ir_node *node)
4301 {
4302         ir_node  *block       = be_transform_node(get_nodes_block(node));
4303         ir_node  *call        = get_Proj_pred(node);
4304         ir_node  *new_call    = be_transform_node(call);
4305         ir_graph *irg         = current_ir_graph;
4306         dbg_info *dbgi        = get_irn_dbg_info(node);
4307         ir_type  *method_type = be_Call_get_type(call);
4308         int       n_res       = get_method_n_ress(method_type);
4309         long      proj        = get_Proj_proj(node);
4310         ir_mode  *mode        = get_irn_mode(node);
4311         ir_node  *sse_load;
4312         const arch_register_class_t *cls;
4313         ir_node                     *res;
4314
4315         /* The following is kinda tricky: If we're using SSE, then we have to
4316          * move the result value of the call in floating point registers to an
4317          * xmm register, we therefore construct a GetST0 -> xLoad sequence
4318          * after the call, we have to make sure to correctly make the
4319          * MemProj and the result Proj use these 2 nodes
4320          */
4321         if (proj == pn_be_Call_M_regular) {
4322                 // get new node for result, are we doing the sse load/store hack?
4323                 ir_node *call_res = be_get_Proj_for_pn(call, pn_be_Call_first_res);
4324                 ir_node *call_res_new;
4325                 ir_node *call_res_pred = NULL;
4326
4327                 if (call_res != NULL) {
4328                         call_res_new  = be_transform_node(call_res);
4329                         call_res_pred = get_Proj_pred(call_res_new);
4330                 }
4331
4332                 if (call_res_pred == NULL || is_ia32_Call(call_res_pred)) {
4333                         return new_rd_Proj(dbgi, irg, block, new_call, mode_M,
4334                                            n_ia32_Call_mem);
4335                 } else {
4336                         assert(is_ia32_xLoad(call_res_pred));
4337                         return new_rd_Proj(dbgi, irg, block, call_res_pred, mode_M,
4338                                            pn_ia32_xLoad_M);
4339                 }
4340         }
4341         if (ia32_cg_config.use_sse2 && proj >= pn_be_Call_first_res
4342                         && proj < (pn_be_Call_first_res + n_res) && mode_is_float(mode)) {
4343                 ir_node *fstp;
4344                 ir_node *frame = get_irg_frame(irg);
4345                 ir_node *noreg = ia32_new_NoReg_gp(env_cg);
4346                 //ir_node *p;
4347                 ir_node *call_mem = be_get_Proj_for_pn(call, pn_be_Call_M_regular);
4348                 ir_node *call_res;
4349
4350                 /* in case there is no memory output: create one to serialize the copy
4351                    FPU -> SSE */
4352                 call_mem = new_rd_Proj(dbgi, irg, block, new_call, mode_M,
4353                                        pn_be_Call_M_regular);
4354                 call_res = new_rd_Proj(dbgi, irg, block, new_call, mode,
4355                                        pn_be_Call_first_res);
4356
4357                 /* store st(0) onto stack */
4358                 fstp = new_rd_ia32_vfst(dbgi, irg, block, frame, noreg, call_mem,
4359                                         call_res, mode);
4360                 set_ia32_op_type(fstp, ia32_AddrModeD);
4361                 set_ia32_use_frame(fstp);
4362
4363                 /* load into SSE register */
4364                 sse_load = new_rd_ia32_xLoad(dbgi, irg, block, frame, noreg, fstp,
4365                                              mode);
4366                 set_ia32_op_type(sse_load, ia32_AddrModeS);
4367                 set_ia32_use_frame(sse_load);
4368
4369                 sse_load = new_rd_Proj(dbgi, irg, block, sse_load, mode_xmm,
4370                                        pn_ia32_xLoad_res);
4371
4372                 return sse_load;
4373         }
4374
4375         /* transform call modes */
4376         if (mode_is_data(mode)) {
4377                 cls  = arch_get_irn_reg_class(node, -1);
4378                 mode = cls->mode;
4379         }
4380
4381         /* Map from be_Call to ia32_Call proj number */
4382         if (proj == pn_be_Call_sp) {
4383                 proj = pn_ia32_Call_stack;
4384         } else if (proj == pn_be_Call_M_regular) {
4385                 proj = pn_ia32_Call_M;
4386         } else {
4387                 arch_register_req_t const *const req    = arch_get_register_req(node, BE_OUT_POS(proj));
4388                 int                        const n_outs = get_ia32_n_res(new_call);
4389                 int                              i;
4390
4391                 assert(proj      >= pn_be_Call_first_res);
4392                 assert(req->type == arch_register_req_type_limited);
4393
4394                 for (i = 0; i < n_outs; ++i) {
4395                         arch_register_req_t const *const new_req = get_ia32_out_req(new_call, i);
4396
4397                         if (new_req->type     != arch_register_req_type_limited ||
4398                             new_req->cls      != req->cls                       ||
4399                             *new_req->limited != *req->limited)
4400                                 continue;
4401
4402                         proj = i;
4403                         break;
4404                 }
4405                 assert(i < n_outs);
4406         }
4407
4408         res = new_rd_Proj(dbgi, irg, block, new_call, mode, proj);
4409
4410         /* TODO arch_set_irn_register() only operates on Projs, need variant with index */
4411         switch (proj) {
4412                 case pn_ia32_Call_stack:
4413                         arch_set_irn_register(res, &ia32_gp_regs[REG_ESP]);
4414                         break;
4415
4416                 case pn_ia32_Call_fpcw:
4417                         arch_set_irn_register(res, &ia32_fp_cw_regs[REG_FPCW]);
4418                         break;
4419         }
4420
4421         return res;
4422 }
4423
4424 /**
4425  * Transform the Projs from a Cmp.
4426  */
4427 static ir_node *gen_Proj_Cmp(ir_node *node)
4428 {
4429         /* this probably means not all mode_b nodes were lowered... */
4430         panic("trying to directly transform Proj_Cmp %+F (mode_b not lowered?)",
4431               node);
4432 }
4433
4434 /**
4435  * Transform the Projs from a Bound.
4436  */
4437 static ir_node *gen_Proj_Bound(ir_node *node)
4438 {
4439         ir_node *new_node, *block;
4440         ir_node *pred = get_Proj_pred(node);
4441
4442         switch (get_Proj_proj(node)) {
4443         case pn_Bound_M:
4444                 return be_transform_node(get_Bound_mem(pred));
4445         case pn_Bound_X_regular:
4446                 new_node = be_transform_node(pred);
4447                 block    = get_nodes_block(new_node);
4448                 return new_r_Proj(current_ir_graph, block, new_node, mode_X, pn_ia32_Jcc_true);
4449         case pn_Bound_X_except:
4450                 new_node = be_transform_node(pred);
4451                 block    = get_nodes_block(new_node);
4452                 return new_r_Proj(current_ir_graph, block, new_node, mode_X, pn_ia32_Jcc_false);
4453         case pn_Bound_res:
4454                 return be_transform_node(get_Bound_index(pred));
4455         default:
4456                 panic("unsupported Proj from Bound");
4457         }
4458 }
4459
4460 static ir_node *gen_Proj_ASM(ir_node *node)
4461 {
4462         ir_node *pred;
4463         ir_node *new_pred;
4464         ir_node *block;
4465
4466         if (get_irn_mode(node) != mode_M)
4467                 return be_duplicate_node(node);
4468
4469         pred     = get_Proj_pred(node);
4470         new_pred = be_transform_node(pred);
4471         block    = get_nodes_block(new_pred);
4472         return new_r_Proj(current_ir_graph, block, new_pred, mode_M,
4473                         get_ia32_n_res(new_pred) + 1);
4474 }
4475
4476 /**
4477  * Transform and potentially renumber Proj nodes.
4478  */
4479 static ir_node *gen_Proj(ir_node *node)
4480 {
4481         ir_node *pred = get_Proj_pred(node);
4482         long    proj;
4483
4484         switch (get_irn_opcode(pred)) {
4485         case iro_Store:
4486                 proj = get_Proj_proj(node);
4487                 if (proj == pn_Store_M) {
4488                         return be_transform_node(pred);
4489                 } else {
4490                         panic("No idea how to transform proj->Store");
4491                 }
4492         case iro_Load:
4493                 return gen_Proj_Load(node);
4494         case iro_ASM:
4495                 return gen_Proj_ASM(node);
4496         case iro_Div:
4497         case iro_Mod:
4498         case iro_DivMod:
4499                 return gen_Proj_DivMod(node);
4500         case iro_CopyB:
4501                 return gen_Proj_CopyB(node);
4502         case iro_Quot:
4503                 return gen_Proj_Quot(node);
4504         case beo_SubSP:
4505                 return gen_Proj_be_SubSP(node);
4506         case beo_AddSP:
4507                 return gen_Proj_be_AddSP(node);
4508         case beo_Call:
4509                 return gen_Proj_be_Call(node);
4510         case iro_Cmp:
4511                 return gen_Proj_Cmp(node);
4512         case iro_Bound:
4513                 return gen_Proj_Bound(node);
4514         case iro_Start:
4515                 proj = get_Proj_proj(node);
4516                 switch (proj) {
4517                         case pn_Start_X_initial_exec: {
4518                                 ir_node  *block     = get_nodes_block(pred);
4519                                 ir_node  *new_block = be_transform_node(block);
4520                                 dbg_info *dbgi      = get_irn_dbg_info(node);
4521                                 /* we exchange the ProjX with a jump */
4522                                 ir_node  *jump      = new_rd_Jmp(dbgi, current_ir_graph, new_block);
4523
4524                                 return jump;
4525                         }
4526
4527                         case pn_Start_P_tls:
4528                                 return gen_Proj_tls(node);
4529                 }
4530                 break;
4531
4532         default:
4533                 if (is_ia32_l_FloattoLL(pred)) {
4534                         return gen_Proj_l_FloattoLL(node);
4535 #ifdef FIRM_EXT_GRS
4536                 } else if (!is_ia32_irn(pred)) { // Quick hack for SIMD optimization
4537 #else
4538                 } else {
4539 #endif
4540                         ir_mode *mode = get_irn_mode(node);
4541                         if (ia32_mode_needs_gp_reg(mode)) {
4542                                 ir_node *new_pred = be_transform_node(pred);
4543                                 ir_node *block    = be_transform_node(get_nodes_block(node));
4544                                 ir_node *new_proj = new_r_Proj(current_ir_graph, block, new_pred,
4545                                                                                            mode_Iu, get_Proj_proj(node));
4546 #ifdef DEBUG_libfirm
4547                                 new_proj->node_nr = node->node_nr;
4548 #endif
4549                                 return new_proj;
4550                         }
4551                 }
4552         }
4553         return be_duplicate_node(node);
4554 }
4555
4556 /**
4557  * Enters all transform functions into the generic pointer
4558  */
4559 static void register_transformers(void)
4560 {
4561         ir_op *op_Mulh;
4562
4563         /* first clear the generic function pointer for all ops */
4564         clear_irp_opcodes_generic_func();
4565
4566 #define GEN(a)   { be_transform_func *func = gen_##a; op_##a->ops.generic = (op_func) func; }
4567 #define BAD(a)   op_##a->ops.generic = (op_func)bad_transform
4568
4569         GEN(Add);
4570         GEN(Sub);
4571         GEN(Mul);
4572         GEN(And);
4573         GEN(Or);
4574         GEN(Eor);
4575
4576         GEN(Shl);
4577         GEN(Shr);
4578         GEN(Shrs);
4579         GEN(Rotl);
4580
4581         GEN(Quot);
4582
4583         GEN(Div);
4584         GEN(Mod);
4585         GEN(DivMod);
4586
4587         GEN(Minus);
4588         GEN(Conv);
4589         GEN(Abs);
4590         GEN(Not);
4591
4592         GEN(Load);
4593         GEN(Store);
4594         GEN(Cond);
4595
4596         GEN(Cmp);
4597         GEN(ASM);
4598         GEN(CopyB);
4599         GEN(Mux);
4600         GEN(Proj);
4601         GEN(Phi);
4602         GEN(IJmp);
4603         GEN(Bound);
4604
4605         /* transform ops from intrinsic lowering */
4606         GEN(ia32_l_Add);
4607         GEN(ia32_l_Adc);
4608         GEN(ia32_l_Mul);
4609         GEN(ia32_l_IMul);
4610         GEN(ia32_l_ShlDep);
4611         GEN(ia32_l_ShrDep);
4612         GEN(ia32_l_SarDep);
4613         GEN(ia32_l_ShlD);
4614         GEN(ia32_l_ShrD);
4615         GEN(ia32_l_Sub);
4616         GEN(ia32_l_Sbb);
4617         GEN(ia32_l_LLtoFloat);
4618         GEN(ia32_l_FloattoLL);
4619
4620         GEN(Const);
4621         GEN(SymConst);
4622         GEN(Unknown);
4623
4624         /* we should never see these nodes */
4625         BAD(Raise);
4626         BAD(Sel);
4627         BAD(InstOf);
4628         BAD(Cast);
4629         BAD(Free);
4630         BAD(Tuple);
4631         BAD(Id);
4632         //BAD(Bad);
4633         BAD(Confirm);
4634         BAD(Filter);
4635         BAD(CallBegin);
4636         BAD(EndReg);
4637         BAD(EndExcept);
4638
4639         /* handle generic backend nodes */
4640         GEN(be_FrameAddr);
4641         GEN(be_Call);
4642         GEN(be_IncSP);
4643         GEN(be_Return);
4644         GEN(be_AddSP);
4645         GEN(be_SubSP);
4646         GEN(be_Copy);
4647
4648         op_Mulh = get_op_Mulh();
4649         if (op_Mulh)
4650                 GEN(Mulh);
4651
4652 #undef GEN
4653 #undef BAD
4654 }
4655
4656 /**
4657  * Pre-transform all unknown and noreg nodes.
4658  */
4659 static void ia32_pretransform_node(void)
4660 {
4661         ia32_code_gen_t *cg = env_cg;
4662
4663         cg->unknown_gp  = be_pre_transform_node(cg->unknown_gp);
4664         cg->unknown_vfp = be_pre_transform_node(cg->unknown_vfp);
4665         cg->unknown_xmm = be_pre_transform_node(cg->unknown_xmm);
4666         cg->noreg_gp    = be_pre_transform_node(cg->noreg_gp);
4667         cg->noreg_vfp   = be_pre_transform_node(cg->noreg_vfp);
4668         cg->noreg_xmm   = be_pre_transform_node(cg->noreg_xmm);
4669         get_fpcw();
4670 }
4671
4672 /**
4673  * Walker, checks if all ia32 nodes producing more than one result have their
4674  * Projs, otherwise creates new Projs and keeps them using a be_Keep node.
4675  */
4676 static void add_missing_keep_walker(ir_node *node, void *data)
4677 {
4678         int              n_outs, i;
4679         unsigned         found_projs = 0;
4680         const ir_edge_t *edge;
4681         ir_mode         *mode = get_irn_mode(node);
4682         ir_node         *last_keep;
4683         (void) data;
4684         if (mode != mode_T)
4685                 return;
4686         if (!is_ia32_irn(node))
4687                 return;
4688
4689         n_outs = get_ia32_n_res(node);
4690         if (n_outs <= 0)
4691                 return;
4692         if (is_ia32_SwitchJmp(node))
4693                 return;
4694
4695         assert(n_outs < (int) sizeof(unsigned) * 8);
4696         foreach_out_edge(node, edge) {
4697                 ir_node *proj = get_edge_src_irn(edge);
4698                 int      pn;
4699
4700                 /* The node could be kept */
4701                 if (is_End(proj))
4702                         continue;
4703
4704                 if (get_irn_mode(proj) == mode_M)
4705                         continue;
4706
4707                 pn = get_Proj_proj(proj);
4708                 assert(pn < n_outs);
4709                 found_projs |= 1 << pn;
4710         }
4711
4712
4713         /* are keeps missing? */
4714         last_keep = NULL;
4715         for (i = 0; i < n_outs; ++i) {
4716                 ir_node                     *block;
4717                 ir_node                     *in[1];
4718                 const arch_register_req_t   *req;
4719                 const arch_register_class_t *cls;
4720
4721                 if (found_projs & (1 << i)) {
4722                         continue;
4723                 }
4724
4725                 req = get_ia32_out_req(node, i);
4726                 cls = req->cls;
4727                 if (cls == NULL) {
4728                         continue;
4729                 }
4730                 if (cls == &ia32_reg_classes[CLASS_ia32_flags]) {
4731                         continue;
4732                 }
4733
4734                 block = get_nodes_block(node);
4735                 in[0] = new_r_Proj(current_ir_graph, block, node,
4736                                    arch_register_class_mode(cls), i);
4737                 if (last_keep != NULL) {
4738                         be_Keep_add_node(last_keep, cls, in[0]);
4739                 } else {
4740                         last_keep = be_new_Keep(cls, current_ir_graph, block, 1, in);
4741                         if (sched_is_scheduled(node)) {
4742                                 sched_add_after(node, last_keep);
4743                         }
4744                 }
4745         }
4746 }
4747
4748 /**
4749  * Adds missing keeps to nodes. Adds missing Proj nodes for unused outputs
4750  * and keeps them.
4751  */
4752 void ia32_add_missing_keeps(ia32_code_gen_t *cg)
4753 {
4754         ir_graph *irg = be_get_birg_irg(cg->birg);
4755         irg_walk_graph(irg, add_missing_keep_walker, NULL, NULL);
4756 }
4757
4758 /* do the transformation */
4759 void ia32_transform_graph(ia32_code_gen_t *cg)
4760 {
4761         int cse_last;
4762
4763         register_transformers();
4764         env_cg       = cg;
4765         initial_fpcw = NULL;
4766
4767         BE_TIMER_PUSH(t_heights);
4768         heights      = heights_new(cg->irg);
4769         BE_TIMER_POP(t_heights);
4770         ia32_calculate_non_address_mode_nodes(cg->birg);
4771
4772         /* the transform phase is not safe for CSE (yet) because several nodes get
4773          * attributes set after their creation */
4774         cse_last = get_opt_cse();
4775         set_opt_cse(0);
4776
4777         be_transform_graph(cg->birg, ia32_pretransform_node);
4778
4779         set_opt_cse(cse_last);
4780
4781         ia32_free_non_address_mode_nodes();
4782         heights_free(heights);
4783         heights = NULL;
4784 }
4785
4786 void ia32_init_transform(void)
4787 {
4788         FIRM_DBG_REGISTER(dbg, "firm.be.ia32.transform");
4789 }