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 relation_to_condition_code(ir_relation relation,
1920                                                         ir_mode *mode)
1921 {
1922         if (mode_is_float(mode)) {
1923                 switch (relation) {
1924                 case ir_relation_equal:              return ia32_cc_float_equal;
1925                 case ir_relation_less:               return ia32_cc_float_below;
1926                 case ir_relation_less_equal:         return ia32_cc_float_below_equal;
1927                 case ir_relation_greater:            return ia32_cc_float_above;
1928                 case ir_relation_greater_equal:      return ia32_cc_float_above_equal;
1929                 case ir_relation_less_greater:       return ia32_cc_not_equal;
1930                 case ir_relation_less_equal_greater: return ia32_cc_not_parity;
1931                 case ir_relation_unordered:          return ia32_cc_parity;
1932                 case ir_relation_unordered_equal:    return ia32_cc_equal;
1933                 case ir_relation_unordered_less:   return ia32_cc_float_unordered_below;
1934                 case ir_relation_unordered_less_equal:
1935                                              return ia32_cc_float_unordered_below_equal;
1936                 case ir_relation_unordered_greater:
1937                                              return ia32_cc_float_unordered_above;
1938                 case ir_relation_unordered_greater_equal:
1939                                              return ia32_cc_float_unordered_above_equal;
1940                 case ir_relation_unordered_less_greater:
1941                                              return ia32_cc_float_not_equal;
1942                 case ir_relation_false:
1943                 case ir_relation_true:
1944                         /* should we introduce a jump always/jump never? */
1945                         break;
1946                 }
1947                 panic("Unexpected float pnc");
1948         } else if (mode_is_signed(mode)) {
1949                 switch (relation) {
1950                 case ir_relation_unordered_equal:
1951                 case ir_relation_equal:                return ia32_cc_equal;
1952                 case ir_relation_unordered_less:
1953                 case ir_relation_less:                 return ia32_cc_less;
1954                 case ir_relation_unordered_less_equal:
1955                 case ir_relation_less_equal:           return ia32_cc_less_equal;
1956                 case ir_relation_unordered_greater:
1957                 case ir_relation_greater:              return ia32_cc_greater;
1958                 case ir_relation_unordered_greater_equal:
1959                 case ir_relation_greater_equal:        return ia32_cc_greater_equal;
1960                 case ir_relation_unordered_less_greater:
1961                 case ir_relation_less_greater:         return ia32_cc_not_equal;
1962                 case ir_relation_less_equal_greater:
1963                 case ir_relation_unordered:
1964                 case ir_relation_false:
1965                 case ir_relation_true:
1966                         /* introduce jump always/jump never? */
1967                         break;
1968                 }
1969                 panic("Unexpected pnc");
1970         } else {
1971                 switch (relation) {
1972                 case ir_relation_unordered_equal:
1973                 case ir_relation_equal:         return ia32_cc_equal;
1974                 case ir_relation_unordered_less:
1975                 case ir_relation_less:          return ia32_cc_below;
1976                 case ir_relation_unordered_less_equal:
1977                 case ir_relation_less_equal:    return ia32_cc_below_equal;
1978                 case ir_relation_unordered_greater:
1979                 case ir_relation_greater:       return ia32_cc_above;
1980                 case ir_relation_unordered_greater_equal:
1981                 case ir_relation_greater_equal: return ia32_cc_above_equal;
1982                 case ir_relation_unordered_less_greater:
1983                 case ir_relation_less_greater:  return ia32_cc_not_equal;
1984                 case ir_relation_less_equal_greater:
1985                 case ir_relation_unordered:
1986                 case ir_relation_false:
1987                 case ir_relation_true:
1988                         /* introduce jump always/jump never? */
1989                         break;
1990                 }
1991                 panic("Unexpected pnc");
1992         }
1993 }
1994
1995 static ir_node *get_flags_mode_b(ir_node *node, ia32_condition_code_t *cc_out)
1996 {
1997         /* a mode_b value, we have to compare it against 0 */
1998         dbg_info *dbgi      = get_irn_dbg_info(node);
1999         ir_node  *new_block = be_transform_node(get_nodes_block(node));
2000         ir_node  *new_op    = be_transform_node(node);
2001         ir_node  *flags     = new_bd_ia32_Test(dbgi, new_block, noreg_GP, noreg_GP, nomem, new_op, new_op, false);
2002         *cc_out  = ia32_cc_not_equal;
2003         return flags;
2004 }
2005
2006 static ir_node *get_flags_node_cmp(ir_node *cmp, ia32_condition_code_t *cc_out)
2007 {
2008         /* must have a Cmp as input */
2009         ir_relation relation = get_Cmp_relation(cmp);
2010         ir_relation possible;
2011         ir_node    *l        = get_Cmp_left(cmp);
2012         ir_node    *r        = get_Cmp_right(cmp);
2013         ir_mode    *mode     = get_irn_mode(l);
2014         ir_node    *flags;
2015
2016         /* check for bit-test */
2017         if (ia32_cg_config.use_bt && (relation == ir_relation_equal
2018                         || (mode_is_signed(mode) && relation == ir_relation_less_greater)
2019                         || (!mode_is_signed(mode) && ((relation & ir_relation_greater_equal) == ir_relation_greater)))
2020                     && 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 (relation & ir_relation_equal)
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         /* the middle-end tries to eliminate impossible relations, so a ptr != 0
2045          * test becomes ptr > 0. But for x86 an equal comparison is preferable to
2046          * a >0 (we can sometimes eliminate the cmp in favor of flags produced by
2047          * a predecessor node). So add the < bit */
2048         possible = ir_get_possible_cmp_relations(l, r);
2049         if (((relation & ir_relation_less) && !(possible & ir_relation_greater))
2050           || ((relation & ir_relation_greater) && !(possible & ir_relation_less)))
2051                 relation |= ir_relation_less_greater;
2052
2053         /* just do a normal transformation of the Cmp */
2054         *cc_out = relation_to_condition_code(relation, mode);
2055         flags   = be_transform_node(cmp);
2056         return flags;
2057 }
2058
2059 /**
2060  * Transform a node returning a "flag" result.
2061  *
2062  * @param node    the node to transform
2063  * @param cc_out  the compare mode to use
2064  */
2065 static ir_node *get_flags_node(ir_node *node, ia32_condition_code_t *cc_out)
2066 {
2067         if (is_Cmp(node))
2068                 return get_flags_node_cmp(node, cc_out);
2069         assert(get_irn_mode(node) == mode_b);
2070         return get_flags_mode_b(node, cc_out);
2071 }
2072
2073 /**
2074  * Transforms a Load.
2075  *
2076  * @return the created ia32 Load node
2077  */
2078 static ir_node *gen_Load(ir_node *node)
2079 {
2080         ir_node  *old_block = get_nodes_block(node);
2081         ir_node  *block     = be_transform_node(old_block);
2082         ir_node  *ptr       = get_Load_ptr(node);
2083         ir_node  *mem       = get_Load_mem(node);
2084         ir_node  *new_mem   = be_transform_node(mem);
2085         dbg_info *dbgi      = get_irn_dbg_info(node);
2086         ir_mode  *mode      = get_Load_mode(node);
2087         ir_node  *base;
2088         ir_node  *index;
2089         ir_node  *new_node;
2090         ia32_address_t addr;
2091
2092         /* construct load address */
2093         memset(&addr, 0, sizeof(addr));
2094         ia32_create_address_mode(&addr, ptr, ia32_create_am_normal);
2095         base  = addr.base;
2096         index = addr.index;
2097
2098         if (base == NULL) {
2099                 base = noreg_GP;
2100         } else {
2101                 base = be_transform_node(base);
2102         }
2103
2104         if (index == NULL) {
2105                 index = noreg_GP;
2106         } else {
2107                 index = be_transform_node(index);
2108         }
2109
2110         if (mode_is_float(mode)) {
2111                 if (ia32_cg_config.use_sse2) {
2112                         new_node = new_bd_ia32_xLoad(dbgi, block, base, index, new_mem,
2113                                                      mode);
2114                 } else {
2115                         new_node = new_bd_ia32_vfld(dbgi, block, base, index, new_mem,
2116                                                     mode);
2117                 }
2118         } else {
2119                 assert(mode != mode_b);
2120
2121                 /* create a conv node with address mode for smaller modes */
2122                 if (get_mode_size_bits(mode) < 32) {
2123                         new_node = new_bd_ia32_Conv_I2I(dbgi, block, base, index,
2124                                                         new_mem, noreg_GP, mode);
2125                 } else {
2126                         new_node = new_bd_ia32_Load(dbgi, block, base, index, new_mem);
2127                 }
2128         }
2129
2130         set_irn_pinned(new_node, get_irn_pinned(node));
2131         set_ia32_op_type(new_node, ia32_AddrModeS);
2132         set_ia32_ls_mode(new_node, mode);
2133         set_address(new_node, &addr);
2134
2135         if (get_irn_pinned(node) == op_pin_state_floats) {
2136                 assert((int)pn_ia32_xLoad_res == (int)pn_ia32_vfld_res
2137                                 && (int)pn_ia32_vfld_res == (int)pn_ia32_Load_res
2138                                 && (int)pn_ia32_Load_res == (int)pn_ia32_res);
2139                 arch_irn_add_flags(new_node, arch_irn_flags_rematerializable);
2140         }
2141
2142         SET_IA32_ORIG_NODE(new_node, node);
2143
2144         be_dep_on_frame(new_node);
2145         return new_node;
2146 }
2147
2148 static int use_dest_am(ir_node *block, ir_node *node, ir_node *mem,
2149                        ir_node *ptr, ir_node *other)
2150 {
2151         ir_node *load;
2152
2153         if (!is_Proj(node))
2154                 return 0;
2155
2156         /* we only use address mode if we're the only user of the load */
2157         if (get_irn_n_edges(node) > 1)
2158                 return 0;
2159
2160         load = get_Proj_pred(node);
2161         if (!is_Load(load))
2162                 return 0;
2163         if (get_nodes_block(load) != block)
2164                 return 0;
2165
2166         /* store should have the same pointer as the load */
2167         if (get_Load_ptr(load) != ptr)
2168                 return 0;
2169
2170         /* don't do AM if other node inputs depend on the load (via mem-proj) */
2171         if (other != NULL                   &&
2172             get_nodes_block(other) == block &&
2173             heights_reachable_in_block(ia32_heights, other, load)) {
2174                 return 0;
2175         }
2176
2177         if (ia32_prevents_AM(block, load, mem))
2178                 return 0;
2179         /* Store should be attached to the load via mem */
2180         assert(heights_reachable_in_block(ia32_heights, mem, load));
2181
2182         return 1;
2183 }
2184
2185 static ir_node *dest_am_binop(ir_node *node, ir_node *op1, ir_node *op2,
2186                               ir_node *mem, ir_node *ptr, ir_mode *mode,
2187                               construct_binop_dest_func *func,
2188                               construct_binop_dest_func *func8bit,
2189                                                           match_flags_t flags)
2190 {
2191         ir_node  *src_block = get_nodes_block(node);
2192         ir_node  *block;
2193         dbg_info *dbgi;
2194         ir_node  *new_mem;
2195         ir_node  *new_node;
2196         ir_node  *new_op;
2197         ir_node  *mem_proj;
2198         int       commutative;
2199         ia32_address_mode_t  am;
2200         ia32_address_t      *addr = &am.addr;
2201         memset(&am, 0, sizeof(am));
2202
2203         assert(flags & match_immediate); /* there is no destam node without... */
2204         commutative = (flags & match_commutative) != 0;
2205
2206         if (use_dest_am(src_block, op1, mem, ptr, op2)) {
2207                 build_address(&am, op1, ia32_create_am_double_use);
2208                 new_op = create_immediate_or_transform(op2, 0);
2209         } else if (commutative && use_dest_am(src_block, op2, mem, ptr, op1)) {
2210                 build_address(&am, op2, ia32_create_am_double_use);
2211                 new_op = create_immediate_or_transform(op1, 0);
2212         } else {
2213                 return NULL;
2214         }
2215
2216         if (addr->base == NULL)
2217                 addr->base = noreg_GP;
2218         if (addr->index == NULL)
2219                 addr->index = noreg_GP;
2220         if (addr->mem == NULL)
2221                 addr->mem = nomem;
2222
2223         dbgi    = get_irn_dbg_info(node);
2224         block   = be_transform_node(src_block);
2225         new_mem = transform_AM_mem(block, am.am_node, mem, addr->mem);
2226
2227         if (get_mode_size_bits(mode) == 8) {
2228                 new_node = func8bit(dbgi, block, addr->base, addr->index, new_mem, new_op);
2229         } else {
2230                 new_node = func(dbgi, block, addr->base, addr->index, new_mem, new_op);
2231         }
2232         set_address(new_node, addr);
2233         set_ia32_op_type(new_node, ia32_AddrModeD);
2234         set_ia32_ls_mode(new_node, mode);
2235         SET_IA32_ORIG_NODE(new_node, node);
2236
2237         be_set_transformed_node(get_Proj_pred(am.mem_proj), new_node);
2238         mem_proj = be_transform_node(am.mem_proj);
2239         be_set_transformed_node(mem_proj ? mem_proj : am.mem_proj, new_node);
2240
2241         return new_node;
2242 }
2243
2244 static ir_node *dest_am_unop(ir_node *node, ir_node *op, ir_node *mem,
2245                              ir_node *ptr, ir_mode *mode,
2246                              construct_unop_dest_func *func)
2247 {
2248         ir_node  *src_block = get_nodes_block(node);
2249         ir_node  *block;
2250         dbg_info *dbgi;
2251         ir_node  *new_mem;
2252         ir_node  *new_node;
2253         ir_node  *mem_proj;
2254         ia32_address_mode_t  am;
2255         ia32_address_t *addr = &am.addr;
2256
2257         if (!use_dest_am(src_block, op, mem, ptr, NULL))
2258                 return NULL;
2259
2260         memset(&am, 0, sizeof(am));
2261         build_address(&am, op, ia32_create_am_double_use);
2262
2263         dbgi     = get_irn_dbg_info(node);
2264         block    = be_transform_node(src_block);
2265         new_mem  = transform_AM_mem(block, am.am_node, mem, addr->mem);
2266         new_node = func(dbgi, block, addr->base, addr->index, new_mem);
2267         set_address(new_node, addr);
2268         set_ia32_op_type(new_node, ia32_AddrModeD);
2269         set_ia32_ls_mode(new_node, mode);
2270         SET_IA32_ORIG_NODE(new_node, node);
2271
2272         be_set_transformed_node(get_Proj_pred(am.mem_proj), new_node);
2273         mem_proj = be_transform_node(am.mem_proj);
2274         be_set_transformed_node(mem_proj ? mem_proj : am.mem_proj, new_node);
2275
2276         return new_node;
2277 }
2278
2279 static ir_node *try_create_SetMem(ir_node *node, ir_node *ptr, ir_node *mem)
2280 {
2281         ir_mode              *mode      = get_irn_mode(node);
2282         ir_node              *mux_true  = get_Mux_true(node);
2283         ir_node              *mux_false = get_Mux_false(node);
2284         ir_node              *cond;
2285         dbg_info             *dbgi;
2286         ir_node              *block;
2287         ir_node              *new_block;
2288         ir_node              *flags;
2289         ir_node              *new_node;
2290         bool                  negated;
2291         ia32_condition_code_t cc;
2292         ia32_address_t        addr;
2293
2294         if (get_mode_size_bits(mode) != 8)
2295                 return NULL;
2296
2297         if (is_Const_1(mux_true) && is_Const_0(mux_false)) {
2298                 negated = false;
2299         } else if (is_Const_0(mux_true) && is_Const_1(mux_false)) {
2300                 negated = true;
2301         } else {
2302                 return NULL;
2303         }
2304
2305         cond  = get_Mux_sel(node);
2306         flags = get_flags_node(cond, &cc);
2307         /* we can't handle the float special cases with SetM */
2308         if (cc & ia32_cc_additional_float_cases)
2309                 return NULL;
2310         if (negated)
2311                 cc = ia32_negate_condition_code(cc);
2312
2313         build_address_ptr(&addr, ptr, mem);
2314
2315         dbgi      = get_irn_dbg_info(node);
2316         block     = get_nodes_block(node);
2317         new_block = be_transform_node(block);
2318         new_node  = new_bd_ia32_SetccMem(dbgi, new_block, addr.base,
2319                                          addr.index, addr.mem, flags, cc);
2320         set_address(new_node, &addr);
2321         set_ia32_op_type(new_node, ia32_AddrModeD);
2322         set_ia32_ls_mode(new_node, mode);
2323         SET_IA32_ORIG_NODE(new_node, node);
2324
2325         return new_node;
2326 }
2327
2328 static ir_node *try_create_dest_am(ir_node *node)
2329 {
2330         ir_node  *val  = get_Store_value(node);
2331         ir_node  *mem  = get_Store_mem(node);
2332         ir_node  *ptr  = get_Store_ptr(node);
2333         ir_mode  *mode = get_irn_mode(val);
2334         unsigned  bits = get_mode_size_bits(mode);
2335         ir_node  *op1;
2336         ir_node  *op2;
2337         ir_node  *new_node;
2338
2339         /* handle only GP modes for now... */
2340         if (!ia32_mode_needs_gp_reg(mode))
2341                 return NULL;
2342
2343         for (;;) {
2344                 /* store must be the only user of the val node */
2345                 if (get_irn_n_edges(val) > 1)
2346                         return NULL;
2347                 /* skip pointless convs */
2348                 if (is_Conv(val)) {
2349                         ir_node *conv_op   = get_Conv_op(val);
2350                         ir_mode *pred_mode = get_irn_mode(conv_op);
2351                         if (!ia32_mode_needs_gp_reg(pred_mode))
2352                                 break;
2353                         if (pred_mode == mode_b || bits <= get_mode_size_bits(pred_mode)) {
2354                                 val = conv_op;
2355                                 continue;
2356                         }
2357                 }
2358                 break;
2359         }
2360
2361         /* value must be in the same block */
2362         if (get_nodes_block(node) != get_nodes_block(val))
2363                 return NULL;
2364
2365         switch (get_irn_opcode(val)) {
2366         case iro_Add:
2367                 op1      = get_Add_left(val);
2368                 op2      = get_Add_right(val);
2369                 if (ia32_cg_config.use_incdec) {
2370                         if (is_Const_1(op2)) {
2371                                 new_node = dest_am_unop(val, op1, mem, ptr, mode, new_bd_ia32_IncMem);
2372                                 break;
2373                         } else if (is_Const_Minus_1(op2)) {
2374                                 new_node = dest_am_unop(val, op1, mem, ptr, mode, new_bd_ia32_DecMem);
2375                                 break;
2376                         }
2377                 }
2378                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2379                                          new_bd_ia32_AddMem, new_bd_ia32_AddMem8Bit,
2380                                          match_commutative | match_immediate);
2381                 break;
2382         case iro_Sub:
2383                 op1      = get_Sub_left(val);
2384                 op2      = get_Sub_right(val);
2385                 if (is_Const(op2)) {
2386                         ir_fprintf(stderr, "Optimisation warning: not-normalized sub ,C found\n");
2387                 }
2388                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2389                                          new_bd_ia32_SubMem, new_bd_ia32_SubMem8Bit,
2390                                          match_immediate);
2391                 break;
2392         case iro_And:
2393                 op1      = get_And_left(val);
2394                 op2      = get_And_right(val);
2395                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2396                                          new_bd_ia32_AndMem, new_bd_ia32_AndMem8Bit,
2397                                          match_commutative | match_immediate);
2398                 break;
2399         case iro_Or:
2400                 op1      = get_Or_left(val);
2401                 op2      = get_Or_right(val);
2402                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2403                                          new_bd_ia32_OrMem, new_bd_ia32_OrMem8Bit,
2404                                          match_commutative | match_immediate);
2405                 break;
2406         case iro_Eor:
2407                 op1      = get_Eor_left(val);
2408                 op2      = get_Eor_right(val);
2409                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2410                                          new_bd_ia32_XorMem, new_bd_ia32_XorMem8Bit,
2411                                          match_commutative | match_immediate);
2412                 break;
2413         case iro_Shl:
2414                 op1      = get_Shl_left(val);
2415                 op2      = get_Shl_right(val);
2416                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2417                                          new_bd_ia32_ShlMem, new_bd_ia32_ShlMem,
2418                                          match_immediate);
2419                 break;
2420         case iro_Shr:
2421                 op1      = get_Shr_left(val);
2422                 op2      = get_Shr_right(val);
2423                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2424                                          new_bd_ia32_ShrMem, new_bd_ia32_ShrMem,
2425                                          match_immediate);
2426                 break;
2427         case iro_Shrs:
2428                 op1      = get_Shrs_left(val);
2429                 op2      = get_Shrs_right(val);
2430                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2431                                          new_bd_ia32_SarMem, new_bd_ia32_SarMem,
2432                                          match_immediate);
2433                 break;
2434         case iro_Rotl:
2435                 op1      = get_Rotl_left(val);
2436                 op2      = get_Rotl_right(val);
2437                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2438                                          new_bd_ia32_RolMem, new_bd_ia32_RolMem,
2439                                          match_immediate);
2440                 break;
2441         /* TODO: match ROR patterns... */
2442         case iro_Mux:
2443                 new_node = try_create_SetMem(val, ptr, mem);
2444                 break;
2445
2446         case iro_Minus:
2447                 op1      = get_Minus_op(val);
2448                 new_node = dest_am_unop(val, op1, mem, ptr, mode, new_bd_ia32_NegMem);
2449                 break;
2450         case iro_Not:
2451                 /* should be lowered already */
2452                 assert(mode != mode_b);
2453                 op1      = get_Not_op(val);
2454                 new_node = dest_am_unop(val, op1, mem, ptr, mode, new_bd_ia32_NotMem);
2455                 break;
2456         default:
2457                 return NULL;
2458         }
2459
2460         if (new_node != NULL) {
2461                 if (get_irn_pinned(new_node) != op_pin_state_pinned &&
2462                                 get_irn_pinned(node) == op_pin_state_pinned) {
2463                         set_irn_pinned(new_node, op_pin_state_pinned);
2464                 }
2465         }
2466
2467         return new_node;
2468 }
2469
2470 static bool possible_int_mode_for_fp(ir_mode *mode)
2471 {
2472         unsigned size;
2473
2474         if (!mode_is_signed(mode))
2475                 return false;
2476         size = get_mode_size_bits(mode);
2477         if (size != 16 && size != 32)
2478                 return false;
2479         return true;
2480 }
2481
2482 static int is_float_to_int_conv(const ir_node *node)
2483 {
2484         ir_mode  *mode = get_irn_mode(node);
2485         ir_node  *conv_op;
2486         ir_mode  *conv_mode;
2487
2488         if (!possible_int_mode_for_fp(mode))
2489                 return 0;
2490
2491         if (!is_Conv(node))
2492                 return 0;
2493         conv_op   = get_Conv_op(node);
2494         conv_mode = get_irn_mode(conv_op);
2495
2496         if (!mode_is_float(conv_mode))
2497                 return 0;
2498
2499         return 1;
2500 }
2501
2502 /**
2503  * Transform a Store(floatConst) into a sequence of
2504  * integer stores.
2505  *
2506  * @return the created ia32 Store node
2507  */
2508 static ir_node *gen_float_const_Store(ir_node *node, ir_node *cns)
2509 {
2510         ir_mode        *mode      = get_irn_mode(cns);
2511         unsigned        size      = get_mode_size_bytes(mode);
2512         ir_tarval      *tv        = get_Const_tarval(cns);
2513         ir_node        *block     = get_nodes_block(node);
2514         ir_node        *new_block = be_transform_node(block);
2515         ir_node        *ptr       = get_Store_ptr(node);
2516         ir_node        *mem       = get_Store_mem(node);
2517         dbg_info       *dbgi      = get_irn_dbg_info(node);
2518         int             ofs       = 0;
2519         int             i         = 0;
2520         ir_node        *ins[4];
2521         ia32_address_t  addr;
2522
2523         assert(size % 4 ==  0);
2524         assert(size     <= 16);
2525
2526         build_address_ptr(&addr, ptr, mem);
2527
2528         do {
2529                 unsigned val =
2530                          get_tarval_sub_bits(tv, ofs)            |
2531                         (get_tarval_sub_bits(tv, ofs + 1) <<  8) |
2532                         (get_tarval_sub_bits(tv, ofs + 2) << 16) |
2533                         (get_tarval_sub_bits(tv, ofs + 3) << 24);
2534                 ir_node *imm = ia32_create_Immediate(NULL, 0, val);
2535
2536                 ir_node *new_node = new_bd_ia32_Store(dbgi, new_block, addr.base,
2537                         addr.index, addr.mem, imm);
2538
2539                 set_irn_pinned(new_node, get_irn_pinned(node));
2540                 set_ia32_op_type(new_node, ia32_AddrModeD);
2541                 set_ia32_ls_mode(new_node, mode_Iu);
2542                 set_address(new_node, &addr);
2543                 SET_IA32_ORIG_NODE(new_node, node);
2544
2545                 assert(i < 4);
2546                 ins[i++] = new_node;
2547
2548                 size        -= 4;
2549                 ofs         += 4;
2550                 addr.offset += 4;
2551         } while (size != 0);
2552
2553         if (i > 1) {
2554                 return new_rd_Sync(dbgi, new_block, i, ins);
2555         } else {
2556                 return ins[0];
2557         }
2558 }
2559
2560 /**
2561  * Generate a vfist or vfisttp instruction.
2562  */
2563 static ir_node *gen_vfist(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index,
2564                           ir_node *mem,  ir_node *val, ir_node **fist)
2565 {
2566         ir_node *new_node;
2567
2568         if (ia32_cg_config.use_fisttp) {
2569                 /* Note: fisttp ALWAYS pop the tos. We have to ensure here that the value is copied
2570                 if other users exists */
2571                 ir_node *vfisttp = new_bd_ia32_vfisttp(dbgi, block, base, index, mem, val);
2572                 ir_node *value   = new_r_Proj(vfisttp, mode_E, pn_ia32_vfisttp_res);
2573                 be_new_Keep(block, 1, &value);
2574
2575                 new_node = new_r_Proj(vfisttp, mode_M, pn_ia32_vfisttp_M);
2576                 *fist    = vfisttp;
2577         } else {
2578                 ir_node *trunc_mode = ia32_new_Fpu_truncate(current_ir_graph);
2579
2580                 /* do a fist */
2581                 new_node = new_bd_ia32_vfist(dbgi, block, base, index, mem, val, trunc_mode);
2582                 *fist    = new_node;
2583         }
2584         return new_node;
2585 }
2586 /**
2587  * Transforms a general (no special case) Store.
2588  *
2589  * @return the created ia32 Store node
2590  */
2591 static ir_node *gen_general_Store(ir_node *node)
2592 {
2593         ir_node  *val       = get_Store_value(node);
2594         ir_mode  *mode      = get_irn_mode(val);
2595         ir_node  *block     = get_nodes_block(node);
2596         ir_node  *new_block = be_transform_node(block);
2597         ir_node  *ptr       = get_Store_ptr(node);
2598         ir_node  *mem       = get_Store_mem(node);
2599         dbg_info *dbgi      = get_irn_dbg_info(node);
2600         ir_node  *new_val, *new_node, *store;
2601         ia32_address_t addr;
2602
2603         /* check for destination address mode */
2604         new_node = try_create_dest_am(node);
2605         if (new_node != NULL)
2606                 return new_node;
2607
2608         /* construct store address */
2609         memset(&addr, 0, sizeof(addr));
2610         ia32_create_address_mode(&addr, ptr, ia32_create_am_normal);
2611
2612         if (addr.base == NULL) {
2613                 addr.base = noreg_GP;
2614         } else {
2615                 addr.base = be_transform_node(addr.base);
2616         }
2617
2618         if (addr.index == NULL) {
2619                 addr.index = noreg_GP;
2620         } else {
2621                 addr.index = be_transform_node(addr.index);
2622         }
2623         addr.mem = be_transform_node(mem);
2624
2625         if (mode_is_float(mode)) {
2626                 /* Convs (and strict-Convs) before stores are unnecessary if the mode
2627                    is the same. */
2628                 while (is_Conv(val) && mode == get_irn_mode(val)) {
2629                         ir_node *op = get_Conv_op(val);
2630                         if (!mode_is_float(get_irn_mode(op)))
2631                                 break;
2632                         val = op;
2633                 }
2634                 new_val = be_transform_node(val);
2635                 if (ia32_cg_config.use_sse2) {
2636                         new_node = new_bd_ia32_xStore(dbgi, new_block, addr.base,
2637                                                       addr.index, addr.mem, new_val);
2638                 } else {
2639                         new_node = new_bd_ia32_vfst(dbgi, new_block, addr.base,
2640                                                     addr.index, addr.mem, new_val, mode);
2641                 }
2642                 store = new_node;
2643         } else if (!ia32_cg_config.use_sse2 && is_float_to_int_conv(val)) {
2644                 val = get_Conv_op(val);
2645
2646                 /* TODO: is this optimisation still necessary at all (middleend)? */
2647                 /* We can skip ALL float->float up-Convs (and strict-up-Convs) before stores. */
2648                 while (is_Conv(val)) {
2649                         ir_node *op = get_Conv_op(val);
2650                         if (!mode_is_float(get_irn_mode(op)))
2651                                 break;
2652                         if (get_mode_size_bits(get_irn_mode(op)) > get_mode_size_bits(get_irn_mode(val)))
2653                                 break;
2654                         val = op;
2655                 }
2656                 new_val  = be_transform_node(val);
2657                 new_node = gen_vfist(dbgi, new_block, addr.base, addr.index, addr.mem, new_val, &store);
2658         } else {
2659                 new_val = create_immediate_or_transform(val, 0);
2660                 assert(mode != mode_b);
2661
2662                 if (get_mode_size_bits(mode) == 8) {
2663                         new_node = new_bd_ia32_Store8Bit(dbgi, new_block, addr.base,
2664                                                          addr.index, addr.mem, new_val);
2665                 } else {
2666                         new_node = new_bd_ia32_Store(dbgi, new_block, addr.base,
2667                                                      addr.index, addr.mem, new_val);
2668                 }
2669                 store = new_node;
2670         }
2671
2672         set_irn_pinned(store, get_irn_pinned(node));
2673         set_ia32_op_type(store, ia32_AddrModeD);
2674         set_ia32_ls_mode(store, mode);
2675
2676         set_address(store, &addr);
2677         SET_IA32_ORIG_NODE(store, node);
2678
2679         return new_node;
2680 }
2681
2682 /**
2683  * Transforms a Store.
2684  *
2685  * @return the created ia32 Store node
2686  */
2687 static ir_node *gen_Store(ir_node *node)
2688 {
2689         ir_node  *val  = get_Store_value(node);
2690         ir_mode  *mode = get_irn_mode(val);
2691
2692         if (mode_is_float(mode) && is_Const(val)) {
2693                 /* We can transform every floating const store
2694                    into a sequence of integer stores.
2695                    If the constant is already in a register,
2696                    it would be better to use it, but we don't
2697                    have this information here. */
2698                 return gen_float_const_Store(node, val);
2699         }
2700         return gen_general_Store(node);
2701 }
2702
2703 /**
2704  * Transforms a Switch.
2705  *
2706  * @return the created ia32 SwitchJmp node
2707  */
2708 static ir_node *create_Switch(ir_node *node)
2709 {
2710         dbg_info *dbgi       = get_irn_dbg_info(node);
2711         ir_node  *block      = be_transform_node(get_nodes_block(node));
2712         ir_node  *sel        = get_Cond_selector(node);
2713         ir_node  *new_sel    = be_transform_node(sel);
2714         long      switch_min = LONG_MAX;
2715         long      switch_max = LONG_MIN;
2716         long      default_pn = get_Cond_default_proj(node);
2717         ir_node  *new_node;
2718         const ir_edge_t *edge;
2719
2720         assert(get_mode_size_bits(get_irn_mode(sel)) == 32);
2721
2722         /* determine the smallest switch case value */
2723         foreach_out_edge(node, edge) {
2724                 ir_node *proj = get_edge_src_irn(edge);
2725                 long     pn   = get_Proj_proj(proj);
2726                 if (pn == default_pn)
2727                         continue;
2728
2729                 if (pn < switch_min)
2730                         switch_min = pn;
2731                 if (pn > switch_max)
2732                         switch_max = pn;
2733         }
2734
2735         if ((unsigned long) (switch_max - switch_min) > 128000) {
2736                 panic("Size of switch %+F bigger than 128000", node);
2737         }
2738
2739         if (switch_min != 0) {
2740                 /* if smallest switch case is not 0 we need an additional sub */
2741                 new_sel = new_bd_ia32_Lea(dbgi, block, new_sel, noreg_GP);
2742                 add_ia32_am_offs_int(new_sel, -switch_min);
2743                 set_ia32_op_type(new_sel, ia32_AddrModeS);
2744
2745                 SET_IA32_ORIG_NODE(new_sel, node);
2746         }
2747
2748         new_node = new_bd_ia32_SwitchJmp(dbgi, block, new_sel, default_pn);
2749         SET_IA32_ORIG_NODE(new_node, node);
2750
2751         return new_node;
2752 }
2753
2754 /**
2755  * Transform a Cond node.
2756  */
2757 static ir_node *gen_Cond(ir_node *node)
2758 {
2759         ir_node              *block     = get_nodes_block(node);
2760         ir_node              *new_block = be_transform_node(block);
2761         dbg_info             *dbgi      = get_irn_dbg_info(node);
2762         ir_node              *sel       = get_Cond_selector(node);
2763         ir_mode              *sel_mode  = get_irn_mode(sel);
2764         ir_node              *flags     = NULL;
2765         ir_node              *new_node;
2766         ia32_condition_code_t cc;
2767
2768         if (sel_mode != mode_b) {
2769                 return create_Switch(node);
2770         }
2771
2772         /* we get flags from a Cmp */
2773         flags = get_flags_node(sel, &cc);
2774
2775         new_node = new_bd_ia32_Jcc(dbgi, new_block, flags, cc);
2776         SET_IA32_ORIG_NODE(new_node, node);
2777
2778         return new_node;
2779 }
2780
2781 /**
2782  * Transform a be_Copy.
2783  */
2784 static ir_node *gen_be_Copy(ir_node *node)
2785 {
2786         ir_node *new_node = be_duplicate_node(node);
2787         ir_mode *mode     = get_irn_mode(new_node);
2788
2789         if (ia32_mode_needs_gp_reg(mode)) {
2790                 set_irn_mode(new_node, mode_Iu);
2791         }
2792
2793         return new_node;
2794 }
2795
2796 static ir_node *create_Fucom(ir_node *node)
2797 {
2798         dbg_info *dbgi      = get_irn_dbg_info(node);
2799         ir_node  *block     = get_nodes_block(node);
2800         ir_node  *new_block = be_transform_node(block);
2801         ir_node  *left      = get_Cmp_left(node);
2802         ir_node  *new_left  = be_transform_node(left);
2803         ir_node  *right     = get_Cmp_right(node);
2804         ir_node  *new_right;
2805         ir_node  *new_node;
2806
2807         if (ia32_cg_config.use_fucomi) {
2808                 new_right = be_transform_node(right);
2809                 new_node  = new_bd_ia32_vFucomi(dbgi, new_block, new_left,
2810                                                 new_right, 0);
2811                 set_ia32_commutative(new_node);
2812                 SET_IA32_ORIG_NODE(new_node, node);
2813         } else {
2814                 if (ia32_cg_config.use_ftst && is_Const_0(right)) {
2815                         new_node = new_bd_ia32_vFtstFnstsw(dbgi, new_block, new_left, 0);
2816                 } else {
2817                         new_right = be_transform_node(right);
2818                         new_node  = new_bd_ia32_vFucomFnstsw(dbgi, new_block, new_left, new_right, 0);
2819                 }
2820
2821                 set_ia32_commutative(new_node);
2822
2823                 SET_IA32_ORIG_NODE(new_node, node);
2824
2825                 new_node = new_bd_ia32_Sahf(dbgi, new_block, new_node);
2826                 SET_IA32_ORIG_NODE(new_node, node);
2827         }
2828
2829         return new_node;
2830 }
2831
2832 static ir_node *create_Ucomi(ir_node *node)
2833 {
2834         dbg_info *dbgi      = get_irn_dbg_info(node);
2835         ir_node  *src_block = get_nodes_block(node);
2836         ir_node  *new_block = be_transform_node(src_block);
2837         ir_node  *left      = get_Cmp_left(node);
2838         ir_node  *right     = get_Cmp_right(node);
2839         ir_node  *new_node;
2840         ia32_address_mode_t  am;
2841         ia32_address_t      *addr = &am.addr;
2842
2843         match_arguments(&am, src_block, left, right, NULL,
2844                         match_commutative | match_am);
2845
2846         new_node = new_bd_ia32_Ucomi(dbgi, new_block, addr->base, addr->index,
2847                                      addr->mem, am.new_op1, am.new_op2,
2848                                      am.ins_permuted);
2849         set_am_attributes(new_node, &am);
2850
2851         SET_IA32_ORIG_NODE(new_node, node);
2852
2853         new_node = fix_mem_proj(new_node, &am);
2854
2855         return new_node;
2856 }
2857
2858 /**
2859  * returns true if it is assured, that the upper bits of a node are "clean"
2860  * which means for a 16 or 8 bit value, that the upper bits in the register
2861  * are 0 for unsigned and a copy of the last significant bit for signed
2862  * numbers.
2863  */
2864 static bool upper_bits_clean(ir_node *transformed_node, ir_mode *mode)
2865 {
2866         assert(ia32_mode_needs_gp_reg(mode));
2867         if (get_mode_size_bits(mode) >= 32)
2868                 return true;
2869
2870         if (is_Proj(transformed_node))
2871                 return upper_bits_clean(get_Proj_pred(transformed_node), mode);
2872
2873         switch (get_ia32_irn_opcode(transformed_node)) {
2874                 case iro_ia32_Conv_I2I:
2875                 case iro_ia32_Conv_I2I8Bit: {
2876                         ir_mode *smaller_mode = get_ia32_ls_mode(transformed_node);
2877                         if (mode_is_signed(smaller_mode) != mode_is_signed(mode))
2878                                 return false;
2879                         if (get_mode_size_bits(smaller_mode) > get_mode_size_bits(mode))
2880                                 return false;
2881
2882                         return true;
2883                 }
2884
2885                 case iro_ia32_Shr:
2886                         if (mode_is_signed(mode)) {
2887                                 return false; /* TODO handle signed modes */
2888                         } else {
2889                                 ir_node *right = get_irn_n(transformed_node, n_ia32_Shr_count);
2890                                 if (is_ia32_Immediate(right) || is_ia32_Const(right)) {
2891                                         const ia32_immediate_attr_t *attr
2892                                                 = get_ia32_immediate_attr_const(right);
2893                                         if (attr->symconst == 0 &&
2894                                                         (unsigned)attr->offset >= 32 - get_mode_size_bits(mode)) {
2895                                                 return true;
2896                                         }
2897                                 }
2898                                 return upper_bits_clean(get_irn_n(transformed_node, n_ia32_Shr_val), mode);
2899                         }
2900
2901                 case iro_ia32_Sar:
2902                         /* TODO too conservative if shift amount is constant */
2903                         return upper_bits_clean(get_irn_n(transformed_node, n_ia32_Sar_val), mode);
2904
2905                 case iro_ia32_And:
2906                         if (!mode_is_signed(mode)) {
2907                                 return
2908                                         upper_bits_clean(get_irn_n(transformed_node, n_ia32_And_right), mode) ||
2909                                         upper_bits_clean(get_irn_n(transformed_node, n_ia32_And_left),  mode);
2910                         }
2911                         /* TODO if one is known to be zero extended, then || is sufficient */
2912                         /* FALLTHROUGH */
2913                 case iro_ia32_Or:
2914                 case iro_ia32_Xor:
2915                         return
2916                                 upper_bits_clean(get_irn_n(transformed_node, n_ia32_binary_right), mode) &&
2917                                 upper_bits_clean(get_irn_n(transformed_node, n_ia32_binary_left),  mode);
2918
2919                 case iro_ia32_Const:
2920                 case iro_ia32_Immediate: {
2921                         const ia32_immediate_attr_t *attr =
2922                                 get_ia32_immediate_attr_const(transformed_node);
2923                         if (mode_is_signed(mode)) {
2924                                 long shifted = attr->offset >> (get_mode_size_bits(mode) - 1);
2925                                 return shifted == 0 || shifted == -1;
2926                         } else {
2927                                 unsigned long shifted = (unsigned long)attr->offset;
2928                                 shifted >>= get_mode_size_bits(mode);
2929                                 return shifted == 0;
2930                         }
2931                 }
2932
2933                 default:
2934                         return false;
2935         }
2936 }
2937
2938 /**
2939  * Generate code for a Cmp.
2940  */
2941 static ir_node *gen_Cmp(ir_node *node)
2942 {
2943         dbg_info *dbgi      = get_irn_dbg_info(node);
2944         ir_node  *block     = get_nodes_block(node);
2945         ir_node  *new_block = be_transform_node(block);
2946         ir_node  *left      = get_Cmp_left(node);
2947         ir_node  *right     = get_Cmp_right(node);
2948         ir_mode  *cmp_mode  = get_irn_mode(left);
2949         ir_node  *new_node;
2950         ia32_address_mode_t  am;
2951         ia32_address_t      *addr = &am.addr;
2952
2953         if (mode_is_float(cmp_mode)) {
2954                 if (ia32_cg_config.use_sse2) {
2955                         return create_Ucomi(node);
2956                 } else {
2957                         return create_Fucom(node);
2958                 }
2959         }
2960
2961         assert(ia32_mode_needs_gp_reg(cmp_mode));
2962
2963         /* Prefer the Test instruction, when encountering (x & y) ==/!= 0 */
2964         if (is_Const_0(right)          &&
2965             is_And(left)               &&
2966             get_irn_n_edges(left) == 1) {
2967                 /* Test(and_left, and_right) */
2968                 ir_node *and_left  = get_And_left(left);
2969                 ir_node *and_right = get_And_right(left);
2970
2971                 /* matze: code here used mode instead of cmd_mode, I think it is always
2972                  * the same as cmp_mode, but I leave this here to see if this is really
2973                  * true...
2974                  */
2975                 assert(get_irn_mode(and_left) == cmp_mode);
2976
2977                 match_arguments(&am, block, and_left, and_right, NULL,
2978                                                                                 match_commutative |
2979                                                                                 match_am | match_8bit_am | match_16bit_am |
2980                                                                                 match_am_and_immediates | match_immediate);
2981
2982                 /* use 32bit compare mode if possible since the opcode is smaller */
2983                 if (upper_bits_clean(am.new_op1, cmp_mode) &&
2984                     upper_bits_clean(am.new_op2, cmp_mode)) {
2985                         cmp_mode = mode_is_signed(cmp_mode) ? mode_Is : mode_Iu;
2986                 }
2987
2988                 if (get_mode_size_bits(cmp_mode) == 8) {
2989                         new_node = new_bd_ia32_Test8Bit(dbgi, new_block, addr->base,
2990                                         addr->index, addr->mem, am.new_op1, am.new_op2, am.ins_permuted);
2991                 } else {
2992                         new_node = new_bd_ia32_Test(dbgi, new_block, addr->base, addr->index,
2993                                         addr->mem, am.new_op1, am.new_op2, am.ins_permuted);
2994                 }
2995         } else {
2996                 /* Cmp(left, right) */
2997                 match_arguments(&am, block, left, right, NULL,
2998                                 match_commutative | match_am | match_8bit_am |
2999                                 match_16bit_am | match_am_and_immediates |
3000                                 match_immediate);
3001                 /* use 32bit compare mode if possible since the opcode is smaller */
3002                 if (upper_bits_clean(am.new_op1, cmp_mode) &&
3003                     upper_bits_clean(am.new_op2, cmp_mode)) {
3004                         cmp_mode = mode_is_signed(cmp_mode) ? mode_Is : mode_Iu;
3005                 }
3006
3007                 if (get_mode_size_bits(cmp_mode) == 8) {
3008                         new_node = new_bd_ia32_Cmp8Bit(dbgi, new_block, addr->base,
3009                                                        addr->index, addr->mem, am.new_op1,
3010                                                        am.new_op2, am.ins_permuted);
3011                 } else {
3012                         new_node = new_bd_ia32_Cmp(dbgi, new_block, addr->base, addr->index,
3013                                         addr->mem, am.new_op1, am.new_op2, am.ins_permuted);
3014                 }
3015         }
3016         set_am_attributes(new_node, &am);
3017         set_ia32_ls_mode(new_node, cmp_mode);
3018
3019         SET_IA32_ORIG_NODE(new_node, node);
3020
3021         new_node = fix_mem_proj(new_node, &am);
3022
3023         return new_node;
3024 }
3025
3026 static ir_node *create_CMov(ir_node *node, ir_node *flags, ir_node *new_flags,
3027                             ia32_condition_code_t cc)
3028 {
3029         dbg_info            *dbgi          = get_irn_dbg_info(node);
3030         ir_node             *block         = get_nodes_block(node);
3031         ir_node             *new_block     = be_transform_node(block);
3032         ir_node             *val_true      = get_Mux_true(node);
3033         ir_node             *val_false     = get_Mux_false(node);
3034         ir_node             *new_node;
3035         ia32_address_mode_t  am;
3036         ia32_address_t      *addr;
3037
3038         assert(ia32_cg_config.use_cmov);
3039         assert(ia32_mode_needs_gp_reg(get_irn_mode(val_true)));
3040
3041         addr = &am.addr;
3042
3043         match_arguments(&am, block, val_false, val_true, flags,
3044                         match_commutative | match_am | match_16bit_am | match_mode_neutral);
3045
3046         if (am.ins_permuted)
3047                 cc = ia32_invert_condition_code(cc);
3048
3049         new_node = new_bd_ia32_CMovcc(dbgi, new_block, addr->base, addr->index,
3050                                       addr->mem, am.new_op1, am.new_op2, new_flags,
3051                                       cc);
3052         set_am_attributes(new_node, &am);
3053
3054         SET_IA32_ORIG_NODE(new_node, node);
3055
3056         new_node = fix_mem_proj(new_node, &am);
3057
3058         return new_node;
3059 }
3060
3061 /**
3062  * Creates a ia32 Setcc instruction.
3063  */
3064 static ir_node *create_set_32bit(dbg_info *dbgi, ir_node *new_block,
3065                                  ir_node *flags, ia32_condition_code_t cc,
3066                                  ir_node *orig_node)
3067 {
3068         ir_mode *mode  = get_irn_mode(orig_node);
3069         ir_node *new_node;
3070
3071         new_node = new_bd_ia32_Setcc(dbgi, new_block, flags, cc);
3072         SET_IA32_ORIG_NODE(new_node, orig_node);
3073
3074         /* we might need to conv the result up */
3075         if (get_mode_size_bits(mode) > 8) {
3076                 new_node = new_bd_ia32_Conv_I2I8Bit(dbgi, new_block, noreg_GP, noreg_GP,
3077                                                     nomem, new_node, mode_Bu);
3078                 SET_IA32_ORIG_NODE(new_node, orig_node);
3079         }
3080
3081         return new_node;
3082 }
3083
3084 /**
3085  * Create instruction for an unsigned Difference or Zero.
3086  */
3087 static ir_node *create_doz(ir_node *psi, ir_node *a, ir_node *b)
3088 {
3089         ir_mode *mode  = get_irn_mode(psi);
3090         ir_node *new_node;
3091         ir_node *sub;
3092         ir_node *sbb;
3093         ir_node *notn;
3094         ir_node *eflags;
3095         ir_node *block;
3096
3097         dbg_info *dbgi;
3098
3099         new_node = gen_binop(psi, a, b, new_bd_ia32_Sub,
3100                 match_mode_neutral | match_am | match_immediate | match_two_users);
3101
3102         block = get_nodes_block(new_node);
3103
3104         if (is_Proj(new_node)) {
3105                 sub = get_Proj_pred(new_node);
3106         } else {
3107                 sub = new_node;
3108                 set_irn_mode(sub, mode_T);
3109                 new_node = new_rd_Proj(NULL, sub, mode, pn_ia32_res);
3110         }
3111         assert(is_ia32_Sub(sub));
3112         eflags = new_rd_Proj(NULL, sub, mode_Iu, pn_ia32_Sub_flags);
3113
3114         dbgi = get_irn_dbg_info(psi);
3115         sbb  = new_bd_ia32_Sbb0(dbgi, block, eflags);
3116         notn = new_bd_ia32_Not(dbgi, block, sbb);
3117
3118         new_node = new_bd_ia32_And(dbgi, block, noreg_GP, noreg_GP, nomem, new_node, notn);
3119         set_ia32_commutative(new_node);
3120         return new_node;
3121 }
3122
3123 /**
3124  * Create an const array of two float consts.
3125  *
3126  * @param c0        the first constant
3127  * @param c1        the second constant
3128  * @param new_mode  IN/OUT for the mode of the constants, if NULL
3129  *                  smallest possible mode will be used
3130  */
3131 static ir_entity *ia32_create_const_array(ir_node *c0, ir_node *c1, ir_mode **new_mode)
3132 {
3133         ir_entity        *ent;
3134         ir_mode          *mode = *new_mode;
3135         ir_type          *tp;
3136         ir_initializer_t *initializer;
3137         ir_tarval        *tv0 = get_Const_tarval(c0);
3138         ir_tarval        *tv1 = get_Const_tarval(c1);
3139
3140         if (mode == NULL) {
3141                 /* detect the best mode for the constants */
3142                 mode = get_tarval_mode(tv0);
3143
3144                 if (mode != mode_F) {
3145                         if (tarval_ieee754_can_conv_lossless(tv0, mode_F) &&
3146                             tarval_ieee754_can_conv_lossless(tv1, mode_F)) {
3147                                 mode = mode_F;
3148                                 tv0 = tarval_convert_to(tv0, mode);
3149                                 tv1 = tarval_convert_to(tv1, mode);
3150                         } else if (mode != mode_D) {
3151                                 if (tarval_ieee754_can_conv_lossless(tv0, mode_D) &&
3152                                     tarval_ieee754_can_conv_lossless(tv1, mode_D)) {
3153                                         mode = mode_D;
3154                                         tv0 = tarval_convert_to(tv0, mode);
3155                                         tv1 = tarval_convert_to(tv1, mode);
3156                                 }
3157                         }
3158                 }
3159
3160         }
3161
3162         tp = ia32_create_float_type(mode, 4);
3163         tp = ia32_create_float_array(tp);
3164
3165         ent = new_entity(get_glob_type(), id_unique("C%u"), tp);
3166
3167         set_entity_ld_ident(ent, get_entity_ident(ent));
3168         set_entity_visibility(ent, ir_visibility_private);
3169         add_entity_linkage(ent, IR_LINKAGE_CONSTANT);
3170
3171         initializer = create_initializer_compound(2);
3172
3173         set_initializer_compound_value(initializer, 0, create_initializer_tarval(tv0));
3174         set_initializer_compound_value(initializer, 1, create_initializer_tarval(tv1));
3175
3176         set_entity_initializer(ent, initializer);
3177
3178         *new_mode = mode;
3179         return ent;
3180 }
3181
3182 /**
3183  * Possible transformations for creating a Setcc.
3184  */
3185 enum setcc_transform_insn {
3186         SETCC_TR_ADD,
3187         SETCC_TR_ADDxx,
3188         SETCC_TR_LEA,
3189         SETCC_TR_LEAxx,
3190         SETCC_TR_SHL,
3191         SETCC_TR_NEG,
3192         SETCC_TR_NOT,
3193         SETCC_TR_AND,
3194         SETCC_TR_SET,
3195         SETCC_TR_SBB,
3196 };
3197
3198 typedef struct setcc_transform {
3199         unsigned              num_steps;
3200         ia32_condition_code_t cc;
3201         struct {
3202                 enum setcc_transform_insn  transform;
3203                 long val;
3204                 int  scale;
3205         } steps[4];
3206 } setcc_transform_t;
3207
3208 /**
3209  * Setcc can only handle 0 and 1 result.
3210  * Find a transformation that creates 0 and 1 from
3211  * tv_t and tv_f.
3212  */
3213 static void find_const_transform(ia32_condition_code_t cc,
3214                                  ir_tarval *t, ir_tarval *f,
3215                                  setcc_transform_t *res)
3216 {
3217         unsigned step = 0;
3218
3219         res->num_steps = 0;
3220
3221         if (tarval_is_null(t)) {
3222                 ir_tarval *tmp = t;
3223                 t = f;
3224                 f = tmp;
3225                 cc = ia32_negate_condition_code(cc);
3226         } else if (tarval_cmp(t, f) == ir_relation_less) {
3227                 // now, t is the bigger one
3228                 ir_tarval *tmp = t;
3229                 t = f;
3230                 f = tmp;
3231                 cc = ia32_negate_condition_code(cc);
3232         }
3233         res->cc = cc;
3234
3235         if (! tarval_is_null(f)) {
3236                 ir_tarval *t_sub = tarval_sub(t, f, NULL);
3237
3238                 t = t_sub;
3239                 res->steps[step].transform = SETCC_TR_ADD;
3240
3241                 if (t == tarval_bad)
3242                         panic("constant subtract failed");
3243                 if (! tarval_is_long(f))
3244                         panic("tarval is not long");
3245
3246                 res->steps[step].val = get_tarval_long(f);
3247                 ++step;
3248                 f = tarval_sub(f, f, NULL);
3249                 assert(tarval_is_null(f));
3250         }
3251
3252         if (tarval_is_one(t)) {
3253                 res->steps[step].transform = SETCC_TR_SET;
3254                 res->num_steps = ++step;
3255                 return;
3256         }
3257
3258         if (tarval_is_minus_one(t)) {
3259                 res->steps[step].transform = SETCC_TR_NEG;
3260                 ++step;
3261                 res->steps[step].transform = SETCC_TR_SET;
3262                 res->num_steps = ++step;
3263                 return;
3264         }
3265         if (tarval_is_long(t)) {
3266                 long v = get_tarval_long(t);
3267
3268                 res->steps[step].val = 0;
3269                 switch (v) {
3270                 case 9:
3271                         if (step > 0 && res->steps[step - 1].transform == SETCC_TR_ADD)
3272                                 --step;
3273                         res->steps[step].transform = SETCC_TR_LEAxx;
3274                         res->steps[step].scale     = 3; /* (a << 3) + a */
3275                         break;
3276                 case 8:
3277                         if (step > 0 && res->steps[step - 1].transform == SETCC_TR_ADD)
3278                                 --step;
3279                         res->steps[step].transform = res->steps[step].val == 0 ? SETCC_TR_SHL : SETCC_TR_LEA;
3280                         res->steps[step].scale     = 3; /* (a << 3) */
3281                         break;
3282                 case 5:
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     = 2; /* (a << 2) + a */
3287                         break;
3288                 case 4:
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     = 2; /* (a << 2) */
3293                         break;
3294                 case 3:
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     = 1; /* (a << 1) + a */
3299                         break;
3300                 case 2:
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     = 1; /* (a << 1) */
3305                         break;
3306                 case 1:
3307                         res->num_steps = step;
3308                         return;
3309                 default:
3310                         if (! tarval_is_single_bit(t)) {
3311                                 res->steps[step].transform = SETCC_TR_AND;
3312                                 res->steps[step].val       = v;
3313                                 ++step;
3314                                 res->steps[step].transform = SETCC_TR_NEG;
3315                         } else {
3316                                 int v = get_tarval_lowest_bit(t);
3317                                 assert(v >= 0);
3318
3319                                 res->steps[step].transform = SETCC_TR_SHL;
3320                                 res->steps[step].scale     = v;
3321                         }
3322                 }
3323                 ++step;
3324                 res->steps[step].transform = SETCC_TR_SET;
3325                 res->num_steps = ++step;
3326                 return;
3327         }
3328         panic("tarval is not long");
3329 }
3330
3331 /**
3332  * Transforms a Mux node into some code sequence.
3333  *
3334  * @return The transformed node.
3335  */
3336 static ir_node *gen_Mux(ir_node *node)
3337 {
3338         dbg_info             *dbgi      = get_irn_dbg_info(node);
3339         ir_node              *block     = get_nodes_block(node);
3340         ir_node              *new_block = be_transform_node(block);
3341         ir_node              *mux_true  = get_Mux_true(node);
3342         ir_node              *mux_false = get_Mux_false(node);
3343         ir_node              *sel       = get_Mux_sel(node);
3344         ir_mode              *mode      = get_irn_mode(node);
3345         ir_node              *flags;
3346         ir_node              *new_node;
3347         int                   is_abs;
3348         ia32_condition_code_t cc;
3349
3350         assert(get_irn_mode(sel) == mode_b);
3351
3352         is_abs = be_mux_is_abs(sel, mux_true, mux_false);
3353         if (is_abs != 0) {
3354                 return create_abs(dbgi, block, be_get_abs_op(sel), is_abs < 0, node);
3355         }
3356
3357         /* Note: a Mux node uses a Load two times IFF it's used in the compare AND in the result */
3358         if (mode_is_float(mode)) {
3359                 ir_node    *cmp_left  = get_Cmp_left(sel);
3360                 ir_node    *cmp_right = get_Cmp_right(sel);
3361                 ir_relation relation  = get_Cmp_relation(sel);
3362
3363                 if (ia32_cg_config.use_sse2) {
3364                         if (relation == ir_relation_less || relation == ir_relation_less_equal) {
3365                                 if (cmp_left == mux_true && cmp_right == mux_false) {
3366                                         /* Mux(a <= b, a, b) => MIN */
3367                                         return gen_binop(node, cmp_left, cmp_right, new_bd_ia32_xMin,
3368                                          match_commutative | match_am | match_two_users);
3369                                 } else if (cmp_left == mux_false && cmp_right == mux_true) {
3370                                         /* Mux(a <= b, b, a) => MAX */
3371                                         return gen_binop(node, cmp_left, cmp_right, new_bd_ia32_xMax,
3372                                          match_commutative | match_am | match_two_users);
3373                                 }
3374                         } else if (relation == ir_relation_greater || relation == ir_relation_greater_equal) {
3375                                 if (cmp_left == mux_true && cmp_right == mux_false) {
3376                                         /* Mux(a >= b, a, b) => MAX */
3377                                         return gen_binop(node, cmp_left, cmp_right, new_bd_ia32_xMax,
3378                                          match_commutative | match_am | match_two_users);
3379                                 } else if (cmp_left == mux_false && cmp_right == mux_true) {
3380                                         /* Mux(a >= b, b, a) => MIN */
3381                                         return gen_binop(node, cmp_left, cmp_right, new_bd_ia32_xMin,
3382                                          match_commutative | match_am | match_two_users);
3383                                 }
3384                         }
3385                 }
3386
3387                 if (is_Const(mux_true) && is_Const(mux_false)) {
3388                         ia32_address_mode_t am;
3389                         ir_node             *load;
3390                         ir_mode             *new_mode;
3391                         unsigned            scale;
3392
3393                         flags    = get_flags_node(sel, &cc);
3394                         new_node = create_set_32bit(dbgi, new_block, flags, cc, node);
3395
3396                         if (ia32_cg_config.use_sse2) {
3397                                 /* cannot load from different mode on SSE */
3398                                 new_mode = mode;
3399                         } else {
3400                                 /* x87 can load any mode */
3401                                 new_mode = NULL;
3402                         }
3403
3404                         am.addr.symconst_ent = ia32_create_const_array(mux_false, mux_true, &new_mode);
3405
3406                         switch (get_mode_size_bytes(new_mode)) {
3407                         case 4:
3408                                 scale = 2;
3409                                 break;
3410                         case 8:
3411                                 scale = 3;
3412                                 break;
3413                         case 10:
3414                                 /* use 2 * 5 */
3415                                 scale = 1;
3416                                 new_node = new_bd_ia32_Lea(dbgi, new_block, new_node, new_node);
3417                                 set_ia32_am_scale(new_node, 2);
3418                                 break;
3419                         case 12:
3420                                 /* use 4 * 3 */
3421                                 scale = 2;
3422                                 new_node = new_bd_ia32_Lea(dbgi, new_block, new_node, new_node);
3423                                 set_ia32_am_scale(new_node, 1);
3424                                 break;
3425                         case 16:
3426                                 /* arg, shift 16 NOT supported */
3427                                 scale = 3;
3428                                 new_node = new_bd_ia32_Lea(dbgi, new_block, new_node, new_node);
3429                                 break;
3430                         default:
3431                                 panic("Unsupported constant size");
3432                         }
3433
3434                         am.ls_mode            = new_mode;
3435                         am.addr.base          = get_symconst_base();
3436                         am.addr.index         = new_node;
3437                         am.addr.mem           = nomem;
3438                         am.addr.offset        = 0;
3439                         am.addr.scale         = scale;
3440                         am.addr.use_frame     = 0;
3441                         am.addr.frame_entity  = NULL;
3442                         am.addr.symconst_sign = 0;
3443                         am.mem_proj           = am.addr.mem;
3444                         am.op_type            = ia32_AddrModeS;
3445                         am.new_op1            = NULL;
3446                         am.new_op2            = NULL;
3447                         am.pinned             = op_pin_state_floats;
3448                         am.commutative        = 1;
3449                         am.ins_permuted       = false;
3450
3451                         if (ia32_cg_config.use_sse2)
3452                                 load = new_bd_ia32_xLoad(dbgi, block, am.addr.base, am.addr.index, am.addr.mem, new_mode);
3453                         else
3454                                 load = new_bd_ia32_vfld(dbgi, block, am.addr.base, am.addr.index, am.addr.mem, new_mode);
3455                         set_am_attributes(load, &am);
3456
3457                         return new_rd_Proj(NULL, load, mode_vfp, pn_ia32_res);
3458                 }
3459                 panic("cannot transform floating point Mux");
3460
3461         } else {
3462                 assert(ia32_mode_needs_gp_reg(mode));
3463
3464                 if (is_Cmp(sel)) {
3465                         ir_node    *cmp_left  = get_Cmp_left(sel);
3466                         ir_node    *cmp_right = get_Cmp_right(sel);
3467                         ir_relation relation  = get_Cmp_relation(sel);
3468                         ir_node    *val_true  = mux_true;
3469                         ir_node    *val_false = mux_false;
3470
3471                         if (is_Const(val_true) && is_Const_null(val_true)) {
3472                                 ir_node *tmp = val_false;
3473                                 val_false = val_true;
3474                                 val_true  = tmp;
3475                                 relation  = get_negated_relation(relation);
3476                         }
3477                         if (is_Const_0(val_false) && is_Sub(val_true)) {
3478                                 if ((relation & ir_relation_greater)
3479                                         && get_Sub_left(val_true) == cmp_left
3480                                         && get_Sub_right(val_true) == cmp_right) {
3481                                         return create_doz(node, cmp_left, cmp_right);
3482                                 }
3483                                 if ((relation & ir_relation_less)
3484                                         && get_Sub_left(val_true) == cmp_right
3485                                         && get_Sub_right(val_true) == cmp_left) {
3486                                         return create_doz(node, cmp_right, cmp_left);
3487                                 }
3488                         }
3489                 }
3490
3491                 flags = get_flags_node(sel, &cc);
3492
3493                 if (is_Const(mux_true) && is_Const(mux_false)) {
3494                         /* both are const, good */
3495                         ir_tarval *tv_true  = get_Const_tarval(mux_true);
3496                         ir_tarval *tv_false = get_Const_tarval(mux_false);
3497                         setcc_transform_t res;
3498                         int step;
3499
3500                         find_const_transform(cc, tv_true, tv_false, &res);
3501                         new_node = node;
3502                         for (step = (int)res.num_steps - 1; step >= 0; --step) {
3503                                 ir_node *imm;
3504
3505                                 switch (res.steps[step].transform) {
3506                                 case SETCC_TR_ADD:
3507                                         new_node = new_bd_ia32_Lea(dbgi, new_block, new_node, noreg_GP);
3508                                         add_ia32_am_offs_int(new_node, res.steps[step].val);
3509                                         break;
3510                                 case SETCC_TR_ADDxx:
3511                                         new_node = new_bd_ia32_Lea(dbgi, new_block, new_node, new_node);
3512                                         break;
3513                                 case SETCC_TR_LEA:
3514                                         new_node = new_bd_ia32_Lea(dbgi, new_block, noreg_GP, new_node);
3515                                         set_ia32_am_scale(new_node, res.steps[step].scale);
3516                                         set_ia32_am_offs_int(new_node, res.steps[step].val);
3517                                         break;
3518                                 case SETCC_TR_LEAxx:
3519                                         new_node = new_bd_ia32_Lea(dbgi, new_block, new_node, new_node);
3520                                         set_ia32_am_scale(new_node, res.steps[step].scale);
3521                                         set_ia32_am_offs_int(new_node, res.steps[step].val);
3522                                         break;
3523                                 case SETCC_TR_SHL:
3524                                         imm = ia32_immediate_from_long(res.steps[step].scale);
3525                                         new_node = new_bd_ia32_Shl(dbgi, new_block, new_node, imm);
3526                                         break;
3527                                 case SETCC_TR_NEG:
3528                                         new_node = new_bd_ia32_Neg(dbgi, new_block, new_node);
3529                                         break;
3530                                 case SETCC_TR_NOT:
3531                                         new_node = new_bd_ia32_Not(dbgi, new_block, new_node);
3532                                         break;
3533                                 case SETCC_TR_AND:
3534                                         imm = ia32_immediate_from_long(res.steps[step].val);
3535                                         new_node = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, new_node, imm);
3536                                         break;
3537                                 case SETCC_TR_SET:
3538                                         new_node = create_set_32bit(dbgi, new_block, flags, res.cc, node);
3539                                         break;
3540                                 case SETCC_TR_SBB:
3541                                         new_node = new_bd_ia32_Sbb0(dbgi, new_block, flags);
3542                                         break;
3543                                 default:
3544                                         panic("unknown setcc transform");
3545                                 }
3546                         }
3547                 } else {
3548                         new_node = create_CMov(node, sel, flags, cc);
3549                 }
3550                 return new_node;
3551         }
3552 }
3553
3554
3555 /**
3556  * Create a conversion from x87 state register to general purpose.
3557  */
3558 static ir_node *gen_x87_fp_to_gp(ir_node *node)
3559 {
3560         ir_node         *block      = be_transform_node(get_nodes_block(node));
3561         ir_node         *op         = get_Conv_op(node);
3562         ir_node         *new_op     = be_transform_node(op);
3563         ir_graph        *irg        = current_ir_graph;
3564         dbg_info        *dbgi       = get_irn_dbg_info(node);
3565         ir_mode         *mode       = get_irn_mode(node);
3566         ir_node         *fist, *load, *mem;
3567
3568         mem = gen_vfist(dbgi, block, get_irg_frame(irg), noreg_GP, nomem, new_op, &fist);
3569         set_irn_pinned(fist, op_pin_state_floats);
3570         set_ia32_use_frame(fist);
3571         set_ia32_op_type(fist, ia32_AddrModeD);
3572
3573         assert(get_mode_size_bits(mode) <= 32);
3574         /* exception we can only store signed 32 bit integers, so for unsigned
3575            we store a 64bit (signed) integer and load the lower bits */
3576         if (get_mode_size_bits(mode) == 32 && !mode_is_signed(mode)) {
3577                 set_ia32_ls_mode(fist, mode_Ls);
3578         } else {
3579                 set_ia32_ls_mode(fist, mode_Is);
3580         }
3581         SET_IA32_ORIG_NODE(fist, node);
3582
3583         /* do a Load */
3584         load = new_bd_ia32_Load(dbgi, block, get_irg_frame(irg), noreg_GP, mem);
3585
3586         set_irn_pinned(load, op_pin_state_floats);
3587         set_ia32_use_frame(load);
3588         set_ia32_op_type(load, ia32_AddrModeS);
3589         set_ia32_ls_mode(load, mode_Is);
3590         if (get_ia32_ls_mode(fist) == mode_Ls) {
3591                 ia32_attr_t *attr = get_ia32_attr(load);
3592                 attr->data.need_64bit_stackent = 1;
3593         } else {
3594                 ia32_attr_t *attr = get_ia32_attr(load);
3595                 attr->data.need_32bit_stackent = 1;
3596         }
3597         SET_IA32_ORIG_NODE(load, node);
3598
3599         return new_r_Proj(load, mode_Iu, pn_ia32_Load_res);
3600 }
3601
3602 /**
3603  * Creates a x87 strict Conv by placing a Store and a Load
3604  */
3605 static ir_node *gen_x87_strict_conv(ir_mode *tgt_mode, ir_node *node)
3606 {
3607         ir_node  *block    = get_nodes_block(node);
3608         ir_graph *irg      = get_Block_irg(block);
3609         dbg_info *dbgi     = get_irn_dbg_info(node);
3610         ir_node  *frame    = get_irg_frame(irg);
3611         ir_node  *store, *load;
3612         ir_node  *new_node;
3613
3614         store = new_bd_ia32_vfst(dbgi, block, frame, noreg_GP, nomem, node, tgt_mode);
3615         set_ia32_use_frame(store);
3616         set_ia32_op_type(store, ia32_AddrModeD);
3617         SET_IA32_ORIG_NODE(store, node);
3618
3619         load = new_bd_ia32_vfld(dbgi, block, frame, noreg_GP, store, tgt_mode);
3620         set_ia32_use_frame(load);
3621         set_ia32_op_type(load, ia32_AddrModeS);
3622         SET_IA32_ORIG_NODE(load, node);
3623
3624         new_node = new_r_Proj(load, mode_E, pn_ia32_vfld_res);
3625         return new_node;
3626 }
3627
3628 static ir_node *create_Conv_I2I(dbg_info *dbgi, ir_node *block, ir_node *base,
3629                 ir_node *index, ir_node *mem, ir_node *val, ir_mode *mode)
3630 {
3631         ir_node *(*func)(dbg_info*, ir_node*, ir_node*, ir_node*, ir_node*, ir_node*, ir_mode*);
3632
3633         func = get_mode_size_bits(mode) == 8 ?
3634                 new_bd_ia32_Conv_I2I8Bit : new_bd_ia32_Conv_I2I;
3635         return func(dbgi, block, base, index, mem, val, mode);
3636 }
3637
3638 /**
3639  * Create a conversion from general purpose to x87 register
3640  */
3641 static ir_node *gen_x87_gp_to_fp(ir_node *node, ir_mode *src_mode)
3642 {
3643         ir_node  *src_block = get_nodes_block(node);
3644         ir_node  *block     = be_transform_node(src_block);
3645         ir_graph *irg       = get_Block_irg(block);
3646         dbg_info *dbgi      = get_irn_dbg_info(node);
3647         ir_node  *op        = get_Conv_op(node);
3648         ir_node  *new_op    = NULL;
3649         ir_mode  *mode;
3650         ir_mode  *store_mode;
3651         ir_node  *fild;
3652         ir_node  *store;
3653         ir_node  *new_node;
3654
3655         /* fild can use source AM if the operand is a signed 16bit or 32bit integer */
3656         if (possible_int_mode_for_fp(src_mode)) {
3657                 ia32_address_mode_t am;
3658
3659                 match_arguments(&am, src_block, NULL, op, NULL, match_am | match_try_am | match_16bit_am);
3660                 if (am.op_type == ia32_AddrModeS) {
3661                         ia32_address_t *addr = &am.addr;
3662
3663                         fild     = new_bd_ia32_vfild(dbgi, block, addr->base, addr->index, addr->mem);
3664                         new_node = new_r_Proj(fild, mode_vfp, pn_ia32_vfild_res);
3665
3666                         set_am_attributes(fild, &am);
3667                         SET_IA32_ORIG_NODE(fild, node);
3668
3669                         fix_mem_proj(fild, &am);
3670
3671                         return new_node;
3672                 }
3673         }
3674         if (new_op == NULL) {
3675                 new_op = be_transform_node(op);
3676         }
3677
3678         mode = get_irn_mode(op);
3679
3680         /* first convert to 32 bit signed if necessary */
3681         if (get_mode_size_bits(src_mode) < 32) {
3682                 if (!upper_bits_clean(new_op, src_mode)) {
3683                         new_op = create_Conv_I2I(dbgi, block, noreg_GP, noreg_GP, nomem, new_op, src_mode);
3684                         SET_IA32_ORIG_NODE(new_op, node);
3685                 }
3686                 mode = mode_Is;
3687         }
3688
3689         assert(get_mode_size_bits(mode) == 32);
3690
3691         /* do a store */
3692         store = new_bd_ia32_Store(dbgi, block, get_irg_frame(irg), noreg_GP, nomem, new_op);
3693
3694         set_ia32_use_frame(store);
3695         set_ia32_op_type(store, ia32_AddrModeD);
3696         set_ia32_ls_mode(store, mode_Iu);
3697
3698         /* exception for 32bit unsigned, do a 64bit spill+load */
3699         if (!mode_is_signed(mode)) {
3700                 ir_node *in[2];
3701                 /* store a zero */
3702                 ir_node *zero_const = ia32_create_Immediate(NULL, 0, 0);
3703
3704                 ir_node *zero_store = new_bd_ia32_Store(dbgi, block, get_irg_frame(irg),
3705                                                         noreg_GP, nomem, zero_const);
3706
3707                 set_ia32_use_frame(zero_store);
3708                 set_ia32_op_type(zero_store, ia32_AddrModeD);
3709                 add_ia32_am_offs_int(zero_store, 4);
3710                 set_ia32_ls_mode(zero_store, mode_Iu);
3711
3712                 in[0] = zero_store;
3713                 in[1] = store;
3714
3715                 store      = new_rd_Sync(dbgi, block, 2, in);
3716                 store_mode = mode_Ls;
3717         } else {
3718                 store_mode = mode_Is;
3719         }
3720
3721         /* do a fild */
3722         fild = new_bd_ia32_vfild(dbgi, block, get_irg_frame(irg), noreg_GP, store);
3723
3724         set_ia32_use_frame(fild);
3725         set_ia32_op_type(fild, ia32_AddrModeS);
3726         set_ia32_ls_mode(fild, store_mode);
3727
3728         new_node = new_r_Proj(fild, mode_vfp, pn_ia32_vfild_res);
3729
3730         return new_node;
3731 }
3732
3733 /**
3734  * Create a conversion from one integer mode into another one
3735  */
3736 static ir_node *create_I2I_Conv(ir_mode *src_mode, ir_mode *tgt_mode,
3737                                 dbg_info *dbgi, ir_node *block, ir_node *op,
3738                                 ir_node *node)
3739 {
3740         ir_node             *new_block = be_transform_node(block);
3741         ir_node             *new_node;
3742         ir_mode             *smaller_mode;
3743         ia32_address_mode_t  am;
3744         ia32_address_t      *addr = &am.addr;
3745
3746         (void) node;
3747         if (get_mode_size_bits(src_mode) < get_mode_size_bits(tgt_mode)) {
3748                 smaller_mode = src_mode;
3749         } else {
3750                 smaller_mode = tgt_mode;
3751         }
3752
3753 #ifdef DEBUG_libfirm
3754         if (is_Const(op)) {
3755                 ir_fprintf(stderr, "Optimisation warning: conv after constant %+F\n",
3756                            op);
3757         }
3758 #endif
3759
3760         match_arguments(&am, block, NULL, op, NULL,
3761                         match_am | match_8bit_am | match_16bit_am);
3762
3763         if (upper_bits_clean(am.new_op2, smaller_mode)) {
3764                 /* unnecessary conv. in theory it shouldn't have been AM */
3765                 assert(is_ia32_NoReg_GP(addr->base));
3766                 assert(is_ia32_NoReg_GP(addr->index));
3767                 assert(is_NoMem(addr->mem));
3768                 assert(am.addr.offset == 0);
3769                 assert(am.addr.symconst_ent == NULL);
3770                 return am.new_op2;
3771         }
3772
3773         new_node = create_Conv_I2I(dbgi, new_block, addr->base, addr->index,
3774                         addr->mem, am.new_op2, smaller_mode);
3775         set_am_attributes(new_node, &am);
3776         /* match_arguments assume that out-mode = in-mode, this isn't true here
3777          * so fix it */
3778         set_ia32_ls_mode(new_node, smaller_mode);
3779         SET_IA32_ORIG_NODE(new_node, node);
3780         new_node = fix_mem_proj(new_node, &am);
3781         return new_node;
3782 }
3783
3784 /**
3785  * Transforms a Conv node.
3786  *
3787  * @return The created ia32 Conv node
3788  */
3789 static ir_node *gen_Conv(ir_node *node)
3790 {
3791         ir_node  *block     = get_nodes_block(node);
3792         ir_node  *new_block = be_transform_node(block);
3793         ir_node  *op        = get_Conv_op(node);
3794         ir_node  *new_op    = NULL;
3795         dbg_info *dbgi      = get_irn_dbg_info(node);
3796         ir_mode  *src_mode  = get_irn_mode(op);
3797         ir_mode  *tgt_mode  = get_irn_mode(node);
3798         int       src_bits  = get_mode_size_bits(src_mode);
3799         int       tgt_bits  = get_mode_size_bits(tgt_mode);
3800         ir_node  *res       = NULL;
3801
3802         assert(!mode_is_int(src_mode) || src_bits <= 32);
3803         assert(!mode_is_int(tgt_mode) || tgt_bits <= 32);
3804
3805         /* modeB -> X should already be lowered by the lower_mode_b pass */
3806         if (src_mode == mode_b) {
3807                 panic("ConvB not lowered %+F", node);
3808         }
3809
3810         if (src_mode == tgt_mode) {
3811                 if (get_Conv_strict(node)) {
3812                         if (ia32_cg_config.use_sse2) {
3813                                 /* when we are in SSE mode, we can kill all strict no-op conversion */
3814                                 return be_transform_node(op);
3815                         }
3816                 } else {
3817                         /* this should be optimized already, but who knows... */
3818                         DEBUG_ONLY(ir_fprintf(stderr, "Debug warning: conv %+F is pointless\n", node));
3819                         DB((dbg, LEVEL_1, "killed Conv(mode, mode) ..."));
3820                         return be_transform_node(op);
3821                 }
3822         }
3823
3824         if (mode_is_float(src_mode)) {
3825                 new_op = be_transform_node(op);
3826                 /* we convert from float ... */
3827                 if (mode_is_float(tgt_mode)) {
3828                         /* ... to float */
3829                         if (ia32_cg_config.use_sse2) {
3830                                 DB((dbg, LEVEL_1, "create Conv(float, float) ..."));
3831                                 res = new_bd_ia32_Conv_FP2FP(dbgi, new_block, noreg_GP, noreg_GP,
3832                                                              nomem, new_op);
3833                                 set_ia32_ls_mode(res, tgt_mode);
3834                         } else {
3835                                 if (get_Conv_strict(node)) {
3836                                         /* if fp_no_float_fold is not set then we assume that we
3837                                          * don't have any float operations in a non
3838                                          * mode_float_arithmetic mode and can skip strict upconvs */
3839                                         if (src_bits < tgt_bits) {
3840                                                 DB((dbg, LEVEL_1, "killed Conv(float, float) ..."));
3841                                                 return new_op;
3842                                         } else {
3843                                                 res = gen_x87_strict_conv(tgt_mode, new_op);
3844                                                 SET_IA32_ORIG_NODE(get_Proj_pred(res), node);
3845                                                 return res;
3846                                         }
3847                                 }
3848                                 DB((dbg, LEVEL_1, "killed Conv(float, float) ..."));
3849                                 return new_op;
3850                         }
3851                 } else {
3852                         /* ... to int */
3853                         DB((dbg, LEVEL_1, "create Conv(float, int) ..."));
3854                         if (ia32_cg_config.use_sse2) {
3855                                 res = new_bd_ia32_Conv_FP2I(dbgi, new_block, noreg_GP, noreg_GP,
3856                                                             nomem, new_op);
3857                                 set_ia32_ls_mode(res, src_mode);
3858                         } else {
3859                                 return gen_x87_fp_to_gp(node);
3860                         }
3861                 }
3862         } else {
3863                 /* we convert from int ... */
3864                 if (mode_is_float(tgt_mode)) {
3865                         /* ... to float */
3866                         DB((dbg, LEVEL_1, "create Conv(int, float) ..."));
3867                         if (ia32_cg_config.use_sse2) {
3868                                 new_op = be_transform_node(op);
3869                                 res = new_bd_ia32_Conv_I2FP(dbgi, new_block, noreg_GP, noreg_GP,
3870                                                             nomem, new_op);
3871                                 set_ia32_ls_mode(res, tgt_mode);
3872                         } else {
3873                                 unsigned int_mantissa   = get_mode_size_bits(src_mode) - (mode_is_signed(src_mode) ? 1 : 0);
3874                                 unsigned float_mantissa = tarval_ieee754_get_mantissa_size(tgt_mode);
3875                                 res = gen_x87_gp_to_fp(node, src_mode);
3876
3877                                 /* we need a strict-Conv, if the int mode has more bits than the
3878                                  * float mantissa */
3879                                 if (float_mantissa < int_mantissa) {
3880                                         res = gen_x87_strict_conv(tgt_mode, res);
3881                                         SET_IA32_ORIG_NODE(get_Proj_pred(res), node);
3882                                 }
3883                                 return res;
3884                         }
3885                 } else if (tgt_mode == mode_b) {
3886                         /* mode_b lowering already took care that we only have 0/1 values */
3887                         DB((dbg, LEVEL_1, "omitting unnecessary Conv(%+F, %+F) ...",
3888                             src_mode, tgt_mode));
3889                         return be_transform_node(op);
3890                 } else {
3891                         /* to int */
3892                         if (src_bits == tgt_bits) {
3893                                 DB((dbg, LEVEL_1, "omitting unnecessary Conv(%+F, %+F) ...",
3894                                     src_mode, tgt_mode));
3895                                 return be_transform_node(op);
3896                         }
3897
3898                         res = create_I2I_Conv(src_mode, tgt_mode, dbgi, block, op, node);
3899                         return res;
3900                 }
3901         }
3902
3903         return res;
3904 }
3905
3906 static ir_node *create_immediate_or_transform(ir_node *node,
3907                                               char immediate_constraint_type)
3908 {
3909         ir_node *new_node = ia32_try_create_Immediate(node, immediate_constraint_type);
3910         if (new_node == NULL) {
3911                 new_node = be_transform_node(node);
3912         }
3913         return new_node;
3914 }
3915
3916 /**
3917  * Transforms a FrameAddr into an ia32 Add.
3918  */
3919 static ir_node *gen_be_FrameAddr(ir_node *node)
3920 {
3921         ir_node  *block  = be_transform_node(get_nodes_block(node));
3922         ir_node  *op     = be_get_FrameAddr_frame(node);
3923         ir_node  *new_op = be_transform_node(op);
3924         dbg_info *dbgi   = get_irn_dbg_info(node);
3925         ir_node  *new_node;
3926
3927         new_node = new_bd_ia32_Lea(dbgi, block, new_op, noreg_GP);
3928         set_ia32_frame_ent(new_node, arch_get_frame_entity(node));
3929         set_ia32_use_frame(new_node);
3930
3931         SET_IA32_ORIG_NODE(new_node, node);
3932
3933         return new_node;
3934 }
3935
3936 /**
3937  * In case SSE is used we need to copy the result from XMM0 to FPU TOS before return.
3938  */
3939 static ir_node *gen_be_Return(ir_node *node)
3940 {
3941         ir_graph  *irg     = current_ir_graph;
3942         ir_node   *ret_val = get_irn_n(node, be_pos_Return_val);
3943         ir_node   *ret_mem = get_irn_n(node, be_pos_Return_mem);
3944         ir_entity *ent     = get_irg_entity(irg);
3945         ir_type   *tp      = get_entity_type(ent);
3946         dbg_info  *dbgi;
3947         ir_node   *block;
3948         ir_type   *res_type;
3949         ir_mode   *mode;
3950         ir_node   *frame, *sse_store, *fld, *mproj, *barrier;
3951         ir_node   *new_barrier, *new_ret_val, *new_ret_mem;
3952         ir_node   **in;
3953         int       pn_ret_val, pn_ret_mem, arity, i;
3954
3955         assert(ret_val != NULL);
3956         if (be_Return_get_n_rets(node) < 1 || ! ia32_cg_config.use_sse2) {
3957                 return be_duplicate_node(node);
3958         }
3959
3960         res_type = get_method_res_type(tp, 0);
3961
3962         if (! is_Primitive_type(res_type)) {
3963                 return be_duplicate_node(node);
3964         }
3965
3966         mode = get_type_mode(res_type);
3967         if (! mode_is_float(mode)) {
3968                 return be_duplicate_node(node);
3969         }
3970
3971         assert(get_method_n_ress(tp) == 1);
3972
3973         pn_ret_val = get_Proj_proj(ret_val);
3974         pn_ret_mem = get_Proj_proj(ret_mem);
3975
3976         /* get the Barrier */
3977         barrier = get_Proj_pred(ret_val);
3978
3979         /* get result input of the Barrier */
3980         ret_val     = get_irn_n(barrier, pn_ret_val);
3981         new_ret_val = be_transform_node(ret_val);
3982
3983         /* get memory input of the Barrier */
3984         ret_mem     = get_irn_n(barrier, pn_ret_mem);
3985         new_ret_mem = be_transform_node(ret_mem);
3986
3987         frame = get_irg_frame(irg);
3988
3989         dbgi  = get_irn_dbg_info(barrier);
3990         block = be_transform_node(get_nodes_block(barrier));
3991
3992         /* store xmm0 onto stack */
3993         sse_store = new_bd_ia32_xStoreSimple(dbgi, block, frame, noreg_GP,
3994                                              new_ret_mem, new_ret_val);
3995         set_ia32_ls_mode(sse_store, mode);
3996         set_ia32_op_type(sse_store, ia32_AddrModeD);
3997         set_ia32_use_frame(sse_store);
3998
3999         /* load into x87 register */
4000         fld = new_bd_ia32_vfld(dbgi, block, frame, noreg_GP, sse_store, mode);
4001         set_ia32_op_type(fld, ia32_AddrModeS);
4002         set_ia32_use_frame(fld);
4003
4004         mproj = new_r_Proj(fld, mode_M, pn_ia32_vfld_M);
4005         fld   = new_r_Proj(fld, mode_vfp, pn_ia32_vfld_res);
4006
4007         /* create a new barrier */
4008         arity = get_irn_arity(barrier);
4009         in    = ALLOCAN(ir_node*, arity);
4010         for (i = 0; i < arity; ++i) {
4011                 ir_node *new_in;
4012
4013                 if (i == pn_ret_val) {
4014                         new_in = fld;
4015                 } else if (i == pn_ret_mem) {
4016                         new_in = mproj;
4017                 } else {
4018                         ir_node *in = get_irn_n(barrier, i);
4019                         new_in = be_transform_node(in);
4020                 }
4021                 in[i] = new_in;
4022         }
4023
4024         new_barrier = new_ir_node(dbgi, irg, block,
4025                                   get_irn_op(barrier), get_irn_mode(barrier),
4026                                   arity, in);
4027         copy_node_attr(irg, barrier, new_barrier);
4028         be_duplicate_deps(barrier, new_barrier);
4029         be_set_transformed_node(barrier, new_barrier);
4030
4031         /* transform normally */
4032         return be_duplicate_node(node);
4033 }
4034
4035 /**
4036  * Transform a be_AddSP into an ia32_SubSP.
4037  */
4038 static ir_node *gen_be_AddSP(ir_node *node)
4039 {
4040         ir_node  *sz = get_irn_n(node, be_pos_AddSP_size);
4041         ir_node  *sp = get_irn_n(node, be_pos_AddSP_old_sp);
4042
4043         return gen_binop(node, sp, sz, new_bd_ia32_SubSP,
4044                          match_am | match_immediate);
4045 }
4046
4047 /**
4048  * Transform a be_SubSP into an ia32_AddSP
4049  */
4050 static ir_node *gen_be_SubSP(ir_node *node)
4051 {
4052         ir_node  *sz = get_irn_n(node, be_pos_SubSP_size);
4053         ir_node  *sp = get_irn_n(node, be_pos_SubSP_old_sp);
4054
4055         return gen_binop(node, sp, sz, new_bd_ia32_AddSP,
4056                          match_am | match_immediate);
4057 }
4058
4059 /**
4060  * Change some phi modes
4061  */
4062 static ir_node *gen_Phi(ir_node *node)
4063 {
4064         const arch_register_req_t *req;
4065         ir_node  *block = be_transform_node(get_nodes_block(node));
4066         ir_graph *irg   = current_ir_graph;
4067         dbg_info *dbgi  = get_irn_dbg_info(node);
4068         ir_mode  *mode  = get_irn_mode(node);
4069         ir_node  *phi;
4070
4071         if (ia32_mode_needs_gp_reg(mode)) {
4072                 /* we shouldn't have any 64bit stuff around anymore */
4073                 assert(get_mode_size_bits(mode) <= 32);
4074                 /* all integer operations are on 32bit registers now */
4075                 mode = mode_Iu;
4076                 req  = ia32_reg_classes[CLASS_ia32_gp].class_req;
4077         } else if (mode_is_float(mode)) {
4078                 if (ia32_cg_config.use_sse2) {
4079                         mode = mode_xmm;
4080                         req  = ia32_reg_classes[CLASS_ia32_xmm].class_req;
4081                 } else {
4082                         mode = mode_vfp;
4083                         req  = ia32_reg_classes[CLASS_ia32_vfp].class_req;
4084                 }
4085         } else {
4086                 req = arch_no_register_req;
4087         }
4088
4089         /* phi nodes allow loops, so we use the old arguments for now
4090          * and fix this later */
4091         phi = new_ir_node(dbgi, irg, block, op_Phi, mode, get_irn_arity(node),
4092                           get_irn_in(node) + 1);
4093         copy_node_attr(irg, node, phi);
4094         be_duplicate_deps(node, phi);
4095
4096         arch_set_out_register_req(phi, 0, req);
4097
4098         be_enqueue_preds(node);
4099
4100         return phi;
4101 }
4102
4103 static ir_node *gen_Jmp(ir_node *node)
4104 {
4105         ir_node  *block     = get_nodes_block(node);
4106         ir_node  *new_block = be_transform_node(block);
4107         dbg_info *dbgi      = get_irn_dbg_info(node);
4108         ir_node  *new_node;
4109
4110         new_node = new_bd_ia32_Jmp(dbgi, new_block);
4111         SET_IA32_ORIG_NODE(new_node, node);
4112
4113         return new_node;
4114 }
4115
4116 /**
4117  * Transform IJmp
4118  */
4119 static ir_node *gen_IJmp(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  *op        = get_IJmp_target(node);
4125         ir_node  *new_node;
4126         ia32_address_mode_t  am;
4127         ia32_address_t      *addr = &am.addr;
4128
4129         assert(get_irn_mode(op) == mode_P);
4130
4131         match_arguments(&am, block, NULL, op, NULL, match_am | match_immediate);
4132
4133         new_node = new_bd_ia32_IJmp(dbgi, new_block, addr->base, addr->index,
4134                         addr->mem, am.new_op2);
4135         set_am_attributes(new_node, &am);
4136         SET_IA32_ORIG_NODE(new_node, node);
4137
4138         new_node = fix_mem_proj(new_node, &am);
4139
4140         return new_node;
4141 }
4142
4143 static ir_node *gen_ia32_l_ShlDep(ir_node *node)
4144 {
4145         ir_node *left  = get_irn_n(node, n_ia32_l_ShlDep_val);
4146         ir_node *right = get_irn_n(node, n_ia32_l_ShlDep_count);
4147
4148         return gen_shift_binop(node, left, right, new_bd_ia32_Shl,
4149                                match_immediate | match_mode_neutral);
4150 }
4151
4152 static ir_node *gen_ia32_l_ShrDep(ir_node *node)
4153 {
4154         ir_node *left  = get_irn_n(node, n_ia32_l_ShrDep_val);
4155         ir_node *right = get_irn_n(node, n_ia32_l_ShrDep_count);
4156         return gen_shift_binop(node, left, right, new_bd_ia32_Shr,
4157                                match_immediate);
4158 }
4159
4160 static ir_node *gen_ia32_l_SarDep(ir_node *node)
4161 {
4162         ir_node *left  = get_irn_n(node, n_ia32_l_SarDep_val);
4163         ir_node *right = get_irn_n(node, n_ia32_l_SarDep_count);
4164         return gen_shift_binop(node, left, right, new_bd_ia32_Sar,
4165                                match_immediate);
4166 }
4167
4168 static ir_node *gen_ia32_l_Add(ir_node *node)
4169 {
4170         ir_node *left    = get_irn_n(node, n_ia32_l_Add_left);
4171         ir_node *right   = get_irn_n(node, n_ia32_l_Add_right);
4172         ir_node *lowered = gen_binop(node, left, right, new_bd_ia32_Add,
4173                         match_commutative | match_am | match_immediate |
4174                         match_mode_neutral);
4175
4176         if (is_Proj(lowered)) {
4177                 lowered = get_Proj_pred(lowered);
4178         } else {
4179                 assert(is_ia32_Add(lowered));
4180                 set_irn_mode(lowered, mode_T);
4181         }
4182
4183         return lowered;
4184 }
4185
4186 static ir_node *gen_ia32_l_Adc(ir_node *node)
4187 {
4188         return gen_binop_flags(node, new_bd_ia32_Adc,
4189                         match_commutative | match_am | match_immediate |
4190                         match_mode_neutral);
4191 }
4192
4193 /**
4194  * Transforms a l_MulS into a "real" MulS node.
4195  *
4196  * @return the created ia32 Mul node
4197  */
4198 static ir_node *gen_ia32_l_Mul(ir_node *node)
4199 {
4200         ir_node *left  = get_binop_left(node);
4201         ir_node *right = get_binop_right(node);
4202
4203         return gen_binop(node, left, right, new_bd_ia32_Mul,
4204                          match_commutative | match_am | match_mode_neutral);
4205 }
4206
4207 /**
4208  * Transforms a l_IMulS into a "real" IMul1OPS node.
4209  *
4210  * @return the created ia32 IMul1OP node
4211  */
4212 static ir_node *gen_ia32_l_IMul(ir_node *node)
4213 {
4214         ir_node  *left  = get_binop_left(node);
4215         ir_node  *right = get_binop_right(node);
4216
4217         return gen_binop(node, left, right, new_bd_ia32_IMul1OP,
4218                          match_commutative | match_am | match_mode_neutral);
4219 }
4220
4221 static ir_node *gen_ia32_l_Sub(ir_node *node)
4222 {
4223         ir_node *left    = get_irn_n(node, n_ia32_l_Sub_minuend);
4224         ir_node *right   = get_irn_n(node, n_ia32_l_Sub_subtrahend);
4225         ir_node *lowered = gen_binop(node, left, right, new_bd_ia32_Sub,
4226                         match_am | match_immediate | match_mode_neutral);
4227
4228         if (is_Proj(lowered)) {
4229                 lowered = get_Proj_pred(lowered);
4230         } else {
4231                 assert(is_ia32_Sub(lowered));
4232                 set_irn_mode(lowered, mode_T);
4233         }
4234
4235         return lowered;
4236 }
4237
4238 static ir_node *gen_ia32_l_Sbb(ir_node *node)
4239 {
4240         return gen_binop_flags(node, new_bd_ia32_Sbb,
4241                         match_am | match_immediate | match_mode_neutral);
4242 }
4243
4244 /**
4245  * Transforms a l_ShlD/l_ShrD into a ShlD/ShrD. Those nodes have 3 data inputs:
4246  * op1 - target to be shifted
4247  * op2 - contains bits to be shifted into target
4248  * op3 - shift count
4249  * Only op3 can be an immediate.
4250  */
4251 static ir_node *gen_lowered_64bit_shifts(ir_node *node, ir_node *high,
4252                                          ir_node *low, ir_node *count)
4253 {
4254         ir_node  *block     = get_nodes_block(node);
4255         ir_node  *new_block = be_transform_node(block);
4256         dbg_info *dbgi      = get_irn_dbg_info(node);
4257         ir_node  *new_high  = be_transform_node(high);
4258         ir_node  *new_low   = be_transform_node(low);
4259         ir_node  *new_count;
4260         ir_node  *new_node;
4261
4262         /* the shift amount can be any mode that is bigger than 5 bits, since all
4263          * other bits are ignored anyway */
4264         while (is_Conv(count)              &&
4265                get_irn_n_edges(count) == 1 &&
4266                mode_is_int(get_irn_mode(count))) {
4267                 assert(get_mode_size_bits(get_irn_mode(count)) >= 5);
4268                 count = get_Conv_op(count);
4269         }
4270         new_count = create_immediate_or_transform(count, 0);
4271
4272         if (is_ia32_l_ShlD(node)) {
4273                 new_node = new_bd_ia32_ShlD(dbgi, new_block, new_high, new_low,
4274                                             new_count);
4275         } else {
4276                 new_node = new_bd_ia32_ShrD(dbgi, new_block, new_high, new_low,
4277                                             new_count);
4278         }
4279         SET_IA32_ORIG_NODE(new_node, node);
4280
4281         return new_node;
4282 }
4283
4284 static ir_node *gen_ia32_l_ShlD(ir_node *node)
4285 {
4286         ir_node *high  = get_irn_n(node, n_ia32_l_ShlD_val_high);
4287         ir_node *low   = get_irn_n(node, n_ia32_l_ShlD_val_low);
4288         ir_node *count = get_irn_n(node, n_ia32_l_ShlD_count);
4289         return gen_lowered_64bit_shifts(node, high, low, count);
4290 }
4291
4292 static ir_node *gen_ia32_l_ShrD(ir_node *node)
4293 {
4294         ir_node *high  = get_irn_n(node, n_ia32_l_ShrD_val_high);
4295         ir_node *low   = get_irn_n(node, n_ia32_l_ShrD_val_low);
4296         ir_node *count = get_irn_n(node, n_ia32_l_ShrD_count);
4297         return gen_lowered_64bit_shifts(node, high, low, count);
4298 }
4299
4300 static ir_node *gen_ia32_l_LLtoFloat(ir_node *node)
4301 {
4302         ir_node  *src_block    = get_nodes_block(node);
4303         ir_node  *block        = be_transform_node(src_block);
4304         ir_graph *irg          = current_ir_graph;
4305         dbg_info *dbgi         = get_irn_dbg_info(node);
4306         ir_node  *frame        = get_irg_frame(irg);
4307         ir_node  *val_low      = get_irn_n(node, n_ia32_l_LLtoFloat_val_low);
4308         ir_node  *val_high     = get_irn_n(node, n_ia32_l_LLtoFloat_val_high);
4309         ir_node  *new_val_low  = be_transform_node(val_low);
4310         ir_node  *new_val_high = be_transform_node(val_high);
4311         ir_node  *in[2];
4312         ir_node  *sync, *fild, *res;
4313         ir_node  *store_low, *store_high;
4314
4315         if (ia32_cg_config.use_sse2) {
4316                 panic("ia32_l_LLtoFloat not implemented for SSE2");
4317         }
4318
4319         /* do a store */
4320         store_low = new_bd_ia32_Store(dbgi, block, frame, noreg_GP, nomem,
4321                                       new_val_low);
4322         store_high = new_bd_ia32_Store(dbgi, block, frame, noreg_GP, nomem,
4323                                        new_val_high);
4324         SET_IA32_ORIG_NODE(store_low,  node);
4325         SET_IA32_ORIG_NODE(store_high, node);
4326
4327         set_ia32_use_frame(store_low);
4328         set_ia32_use_frame(store_high);
4329         set_ia32_op_type(store_low, ia32_AddrModeD);
4330         set_ia32_op_type(store_high, ia32_AddrModeD);
4331         set_ia32_ls_mode(store_low, mode_Iu);
4332         set_ia32_ls_mode(store_high, mode_Is);
4333         add_ia32_am_offs_int(store_high, 4);
4334
4335         in[0] = store_low;
4336         in[1] = store_high;
4337         sync  = new_rd_Sync(dbgi, block, 2, in);
4338
4339         /* do a fild */
4340         fild = new_bd_ia32_vfild(dbgi, block, frame, noreg_GP, sync);
4341
4342         set_ia32_use_frame(fild);
4343         set_ia32_op_type(fild, ia32_AddrModeS);
4344         set_ia32_ls_mode(fild, mode_Ls);
4345
4346         SET_IA32_ORIG_NODE(fild, node);
4347
4348         res = new_r_Proj(fild, mode_vfp, pn_ia32_vfild_res);
4349
4350         if (! mode_is_signed(get_irn_mode(val_high))) {
4351                 ia32_address_mode_t  am;
4352
4353                 ir_node *count = ia32_create_Immediate(NULL, 0, 31);
4354                 ir_node *fadd;
4355
4356                 am.addr.base          = get_symconst_base();
4357                 am.addr.index         = new_bd_ia32_Shr(dbgi, block, new_val_high, count);
4358                 am.addr.mem           = nomem;
4359                 am.addr.offset        = 0;
4360                 am.addr.scale         = 2;
4361                 am.addr.symconst_ent  = ia32_gen_fp_known_const(ia32_ULLBIAS);
4362                 am.addr.use_frame     = 0;
4363                 am.addr.frame_entity  = NULL;
4364                 am.addr.symconst_sign = 0;
4365                 am.ls_mode            = mode_F;
4366                 am.mem_proj           = nomem;
4367                 am.op_type            = ia32_AddrModeS;
4368                 am.new_op1            = res;
4369                 am.new_op2            = ia32_new_NoReg_vfp(current_ir_graph);
4370                 am.pinned             = op_pin_state_floats;
4371                 am.commutative        = 1;
4372                 am.ins_permuted       = false;
4373
4374                 fadd  = new_bd_ia32_vfadd(dbgi, block, am.addr.base, am.addr.index, am.addr.mem,
4375                         am.new_op1, am.new_op2, get_fpcw());
4376                 set_am_attributes(fadd, &am);
4377
4378                 set_irn_mode(fadd, mode_T);
4379                 res = new_rd_Proj(NULL, fadd, mode_vfp, pn_ia32_res);
4380         }
4381         return res;
4382 }
4383
4384 static ir_node *gen_ia32_l_FloattoLL(ir_node *node)
4385 {
4386         ir_node  *src_block  = get_nodes_block(node);
4387         ir_node  *block      = be_transform_node(src_block);
4388         ir_graph *irg        = get_Block_irg(block);
4389         dbg_info *dbgi       = get_irn_dbg_info(node);
4390         ir_node  *frame      = get_irg_frame(irg);
4391         ir_node  *val        = get_irn_n(node, n_ia32_l_FloattoLL_val);
4392         ir_node  *new_val    = be_transform_node(val);
4393         ir_node  *fist, *mem;
4394
4395         mem = gen_vfist(dbgi, block, frame, noreg_GP, nomem, new_val, &fist);
4396         SET_IA32_ORIG_NODE(fist, node);
4397         set_ia32_use_frame(fist);
4398         set_ia32_op_type(fist, ia32_AddrModeD);
4399         set_ia32_ls_mode(fist, mode_Ls);
4400
4401         return mem;
4402 }
4403
4404 static ir_node *gen_Proj_l_FloattoLL(ir_node *node)
4405 {
4406         ir_node  *block    = be_transform_node(get_nodes_block(node));
4407         ir_graph *irg      = get_Block_irg(block);
4408         ir_node  *pred     = get_Proj_pred(node);
4409         ir_node  *new_pred = be_transform_node(pred);
4410         ir_node  *frame    = get_irg_frame(irg);
4411         dbg_info *dbgi     = get_irn_dbg_info(node);
4412         long      pn       = get_Proj_proj(node);
4413         ir_node  *load;
4414         ir_node  *proj;
4415         ia32_attr_t *attr;
4416
4417         load = new_bd_ia32_Load(dbgi, block, frame, noreg_GP, new_pred);
4418         SET_IA32_ORIG_NODE(load, node);
4419         set_ia32_use_frame(load);
4420         set_ia32_op_type(load, ia32_AddrModeS);
4421         set_ia32_ls_mode(load, mode_Iu);
4422         /* we need a 64bit stackslot (fist stores 64bit) even though we only load
4423          * 32 bit from it with this particular load */
4424         attr = get_ia32_attr(load);
4425         attr->data.need_64bit_stackent = 1;
4426
4427         if (pn == pn_ia32_l_FloattoLL_res_high) {
4428                 add_ia32_am_offs_int(load, 4);
4429         } else {
4430                 assert(pn == pn_ia32_l_FloattoLL_res_low);
4431         }
4432
4433         proj = new_r_Proj(load, mode_Iu, pn_ia32_Load_res);
4434
4435         return proj;
4436 }
4437
4438 /**
4439  * Transform the Projs of an AddSP.
4440  */
4441 static ir_node *gen_Proj_be_AddSP(ir_node *node)
4442 {
4443         ir_node  *pred     = get_Proj_pred(node);
4444         ir_node  *new_pred = be_transform_node(pred);
4445         dbg_info *dbgi     = get_irn_dbg_info(node);
4446         long     proj      = get_Proj_proj(node);
4447
4448         if (proj == pn_be_AddSP_sp) {
4449                 ir_node *res = new_rd_Proj(dbgi, new_pred, mode_Iu,
4450                                            pn_ia32_SubSP_stack);
4451                 arch_set_irn_register(res, &ia32_registers[REG_ESP]);
4452                 return res;
4453         } else if (proj == pn_be_AddSP_res) {
4454                 return new_rd_Proj(dbgi, new_pred, mode_Iu,
4455                                    pn_ia32_SubSP_addr);
4456         } else if (proj == pn_be_AddSP_M) {
4457                 return new_rd_Proj(dbgi, new_pred, mode_M, pn_ia32_SubSP_M);
4458         }
4459
4460         panic("No idea how to transform proj->AddSP");
4461 }
4462
4463 /**
4464  * Transform the Projs of a SubSP.
4465  */
4466 static ir_node *gen_Proj_be_SubSP(ir_node *node)
4467 {
4468         ir_node  *pred     = get_Proj_pred(node);
4469         ir_node  *new_pred = be_transform_node(pred);
4470         dbg_info *dbgi     = get_irn_dbg_info(node);
4471         long     proj      = get_Proj_proj(node);
4472
4473         if (proj == pn_be_SubSP_sp) {
4474                 ir_node *res = new_rd_Proj(dbgi, new_pred, mode_Iu,
4475                                            pn_ia32_AddSP_stack);
4476                 arch_set_irn_register(res, &ia32_registers[REG_ESP]);
4477                 return res;
4478         } else if (proj == pn_be_SubSP_M) {
4479                 return new_rd_Proj(dbgi, new_pred, mode_M, pn_ia32_AddSP_M);
4480         }
4481
4482         panic("No idea how to transform proj->SubSP");
4483 }
4484
4485 /**
4486  * Transform and renumber the Projs from a Load.
4487  */
4488 static ir_node *gen_Proj_Load(ir_node *node)
4489 {
4490         ir_node  *new_pred;
4491         ir_node  *block    = be_transform_node(get_nodes_block(node));
4492         ir_node  *pred     = get_Proj_pred(node);
4493         dbg_info *dbgi     = get_irn_dbg_info(node);
4494         long     proj      = get_Proj_proj(node);
4495
4496         /* loads might be part of source address mode matches, so we don't
4497          * transform the ProjMs yet (with the exception of loads whose result is
4498          * not used)
4499          */
4500         if (is_Load(pred) && proj == pn_Load_M && get_irn_n_edges(pred) > 1) {
4501                 ir_node *res;
4502
4503                 /* this is needed, because sometimes we have loops that are only
4504                    reachable through the ProjM */
4505                 be_enqueue_preds(node);
4506                 /* do it in 2 steps, to silence firm verifier */
4507                 res = new_rd_Proj(dbgi, pred, mode_M, pn_Load_M);
4508                 set_Proj_proj(res, pn_ia32_mem);
4509                 return res;
4510         }
4511
4512         /* renumber the proj */
4513         new_pred = be_transform_node(pred);
4514         if (is_ia32_Load(new_pred)) {
4515                 switch (proj) {
4516                 case pn_Load_res:
4517                         return new_rd_Proj(dbgi, new_pred, mode_Iu, pn_ia32_Load_res);
4518                 case pn_Load_M:
4519                         return new_rd_Proj(dbgi, new_pred, mode_M, pn_ia32_Load_M);
4520                 case pn_Load_X_regular:
4521                         return new_rd_Jmp(dbgi, block);
4522                 case pn_Load_X_except:
4523                         /* This Load might raise an exception. Mark it. */
4524                         set_ia32_exc_label(new_pred, 1);
4525                         return new_rd_Proj(dbgi, new_pred, mode_X, pn_ia32_Load_X_exc);
4526                 default:
4527                         break;
4528                 }
4529         } else if (is_ia32_Conv_I2I(new_pred) ||
4530                    is_ia32_Conv_I2I8Bit(new_pred)) {
4531                 set_irn_mode(new_pred, mode_T);
4532                 if (proj == pn_Load_res) {
4533                         return new_rd_Proj(dbgi, new_pred, mode_Iu, pn_ia32_res);
4534                 } else if (proj == pn_Load_M) {
4535                         return new_rd_Proj(dbgi, new_pred, mode_M, pn_ia32_mem);
4536                 }
4537         } else if (is_ia32_xLoad(new_pred)) {
4538                 switch (proj) {
4539                 case pn_Load_res:
4540                         return new_rd_Proj(dbgi, new_pred, mode_xmm, pn_ia32_xLoad_res);
4541                 case pn_Load_M:
4542                         return new_rd_Proj(dbgi, new_pred, mode_M, pn_ia32_xLoad_M);
4543                 case pn_Load_X_regular:
4544                         return new_rd_Jmp(dbgi, block);
4545                 case pn_Load_X_except:
4546                         /* This Load might raise an exception. Mark it. */
4547                         set_ia32_exc_label(new_pred, 1);
4548                         return new_rd_Proj(dbgi, new_pred, mode_X, pn_ia32_xLoad_X_exc);
4549                 default:
4550                         break;
4551                 }
4552         } else if (is_ia32_vfld(new_pred)) {
4553                 switch (proj) {
4554                 case pn_Load_res:
4555                         return new_rd_Proj(dbgi, new_pred, mode_vfp, pn_ia32_vfld_res);
4556                 case pn_Load_M:
4557                         return new_rd_Proj(dbgi, new_pred, mode_M, pn_ia32_vfld_M);
4558                 case pn_Load_X_regular:
4559                         return new_rd_Jmp(dbgi, block);
4560                 case pn_Load_X_except:
4561                         /* This Load might raise an exception. Mark it. */
4562                         set_ia32_exc_label(new_pred, 1);
4563                         return new_rd_Proj(dbgi, new_pred, mode_X, pn_ia32_vfld_X_exc);
4564                 default:
4565                         break;
4566                 }
4567         } else {
4568                 /* can happen for ProJMs when source address mode happened for the
4569                    node */
4570
4571                 /* however it should not be the result proj, as that would mean the
4572                    load had multiple users and should not have been used for
4573                    SourceAM */
4574                 if (proj != pn_Load_M) {
4575                         panic("internal error: transformed node not a Load");
4576                 }
4577                 return new_rd_Proj(dbgi, new_pred, mode_M, 1);
4578         }
4579
4580         panic("No idea how to transform proj");
4581 }
4582
4583 /**
4584  * Transform and renumber the Projs from a Div or Mod instruction.
4585  */
4586 static ir_node *gen_Proj_Div(ir_node *node)
4587 {
4588         ir_node  *block    = be_transform_node(get_nodes_block(node));
4589         ir_node  *pred     = get_Proj_pred(node);
4590         ir_node  *new_pred = be_transform_node(pred);
4591         dbg_info *dbgi     = get_irn_dbg_info(node);
4592         long     proj      = get_Proj_proj(node);
4593
4594         assert(pn_ia32_Div_M == pn_ia32_IDiv_M);
4595         assert(pn_ia32_Div_div_res == pn_ia32_IDiv_div_res);
4596
4597         switch (proj) {
4598         case pn_Div_M:
4599                 if (is_ia32_Div(new_pred) || is_ia32_IDiv(new_pred)) {
4600                         return new_rd_Proj(dbgi, new_pred, mode_M, pn_ia32_Div_M);
4601                 } else if (is_ia32_xDiv(new_pred)) {
4602                         return new_rd_Proj(dbgi, new_pred, mode_M, pn_ia32_xDiv_M);
4603                 } else if (is_ia32_vfdiv(new_pred)) {
4604                         return new_rd_Proj(dbgi, new_pred, mode_M, pn_ia32_vfdiv_M);
4605                 } else {
4606                         panic("Div transformed to unexpected thing %+F", new_pred);
4607                 }
4608         case pn_Div_res:
4609                 if (is_ia32_Div(new_pred) || is_ia32_IDiv(new_pred)) {
4610                         return new_rd_Proj(dbgi, new_pred, mode_Iu, pn_ia32_Div_div_res);
4611                 } else if (is_ia32_xDiv(new_pred)) {
4612                         return new_rd_Proj(dbgi, new_pred, mode_xmm, pn_ia32_xDiv_res);
4613                 } else if (is_ia32_vfdiv(new_pred)) {
4614                         return new_rd_Proj(dbgi, new_pred, mode_vfp, pn_ia32_vfdiv_res);
4615                 } else {
4616                         panic("Div transformed to unexpected thing %+F", new_pred);
4617                 }
4618         case pn_Div_X_regular:
4619                 return new_rd_Jmp(dbgi, block);
4620         case pn_Div_X_except:
4621                 set_ia32_exc_label(new_pred, 1);
4622                 return new_rd_Proj(dbgi, new_pred, mode_X, pn_ia32_Div_X_exc);
4623         default:
4624                 break;
4625         }
4626
4627         panic("No idea how to transform proj->Div");
4628 }
4629
4630 /**
4631  * Transform and renumber the Projs from a Div or Mod instruction.
4632  */
4633 static ir_node *gen_Proj_Mod(ir_node *node)
4634 {
4635         ir_node  *pred     = get_Proj_pred(node);
4636         ir_node  *new_pred = be_transform_node(pred);
4637         dbg_info *dbgi     = get_irn_dbg_info(node);
4638         long     proj      = get_Proj_proj(node);
4639
4640         assert(is_ia32_Div(new_pred) || is_ia32_IDiv(new_pred));
4641         assert(pn_ia32_Div_M == pn_ia32_IDiv_M);
4642         assert(pn_ia32_Div_mod_res == pn_ia32_IDiv_mod_res);
4643
4644         switch (proj) {
4645         case pn_Mod_M:
4646                 return new_rd_Proj(dbgi, new_pred, mode_M, pn_ia32_Div_M);
4647         case pn_Mod_res:
4648                 return new_rd_Proj(dbgi, new_pred, mode_Iu, pn_ia32_Div_mod_res);
4649         case pn_Mod_X_except:
4650                 set_ia32_exc_label(new_pred, 1);
4651                 return new_rd_Proj(dbgi, new_pred, mode_X, pn_ia32_Div_X_exc);
4652         default:
4653                 break;
4654         }
4655         panic("No idea how to transform proj->Mod");
4656 }
4657
4658 /**
4659  * Transform and renumber the Projs from a CopyB.
4660  */
4661 static ir_node *gen_Proj_CopyB(ir_node *node)
4662 {
4663         ir_node  *pred     = get_Proj_pred(node);
4664         ir_node  *new_pred = be_transform_node(pred);
4665         dbg_info *dbgi     = get_irn_dbg_info(node);
4666         long     proj      = get_Proj_proj(node);
4667
4668         switch (proj) {
4669         case pn_CopyB_M:
4670                 if (is_ia32_CopyB_i(new_pred)) {
4671                         return new_rd_Proj(dbgi, new_pred, mode_M, pn_ia32_CopyB_i_M);
4672                 } else if (is_ia32_CopyB(new_pred)) {
4673                         return new_rd_Proj(dbgi, new_pred, mode_M, pn_ia32_CopyB_M);
4674                 }
4675                 break;
4676         default:
4677                 break;
4678         }
4679
4680         panic("No idea how to transform proj->CopyB");
4681 }
4682
4683 static ir_node *gen_be_Call(ir_node *node)
4684 {
4685         dbg_info       *const dbgi      = get_irn_dbg_info(node);
4686         ir_node        *const src_block = get_nodes_block(node);
4687         ir_node        *const block     = be_transform_node(src_block);
4688         ir_node        *const src_mem   = get_irn_n(node, be_pos_Call_mem);
4689         ir_node        *const src_sp    = get_irn_n(node, be_pos_Call_sp);
4690         ir_node        *const sp        = be_transform_node(src_sp);
4691         ir_node        *const src_ptr   = get_irn_n(node, be_pos_Call_ptr);
4692         ia32_address_mode_t   am;
4693         ia32_address_t *const addr      = &am.addr;
4694         ir_node        *      mem;
4695         ir_node        *      call;
4696         int                   i;
4697         ir_node        *      fpcw;
4698         ir_node        *      eax       = noreg_GP;
4699         ir_node        *      ecx       = noreg_GP;
4700         ir_node        *      edx       = noreg_GP;
4701         unsigned        const pop       = be_Call_get_pop(node);
4702         ir_type        *const call_tp   = be_Call_get_type(node);
4703         int                   old_no_pic_adjust;
4704
4705         /* Run the x87 simulator if the call returns a float value */
4706         if (get_method_n_ress(call_tp) > 0) {
4707                 ir_type *const res_type = get_method_res_type(call_tp, 0);
4708                 ir_mode *const res_mode = get_type_mode(res_type);
4709
4710                 if (res_mode != NULL && mode_is_float(res_mode)) {
4711                         ir_graph        *irg      = current_ir_graph;
4712                         ia32_irg_data_t *irg_data = ia32_get_irg_data(irg);
4713                         irg_data->do_x87_sim = 1;
4714                 }
4715         }
4716
4717         /* We do not want be_Call direct calls */
4718         assert(be_Call_get_entity(node) == NULL);
4719
4720         /* special case for PIC trampoline calls */
4721         old_no_pic_adjust  = ia32_no_pic_adjust;
4722         ia32_no_pic_adjust = be_get_irg_options(current_ir_graph)->pic;
4723
4724         match_arguments(&am, src_block, NULL, src_ptr, src_mem,
4725                         match_am | match_immediate);
4726
4727         ia32_no_pic_adjust = old_no_pic_adjust;
4728
4729         i    = get_irn_arity(node) - 1;
4730         fpcw = be_transform_node(get_irn_n(node, i--));
4731         for (; i >= be_pos_Call_first_arg; --i) {
4732                 arch_register_req_t const *const req = arch_get_register_req(node, i);
4733                 ir_node *const reg_parm = be_transform_node(get_irn_n(node, i));
4734
4735                 assert(req->type == arch_register_req_type_limited);
4736                 assert(req->cls == &ia32_reg_classes[CLASS_ia32_gp]);
4737
4738                 switch (*req->limited) {
4739                         case 1 << REG_GP_EAX: assert(eax == noreg_GP); eax = reg_parm; break;
4740                         case 1 << REG_GP_ECX: assert(ecx == noreg_GP); ecx = reg_parm; break;
4741                         case 1 << REG_GP_EDX: assert(edx == noreg_GP); edx = reg_parm; break;
4742                         default: panic("Invalid GP register for register parameter");
4743                 }
4744         }
4745
4746         mem  = transform_AM_mem(block, src_ptr, src_mem, addr->mem);
4747         call = new_bd_ia32_Call(dbgi, block, addr->base, addr->index, mem,
4748                                 am.new_op2, sp, fpcw, eax, ecx, edx, pop, call_tp);
4749         set_am_attributes(call, &am);
4750         call = fix_mem_proj(call, &am);
4751
4752         if (get_irn_pinned(node) == op_pin_state_pinned)
4753                 set_irn_pinned(call, op_pin_state_pinned);
4754
4755         SET_IA32_ORIG_NODE(call, node);
4756
4757         if (ia32_cg_config.use_sse2) {
4758                 /* remember this call for post-processing */
4759                 ARR_APP1(ir_node *, call_list, call);
4760                 ARR_APP1(ir_type *, call_types, be_Call_get_type(node));
4761         }
4762
4763         return call;
4764 }
4765
4766 /**
4767  * Transform Builtin trap
4768  */
4769 static ir_node *gen_trap(ir_node *node)
4770 {
4771         dbg_info *dbgi  = get_irn_dbg_info(node);
4772         ir_node *block  = be_transform_node(get_nodes_block(node));
4773         ir_node *mem    = be_transform_node(get_Builtin_mem(node));
4774
4775         return new_bd_ia32_UD2(dbgi, block, mem);
4776 }
4777
4778 /**
4779  * Transform Builtin debugbreak
4780  */
4781 static ir_node *gen_debugbreak(ir_node *node)
4782 {
4783         dbg_info *dbgi  = get_irn_dbg_info(node);
4784         ir_node *block  = be_transform_node(get_nodes_block(node));
4785         ir_node *mem    = be_transform_node(get_Builtin_mem(node));
4786
4787         return new_bd_ia32_Breakpoint(dbgi, block, mem);
4788 }
4789
4790 /**
4791  * Transform Builtin return_address
4792  */
4793 static ir_node *gen_return_address(ir_node *node)
4794 {
4795         ir_node   *param    = get_Builtin_param(node, 0);
4796         ir_node   *frame    = get_Builtin_param(node, 1);
4797         dbg_info  *dbgi     = get_irn_dbg_info(node);
4798         ir_tarval *tv       = get_Const_tarval(param);
4799         unsigned long value = get_tarval_long(tv);
4800
4801         ir_node *block  = be_transform_node(get_nodes_block(node));
4802         ir_node *ptr    = be_transform_node(frame);
4803         ir_node *load;
4804
4805         if (value > 0) {
4806                 ir_node *cnt = new_bd_ia32_ProduceVal(dbgi, block);
4807                 ir_node *res = new_bd_ia32_ProduceVal(dbgi, block);
4808                 ptr = new_bd_ia32_ClimbFrame(dbgi, block, ptr, cnt, res, value);
4809         }
4810
4811         /* load the return address from this frame */
4812         load = new_bd_ia32_Load(dbgi, block, ptr, noreg_GP, nomem);
4813
4814         set_irn_pinned(load, get_irn_pinned(node));
4815         set_ia32_op_type(load, ia32_AddrModeS);
4816         set_ia32_ls_mode(load, mode_Iu);
4817
4818         set_ia32_am_offs_int(load, 0);
4819         set_ia32_use_frame(load);
4820         set_ia32_frame_ent(load, ia32_get_return_address_entity());
4821
4822         if (get_irn_pinned(node) == op_pin_state_floats) {
4823                 assert((int)pn_ia32_xLoad_res == (int)pn_ia32_vfld_res
4824                                 && (int)pn_ia32_vfld_res == (int)pn_ia32_Load_res
4825                                 && (int)pn_ia32_Load_res == (int)pn_ia32_res);
4826                 arch_irn_add_flags(load, arch_irn_flags_rematerializable);
4827         }
4828
4829         SET_IA32_ORIG_NODE(load, node);
4830         return new_r_Proj(load, mode_Iu, pn_ia32_Load_res);
4831 }
4832
4833 /**
4834  * Transform Builtin frame_address
4835  */
4836 static ir_node *gen_frame_address(ir_node *node)
4837 {
4838         ir_node   *param    = get_Builtin_param(node, 0);
4839         ir_node   *frame    = get_Builtin_param(node, 1);
4840         dbg_info  *dbgi     = get_irn_dbg_info(node);
4841         ir_tarval *tv       = get_Const_tarval(param);
4842         unsigned long value = get_tarval_long(tv);
4843
4844         ir_node *block  = be_transform_node(get_nodes_block(node));
4845         ir_node *ptr    = be_transform_node(frame);
4846         ir_node *load;
4847         ir_entity *ent;
4848
4849         if (value > 0) {
4850                 ir_node *cnt = new_bd_ia32_ProduceVal(dbgi, block);
4851                 ir_node *res = new_bd_ia32_ProduceVal(dbgi, block);
4852                 ptr = new_bd_ia32_ClimbFrame(dbgi, block, ptr, cnt, res, value);
4853         }
4854
4855         /* load the frame address from this frame */
4856         load = new_bd_ia32_Load(dbgi, block, ptr, noreg_GP, nomem);
4857
4858         set_irn_pinned(load, get_irn_pinned(node));
4859         set_ia32_op_type(load, ia32_AddrModeS);
4860         set_ia32_ls_mode(load, mode_Iu);
4861
4862         ent = ia32_get_frame_address_entity();
4863         if (ent != NULL) {
4864                 set_ia32_am_offs_int(load, 0);
4865                 set_ia32_use_frame(load);
4866                 set_ia32_frame_ent(load, ent);
4867         } else {
4868                 /* will fail anyway, but gcc does this: */
4869                 set_ia32_am_offs_int(load, 0);
4870         }
4871
4872         if (get_irn_pinned(node) == op_pin_state_floats) {
4873                 assert((int)pn_ia32_xLoad_res == (int)pn_ia32_vfld_res
4874                                 && (int)pn_ia32_vfld_res == (int)pn_ia32_Load_res
4875                                 && (int)pn_ia32_Load_res == (int)pn_ia32_res);
4876                 arch_irn_add_flags(load, arch_irn_flags_rematerializable);
4877         }
4878
4879         SET_IA32_ORIG_NODE(load, node);
4880         return new_r_Proj(load, mode_Iu, pn_ia32_Load_res);
4881 }
4882
4883 /**
4884  * Transform Builtin frame_address
4885  */
4886 static ir_node *gen_prefetch(ir_node *node)
4887 {
4888         dbg_info       *dbgi;
4889         ir_node        *ptr, *block, *mem, *base, *index;
4890         ir_node        *param,  *new_node;
4891         long           rw, locality;
4892         ir_tarval      *tv;
4893         ia32_address_t addr;
4894
4895         if (!ia32_cg_config.use_sse_prefetch && !ia32_cg_config.use_3dnow_prefetch) {
4896                 /* no prefetch at all, route memory */
4897                 return be_transform_node(get_Builtin_mem(node));
4898         }
4899
4900         param = get_Builtin_param(node, 1);
4901         tv    = get_Const_tarval(param);
4902         rw    = get_tarval_long(tv);
4903
4904         /* construct load address */
4905         memset(&addr, 0, sizeof(addr));
4906         ptr = get_Builtin_param(node, 0);
4907         ia32_create_address_mode(&addr, ptr, ia32_create_am_normal);
4908         base  = addr.base;
4909         index = addr.index;
4910
4911         if (base == NULL) {
4912                 base = noreg_GP;
4913         } else {
4914                 base = be_transform_node(base);
4915         }
4916
4917         if (index == NULL) {
4918                 index = noreg_GP;
4919         } else {
4920                 index = be_transform_node(index);
4921         }
4922
4923         dbgi     = get_irn_dbg_info(node);
4924         block    = be_transform_node(get_nodes_block(node));
4925         mem      = be_transform_node(get_Builtin_mem(node));
4926
4927         if (rw == 1 && ia32_cg_config.use_3dnow_prefetch) {
4928                 /* we have 3DNow!, this was already checked above */
4929                 new_node = new_bd_ia32_PrefetchW(dbgi, block, base, index, mem);
4930         } else if (ia32_cg_config.use_sse_prefetch) {
4931                 /* note: rw == 1 is IGNORED in that case */
4932                 param    = get_Builtin_param(node, 2);
4933                 tv       = get_Const_tarval(param);
4934                 locality = get_tarval_long(tv);
4935
4936                 /* SSE style prefetch */
4937                 switch (locality) {
4938                 case 0:
4939                         new_node = new_bd_ia32_PrefetchNTA(dbgi, block, base, index, mem);
4940                         break;
4941                 case 1:
4942                         new_node = new_bd_ia32_Prefetch2(dbgi, block, base, index, mem);
4943                         break;
4944                 case 2:
4945                         new_node = new_bd_ia32_Prefetch1(dbgi, block, base, index, mem);
4946                         break;
4947                 default:
4948                         new_node = new_bd_ia32_Prefetch0(dbgi, block, base, index, mem);
4949                         break;
4950                 }
4951         } else {
4952                 assert(ia32_cg_config.use_3dnow_prefetch);
4953                 /* 3DNow! style prefetch */
4954                 new_node = new_bd_ia32_Prefetch(dbgi, block, base, index, mem);
4955         }
4956
4957         set_irn_pinned(new_node, get_irn_pinned(node));
4958         set_ia32_op_type(new_node, ia32_AddrModeS);
4959         set_ia32_ls_mode(new_node, mode_Bu);
4960         set_address(new_node, &addr);
4961
4962         SET_IA32_ORIG_NODE(new_node, node);
4963
4964         be_dep_on_frame(new_node);
4965         return new_r_Proj(new_node, mode_M, pn_ia32_Prefetch_M);
4966 }
4967
4968 /**
4969  * Transform bsf like node
4970  */
4971 static ir_node *gen_unop_AM(ir_node *node, construct_binop_dest_func *func)
4972 {
4973         ir_node *param     = get_Builtin_param(node, 0);
4974         dbg_info *dbgi     = get_irn_dbg_info(node);
4975
4976         ir_node *block     = get_nodes_block(node);
4977         ir_node *new_block = be_transform_node(block);
4978
4979         ia32_address_mode_t  am;
4980         ia32_address_t      *addr = &am.addr;
4981         ir_node             *cnt;
4982
4983         match_arguments(&am, block, NULL, param, NULL, match_am);
4984
4985         cnt = func(dbgi, new_block, addr->base, addr->index, addr->mem, am.new_op2);
4986         set_am_attributes(cnt, &am);
4987         set_ia32_ls_mode(cnt, get_irn_mode(param));
4988
4989         SET_IA32_ORIG_NODE(cnt, node);
4990         return fix_mem_proj(cnt, &am);
4991 }
4992
4993 /**
4994  * Transform builtin ffs.
4995  */
4996 static ir_node *gen_ffs(ir_node *node)
4997 {
4998         ir_node  *bsf   = gen_unop_AM(node, new_bd_ia32_Bsf);
4999         ir_node  *real  = skip_Proj(bsf);
5000         dbg_info *dbgi  = get_irn_dbg_info(real);
5001         ir_node  *block = get_nodes_block(real);
5002         ir_node  *flag, *set, *conv, *neg, *orn, *add;
5003
5004         /* bsf x */
5005         if (get_irn_mode(real) != mode_T) {
5006                 set_irn_mode(real, mode_T);
5007                 bsf = new_r_Proj(real, mode_Iu, pn_ia32_res);
5008         }
5009
5010         flag = new_r_Proj(real, mode_b, pn_ia32_flags);
5011
5012         /* sete */
5013         set = new_bd_ia32_Setcc(dbgi, block, flag, ia32_cc_equal);
5014         SET_IA32_ORIG_NODE(set, node);
5015
5016         /* conv to 32bit */
5017         conv = new_bd_ia32_Conv_I2I8Bit(dbgi, block, noreg_GP, noreg_GP, nomem, set, mode_Bu);
5018         SET_IA32_ORIG_NODE(conv, node);
5019
5020         /* neg */
5021         neg = new_bd_ia32_Neg(dbgi, block, conv);
5022
5023         /* or */
5024         orn = new_bd_ia32_Or(dbgi, block, noreg_GP, noreg_GP, nomem, bsf, neg);
5025         set_ia32_commutative(orn);
5026
5027         /* add 1 */
5028         add = new_bd_ia32_Lea(dbgi, block, orn, noreg_GP);
5029         add_ia32_am_offs_int(add, 1);
5030         return add;
5031 }
5032
5033 /**
5034  * Transform builtin clz.
5035  */
5036 static ir_node *gen_clz(ir_node *node)
5037 {
5038         ir_node  *bsr   = gen_unop_AM(node, new_bd_ia32_Bsr);
5039         ir_node  *real  = skip_Proj(bsr);
5040         dbg_info *dbgi  = get_irn_dbg_info(real);
5041         ir_node  *block = get_nodes_block(real);
5042         ir_node  *imm   = ia32_create_Immediate(NULL, 0, 31);
5043
5044         return new_bd_ia32_Xor(dbgi, block, noreg_GP, noreg_GP, nomem, bsr, imm);
5045 }
5046
5047 /**
5048  * Transform builtin ctz.
5049  */
5050 static ir_node *gen_ctz(ir_node *node)
5051 {
5052         return gen_unop_AM(node, new_bd_ia32_Bsf);
5053 }
5054
5055 /**
5056  * Transform builtin parity.
5057  */
5058 static ir_node *gen_parity(ir_node *node)
5059 {
5060         dbg_info *dbgi      = get_irn_dbg_info(node);
5061         ir_node  *block     = get_nodes_block(node);
5062         ir_node  *new_block = be_transform_node(block);
5063         ir_node  *param     = get_Builtin_param(node, 0);
5064         ir_node  *new_param = be_transform_node(param);
5065         ir_node  *new_node;
5066
5067         /* the x86 parity bit is stupid: it only looks at the lowest byte,
5068          * so we have to do complicated xoring first.
5069          * (we should also better lower this before the backend so we still have a
5070          * chance for CSE, constant folding and other goodies for some of these
5071          * operations)
5072          */
5073         ir_node *count = ia32_create_Immediate(NULL, 0, 16);
5074         ir_node *shr = new_bd_ia32_Shr(dbgi, new_block, new_param, count);
5075         ir_node *xor = new_bd_ia32_Xor(dbgi, new_block, noreg_GP, noreg_GP, nomem,
5076                                        shr, new_param);
5077         ir_node *xor2 = new_bd_ia32_XorHighLow(dbgi, new_block, xor);
5078         ir_node *flags;
5079
5080         set_irn_mode(xor2, mode_T);
5081         flags = new_r_Proj(xor2, mode_Iu, pn_ia32_XorHighLow_flags);
5082
5083         /* setp */
5084         new_node = new_bd_ia32_Setcc(dbgi, new_block, flags, ia32_cc_not_parity);
5085         SET_IA32_ORIG_NODE(new_node, node);
5086
5087         /* conv to 32bit */
5088         new_node = new_bd_ia32_Conv_I2I8Bit(dbgi, new_block, noreg_GP, noreg_GP,
5089                                             nomem, new_node, mode_Bu);
5090         SET_IA32_ORIG_NODE(new_node, node);
5091         return new_node;
5092 }
5093
5094 /**
5095  * Transform builtin popcount
5096  */
5097 static ir_node *gen_popcount(ir_node *node)
5098 {
5099         ir_node *param     = get_Builtin_param(node, 0);
5100         dbg_info *dbgi     = get_irn_dbg_info(node);
5101
5102         ir_node *block     = get_nodes_block(node);
5103         ir_node *new_block = be_transform_node(block);
5104
5105         ir_node *new_param;
5106         ir_node *imm, *simm, *m1, *s1, *s2, *s3, *s4, *s5, *m2, *m3, *m4, *m5, *m6, *m7, *m8, *m9, *m10, *m11, *m12, *m13;
5107
5108         /* check for SSE4.2 or SSE4a and use the popcnt instruction */
5109         if (ia32_cg_config.use_popcnt) {
5110                 ia32_address_mode_t am;
5111                 ia32_address_t      *addr = &am.addr;
5112                 ir_node             *cnt;
5113
5114                 match_arguments(&am, block, NULL, param, NULL, match_am | match_16bit_am);
5115
5116                 cnt = new_bd_ia32_Popcnt(dbgi, new_block, addr->base, addr->index, addr->mem, am.new_op2);
5117                 set_am_attributes(cnt, &am);
5118                 set_ia32_ls_mode(cnt, get_irn_mode(param));
5119
5120                 SET_IA32_ORIG_NODE(cnt, node);
5121                 return fix_mem_proj(cnt, &am);
5122         }
5123
5124         new_param = be_transform_node(param);
5125
5126         /* do the standard popcount algo */
5127         /* TODO: This is stupid, we should transform this before the backend,
5128          * to get CSE, localopts, etc. for the operations
5129          * TODO: This is also not the optimal algorithm (it is just the starting
5130          * example in hackers delight, they optimize it more on the following page)
5131          * But I'm too lazy to fix this now, as the code should get lowered before
5132          * the backend anyway.
5133          */
5134
5135         /* m1 = x & 0x55555555 */
5136         imm = ia32_create_Immediate(NULL, 0, 0x55555555);
5137         m1 = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, new_param, imm);
5138
5139         /* s1 = x >> 1 */
5140         simm = ia32_create_Immediate(NULL, 0, 1);
5141         s1 = new_bd_ia32_Shr(dbgi, new_block, new_param, simm);
5142
5143         /* m2 = s1 & 0x55555555 */
5144         m2 = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, s1, imm);
5145
5146         /* m3 = m1 + m2 */
5147         m3 = new_bd_ia32_Lea(dbgi, new_block, m2, m1);
5148
5149         /* m4 = m3 & 0x33333333 */
5150         imm = ia32_create_Immediate(NULL, 0, 0x33333333);
5151         m4 = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, m3, imm);
5152
5153         /* s2 = m3 >> 2 */
5154         simm = ia32_create_Immediate(NULL, 0, 2);
5155         s2 = new_bd_ia32_Shr(dbgi, new_block, m3, simm);
5156
5157         /* m5 = s2 & 0x33333333 */
5158         m5 = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, s2, imm);
5159
5160         /* m6 = m4 + m5 */
5161         m6 = new_bd_ia32_Lea(dbgi, new_block, m4, m5);
5162
5163         /* m7 = m6 & 0x0F0F0F0F */
5164         imm = ia32_create_Immediate(NULL, 0, 0x0F0F0F0F);
5165         m7 = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, m6, imm);
5166
5167         /* s3 = m6 >> 4 */
5168         simm = ia32_create_Immediate(NULL, 0, 4);
5169         s3 = new_bd_ia32_Shr(dbgi, new_block, m6, simm);
5170
5171         /* m8 = s3 & 0x0F0F0F0F */
5172         m8 = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, s3, imm);
5173
5174         /* m9 = m7 + m8 */
5175         m9 = new_bd_ia32_Lea(dbgi, new_block, m7, m8);
5176
5177         /* m10 = m9 & 0x00FF00FF */
5178         imm = ia32_create_Immediate(NULL, 0, 0x00FF00FF);
5179         m10 = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, m9, imm);
5180
5181         /* s4 = m9 >> 8 */
5182         simm = ia32_create_Immediate(NULL, 0, 8);
5183         s4 = new_bd_ia32_Shr(dbgi, new_block, m9, simm);
5184
5185         /* m11 = s4 & 0x00FF00FF */
5186         m11 = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, s4, imm);
5187
5188         /* m12 = m10 + m11 */
5189         m12 = new_bd_ia32_Lea(dbgi, new_block, m10, m11);
5190
5191         /* m13 = m12 & 0x0000FFFF */
5192         imm = ia32_create_Immediate(NULL, 0, 0x0000FFFF);
5193         m13 = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, m12, imm);
5194
5195         /* s5 = m12 >> 16 */
5196         simm = ia32_create_Immediate(NULL, 0, 16);
5197         s5 = new_bd_ia32_Shr(dbgi, new_block, m12, simm);
5198
5199         /* res = m13 + s5 */
5200         return new_bd_ia32_Lea(dbgi, new_block, m13, s5);
5201 }
5202
5203 /**
5204  * Transform builtin byte swap.
5205  */
5206 static ir_node *gen_bswap(ir_node *node)
5207 {
5208         ir_node *param     = be_transform_node(get_Builtin_param(node, 0));
5209         dbg_info *dbgi     = get_irn_dbg_info(node);
5210
5211         ir_node *block     = get_nodes_block(node);
5212         ir_node *new_block = be_transform_node(block);
5213         ir_mode *mode      = get_irn_mode(param);
5214         unsigned size      = get_mode_size_bits(mode);
5215         ir_node  *m1, *m2, *m3, *m4, *s1, *s2, *s3, *s4;
5216
5217         switch (size) {
5218         case 32:
5219                 if (ia32_cg_config.use_i486) {
5220                         /* swap available */
5221                         return new_bd_ia32_Bswap(dbgi, new_block, param);
5222                 }
5223                 s1 = new_bd_ia32_Shl(dbgi, new_block, param, ia32_create_Immediate(NULL, 0, 24));
5224                 s2 = new_bd_ia32_Shl(dbgi, new_block, param, ia32_create_Immediate(NULL, 0, 8));
5225
5226                 m1 = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, s2, ia32_create_Immediate(NULL, 0, 0xFF00));
5227                 m2 = new_bd_ia32_Lea(dbgi, new_block, s1, m1);
5228
5229                 s3 = new_bd_ia32_Shr(dbgi, new_block, param, ia32_create_Immediate(NULL, 0, 8));
5230
5231                 m3 = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, s3, ia32_create_Immediate(NULL, 0, 0xFF0000));
5232                 m4 = new_bd_ia32_Lea(dbgi, new_block, m2, m3);
5233
5234                 s4 = new_bd_ia32_Shr(dbgi, new_block, param, ia32_create_Immediate(NULL, 0, 24));
5235                 return new_bd_ia32_Lea(dbgi, new_block, m4, s4);
5236
5237         case 16:
5238                 /* swap16 always available */
5239                 return new_bd_ia32_Bswap16(dbgi, new_block, param);
5240
5241         default:
5242                 panic("Invalid bswap size (%d)", size);
5243         }
5244 }
5245
5246 /**
5247  * Transform builtin outport.
5248  */
5249 static ir_node *gen_outport(ir_node *node)
5250 {
5251         ir_node *port  = create_immediate_or_transform(get_Builtin_param(node, 0), 0);
5252         ir_node *oldv  = get_Builtin_param(node, 1);
5253         ir_mode *mode  = get_irn_mode(oldv);
5254         ir_node *value = be_transform_node(oldv);
5255         ir_node *block = be_transform_node(get_nodes_block(node));
5256         ir_node *mem   = be_transform_node(get_Builtin_mem(node));
5257         dbg_info *dbgi = get_irn_dbg_info(node);
5258
5259         ir_node *res = new_bd_ia32_Outport(dbgi, block, port, value, mem);
5260         set_ia32_ls_mode(res, mode);
5261         return res;
5262 }
5263
5264 /**
5265  * Transform builtin inport.
5266  */
5267 static ir_node *gen_inport(ir_node *node)
5268 {
5269         ir_type *tp    = get_Builtin_type(node);
5270         ir_type *rstp  = get_method_res_type(tp, 0);
5271         ir_mode *mode  = get_type_mode(rstp);
5272         ir_node *port  = create_immediate_or_transform(get_Builtin_param(node, 0), 0);
5273         ir_node *block = be_transform_node(get_nodes_block(node));
5274         ir_node *mem   = be_transform_node(get_Builtin_mem(node));
5275         dbg_info *dbgi = get_irn_dbg_info(node);
5276
5277         ir_node *res = new_bd_ia32_Inport(dbgi, block, port, mem);
5278         set_ia32_ls_mode(res, mode);
5279
5280         /* check for missing Result Proj */
5281         return res;
5282 }
5283
5284 /**
5285  * Transform a builtin inner trampoline
5286  */
5287 static ir_node *gen_inner_trampoline(ir_node *node)
5288 {
5289         ir_node  *ptr       = get_Builtin_param(node, 0);
5290         ir_node  *callee    = get_Builtin_param(node, 1);
5291         ir_node  *env       = be_transform_node(get_Builtin_param(node, 2));
5292         ir_node  *mem       = get_Builtin_mem(node);
5293         ir_node  *block     = get_nodes_block(node);
5294         ir_node  *new_block = be_transform_node(block);
5295         ir_node  *val;
5296         ir_node  *store;
5297         ir_node  *rel;
5298         ir_node  *trampoline;
5299         ir_node  *in[2];
5300         dbg_info *dbgi      = get_irn_dbg_info(node);
5301         ia32_address_t addr;
5302
5303         /* construct store address */
5304         memset(&addr, 0, sizeof(addr));
5305         ia32_create_address_mode(&addr, ptr, ia32_create_am_normal);
5306
5307         if (addr.base == NULL) {
5308                 addr.base = noreg_GP;
5309         } else {
5310                 addr.base = be_transform_node(addr.base);
5311         }
5312
5313         if (addr.index == NULL) {
5314                 addr.index = noreg_GP;
5315         } else {
5316                 addr.index = be_transform_node(addr.index);
5317         }
5318         addr.mem = be_transform_node(mem);
5319
5320         /* mov  ecx, <env> */
5321         val   = ia32_create_Immediate(NULL, 0, 0xB9);
5322         store = new_bd_ia32_Store8Bit(dbgi, new_block, addr.base,
5323                                       addr.index, addr.mem, val);
5324         set_irn_pinned(store, get_irn_pinned(node));
5325         set_ia32_op_type(store, ia32_AddrModeD);
5326         set_ia32_ls_mode(store, mode_Bu);
5327         set_address(store, &addr);
5328         addr.mem = store;
5329         addr.offset += 1;
5330
5331         store = new_bd_ia32_Store(dbgi, new_block, addr.base,
5332                                   addr.index, addr.mem, env);
5333         set_irn_pinned(store, get_irn_pinned(node));
5334         set_ia32_op_type(store, ia32_AddrModeD);
5335         set_ia32_ls_mode(store, mode_Iu);
5336         set_address(store, &addr);
5337         addr.mem = store;
5338         addr.offset += 4;
5339
5340         /* jmp rel <callee> */
5341         val   = ia32_create_Immediate(NULL, 0, 0xE9);
5342         store = new_bd_ia32_Store8Bit(dbgi, new_block, addr.base,
5343                                      addr.index, addr.mem, val);
5344         set_irn_pinned(store, get_irn_pinned(node));
5345         set_ia32_op_type(store, ia32_AddrModeD);
5346         set_ia32_ls_mode(store, mode_Bu);
5347         set_address(store, &addr);
5348         addr.mem = store;
5349         addr.offset += 1;
5350
5351         trampoline = be_transform_node(ptr);
5352
5353         /* the callee is typically an immediate */
5354         if (is_SymConst(callee)) {
5355                 rel = new_bd_ia32_Const(dbgi, new_block, get_SymConst_entity(callee), 0, 0, -10);
5356         } else {
5357                 rel = new_bd_ia32_Lea(dbgi, new_block, be_transform_node(callee), noreg_GP);
5358                 add_ia32_am_offs_int(rel, -10);
5359         }
5360         rel = new_bd_ia32_Sub(dbgi, new_block, noreg_GP, noreg_GP, nomem, rel, trampoline);
5361
5362         store = new_bd_ia32_Store(dbgi, new_block, addr.base,
5363                                   addr.index, addr.mem, rel);
5364         set_irn_pinned(store, get_irn_pinned(node));
5365         set_ia32_op_type(store, ia32_AddrModeD);
5366         set_ia32_ls_mode(store, mode_Iu);
5367         set_address(store, &addr);
5368
5369         in[0] = store;
5370         in[1] = trampoline;
5371
5372         return new_r_Tuple(new_block, 2, in);
5373 }
5374
5375 /**
5376  * Transform Builtin node.
5377  */
5378 static ir_node *gen_Builtin(ir_node *node)
5379 {
5380         ir_builtin_kind kind = get_Builtin_kind(node);
5381
5382         switch (kind) {
5383         case ir_bk_trap:
5384                 return gen_trap(node);
5385         case ir_bk_debugbreak:
5386                 return gen_debugbreak(node);
5387         case ir_bk_return_address:
5388                 return gen_return_address(node);
5389         case ir_bk_frame_address:
5390                 return gen_frame_address(node);
5391         case ir_bk_prefetch:
5392                 return gen_prefetch(node);
5393         case ir_bk_ffs:
5394                 return gen_ffs(node);
5395         case ir_bk_clz:
5396                 return gen_clz(node);
5397         case ir_bk_ctz:
5398                 return gen_ctz(node);
5399         case ir_bk_parity:
5400                 return gen_parity(node);
5401         case ir_bk_popcount:
5402                 return gen_popcount(node);
5403         case ir_bk_bswap:
5404                 return gen_bswap(node);
5405         case ir_bk_outport:
5406                 return gen_outport(node);
5407         case ir_bk_inport:
5408                 return gen_inport(node);
5409         case ir_bk_inner_trampoline:
5410                 return gen_inner_trampoline(node);
5411         }
5412         panic("Builtin %s not implemented in IA32", get_builtin_kind_name(kind));
5413 }
5414
5415 /**
5416  * Transform Proj(Builtin) node.
5417  */
5418 static ir_node *gen_Proj_Builtin(ir_node *proj)
5419 {
5420         ir_node         *node     = get_Proj_pred(proj);
5421         ir_node         *new_node = be_transform_node(node);
5422         ir_builtin_kind kind      = get_Builtin_kind(node);
5423
5424         switch (kind) {
5425         case ir_bk_return_address:
5426         case ir_bk_frame_address:
5427         case ir_bk_ffs:
5428         case ir_bk_clz:
5429         case ir_bk_ctz:
5430         case ir_bk_parity:
5431         case ir_bk_popcount:
5432         case ir_bk_bswap:
5433                 assert(get_Proj_proj(proj) == pn_Builtin_1_result);
5434                 return new_node;
5435         case ir_bk_trap:
5436         case ir_bk_debugbreak:
5437         case ir_bk_prefetch:
5438         case ir_bk_outport:
5439                 assert(get_Proj_proj(proj) == pn_Builtin_M);
5440                 return new_node;
5441         case ir_bk_inport:
5442                 if (get_Proj_proj(proj) == pn_Builtin_1_result) {
5443                         return new_r_Proj(new_node, get_irn_mode(proj), pn_ia32_Inport_res);
5444                 } else {
5445                         assert(get_Proj_proj(proj) == pn_Builtin_M);
5446                         return new_r_Proj(new_node, mode_M, pn_ia32_Inport_M);
5447                 }
5448         case ir_bk_inner_trampoline:
5449                 if (get_Proj_proj(proj) == pn_Builtin_1_result) {
5450                         return get_Tuple_pred(new_node, 1);
5451                 } else {
5452                         assert(get_Proj_proj(proj) == pn_Builtin_M);
5453                         return get_Tuple_pred(new_node, 0);
5454                 }
5455         }
5456         panic("Builtin %s not implemented in IA32", get_builtin_kind_name(kind));
5457 }
5458
5459 static ir_node *gen_be_IncSP(ir_node *node)
5460 {
5461         ir_node *res = be_duplicate_node(node);
5462         arch_irn_add_flags(res, arch_irn_flags_modify_flags);
5463
5464         return res;
5465 }
5466
5467 /**
5468  * Transform the Projs from a be_Call.
5469  */
5470 static ir_node *gen_Proj_be_Call(ir_node *node)
5471 {
5472         ir_node  *call        = get_Proj_pred(node);
5473         ir_node  *new_call    = be_transform_node(call);
5474         dbg_info *dbgi        = get_irn_dbg_info(node);
5475         long      proj        = get_Proj_proj(node);
5476         ir_mode  *mode        = get_irn_mode(node);
5477         ir_node  *res;
5478
5479         if (proj == pn_be_Call_M_regular) {
5480                 return new_rd_Proj(dbgi, new_call, mode_M, n_ia32_Call_mem);
5481         }
5482         /* transform call modes */
5483         if (mode_is_data(mode)) {
5484                 const arch_register_class_t *cls = arch_get_irn_reg_class_out(node);
5485                 mode = cls->mode;
5486         }
5487
5488         /* Map from be_Call to ia32_Call proj number */
5489         if (proj == pn_be_Call_sp) {
5490                 proj = pn_ia32_Call_stack;
5491         } else if (proj == pn_be_Call_M_regular) {
5492                 proj = pn_ia32_Call_M;
5493         } else {
5494                 arch_register_req_t const *const req    = arch_get_register_req_out(node);
5495                 int                        const n_outs = arch_irn_get_n_outs(new_call);
5496                 int                              i;
5497
5498                 assert(proj      >= pn_be_Call_first_res);
5499                 assert(req->type & arch_register_req_type_limited);
5500
5501                 for (i = 0; i < n_outs; ++i) {
5502                         arch_register_req_t const *const new_req
5503                                 = arch_get_out_register_req(new_call, i);
5504
5505                         if (!(new_req->type & arch_register_req_type_limited) ||
5506                             new_req->cls      != req->cls                     ||
5507                             *new_req->limited != *req->limited)
5508                                 continue;
5509
5510                         proj = i;
5511                         break;
5512                 }
5513                 assert(i < n_outs);
5514         }
5515
5516         res = new_rd_Proj(dbgi, new_call, mode, proj);
5517
5518         /* TODO arch_set_irn_register() only operates on Projs, need variant with index */
5519         switch (proj) {
5520                 case pn_ia32_Call_stack:
5521                         arch_set_irn_register(res, &ia32_registers[REG_ESP]);
5522                         break;
5523
5524                 case pn_ia32_Call_fpcw:
5525                         arch_set_irn_register(res, &ia32_registers[REG_FPCW]);
5526                         break;
5527         }
5528
5529         return res;
5530 }
5531
5532 /**
5533  * Transform the Projs from a Cmp.
5534  */
5535 static ir_node *gen_Proj_Cmp(ir_node *node)
5536 {
5537         /* this probably means not all mode_b nodes were lowered... */
5538         panic("trying to directly transform Proj_Cmp %+F (mode_b not lowered?)",
5539               node);
5540 }
5541
5542 static ir_node *gen_Proj_ASM(ir_node *node)
5543 {
5544         ir_mode *mode     = get_irn_mode(node);
5545         ir_node *pred     = get_Proj_pred(node);
5546         ir_node *new_pred = be_transform_node(pred);
5547         long     pos      = get_Proj_proj(node);
5548
5549         if (mode == mode_M) {
5550                 pos = arch_irn_get_n_outs(new_pred)-1;
5551         } else if (mode_is_int(mode) || mode_is_reference(mode)) {
5552                 mode = mode_Iu;
5553         } else if (mode_is_float(mode)) {
5554                 mode = mode_E;
5555         } else {
5556                 panic("unexpected proj mode at ASM");
5557         }
5558
5559         return new_r_Proj(new_pred, mode, pos);
5560 }
5561
5562 /**
5563  * Transform and potentially renumber Proj nodes.
5564  */
5565 static ir_node *gen_Proj(ir_node *node)
5566 {
5567         ir_node *pred = get_Proj_pred(node);
5568         long    proj;
5569
5570         switch (get_irn_opcode(pred)) {
5571         case iro_Store:
5572                 proj = get_Proj_proj(node);
5573                 if (proj == pn_Store_M) {
5574                         return be_transform_node(pred);
5575                 } else {
5576                         panic("No idea how to transform proj->Store");
5577                 }
5578         case iro_Load:
5579                 return gen_Proj_Load(node);
5580         case iro_ASM:
5581                 return gen_Proj_ASM(node);
5582         case iro_Builtin:
5583                 return gen_Proj_Builtin(node);
5584         case iro_Div:
5585                 return gen_Proj_Div(node);
5586         case iro_Mod:
5587                 return gen_Proj_Mod(node);
5588         case iro_CopyB:
5589                 return gen_Proj_CopyB(node);
5590         case beo_SubSP:
5591                 return gen_Proj_be_SubSP(node);
5592         case beo_AddSP:
5593                 return gen_Proj_be_AddSP(node);
5594         case beo_Call:
5595                 return gen_Proj_be_Call(node);
5596         case iro_Cmp:
5597                 return gen_Proj_Cmp(node);
5598         case iro_Start:
5599                 proj = get_Proj_proj(node);
5600                 switch (proj) {
5601                         case pn_Start_X_initial_exec: {
5602                                 ir_node  *block     = get_nodes_block(pred);
5603                                 ir_node  *new_block = be_transform_node(block);
5604                                 dbg_info *dbgi      = get_irn_dbg_info(node);
5605                                 /* we exchange the ProjX with a jump */
5606                                 ir_node  *jump      = new_rd_Jmp(dbgi, new_block);
5607
5608                                 return jump;
5609                         }
5610
5611                         case pn_Start_P_tls:
5612                                 return ia32_gen_Proj_tls(node);
5613                 }
5614                 break;
5615
5616         default:
5617                 if (is_ia32_l_FloattoLL(pred)) {
5618                         return gen_Proj_l_FloattoLL(node);
5619 #ifdef FIRM_EXT_GRS
5620                 } else if (!is_ia32_irn(pred)) { // Quick hack for SIMD optimization
5621 #else
5622                 } else {
5623 #endif
5624                         ir_mode *mode = get_irn_mode(node);
5625                         if (ia32_mode_needs_gp_reg(mode)) {
5626                                 ir_node *new_pred = be_transform_node(pred);
5627                                 ir_node *new_proj = new_r_Proj(new_pred, mode_Iu,
5628                                                                get_Proj_proj(node));
5629                                 new_proj->node_nr = node->node_nr;
5630                                 return new_proj;
5631                         }
5632                 }
5633         }
5634         return be_duplicate_node(node);
5635 }
5636
5637 /**
5638  * Enters all transform functions into the generic pointer
5639  */
5640 static void register_transformers(void)
5641 {
5642         /* first clear the generic function pointer for all ops */
5643         be_start_transform_setup();
5644
5645         be_set_transform_function(op_Add,              gen_Add);
5646         be_set_transform_function(op_And,              gen_And);
5647         be_set_transform_function(op_ASM,              ia32_gen_ASM);
5648         be_set_transform_function(op_be_AddSP,         gen_be_AddSP);
5649         be_set_transform_function(op_be_Call,          gen_be_Call);
5650         be_set_transform_function(op_be_Copy,          gen_be_Copy);
5651         be_set_transform_function(op_be_FrameAddr,     gen_be_FrameAddr);
5652         be_set_transform_function(op_be_IncSP,         gen_be_IncSP);
5653         be_set_transform_function(op_be_Return,        gen_be_Return);
5654         be_set_transform_function(op_be_SubSP,         gen_be_SubSP);
5655         be_set_transform_function(op_Builtin,          gen_Builtin);
5656         be_set_transform_function(op_Cmp,              gen_Cmp);
5657         be_set_transform_function(op_Cond,             gen_Cond);
5658         be_set_transform_function(op_Const,            gen_Const);
5659         be_set_transform_function(op_Conv,             gen_Conv);
5660         be_set_transform_function(op_CopyB,            ia32_gen_CopyB);
5661         be_set_transform_function(op_Div,              gen_Div);
5662         be_set_transform_function(op_Eor,              gen_Eor);
5663         be_set_transform_function(op_ia32_l_Adc,       gen_ia32_l_Adc);
5664         be_set_transform_function(op_ia32_l_Add,       gen_ia32_l_Add);
5665         be_set_transform_function(op_ia32_Leave,       be_duplicate_node);
5666         be_set_transform_function(op_ia32_l_FloattoLL, gen_ia32_l_FloattoLL);
5667         be_set_transform_function(op_ia32_l_IMul,      gen_ia32_l_IMul);
5668         be_set_transform_function(op_ia32_l_LLtoFloat, gen_ia32_l_LLtoFloat);
5669         be_set_transform_function(op_ia32_l_Mul,       gen_ia32_l_Mul);
5670         be_set_transform_function(op_ia32_l_SarDep,    gen_ia32_l_SarDep);
5671         be_set_transform_function(op_ia32_l_Sbb,       gen_ia32_l_Sbb);
5672         be_set_transform_function(op_ia32_l_ShlDep,    gen_ia32_l_ShlDep);
5673         be_set_transform_function(op_ia32_l_ShlD,      gen_ia32_l_ShlD);
5674         be_set_transform_function(op_ia32_l_ShrDep,    gen_ia32_l_ShrDep);
5675         be_set_transform_function(op_ia32_l_ShrD,      gen_ia32_l_ShrD);
5676         be_set_transform_function(op_ia32_l_Sub,       gen_ia32_l_Sub);
5677         be_set_transform_function(op_ia32_GetEIP,      be_duplicate_node);
5678         be_set_transform_function(op_ia32_Minus64Bit,  be_duplicate_node);
5679         be_set_transform_function(op_ia32_NoReg_GP,    be_duplicate_node);
5680         be_set_transform_function(op_ia32_NoReg_VFP,   be_duplicate_node);
5681         be_set_transform_function(op_ia32_NoReg_XMM,   be_duplicate_node);
5682         be_set_transform_function(op_ia32_PopEbp,      be_duplicate_node);
5683         be_set_transform_function(op_ia32_Push,        be_duplicate_node);
5684         be_set_transform_function(op_IJmp,             gen_IJmp);
5685         be_set_transform_function(op_Jmp,              gen_Jmp);
5686         be_set_transform_function(op_Load,             gen_Load);
5687         be_set_transform_function(op_Minus,            gen_Minus);
5688         be_set_transform_function(op_Mod,              gen_Mod);
5689         be_set_transform_function(op_Mul,              gen_Mul);
5690         be_set_transform_function(op_Mulh,             gen_Mulh);
5691         be_set_transform_function(op_Mux,              gen_Mux);
5692         be_set_transform_function(op_Not,              gen_Not);
5693         be_set_transform_function(op_Or,               gen_Or);
5694         be_set_transform_function(op_Phi,              gen_Phi);
5695         be_set_transform_function(op_Proj,             gen_Proj);
5696         be_set_transform_function(op_Rotl,             gen_Rotl);
5697         be_set_transform_function(op_Shl,              gen_Shl);
5698         be_set_transform_function(op_Shr,              gen_Shr);
5699         be_set_transform_function(op_Shrs,             gen_Shrs);
5700         be_set_transform_function(op_Store,            gen_Store);
5701         be_set_transform_function(op_Sub,              gen_Sub);
5702         be_set_transform_function(op_SymConst,         gen_SymConst);
5703         be_set_transform_function(op_Unknown,          ia32_gen_Unknown);
5704 }
5705
5706 /**
5707  * Pre-transform all unknown and noreg nodes.
5708  */
5709 static void ia32_pretransform_node(void)
5710 {
5711         ir_graph        *irg      = current_ir_graph;
5712         ia32_irg_data_t *irg_data = ia32_get_irg_data(current_ir_graph);
5713
5714         irg_data->noreg_gp  = be_pre_transform_node(irg_data->noreg_gp);
5715         irg_data->noreg_vfp = be_pre_transform_node(irg_data->noreg_vfp);
5716         irg_data->noreg_xmm = be_pre_transform_node(irg_data->noreg_xmm);
5717
5718         nomem    = get_irg_no_mem(irg);
5719         noreg_GP = ia32_new_NoReg_gp(irg);
5720
5721         get_fpcw();
5722 }
5723
5724 /**
5725  * Post-process all calls if we are in SSE mode.
5726  * The ABI requires that the results are in st0, copy them
5727  * to a xmm register.
5728  */
5729 static void postprocess_fp_call_results(void)
5730 {
5731         size_t i, n;
5732
5733         for (i = 0, n = ARR_LEN(call_list); i < n; ++i) {
5734                 ir_node *call = call_list[i];
5735                 ir_type *mtp  = call_types[i];
5736                 int     j;
5737
5738                 for (j = get_method_n_ress(mtp) - 1; j >= 0; --j) {
5739                         ir_type *res_tp = get_method_res_type(mtp, j);
5740                         ir_node *res, *new_res;
5741                         const ir_edge_t *edge, *next;
5742                         ir_mode *mode;
5743
5744                         if (! is_atomic_type(res_tp)) {
5745                                 /* no floating point return */
5746                                 continue;
5747                         }
5748                         mode = get_type_mode(res_tp);
5749                         if (! mode_is_float(mode)) {
5750                                 /* no floating point return */
5751                                 continue;
5752                         }
5753
5754                         res     = be_get_Proj_for_pn(call, pn_ia32_Call_vf0 + j);
5755                         new_res = NULL;
5756
5757                         /* now patch the users */
5758                         foreach_out_edge_safe(res, edge, next) {
5759                                 ir_node *succ = get_edge_src_irn(edge);
5760
5761                                 /* ignore Keeps */
5762                                 if (be_is_Keep(succ))
5763                                         continue;
5764
5765                                 if (is_ia32_xStore(succ)) {
5766                                         /* an xStore can be patched into an vfst */
5767                                         dbg_info *db    = get_irn_dbg_info(succ);
5768                                         ir_node  *block = get_nodes_block(succ);
5769                                         ir_node  *base  = get_irn_n(succ, n_ia32_xStore_base);
5770                                         ir_node  *index = get_irn_n(succ, n_ia32_xStore_index);
5771                                         ir_node  *mem   = get_irn_n(succ, n_ia32_xStore_mem);
5772                                         ir_node  *value = get_irn_n(succ, n_ia32_xStore_val);
5773                                         ir_mode  *mode  = get_ia32_ls_mode(succ);
5774
5775                                         ir_node  *st = new_bd_ia32_vfst(db, block, base, index, mem, value, mode);
5776                                         set_ia32_am_offs_int(st, get_ia32_am_offs_int(succ));
5777                                         if (is_ia32_use_frame(succ))
5778                                                 set_ia32_use_frame(st);
5779                                         set_ia32_frame_ent(st, get_ia32_frame_ent(succ));
5780                                         set_irn_pinned(st, get_irn_pinned(succ));
5781                                         set_ia32_op_type(st, ia32_AddrModeD);
5782
5783                                         exchange(succ, st);
5784                                 } else {
5785                                         if (new_res == NULL) {
5786                                                 dbg_info *db       = get_irn_dbg_info(call);
5787                                                 ir_node  *block    = get_nodes_block(call);
5788                                                 ir_node  *frame    = get_irg_frame(current_ir_graph);
5789                                                 ir_node  *old_mem  = be_get_Proj_for_pn(call, pn_ia32_Call_M);
5790                                                 ir_node  *call_mem = new_r_Proj(call, mode_M, pn_ia32_Call_M);
5791                                                 ir_node  *vfst, *xld, *new_mem;
5792
5793                                                 /* store st(0) on stack */
5794                                                 vfst = new_bd_ia32_vfst(db, block, frame, noreg_GP, call_mem, res, mode);
5795                                                 set_ia32_op_type(vfst, ia32_AddrModeD);
5796                                                 set_ia32_use_frame(vfst);
5797
5798                                                 /* load into SSE register */
5799                                                 xld = new_bd_ia32_xLoad(db, block, frame, noreg_GP, vfst, mode);
5800                                                 set_ia32_op_type(xld, ia32_AddrModeS);
5801                                                 set_ia32_use_frame(xld);
5802
5803                                                 new_res = new_r_Proj(xld, mode, pn_ia32_xLoad_res);
5804                                                 new_mem = new_r_Proj(xld, mode_M, pn_ia32_xLoad_M);
5805
5806                                                 if (old_mem != NULL) {
5807                                                         edges_reroute(old_mem, new_mem, current_ir_graph);
5808                                                         kill_node(old_mem);
5809                                                 }
5810                                         }
5811                                         set_irn_n(succ, get_edge_src_pos(edge), new_res);
5812                                 }
5813                         }
5814                 }
5815         }
5816 }
5817
5818 /* do the transformation */
5819 void ia32_transform_graph(ir_graph *irg)
5820 {
5821         int cse_last;
5822
5823         register_transformers();
5824         initial_fpcw       = NULL;
5825         ia32_no_pic_adjust = 0;
5826
5827         be_timer_push(T_HEIGHTS);
5828         ia32_heights = heights_new(irg);
5829         be_timer_pop(T_HEIGHTS);
5830         ia32_calculate_non_address_mode_nodes(irg);
5831
5832         /* the transform phase is not safe for CSE (yet) because several nodes get
5833          * attributes set after their creation */
5834         cse_last = get_opt_cse();
5835         set_opt_cse(0);
5836
5837         call_list  = NEW_ARR_F(ir_node *, 0);
5838         call_types = NEW_ARR_F(ir_type *, 0);
5839         be_transform_graph(irg, ia32_pretransform_node);
5840
5841         if (ia32_cg_config.use_sse2)
5842                 postprocess_fp_call_results();
5843         DEL_ARR_F(call_types);
5844         DEL_ARR_F(call_list);
5845
5846         set_opt_cse(cse_last);
5847
5848         ia32_free_non_address_mode_nodes();
5849         heights_free(ia32_heights);
5850         ia32_heights = NULL;
5851 }
5852
5853 void ia32_init_transform(void)
5854 {
5855         FIRM_DBG_REGISTER(dbg, "firm.be.ia32.transform");
5856 }