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

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