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