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