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

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