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