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

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