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