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