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