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

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