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