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