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

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