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