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

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