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