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