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

   1 /*
   2  * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   6  * This file may be distributed and/or modified under the terms of the
   7  * GNU General Public License version 2 as published by the Free Software
   8  * Foundation and appearing in the file LICENSE.GPL included in the
   9  * packaging of this file.
  10  *
  11  * Licensees holding valid libFirm Professional Edition licenses may use
  12  * this file in accordance with the libFirm Commercial License.
  13  * Agreement provided with the Software.
  14  *
  15  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief       This file implements the IR transformation from firm into
  23  *              ia32-Firm.
  24  * @author      Christian Wuerdig, Matthias Braun
  25  * @version     $Id$
  26  */
  27 #include "config.h"
  28
  29 #include <limits.h>
  30 #include <stdbool.h>
  31
  32 #include "irargs_t.h"
  33 #include "irnode_t.h"
  34 #include "irgraph_t.h"
  35 #include "irmode_t.h"
  36 #include "iropt_t.h"
  37 #include "irop_t.h"
  38 #include "irprog_t.h"
  39 #include "iredges_t.h"
  40 #include "irgmod.h"
  41 #include "irvrfy.h"
  42 #include "ircons.h"
  43 #include "irgwalk.h"
  44 #include "irprintf.h"
  45 #include "debug.h"
  46 #include "irdom.h"
  47 #include "error.h"
  48 #include "array_t.h"
  49 #include "height.h"
  50
  51 #include "../benode_t.h"
  52 #include "../besched.h"
  53 #include "../beabi.h"
  54 #include "../beutil.h"
  55 #include "../beirg_t.h"
  56 #include "../betranshlp.h"
  57 #include "../be_t.h"
  58
  59 #include "bearch_ia32_t.h"
  60 #include "ia32_common_transform.h"
  61 #include "ia32_nodes_attr.h"
  62 #include "ia32_transform.h"
  63 #include "ia32_new_nodes.h"
  64 #include "ia32_map_regs.h"
  65 #include "ia32_dbg_stat.h"
  66 #include "ia32_optimize.h"
  67 #include "ia32_util.h"
  68 #include "ia32_address_mode.h"
  69 #include "ia32_architecture.h"
  70
  71 #include "gen_ia32_regalloc_if.h"
  72
  73 #define SFP_SIGN   "0x80000000"
  74 #define DFP_SIGN   "0x8000000000000000"
  75 #define SFP_ABS    "0x7FFFFFFF"
  76 #define DFP_ABS    "0x7FFFFFFFFFFFFFFF"
  77 #define DFP_INTMAX "9223372036854775807"
  78 #define ULL_BIAS   "18446744073709551616"
  79
  80 #define ENT_SFP_SIGN ".LC_ia32_sfp_sign"
  81 #define ENT_DFP_SIGN ".LC_ia32_dfp_sign"
  82 #define ENT_SFP_ABS  ".LC_ia32_sfp_abs"
  83 #define ENT_DFP_ABS  ".LC_ia32_dfp_abs"
  84 #define ENT_ULL_BIAS ".LC_ia32_ull_bias"
  85
  86 #define mode_vfp        (ia32_reg_classes[CLASS_ia32_vfp].mode)
  87 #define mode_xmm    (ia32_reg_classes[CLASS_ia32_xmm].mode)
  88
  89 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
  90
  91 static ir_node         *initial_fpcw = NULL;
  92
  93 extern ir_op *get_op_Mulh(void);
  94
  95 typedef ir_node *construct_binop_func(dbg_info *db, ir_node *block,
  96         ir_node *base, ir_node *index, ir_node *mem, ir_node *op1,
  97         ir_node *op2);
  98
  99 typedef ir_node *construct_binop_flags_func(dbg_info *db, ir_node *block,
 100         ir_node *base, ir_node *index, ir_node *mem, ir_node *op1, ir_node *op2,
 101         ir_node *flags);
 102
 103 typedef ir_node *construct_shift_func(dbg_info *db, ir_node *block,
 104         ir_node *op1, ir_node *op2);
 105
 106 typedef ir_node *construct_binop_dest_func(dbg_info *db, ir_node *block,
 107         ir_node *base, ir_node *index, ir_node *mem, ir_node *op);
 108
 109 typedef ir_node *construct_unop_dest_func(dbg_info *db, ir_node *block,
 110         ir_node *base, ir_node *index, ir_node *mem);
 111
 112 typedef ir_node *construct_binop_float_func(dbg_info *db, ir_node *block,
 113         ir_node *base, ir_node *index, ir_node *mem, ir_node *op1, ir_node *op2,
 114         ir_node *fpcw);
 115
 116 typedef ir_node *construct_unop_func(dbg_info *db, ir_node *block, ir_node *op);
 117
 118 static ir_node *create_immediate_or_transform(ir_node *node,
 119                                               char immediate_constraint_type);
 120
 121 static ir_node *create_I2I_Conv(ir_mode *src_mode, ir_mode *tgt_mode,
 122                                 dbg_info *dbgi, ir_node *block,
 123                                 ir_node *op, ir_node *orig_node);
 124
 125 /** Return non-zero is a node represents the 0 constant. */
 126 static bool is_Const_0(ir_node *node)
 127 {
 128         return is_Const(node) && is_Const_null(node);
 129 }
 130
 131 /** Return non-zero is a node represents the 1 constant. */
 132 static bool is_Const_1(ir_node *node)
 133 {
 134         return is_Const(node) && is_Const_one(node);
 135 }
 136
 137 /** Return non-zero is a node represents the -1 constant. */
 138 static bool is_Const_Minus_1(ir_node *node)
 139 {
 140         return is_Const(node) && is_Const_all_one(node);
 141 }
 142
 143 /**
 144  * returns true if constant can be created with a simple float command
 145  */
 146 static bool is_simple_x87_Const(ir_node *node)
 147 {
 148         tarval *tv = get_Const_tarval(node);
 149         if (tarval_is_null(tv) || tarval_is_one(tv))
 150                 return true;
 151
 152         /* TODO: match all the other float constants */
 153         return false;
 154 }
 155
 156 /**
 157  * returns true if constant can be created with a simple float command
 158  */
 159 static bool is_simple_sse_Const(ir_node *node)
 160 {
 161         tarval  *tv   = get_Const_tarval(node);
 162         ir_mode *mode = get_tarval_mode(tv);
 163
 164         if (mode == mode_F)
 165                 return true;
 166
 167         if (tarval_is_null(tv) || tarval_is_one(tv))
 168                 return true;
 169
 170         if (mode == mode_D) {
 171                 unsigned val = get_tarval_sub_bits(tv, 0) |
 172                         (get_tarval_sub_bits(tv, 1) << 8) |
 173                         (get_tarval_sub_bits(tv, 2) << 16) |
 174                         (get_tarval_sub_bits(tv, 3) << 24);
 175                 if (val == 0)
 176                         /* lower 32bit are zero, really a 32bit constant */
 177                         return true;
 178         }
 179
 180         /* TODO: match all the other float constants */
 181         return false;
 182 }
 183
 184 /**
 185  * Transforms a Const.
 186  */
 187 static ir_node *gen_Const(ir_node *node)
 188 {
 189         ir_node  *old_block = get_nodes_block(node);
 190         ir_node  *block     = be_transform_node(old_block);
 191         dbg_info *dbgi      = get_irn_dbg_info(node);
 192         ir_mode  *mode      = get_irn_mode(node);
 193
 194         assert(is_Const(node));
 195
 196         if (mode_is_float(mode)) {
 197                 ir_node   *res   = NULL;
 198                 ir_node   *noreg = ia32_new_NoReg_gp(env_cg);
 199                 ir_node   *nomem = new_NoMem();
 200                 ir_node   *load;
 201                 ir_entity *floatent;
 202
 203                 if (ia32_cg_config.use_sse2) {
 204                         tarval *tv = get_Const_tarval(node);
 205                         if (tarval_is_null(tv)) {
 206                                 load = new_bd_ia32_xZero(dbgi, block);
 207                                 set_ia32_ls_mode(load, mode);
 208                                 res  = load;
 209                         } else if (tarval_is_one(tv)) {
 210                                 int     cnst  = mode == mode_F ? 26 : 55;
 211                                 ir_node *imm1 = create_Immediate(NULL, 0, cnst);
 212                                 ir_node *imm2 = create_Immediate(NULL, 0, 2);
 213                                 ir_node *pslld, *psrld;
 214
 215                                 load = new_bd_ia32_xAllOnes(dbgi, block);
 216                                 set_ia32_ls_mode(load, mode);
 217                                 pslld = new_bd_ia32_xPslld(dbgi, block, load, imm1);
 218                                 set_ia32_ls_mode(pslld, mode);
 219                                 psrld = new_bd_ia32_xPsrld(dbgi, block, pslld, imm2);
 220                                 set_ia32_ls_mode(psrld, mode);
 221                                 res = psrld;
 222                         } else if (mode == mode_F) {
 223                                 /* we can place any 32bit constant by using a movd gp, sse */
 224                                 unsigned val = get_tarval_sub_bits(tv, 0) |
 225                                                (get_tarval_sub_bits(tv, 1) << 8) |
 226                                                (get_tarval_sub_bits(tv, 2) << 16) |
 227                                                (get_tarval_sub_bits(tv, 3) << 24);
 228                                 ir_node *cnst = new_bd_ia32_Const(dbgi, block, NULL, 0, val);
 229                                 load = new_bd_ia32_xMovd(dbgi, block, cnst);
 230                                 set_ia32_ls_mode(load, mode);
 231                                 res = load;
 232                         } else {
 233                                 if (mode == mode_D) {
 234                                         unsigned val = get_tarval_sub_bits(tv, 0) |
 235                                                 (get_tarval_sub_bits(tv, 1) << 8) |
 236                                                 (get_tarval_sub_bits(tv, 2) << 16) |
 237                                                 (get_tarval_sub_bits(tv, 3) << 24);
 238                                         if (val == 0) {
 239                                                 ir_node *imm32 = create_Immediate(NULL, 0, 32);
 240                                                 ir_node *cnst, *psllq;
 241
 242                                                 /* fine, lower 32bit are zero, produce 32bit value */
 243                                                 val = get_tarval_sub_bits(tv, 4) |
 244                                                         (get_tarval_sub_bits(tv, 5) << 8) |
 245                                                         (get_tarval_sub_bits(tv, 6) << 16) |
 246                                                         (get_tarval_sub_bits(tv, 7) << 24);
 247                                                 cnst = new_bd_ia32_Const(dbgi, block, NULL, 0, val);
 248                                                 load = new_bd_ia32_xMovd(dbgi, block, cnst);
 249                                                 set_ia32_ls_mode(load, mode);
 250                                                 psllq = new_bd_ia32_xPsllq(dbgi, block, load, imm32);
 251                                                 set_ia32_ls_mode(psllq, mode);
 252                                                 res = psllq;
 253                                                 goto end;
 254                                         }
 255                                 }
 256                                 floatent = create_float_const_entity(node);
 257
 258                                 load     = new_bd_ia32_xLoad(dbgi, block, noreg, noreg, nomem,
 259                                                              mode);
 260                                 set_ia32_op_type(load, ia32_AddrModeS);
 261                                 set_ia32_am_sc(load, floatent);
 262                                 arch_irn_add_flags(load, arch_irn_flags_rematerializable);
 263                                 res = new_r_Proj(current_ir_graph, block, load, mode_xmm, pn_ia32_xLoad_res);
 264                         }
 265                 } else {
 266                         if (is_Const_null(node)) {
 267                                 load = new_bd_ia32_vfldz(dbgi, block);
 268                                 res  = load;
 269                                 set_ia32_ls_mode(load, mode);
 270                         } else if (is_Const_one(node)) {
 271                                 load = new_bd_ia32_vfld1(dbgi, block);
 272                                 res  = load;
 273                                 set_ia32_ls_mode(load, mode);
 274                         } else {
 275                                 ir_mode *ls_mode;
 276
 277                                 floatent = create_float_const_entity(node);
 278                                 /* create_float_const_ent is smart and sometimes creates
 279                                    smaller entities */
 280                                 ls_mode  = get_type_mode(get_entity_type(floatent));
 281
 282                                 load     = new_bd_ia32_vfld(dbgi, block, noreg, noreg, nomem,
 283                                                             ls_mode);
 284                                 set_ia32_op_type(load, ia32_AddrModeS);
 285                                 set_ia32_am_sc(load, floatent);
 286                                 arch_irn_add_flags(load, arch_irn_flags_rematerializable);
 287                                 res = new_r_Proj(current_ir_graph, block, load, mode_vfp, pn_ia32_vfld_res);
 288                         }
 289                 }
 290 end:
 291                 SET_IA32_ORIG_NODE(load, node);
 292
 293                 be_dep_on_frame(load);
 294                 return res;
 295         } else { /* non-float mode */
 296                 ir_node *cnst;
 297                 tarval  *tv = get_Const_tarval(node);
 298                 long     val;
 299
 300                 tv = tarval_convert_to(tv, mode_Iu);
 301
 302                 if (tv == get_tarval_bad() || tv == get_tarval_undefined() ||
 303                     tv == NULL) {
 304                         panic("couldn't convert constant tarval (%+F)", node);
 305                 }
 306                 val = get_tarval_long(tv);
 307
 308                 cnst = new_bd_ia32_Const(dbgi, block, NULL, 0, val);
 309                 SET_IA32_ORIG_NODE(cnst, node);
 310
 311                 be_dep_on_frame(cnst);
 312                 return cnst;
 313         }
 314 }
 315
 316 /**
 317  * Transforms a SymConst.
 318  */
 319 static ir_node *gen_SymConst(ir_node *node)
 320 {
 321         ir_node  *old_block = get_nodes_block(node);
 322         ir_node  *block = be_transform_node(old_block);
 323         dbg_info *dbgi  = get_irn_dbg_info(node);
 324         ir_mode  *mode  = get_irn_mode(node);
 325         ir_node  *cnst;
 326
 327         if (mode_is_float(mode)) {
 328                 ir_node *noreg = ia32_new_NoReg_gp(env_cg);
 329                 ir_node *nomem = new_NoMem();
 330
 331                 if (ia32_cg_config.use_sse2)
 332                         cnst = new_bd_ia32_xLoad(dbgi, block, noreg, noreg, nomem, mode_E);
 333                 else
 334                         cnst = new_bd_ia32_vfld(dbgi, block, noreg, noreg, nomem, mode_E);
 335                 set_ia32_am_sc(cnst, get_SymConst_entity(node));
 336                 set_ia32_use_frame(cnst);
 337         } else {
 338                 ir_entity *entity;
 339
 340                 if (get_SymConst_kind(node) != symconst_addr_ent) {
 341                         panic("backend only support symconst_addr_ent (at %+F)", node);
 342                 }
 343                 entity = get_SymConst_entity(node);
 344                 cnst = new_bd_ia32_Const(dbgi, block, entity, 0, 0);
 345         }
 346
 347         SET_IA32_ORIG_NODE(cnst, node);
 348
 349         be_dep_on_frame(cnst);
 350         return cnst;
 351 }
 352
 353 /**
 354  * Create a float type for the given mode and cache it.
 355  *
 356  * @param mode   the mode for the float type (might be integer mode for SSE2 types)
 357  * @param align  alignment
 358  */
 359 static ir_type *ia32_create_float_type(ir_mode *mode, unsigned align) {
 360         char    buf[32];
 361         ir_type *tp;
 362
 363         assert(align <= 16);
 364
 365         if (mode == mode_Iu) {
 366                 static ir_type *int_Iu[16] = {NULL, };
 367
 368                 if (int_Iu[align] == NULL) {
 369                         snprintf(buf, sizeof(buf), "int_Iu_%u", align);
 370                         int_Iu[align] = tp = new_type_primitive(new_id_from_str(buf), mode);
 371                         /* set the specified alignment */
 372                         set_type_alignment_bytes(tp, align);
 373                 }
 374                 return int_Iu[align];
 375         } else if (mode == mode_Lu) {
 376                 static ir_type *int_Lu[16] = {NULL, };
 377
 378                 if (int_Lu[align] == NULL) {
 379                         snprintf(buf, sizeof(buf), "int_Lu_%u", align);
 380                         int_Lu[align] = tp = new_type_primitive(new_id_from_str(buf), mode);
 381                         /* set the specified alignment */
 382                         set_type_alignment_bytes(tp, align);
 383                 }
 384                 return int_Lu[align];
 385         } else if (mode == mode_F) {
 386                 static ir_type *float_F[16] = {NULL, };
 387
 388                 if (float_F[align] == NULL) {
 389                         snprintf(buf, sizeof(buf), "float_F_%u", align);
 390                         float_F[align] = tp = new_type_primitive(new_id_from_str(buf), mode);
 391                         /* set the specified alignment */
 392                         set_type_alignment_bytes(tp, align);
 393                 }
 394                 return float_F[align];
 395         } else if (mode == mode_D) {
 396                 static ir_type *float_D[16] = {NULL, };
 397
 398                 if (float_D[align] == NULL) {
 399                         snprintf(buf, sizeof(buf), "float_D_%u", align);
 400                         float_D[align] = tp = new_type_primitive(new_id_from_str(buf), mode);
 401                         /* set the specified alignment */
 402                         set_type_alignment_bytes(tp, align);
 403                 }
 404                 return float_D[align];
 405         } else {
 406                 static ir_type *float_E[16] = {NULL, };
 407
 408                 if (float_E[align] == NULL) {
 409                         snprintf(buf, sizeof(buf), "float_E_%u", align);
 410                         float_E[align] = tp = new_type_primitive(new_id_from_str(buf), mode);
 411                         /* set the specified alignment */
 412                         set_type_alignment_bytes(tp, align);
 413                 }
 414                 return float_E[align];
 415         }
 416 }
 417
 418 /**
 419  * Create a float[2] array type for the given atomic type.
 420  *
 421  * @param tp  the atomic type
 422  */
 423 static ir_type *ia32_create_float_array(ir_type *tp) {
 424         char     buf[32];
 425         ir_mode  *mode = get_type_mode(tp);
 426         unsigned align = get_type_alignment_bytes(tp);
 427         ir_type  *arr;
 428
 429         assert(align <= 16);
 430
 431         if (mode == mode_F) {
 432                 static ir_type *float_F[16] = {NULL, };
 433
 434                 if (float_F[align] != NULL)
 435                         return float_F[align];
 436                 snprintf(buf, sizeof(buf), "arr_float_F_%u", align);
 437                 arr = float_F[align] = new_type_array(new_id_from_str(buf), 1, tp);
 438         } else if (mode == mode_D) {
 439                 static ir_type *float_D[16] = {NULL, };
 440
 441                 if (float_D[align] != NULL)
 442                         return float_D[align];
 443                 snprintf(buf, sizeof(buf), "arr_float_D_%u", align);
 444                 arr = float_D[align] = new_type_array(new_id_from_str(buf), 1, tp);
 445         } else {
 446                 static ir_type *float_E[16] = {NULL, };
 447
 448                 if (float_E[align] != NULL)
 449                         return float_E[align];
 450                 snprintf(buf, sizeof(buf), "arr_float_E_%u", align);
 451                 arr = float_E[align] = new_type_array(new_id_from_str(buf), 1, tp);
 452         }
 453         set_type_alignment_bytes(arr, align);
 454         set_type_size_bytes(arr, 2 * get_type_size_bytes(tp));
 455         set_type_state(arr, layout_fixed);
 456         return arr;
 457 }
 458
 459 /* Generates an entity for a known FP const (used for FP Neg + Abs) */
 460 ir_entity *ia32_gen_fp_known_const(ia32_known_const_t kct)
 461 {
 462         static const struct {
 463                 const char *ent_name;
 464                 const char *cnst_str;
 465                 char mode;
 466                 unsigned char align;
 467         } names [ia32_known_const_max] = {
 468                 { ENT_SFP_SIGN, SFP_SIGN,   0, 16 }, /* ia32_SSIGN */
 469                 { ENT_DFP_SIGN, DFP_SIGN,   1, 16 }, /* ia32_DSIGN */
 470                 { ENT_SFP_ABS,  SFP_ABS,    0, 16 }, /* ia32_SABS */
 471                 { ENT_DFP_ABS,  DFP_ABS,    1, 16 }, /* ia32_DABS */
 472                 { ENT_ULL_BIAS, ULL_BIAS,   2, 4 }   /* ia32_ULLBIAS */
 473         };
 474         static ir_entity *ent_cache[ia32_known_const_max];
 475
 476         const char    *ent_name, *cnst_str;
 477         ir_type       *tp;
 478         ir_entity     *ent;
 479         tarval        *tv;
 480         ir_mode       *mode;
 481
 482         ent_name = names[kct].ent_name;
 483         if (! ent_cache[kct]) {
 484                 cnst_str = names[kct].cnst_str;
 485
 486                 switch (names[kct].mode) {
 487                 case 0:  mode = mode_Iu; break;
 488                 case 1:  mode = mode_Lu; break;
 489                 default: mode = mode_F;  break;
 490                 }
 491                 tv  = new_tarval_from_str(cnst_str, strlen(cnst_str), mode);
 492                 tp  = ia32_create_float_type(mode, names[kct].align);
 493
 494                 if (kct == ia32_ULLBIAS)
 495                         tp = ia32_create_float_array(tp);
 496                 ent = new_entity(get_glob_type(), new_id_from_str(ent_name), tp);
 497
 498                 set_entity_ld_ident(ent, get_entity_ident(ent));
 499                 set_entity_visibility(ent, visibility_local);
 500                 set_entity_variability(ent, variability_constant);
 501                 set_entity_allocation(ent, allocation_static);
 502
 503                 if (kct == ia32_ULLBIAS) {
 504                         ir_initializer_t *initializer = create_initializer_compound(2);
 505
 506                         set_initializer_compound_value(initializer, 0,
 507                                 create_initializer_tarval(get_tarval_null(mode)));
 508                         set_initializer_compound_value(initializer, 1,
 509                                 create_initializer_tarval(tv));
 510
 511                         set_entity_initializer(ent, initializer);
 512                 } else {
 513                         set_entity_initializer(ent, create_initializer_tarval(tv));
 514                 }
 515
 516                 /* cache the entry */
 517                 ent_cache[kct] = ent;
 518         }
 519
 520         return ent_cache[kct];
 521 }
 522
 523 /**
 524  * return true if the node is a Proj(Load) and could be used in source address
 525  * mode for another node. Will return only true if the @p other node is not
 526  * dependent on the memory of the Load (for binary operations use the other
 527  * input here, for unary operations use NULL).
 528  */
 529 static int ia32_use_source_address_mode(ir_node *block, ir_node *node,
 530                                         ir_node *other, ir_node *other2, match_flags_t flags)
 531 {
 532         ir_node *load;
 533         long     pn;
 534
 535         /* float constants are always available */
 536         if (is_Const(node)) {
 537                 ir_mode *mode = get_irn_mode(node);
 538                 if (mode_is_float(mode)) {
 539                         if (ia32_cg_config.use_sse2) {
 540                                 if (is_simple_sse_Const(node))
 541                                         return 0;
 542                         } else {
 543                                 if (is_simple_x87_Const(node))
 544                                         return 0;
 545                         }
 546                         if (get_irn_n_edges(node) > 1)
 547                                 return 0;
 548                         return 1;
 549                 }
 550         }
 551
 552         if (!is_Proj(node))
 553                 return 0;
 554         load = get_Proj_pred(node);
 555         pn   = get_Proj_proj(node);
 556         if (!is_Load(load) || pn != pn_Load_res)
 557                 return 0;
 558         if (get_nodes_block(load) != block)
 559                 return 0;
 560         /* we only use address mode if we're the only user of the load */
 561         if (get_irn_n_edges(node) != (flags & match_two_users ? 2 : 1))
 562                 return 0;
 563         /* in some edge cases with address mode we might reach the load normally
 564          * and through some AM sequence, if it is already materialized then we
 565          * can't create an AM node from it */
 566         if (be_is_transformed(node))
 567                 return 0;
 568
 569         /* don't do AM if other node inputs depend on the load (via mem-proj) */
 570         if (other != NULL && prevents_AM(block, load, other))
 571                 return 0;
 572
 573         if (other2 != NULL && prevents_AM(block, load, other2))
 574                 return 0;
 575
 576         return 1;
 577 }
 578
 579 typedef struct ia32_address_mode_t ia32_address_mode_t;
 580 struct ia32_address_mode_t {
 581         ia32_address_t  addr;
 582         ir_mode        *ls_mode;
 583         ir_node        *mem_proj;
 584         ir_node        *am_node;
 585         ia32_op_type_t  op_type;
 586         ir_node        *new_op1;
 587         ir_node        *new_op2;
 588         op_pin_state    pinned;
 589         unsigned        commutative  : 1;
 590         unsigned        ins_permuted : 1;
 591 };
 592
 593 static void build_address_ptr(ia32_address_t *addr, ir_node *ptr, ir_node *mem)
 594 {
 595         ir_node *noreg_gp;
 596
 597         /* construct load address */
 598         memset(addr, 0, sizeof(addr[0]));
 599         ia32_create_address_mode(addr, ptr, 0);
 600
 601         noreg_gp    = ia32_new_NoReg_gp(env_cg);
 602         addr->base  = addr->base  ? be_transform_node(addr->base)  : noreg_gp;
 603         addr->index = addr->index ? be_transform_node(addr->index) : noreg_gp;
 604         addr->mem   = be_transform_node(mem);
 605 }
 606
 607 static void build_address(ia32_address_mode_t *am, ir_node *node,
 608                           ia32_create_am_flags_t flags)
 609 {
 610         ir_node        *noreg_gp = ia32_new_NoReg_gp(env_cg);
 611         ia32_address_t *addr     = &am->addr;
 612         ir_node        *load;
 613         ir_node        *ptr;
 614         ir_node        *mem;
 615         ir_node        *new_mem;
 616
 617         if (is_Const(node)) {
 618                 ir_entity *entity  = create_float_const_entity(node);
 619                 addr->base         = noreg_gp;
 620                 addr->index        = noreg_gp;
 621                 addr->mem          = new_NoMem();
 622                 addr->symconst_ent = entity;
 623                 addr->use_frame    = 1;
 624                 am->ls_mode        = get_type_mode(get_entity_type(entity));
 625                 am->pinned         = op_pin_state_floats;
 626                 return;
 627         }
 628
 629         load         = get_Proj_pred(node);
 630         ptr          = get_Load_ptr(load);
 631         mem          = get_Load_mem(load);
 632         new_mem      = be_transform_node(mem);
 633         am->pinned   = get_irn_pinned(load);
 634         am->ls_mode  = get_Load_mode(load);
 635         am->mem_proj = be_get_Proj_for_pn(load, pn_Load_M);
 636         am->am_node  = node;
 637
 638         /* construct load address */
 639         ia32_create_address_mode(addr, ptr, flags);
 640
 641         addr->base  = addr->base  ? be_transform_node(addr->base)  : noreg_gp;
 642         addr->index = addr->index ? be_transform_node(addr->index) : noreg_gp;
 643         addr->mem   = new_mem;
 644 }
 645
 646 static void set_address(ir_node *node, const ia32_address_t *addr)
 647 {
 648         set_ia32_am_scale(node, addr->scale);
 649         set_ia32_am_sc(node, addr->symconst_ent);
 650         set_ia32_am_offs_int(node, addr->offset);
 651         if (addr->symconst_sign)
 652                 set_ia32_am_sc_sign(node);
 653         if (addr->use_frame)
 654                 set_ia32_use_frame(node);
 655         set_ia32_frame_ent(node, addr->frame_entity);
 656 }
 657
 658 /**
 659  * Apply attributes of a given address mode to a node.
 660  */
 661 static void set_am_attributes(ir_node *node, const ia32_address_mode_t *am)
 662 {
 663         set_address(node, &am->addr);
 664
 665         set_ia32_op_type(node, am->op_type);
 666         set_ia32_ls_mode(node, am->ls_mode);
 667         if (am->pinned == op_pin_state_pinned) {
 668                 /* beware: some nodes are already pinned and did not allow to change the state */
 669                 if (get_irn_pinned(node) != op_pin_state_pinned)
 670                         set_irn_pinned(node, op_pin_state_pinned);
 671         }
 672         if (am->commutative)
 673                 set_ia32_commutative(node);
 674 }
 675
 676 /**
 677  * Check, if a given node is a Down-Conv, ie. a integer Conv
 678  * from a mode with a mode with more bits to a mode with lesser bits.
 679  * Moreover, we return only true if the node has not more than 1 user.
 680  *
 681  * @param node   the node
 682  * @return non-zero if node is a Down-Conv
 683  */
 684 static int is_downconv(const ir_node *node)
 685 {
 686         ir_mode *src_mode;
 687         ir_mode *dest_mode;
 688
 689         if (!is_Conv(node))
 690                 return 0;
 691
 692         /* we only want to skip the conv when we're the only user
 693          * (not optimal but for now...)
 694          */
 695         if (get_irn_n_edges(node) > 1)
 696                 return 0;
 697
 698         src_mode  = get_irn_mode(get_Conv_op(node));
 699         dest_mode = get_irn_mode(node);
 700         return
 701                 ia32_mode_needs_gp_reg(src_mode)  &&
 702                 ia32_mode_needs_gp_reg(dest_mode) &&
 703                 get_mode_size_bits(dest_mode) <= get_mode_size_bits(src_mode);
 704 }
 705
 706 /* Skip all Down-Conv's on a given node and return the resulting node. */
 707 ir_node *ia32_skip_downconv(ir_node *node)
 708 {
 709         while (is_downconv(node))
 710                 node = get_Conv_op(node);
 711
 712         return node;
 713 }
 714
 715 static ir_node *create_upconv(ir_node *node, ir_node *orig_node)
 716 {
 717         ir_mode  *mode = get_irn_mode(node);
 718         ir_node  *block;
 719         ir_mode  *tgt_mode;
 720         dbg_info *dbgi;
 721
 722         if (mode_is_signed(mode)) {
 723                 tgt_mode = mode_Is;
 724         } else {
 725                 tgt_mode = mode_Iu;
 726         }
 727         block = get_nodes_block(node);
 728         dbgi  = get_irn_dbg_info(node);
 729
 730         return create_I2I_Conv(mode, tgt_mode, dbgi, block, node, orig_node);
 731 }
 732
 733 /**
 734  * matches operands of a node into ia32 addressing/operand modes. This covers
 735  * usage of source address mode, immediates, operations with non 32-bit modes,
 736  * ...
 737  * The resulting data is filled into the @p am struct. block is the block
 738  * of the node whose arguments are matched. op1, op2 are the first and second
 739  * input that are matched (op1 may be NULL). other_op is another unrelated
 740  * input that is not matched! but which is needed sometimes to check if AM
 741  * for op1/op2 is legal.
 742  * @p flags describes the supported modes of the operation in detail.
 743  */
 744 static void match_arguments(ia32_address_mode_t *am, ir_node *block,
 745                             ir_node *op1, ir_node *op2, ir_node *other_op,
 746                             match_flags_t flags)
 747 {
 748         ia32_address_t *addr      = &am->addr;
 749         ir_mode        *mode      = get_irn_mode(op2);
 750         int             mode_bits = get_mode_size_bits(mode);
 751         ir_node        *noreg_gp, *new_op1, *new_op2;
 752         int             use_am;
 753         unsigned        commutative;
 754         int             use_am_and_immediates;
 755         int             use_immediate;
 756
 757         memset(am, 0, sizeof(am[0]));
 758
 759         commutative           = (flags & match_commutative) != 0;
 760         use_am_and_immediates = (flags & match_am_and_immediates) != 0;
 761         use_am                = (flags & match_am) != 0;
 762         use_immediate         = (flags & match_immediate) != 0;
 763         assert(!use_am_and_immediates || use_immediate);
 764
 765         assert(op2 != NULL);
 766         assert(!commutative || op1 != NULL);
 767         assert(use_am || !(flags & match_8bit_am));
 768         assert(use_am || !(flags & match_16bit_am));
 769
 770         if ((mode_bits ==  8 && !(flags & match_8bit_am)) ||
 771                         (mode_bits == 16 && !(flags & match_16bit_am))) {
 772                 use_am = 0;
 773         }
 774
 775         /* we can simply skip downconvs for mode neutral nodes: the upper bits
 776          * can be random for these operations */
 777         if (flags & match_mode_neutral) {
 778                 op2 = ia32_skip_downconv(op2);
 779                 if (op1 != NULL) {
 780                         op1 = ia32_skip_downconv(op1);
 781                 }
 782         }
 783
 784         /* match immediates. firm nodes are normalized: constants are always on the
 785          * op2 input */
 786         new_op2 = NULL;
 787         if (!(flags & match_try_am) && use_immediate) {
 788                 new_op2 = try_create_Immediate(op2, 0);
 789         }
 790
 791         noreg_gp = ia32_new_NoReg_gp(env_cg);
 792         if (new_op2 == NULL &&
 793             use_am && ia32_use_source_address_mode(block, op2, op1, other_op, flags)) {
 794                 build_address(am, op2, 0);
 795                 new_op1     = (op1 == NULL ? NULL : be_transform_node(op1));
 796                 if (mode_is_float(mode)) {
 797                         new_op2 = ia32_new_NoReg_vfp(env_cg);
 798                 } else {
 799                         new_op2 = noreg_gp;
 800                 }
 801                 am->op_type = ia32_AddrModeS;
 802         } else if (commutative && (new_op2 == NULL || use_am_and_immediates) &&
 803                        use_am &&
 804                        ia32_use_source_address_mode(block, op1, op2, other_op, flags)) {
 805                 ir_node *noreg;
 806                 build_address(am, op1, 0);
 807
 808                 if (mode_is_float(mode)) {
 809                         noreg = ia32_new_NoReg_vfp(env_cg);
 810                 } else {
 811                         noreg = noreg_gp;
 812                 }
 813
 814                 if (new_op2 != NULL) {
 815                         new_op1 = noreg;
 816                 } else {
 817                         new_op1 = be_transform_node(op2);
 818                         new_op2 = noreg;
 819                         am->ins_permuted = 1;
 820                 }
 821                 am->op_type = ia32_AddrModeS;
 822         } else {
 823                 am->op_type = ia32_Normal;
 824
 825                 if (flags & match_try_am) {
 826                         am->new_op1 = NULL;
 827                         am->new_op2 = NULL;
 828                         return;
 829                 }
 830
 831                 new_op1 = (op1 == NULL ? NULL : be_transform_node(op1));
 832                 if (new_op2 == NULL)
 833                         new_op2 = be_transform_node(op2);
 834                 am->ls_mode =
 835                         (flags & match_mode_neutral ? mode_Iu : get_irn_mode(op2));
 836         }
 837         if (addr->base == NULL)
 838                 addr->base = noreg_gp;
 839         if (addr->index == NULL)
 840                 addr->index = noreg_gp;
 841         if (addr->mem == NULL)
 842                 addr->mem = new_NoMem();
 843
 844         am->new_op1     = new_op1;
 845         am->new_op2     = new_op2;
 846         am->commutative = commutative;
 847 }
 848
 849 static ir_node *fix_mem_proj(ir_node *node, ia32_address_mode_t *am)
 850 {
 851         ir_mode  *mode;
 852         ir_node  *load;
 853
 854         if (am->mem_proj == NULL)
 855                 return node;
 856
 857         /* we have to create a mode_T so the old MemProj can attach to us */
 858         mode = get_irn_mode(node);
 859         load = get_Proj_pred(am->mem_proj);
 860
 861         be_set_transformed_node(load, node);
 862
 863         if (mode != mode_T) {
 864                 set_irn_mode(node, mode_T);
 865                 return new_rd_Proj(NULL, current_ir_graph, get_nodes_block(node), node, mode, pn_ia32_res);
 866         } else {
 867                 return node;
 868         }
 869 }
 870
 871 /**
 872  * Construct a standard binary operation, set AM and immediate if required.
 873  *
 874  * @param node  The original node for which the binop is created
 875  * @param op1   The first operand
 876  * @param op2   The second operand
 877  * @param func  The node constructor function
 878  * @return The constructed ia32 node.
 879  */
 880 static ir_node *gen_binop(ir_node *node, ir_node *op1, ir_node *op2,
 881                           construct_binop_func *func, match_flags_t flags)
 882 {
 883         dbg_info            *dbgi;
 884         ir_node             *block, *new_block, *new_node;
 885         ia32_address_mode_t  am;
 886         ia32_address_t      *addr = &am.addr;
 887
 888         block = get_nodes_block(node);
 889         match_arguments(&am, block, op1, op2, NULL, flags);
 890
 891         dbgi      = get_irn_dbg_info(node);
 892         new_block = be_transform_node(block);
 893         new_node  = func(dbgi, new_block, addr->base, addr->index, addr->mem,
 894                         am.new_op1, am.new_op2);
 895         set_am_attributes(new_node, &am);
 896         /* we can't use source address mode anymore when using immediates */
 897         if (!(flags & match_am_and_immediates) &&
 898             (is_ia32_Immediate(am.new_op1) || is_ia32_Immediate(am.new_op2)))
 899                 set_ia32_am_support(new_node, ia32_am_none);
 900         SET_IA32_ORIG_NODE(new_node, node);
 901
 902         new_node = fix_mem_proj(new_node, &am);
 903
 904         return new_node;
 905 }
 906
 907 enum {
 908         n_ia32_l_binop_left,
 909         n_ia32_l_binop_right,
 910         n_ia32_l_binop_eflags
 911 };
 912 COMPILETIME_ASSERT(n_ia32_l_binop_left   == n_ia32_l_Adc_left,       n_Adc_left)
 913 COMPILETIME_ASSERT(n_ia32_l_binop_right  == n_ia32_l_Adc_right,      n_Adc_right)
 914 COMPILETIME_ASSERT(n_ia32_l_binop_eflags == n_ia32_l_Adc_eflags,     n_Adc_eflags)
 915 COMPILETIME_ASSERT(n_ia32_l_binop_left   == n_ia32_l_Sbb_minuend,    n_Sbb_minuend)
 916 COMPILETIME_ASSERT(n_ia32_l_binop_right  == n_ia32_l_Sbb_subtrahend, n_Sbb_subtrahend)
 917 COMPILETIME_ASSERT(n_ia32_l_binop_eflags == n_ia32_l_Sbb_eflags,     n_Sbb_eflags)
 918
 919 /**
 920  * Construct a binary operation which also consumes the eflags.
 921  *
 922  * @param node  The node to transform
 923  * @param func  The node constructor function
 924  * @param flags The match flags
 925  * @return      The constructor ia32 node
 926  */
 927 static ir_node *gen_binop_flags(ir_node *node, construct_binop_flags_func *func,
 928                                 match_flags_t flags)
 929 {
 930         ir_node             *src_block  = get_nodes_block(node);
 931         ir_node             *op1        = get_irn_n(node, n_ia32_l_binop_left);
 932         ir_node             *op2        = get_irn_n(node, n_ia32_l_binop_right);
 933         ir_node             *eflags     = get_irn_n(node, n_ia32_l_binop_eflags);
 934         dbg_info            *dbgi;
 935         ir_node             *block, *new_node, *new_eflags;
 936         ia32_address_mode_t  am;
 937         ia32_address_t      *addr       = &am.addr;
 938
 939         match_arguments(&am, src_block, op1, op2, eflags, flags);
 940
 941         dbgi       = get_irn_dbg_info(node);
 942         block      = be_transform_node(src_block);
 943         new_eflags = be_transform_node(eflags);
 944         new_node   = func(dbgi, block, addr->base, addr->index, addr->mem,
 945                         am.new_op1, am.new_op2, new_eflags);
 946         set_am_attributes(new_node, &am);
 947         /* we can't use source address mode anymore when using immediates */
 948         if (!(flags & match_am_and_immediates) &&
 949             (is_ia32_Immediate(am.new_op1) || is_ia32_Immediate(am.new_op2)))
 950                 set_ia32_am_support(new_node, ia32_am_none);
 951         SET_IA32_ORIG_NODE(new_node, node);
 952
 953         new_node = fix_mem_proj(new_node, &am);
 954
 955         return new_node;
 956 }
 957
 958 static ir_node *get_fpcw(void)
 959 {
 960         ir_node *fpcw;
 961         if (initial_fpcw != NULL)
 962                 return initial_fpcw;
 963
 964         fpcw         = be_abi_get_ignore_irn(env_cg->birg->abi,
 965                                              &ia32_fp_cw_regs[REG_FPCW]);
 966         initial_fpcw = be_transform_node(fpcw);
 967
 968         return initial_fpcw;
 969 }
 970
 971 /**
 972  * Construct a standard binary operation, set AM and immediate if required.
 973  *
 974  * @param op1   The first operand
 975  * @param op2   The second operand
 976  * @param func  The node constructor function
 977  * @return The constructed ia32 node.
 978  */
 979 static ir_node *gen_binop_x87_float(ir_node *node, ir_node *op1, ir_node *op2,
 980                                     construct_binop_float_func *func)
 981 {
 982         ir_mode             *mode  = get_irn_mode(node);
 983         dbg_info            *dbgi;
 984         ir_node             *block, *new_block, *new_node;
 985         ia32_address_mode_t  am;
 986         ia32_address_t      *addr = &am.addr;
 987         ia32_x87_attr_t     *attr;
 988         /* All operations are considered commutative, because there are reverse
 989          * variants */
 990         match_flags_t        flags = match_commutative;
 991
 992         /* cannot use address mode with long double on x87 */
 993         if (get_mode_size_bits(mode) <= 64)
 994                 flags |= match_am;
 995
 996         block = get_nodes_block(node);
 997         match_arguments(&am, block, op1, op2, NULL, flags);
 998
 999         dbgi      = get_irn_dbg_info(node);
1000         new_block = be_transform_node(block);
1001         new_node  = func(dbgi, new_block, addr->base, addr->index, addr->mem,
1002                         am.new_op1, am.new_op2, get_fpcw());
1003         set_am_attributes(new_node, &am);
1004
1005         attr = get_ia32_x87_attr(new_node);
1006         attr->attr.data.ins_permuted = am.ins_permuted;
1007
1008         SET_IA32_ORIG_NODE(new_node, node);
1009
1010         new_node = fix_mem_proj(new_node, &am);
1011
1012         return new_node;
1013 }
1014
1015 /**
1016  * Construct a shift/rotate binary operation, sets AM and immediate if required.
1017  *
1018  * @param op1   The first operand
1019  * @param op2   The second operand
1020  * @param func  The node constructor function
1021  * @return The constructed ia32 node.
1022  */
1023 static ir_node *gen_shift_binop(ir_node *node, ir_node *op1, ir_node *op2,
1024                                 construct_shift_func *func,
1025                                 match_flags_t flags)
1026 {
1027         dbg_info *dbgi;
1028         ir_node  *block, *new_block, *new_op1, *new_op2, *new_node;
1029
1030         assert(! mode_is_float(get_irn_mode(node)));
1031         assert(flags & match_immediate);
1032         assert((flags & ~(match_mode_neutral | match_immediate)) == 0);
1033
1034         if (flags & match_mode_neutral) {
1035                 op1     = ia32_skip_downconv(op1);
1036                 new_op1 = be_transform_node(op1);
1037         } else if (get_mode_size_bits(get_irn_mode(node)) != 32) {
1038                 new_op1 = create_upconv(op1, node);
1039         } else {
1040                 new_op1 = be_transform_node(op1);
1041         }
1042
1043         /* the shift amount can be any mode that is bigger than 5 bits, since all
1044          * other bits are ignored anyway */
1045         while (is_Conv(op2) && get_irn_n_edges(op2) == 1) {
1046                 ir_node *const op = get_Conv_op(op2);
1047                 if (mode_is_float(get_irn_mode(op)))
1048                         break;
1049                 op2 = op;
1050                 assert(get_mode_size_bits(get_irn_mode(op2)) >= 5);
1051         }
1052         new_op2 = create_immediate_or_transform(op2, 0);
1053
1054         dbgi      = get_irn_dbg_info(node);
1055         block     = get_nodes_block(node);
1056         new_block = be_transform_node(block);
1057         new_node  = func(dbgi, new_block, new_op1, new_op2);
1058         SET_IA32_ORIG_NODE(new_node, node);
1059
1060         /* lowered shift instruction may have a dependency operand, handle it here */
1061         if (get_irn_arity(node) == 3) {
1062                 /* we have a dependency */
1063                 ir_node *new_dep = be_transform_node(get_irn_n(node, 2));
1064                 add_irn_dep(new_node, new_dep);
1065         }
1066
1067         return new_node;
1068 }
1069
1070
1071 /**
1072  * Construct a standard unary operation, set AM and immediate if required.
1073  *
1074  * @param op    The operand
1075  * @param func  The node constructor function
1076  * @return The constructed ia32 node.
1077  */
1078 static ir_node *gen_unop(ir_node *node, ir_node *op, construct_unop_func *func,
1079                          match_flags_t flags)
1080 {
1081         dbg_info *dbgi;
1082         ir_node  *block, *new_block, *new_op, *new_node;
1083
1084         assert(flags == 0 || flags == match_mode_neutral);
1085         if (flags & match_mode_neutral) {
1086                 op = ia32_skip_downconv(op);
1087         }
1088
1089         new_op    = be_transform_node(op);
1090         dbgi      = get_irn_dbg_info(node);
1091         block     = get_nodes_block(node);
1092         new_block = be_transform_node(block);
1093         new_node  = func(dbgi, new_block, new_op);
1094
1095         SET_IA32_ORIG_NODE(new_node, node);
1096
1097         return new_node;
1098 }
1099
1100 static ir_node *create_lea_from_address(dbg_info *dbgi, ir_node *block,
1101                                         ia32_address_t *addr)
1102 {
1103         ir_node *base, *index, *res;
1104
1105         base = addr->base;
1106         if (base == NULL) {
1107                 base = ia32_new_NoReg_gp(env_cg);
1108         } else {
1109                 base = be_transform_node(base);
1110         }
1111
1112         index = addr->index;
1113         if (index == NULL) {
1114                 index = ia32_new_NoReg_gp(env_cg);
1115         } else {
1116                 index = be_transform_node(index);
1117         }
1118
1119         res = new_bd_ia32_Lea(dbgi, block, base, index);
1120         set_address(res, addr);
1121
1122         return res;
1123 }
1124
1125 /**
1126  * Returns non-zero if a given address mode has a symbolic or
1127  * numerical offset != 0.
1128  */
1129 static int am_has_immediates(const ia32_address_t *addr)
1130 {
1131         return addr->offset != 0 || addr->symconst_ent != NULL
1132                 || addr->frame_entity || addr->use_frame;
1133 }
1134
1135 /**
1136  * Creates an ia32 Add.
1137  *
1138  * @return the created ia32 Add node
1139  */
1140 static ir_node *gen_Add(ir_node *node)
1141 {
1142         ir_mode  *mode = get_irn_mode(node);
1143         ir_node  *op1  = get_Add_left(node);
1144         ir_node  *op2  = get_Add_right(node);
1145         dbg_info *dbgi;
1146         ir_node  *block, *new_block, *new_node, *add_immediate_op;
1147         ia32_address_t       addr;
1148         ia32_address_mode_t  am;
1149
1150         if (mode_is_float(mode)) {
1151                 if (ia32_cg_config.use_sse2)
1152                         return gen_binop(node, op1, op2, new_bd_ia32_xAdd,
1153                                          match_commutative | match_am);
1154                 else
1155                         return gen_binop_x87_float(node, op1, op2, new_bd_ia32_vfadd);
1156         }
1157
1158         ia32_mark_non_am(node);
1159
1160         op2 = ia32_skip_downconv(op2);
1161         op1 = ia32_skip_downconv(op1);
1162
1163         /**
1164          * Rules for an Add:
1165          *   0. Immediate Trees (example Add(Symconst, Const) -> Const)
1166          *   1. Add with immediate -> Lea
1167          *   2. Add with possible source address mode -> Add
1168          *   3. Otherwise -> Lea
1169          */
1170         memset(&addr, 0, sizeof(addr));
1171         ia32_create_address_mode(&addr, node, ia32_create_am_force);
1172         add_immediate_op = NULL;
1173
1174         dbgi      = get_irn_dbg_info(node);
1175         block     = get_nodes_block(node);
1176         new_block = be_transform_node(block);
1177
1178         /* a constant? */
1179         if (addr.base == NULL && addr.index == NULL) {
1180                 new_node = new_bd_ia32_Const(dbgi, new_block, addr.symconst_ent,
1181                                              addr.symconst_sign, addr.offset);
1182                 be_dep_on_frame(new_node);
1183                 SET_IA32_ORIG_NODE(new_node, node);
1184                 return new_node;
1185         }
1186         /* add with immediate? */
1187         if (addr.index == NULL) {
1188                 add_immediate_op = addr.base;
1189         } else if (addr.base == NULL && addr.scale == 0) {
1190                 add_immediate_op = addr.index;
1191         }
1192
1193         if (add_immediate_op != NULL) {
1194                 if (!am_has_immediates(&addr)) {
1195 #ifdef DEBUG_libfirm
1196                         ir_fprintf(stderr, "Optimisation warning Add x,0 (%+F) found\n",
1197                                            node);
1198 #endif
1199                         return be_transform_node(add_immediate_op);
1200                 }
1201
1202                 new_node = create_lea_from_address(dbgi, new_block, &addr);
1203                 SET_IA32_ORIG_NODE(new_node, node);
1204                 return new_node;
1205         }
1206
1207         /* test if we can use source address mode */
1208         match_arguments(&am, block, op1, op2, NULL, match_commutative
1209                         | match_mode_neutral | match_am | match_immediate | match_try_am);
1210
1211         /* construct an Add with source address mode */
1212         if (am.op_type == ia32_AddrModeS) {
1213                 ia32_address_t *am_addr = &am.addr;
1214                 new_node = new_bd_ia32_Add(dbgi, new_block, am_addr->base,
1215                                          am_addr->index, am_addr->mem, am.new_op1,
1216                                          am.new_op2);
1217                 set_am_attributes(new_node, &am);
1218                 SET_IA32_ORIG_NODE(new_node, node);
1219
1220                 new_node = fix_mem_proj(new_node, &am);
1221
1222                 return new_node;
1223         }
1224
1225         /* otherwise construct a lea */
1226         new_node = create_lea_from_address(dbgi, new_block, &addr);
1227         SET_IA32_ORIG_NODE(new_node, node);
1228         return new_node;
1229 }
1230
1231 /**
1232  * Creates an ia32 Mul.
1233  *
1234  * @return the created ia32 Mul node
1235  */
1236 static ir_node *gen_Mul(ir_node *node)
1237 {
1238         ir_node *op1  = get_Mul_left(node);
1239         ir_node *op2  = get_Mul_right(node);
1240         ir_mode *mode = get_irn_mode(node);
1241
1242         if (mode_is_float(mode)) {
1243                 if (ia32_cg_config.use_sse2)
1244                         return gen_binop(node, op1, op2, new_bd_ia32_xMul,
1245                                          match_commutative | match_am);
1246                 else
1247                         return gen_binop_x87_float(node, op1, op2, new_bd_ia32_vfmul);
1248         }
1249         return gen_binop(node, op1, op2, new_bd_ia32_IMul,
1250                          match_commutative | match_am | match_mode_neutral |
1251                          match_immediate | match_am_and_immediates);
1252 }
1253
1254 /**
1255  * Creates an ia32 Mulh.
1256  * Note: Mul produces a 64Bit result and Mulh returns the upper 32 bit of
1257  * this result while Mul returns the lower 32 bit.
1258  *
1259  * @return the created ia32 Mulh node
1260  */
1261 static ir_node *gen_Mulh(ir_node *node)
1262 {
1263         ir_node              *block     = get_nodes_block(node);
1264         ir_node              *new_block = be_transform_node(block);
1265         dbg_info             *dbgi      = get_irn_dbg_info(node);
1266         ir_node              *op1       = get_Mulh_left(node);
1267         ir_node              *op2       = get_Mulh_right(node);
1268         ir_mode              *mode      = get_irn_mode(node);
1269         ir_node              *new_node;
1270         ir_node              *proj_res_high;
1271
1272         if (mode_is_signed(mode)) {
1273                 new_node = gen_binop(node, op1, op2, new_bd_ia32_IMul1OP, match_commutative | match_am);
1274                 proj_res_high = new_rd_Proj(dbgi, current_ir_graph, new_block, new_node,
1275                                     mode_Iu, pn_ia32_IMul1OP_res_high);
1276         } else {
1277                 new_node = gen_binop(node, op1, op2, new_bd_ia32_Mul, match_commutative | match_am);
1278                 proj_res_high = new_rd_Proj(dbgi, current_ir_graph, new_block, new_node,
1279                                     mode_Iu, pn_ia32_Mul_res_high);
1280         }
1281         return proj_res_high;
1282 }
1283
1284 /**
1285  * Creates an ia32 And.
1286  *
1287  * @return The created ia32 And node
1288  */
1289 static ir_node *gen_And(ir_node *node)
1290 {
1291         ir_node *op1 = get_And_left(node);
1292         ir_node *op2 = get_And_right(node);
1293         assert(! mode_is_float(get_irn_mode(node)));
1294
1295         /* is it a zero extension? */
1296         if (is_Const(op2)) {
1297                 tarval   *tv    = get_Const_tarval(op2);
1298                 long      v     = get_tarval_long(tv);
1299
1300                 if (v == 0xFF || v == 0xFFFF) {
1301                         dbg_info *dbgi   = get_irn_dbg_info(node);
1302                         ir_node  *block  = get_nodes_block(node);
1303                         ir_mode  *src_mode;
1304                         ir_node  *res;
1305
1306                         if (v == 0xFF) {
1307                                 src_mode = mode_Bu;
1308                         } else {
1309                                 assert(v == 0xFFFF);
1310                                 src_mode = mode_Hu;
1311                         }
1312                         res = create_I2I_Conv(src_mode, mode_Iu, dbgi, block, op1, node);
1313
1314                         return res;
1315                 }
1316         }
1317         return gen_binop(node, op1, op2, new_bd_ia32_And,
1318                         match_commutative | match_mode_neutral | match_am | match_immediate);
1319 }
1320
1321
1322
1323 /**
1324  * Creates an ia32 Or.
1325  *
1326  * @return The created ia32 Or node
1327  */
1328 static ir_node *gen_Or(ir_node *node)
1329 {
1330         ir_node *op1 = get_Or_left(node);
1331         ir_node *op2 = get_Or_right(node);
1332
1333         assert (! mode_is_float(get_irn_mode(node)));
1334         return gen_binop(node, op1, op2, new_bd_ia32_Or, match_commutative
1335                         | match_mode_neutral | match_am | match_immediate);
1336 }
1337
1338
1339
1340 /**
1341  * Creates an ia32 Eor.
1342  *
1343  * @return The created ia32 Eor node
1344  */
1345 static ir_node *gen_Eor(ir_node *node)
1346 {
1347         ir_node *op1 = get_Eor_left(node);
1348         ir_node *op2 = get_Eor_right(node);
1349
1350         assert(! mode_is_float(get_irn_mode(node)));
1351         return gen_binop(node, op1, op2, new_bd_ia32_Xor, match_commutative
1352                         | match_mode_neutral | match_am | match_immediate);
1353 }
1354
1355
1356 /**
1357  * Creates an ia32 Sub.
1358  *
1359  * @return The created ia32 Sub node
1360  */
1361 static ir_node *gen_Sub(ir_node *node)
1362 {
1363         ir_node  *op1  = get_Sub_left(node);
1364         ir_node  *op2  = get_Sub_right(node);
1365         ir_mode  *mode = get_irn_mode(node);
1366
1367         if (mode_is_float(mode)) {
1368                 if (ia32_cg_config.use_sse2)
1369                         return gen_binop(node, op1, op2, new_bd_ia32_xSub, match_am);
1370                 else
1371                         return gen_binop_x87_float(node, op1, op2, new_bd_ia32_vfsub);
1372         }
1373
1374         if (is_Const(op2)) {
1375                 ir_fprintf(stderr, "Optimisation warning: found sub with const (%+F)\n",
1376                            node);
1377         }
1378
1379         return gen_binop(node, op1, op2, new_bd_ia32_Sub, match_mode_neutral
1380                         | match_am | match_immediate);
1381 }
1382
1383 static ir_node *transform_AM_mem(ir_graph *const irg, ir_node *const block,
1384                                  ir_node  *const src_val,
1385                                  ir_node  *const src_mem,
1386                                  ir_node  *const am_mem)
1387 {
1388         if (is_NoMem(am_mem)) {
1389                 return be_transform_node(src_mem);
1390         } else if (is_Proj(src_val) &&
1391                    is_Proj(src_mem) &&
1392                    get_Proj_pred(src_val) == get_Proj_pred(src_mem)) {
1393                 /* avoid memory loop */
1394                 return am_mem;
1395         } else if (is_Proj(src_val) && is_Sync(src_mem)) {
1396                 ir_node  *const ptr_pred = get_Proj_pred(src_val);
1397                 int       const arity    = get_Sync_n_preds(src_mem);
1398                 int             n        = 0;
1399                 ir_node **      ins;
1400                 int             i;
1401
1402                 NEW_ARR_A(ir_node*, ins, arity + 1);
1403
1404                 /* NOTE: This sometimes produces dead-code because the old sync in
1405                  * src_mem might not be used anymore, we should detect this case
1406                  * and kill the sync... */
1407                 for (i = arity - 1; i >= 0; --i) {
1408                         ir_node *const pred = get_Sync_pred(src_mem, i);
1409
1410                         /* avoid memory loop */
1411                         if (is_Proj(pred) && get_Proj_pred(pred) == ptr_pred)
1412                                 continue;
1413
1414                         ins[n++] = be_transform_node(pred);
1415                 }
1416
1417                 ins[n++] = am_mem;
1418
1419                 return new_r_Sync(irg, block, n, ins);
1420         } else {
1421                 ir_node *ins[2];
1422
1423                 ins[0] = be_transform_node(src_mem);
1424                 ins[1] = am_mem;
1425                 return new_r_Sync(irg, block, 2, ins);
1426         }
1427 }
1428
1429 static ir_node *create_sex_32_64(dbg_info *dbgi, ir_node *block,
1430                                  ir_node *val, const ir_node *orig)
1431 {
1432         ir_node *res;
1433
1434         (void)orig;
1435         if (ia32_cg_config.use_short_sex_eax) {
1436                 ir_node *pval = new_bd_ia32_ProduceVal(dbgi, block);
1437                 be_dep_on_frame(pval);
1438                 res = new_bd_ia32_Cltd(dbgi, block, val, pval);
1439         } else {
1440                 ir_node *imm31 = create_Immediate(NULL, 0, 31);
1441                 res = new_bd_ia32_Sar(dbgi, block, val, imm31);
1442         }
1443         SET_IA32_ORIG_NODE(res, orig);
1444         return res;
1445 }
1446
1447 /**
1448  * Generates an ia32 DivMod with additional infrastructure for the
1449  * register allocator if needed.
1450  */
1451 static ir_node *create_Div(ir_node *node)
1452 {
1453         dbg_info *dbgi      = get_irn_dbg_info(node);
1454         ir_node  *block     = get_nodes_block(node);
1455         ir_node  *new_block = be_transform_node(block);
1456         ir_node  *mem;
1457         ir_node  *new_mem;
1458         ir_node  *op1;
1459         ir_node  *op2;
1460         ir_node  *new_node;
1461         ir_mode  *mode;
1462         ir_node  *sign_extension;
1463         ia32_address_mode_t  am;
1464         ia32_address_t      *addr = &am.addr;
1465
1466         /* the upper bits have random contents for smaller modes */
1467         switch (get_irn_opcode(node)) {
1468         case iro_Div:
1469                 op1     = get_Div_left(node);
1470                 op2     = get_Div_right(node);
1471                 mem     = get_Div_mem(node);
1472                 mode    = get_Div_resmode(node);
1473                 break;
1474         case iro_Mod:
1475                 op1     = get_Mod_left(node);
1476                 op2     = get_Mod_right(node);
1477                 mem     = get_Mod_mem(node);
1478                 mode    = get_Mod_resmode(node);
1479                 break;
1480         case iro_DivMod:
1481                 op1     = get_DivMod_left(node);
1482                 op2     = get_DivMod_right(node);
1483                 mem     = get_DivMod_mem(node);
1484                 mode    = get_DivMod_resmode(node);
1485                 break;
1486         default:
1487                 panic("invalid divmod node %+F", node);
1488         }
1489
1490         match_arguments(&am, block, op1, op2, NULL, match_am);
1491
1492         /* Beware: We don't need a Sync, if the memory predecessor of the Div node
1493            is the memory of the consumed address. We can have only the second op as address
1494            in Div nodes, so check only op2. */
1495         new_mem = transform_AM_mem(current_ir_graph, block, op2, mem, addr->mem);
1496
1497         if (mode_is_signed(mode)) {
1498                 sign_extension = create_sex_32_64(dbgi, new_block, am.new_op1, node);
1499                 new_node       = new_bd_ia32_IDiv(dbgi, new_block, addr->base,
1500                                 addr->index, new_mem, am.new_op2, am.new_op1, sign_extension);
1501         } else {
1502                 sign_extension = new_bd_ia32_Const(dbgi, new_block, NULL, 0, 0);
1503                 be_dep_on_frame(sign_extension);
1504
1505                 new_node = new_bd_ia32_Div(dbgi, new_block, addr->base,
1506                                            addr->index, new_mem, am.new_op2,
1507                                            am.new_op1, sign_extension);
1508         }
1509
1510         set_irn_pinned(new_node, get_irn_pinned(node));
1511
1512         set_am_attributes(new_node, &am);
1513         SET_IA32_ORIG_NODE(new_node, node);
1514
1515         new_node = fix_mem_proj(new_node, &am);
1516
1517         return new_node;
1518 }
1519
1520
1521 static ir_node *gen_Mod(ir_node *node)
1522 {
1523         return create_Div(node);
1524 }
1525
1526 static ir_node *gen_Div(ir_node *node)
1527 {
1528         return create_Div(node);
1529 }
1530
1531 static ir_node *gen_DivMod(ir_node *node)
1532 {
1533         return create_Div(node);
1534 }
1535
1536
1537
1538 /**
1539  * Creates an ia32 floating Div.
1540  *
1541  * @return The created ia32 xDiv node
1542  */
1543 static ir_node *gen_Quot(ir_node *node)
1544 {
1545         ir_node *op1 = get_Quot_left(node);
1546         ir_node *op2 = get_Quot_right(node);
1547
1548         if (ia32_cg_config.use_sse2) {
1549                 return gen_binop(node, op1, op2, new_bd_ia32_xDiv, match_am);
1550         } else {
1551                 return gen_binop_x87_float(node, op1, op2, new_bd_ia32_vfdiv);
1552         }
1553 }
1554
1555
1556 /**
1557  * Creates an ia32 Shl.
1558  *
1559  * @return The created ia32 Shl node
1560  */
1561 static ir_node *gen_Shl(ir_node *node)
1562 {
1563         ir_node *left  = get_Shl_left(node);
1564         ir_node *right = get_Shl_right(node);
1565
1566         return gen_shift_binop(node, left, right, new_bd_ia32_Shl,
1567                                match_mode_neutral | match_immediate);
1568 }
1569
1570 /**
1571  * Creates an ia32 Shr.
1572  *
1573  * @return The created ia32 Shr node
1574  */
1575 static ir_node *gen_Shr(ir_node *node)
1576 {
1577         ir_node *left  = get_Shr_left(node);
1578         ir_node *right = get_Shr_right(node);
1579
1580         return gen_shift_binop(node, left, right, new_bd_ia32_Shr, match_immediate);
1581 }
1582
1583
1584
1585 /**
1586  * Creates an ia32 Sar.
1587  *
1588  * @return The created ia32 Shrs node
1589  */
1590 static ir_node *gen_Shrs(ir_node *node)
1591 {
1592         ir_node *left  = get_Shrs_left(node);
1593         ir_node *right = get_Shrs_right(node);
1594
1595         if (is_Const(right)) {
1596                 tarval *tv = get_Const_tarval(right);
1597                 long val = get_tarval_long(tv);
1598                 if (val == 31) {
1599                         /* this is a sign extension */
1600                         dbg_info *dbgi   = get_irn_dbg_info(node);
1601                         ir_node  *block  = be_transform_node(get_nodes_block(node));
1602                         ir_node  *new_op = be_transform_node(left);
1603
1604                         return create_sex_32_64(dbgi, block, new_op, node);
1605                 }
1606         }
1607
1608         /* 8 or 16 bit sign extension? */
1609         if (is_Const(right) && is_Shl(left)) {
1610                 ir_node *shl_left  = get_Shl_left(left);
1611                 ir_node *shl_right = get_Shl_right(left);
1612                 if (is_Const(shl_right)) {
1613                         tarval *tv1 = get_Const_tarval(right);
1614                         tarval *tv2 = get_Const_tarval(shl_right);
1615                         if (tv1 == tv2 && tarval_is_long(tv1)) {
1616                                 long val = get_tarval_long(tv1);
1617                                 if (val == 16 || val == 24) {
1618                                         dbg_info *dbgi   = get_irn_dbg_info(node);
1619                                         ir_node  *block  = get_nodes_block(node);
1620                                         ir_mode  *src_mode;
1621                                         ir_node  *res;
1622
1623                                         if (val == 24) {
1624                                                 src_mode = mode_Bs;
1625                                         } else {
1626                                                 assert(val == 16);
1627                                                 src_mode = mode_Hs;
1628                                         }
1629                                         res = create_I2I_Conv(src_mode, mode_Is, dbgi, block,
1630                                                               shl_left, node);
1631
1632                                         return res;
1633                                 }
1634                         }
1635                 }
1636         }
1637
1638         return gen_shift_binop(node, left, right, new_bd_ia32_Sar, match_immediate);
1639 }
1640
1641
1642
1643 /**
1644  * Creates an ia32 Rol.
1645  *
1646  * @param op1   The first operator
1647  * @param op2   The second operator
1648  * @return The created ia32 RotL node
1649  */
1650 static ir_node *gen_Rol(ir_node *node, ir_node *op1, ir_node *op2)
1651 {
1652         return gen_shift_binop(node, op1, op2, new_bd_ia32_Rol, match_immediate);
1653 }
1654
1655
1656
1657 /**
1658  * Creates an ia32 Ror.
1659  * NOTE: There is no RotR with immediate because this would always be a RotL
1660  *       "imm-mode_size_bits" which can be pre-calculated.
1661  *
1662  * @param op1   The first operator
1663  * @param op2   The second operator
1664  * @return The created ia32 RotR node
1665  */
1666 static ir_node *gen_Ror(ir_node *node, ir_node *op1, ir_node *op2)
1667 {
1668         return gen_shift_binop(node, op1, op2, new_bd_ia32_Ror, match_immediate);
1669 }
1670
1671
1672
1673 /**
1674  * Creates an ia32 RotR or RotL (depending on the found pattern).
1675  *
1676  * @return The created ia32 RotL or RotR node
1677  */
1678 static ir_node *gen_Rotl(ir_node *node)
1679 {
1680         ir_node *rotate = NULL;
1681         ir_node *op1    = get_Rotl_left(node);
1682         ir_node *op2    = get_Rotl_right(node);
1683
1684         /* Firm has only RotL, so we are looking for a right (op2)
1685                  operand "-e+mode_size_bits" (it's an already modified "mode_size_bits-e",
1686                  that means we can create a RotR instead of an Add and a RotL */
1687
1688         if (is_Add(op2)) {
1689                 ir_node *add = op2;
1690                 ir_node *left = get_Add_left(add);
1691                 ir_node *right = get_Add_right(add);
1692                 if (is_Const(right)) {
1693                         tarval  *tv   = get_Const_tarval(right);
1694                         ir_mode *mode = get_irn_mode(node);
1695                         long     bits = get_mode_size_bits(mode);
1696
1697                         if (is_Minus(left) &&
1698                             tarval_is_long(tv)       &&
1699                             get_tarval_long(tv) == bits &&
1700                             bits                == 32)
1701                         {
1702                                 DB((dbg, LEVEL_1, "RotL into RotR ... "));
1703                                 rotate = gen_Ror(node, op1, get_Minus_op(left));
1704                         }
1705                 }
1706         }
1707
1708         if (rotate == NULL) {
1709                 rotate = gen_Rol(node, op1, op2);
1710         }
1711
1712         return rotate;
1713 }
1714
1715
1716
1717 /**
1718  * Transforms a Minus node.
1719  *
1720  * @return The created ia32 Minus node
1721  */
1722 static ir_node *gen_Minus(ir_node *node)
1723 {
1724         ir_node   *op    = get_Minus_op(node);
1725         ir_node   *block = be_transform_node(get_nodes_block(node));
1726         dbg_info  *dbgi  = get_irn_dbg_info(node);
1727         ir_mode   *mode  = get_irn_mode(node);
1728         ir_entity *ent;
1729         ir_node   *new_node;
1730         int        size;
1731
1732         if (mode_is_float(mode)) {
1733                 ir_node *new_op = be_transform_node(op);
1734                 if (ia32_cg_config.use_sse2) {
1735                         /* TODO: non-optimal... if we have many xXors, then we should
1736                          * rather create a load for the const and use that instead of
1737                          * several AM nodes... */
1738                         ir_node *noreg_gp  = ia32_new_NoReg_gp(env_cg);
1739                         ir_node *noreg_xmm = ia32_new_NoReg_xmm(env_cg);
1740                         ir_node *nomem     = new_NoMem();
1741
1742                         new_node = new_bd_ia32_xXor(dbgi, block, noreg_gp, noreg_gp,
1743                                                     nomem, new_op, noreg_xmm);
1744
1745                         size = get_mode_size_bits(mode);
1746                         ent  = ia32_gen_fp_known_const(size == 32 ? ia32_SSIGN : ia32_DSIGN);
1747
1748                         set_ia32_am_sc(new_node, ent);
1749                         set_ia32_op_type(new_node, ia32_AddrModeS);
1750                         set_ia32_ls_mode(new_node, mode);
1751                 } else {
1752                         new_node = new_bd_ia32_vfchs(dbgi, block, new_op);
1753                 }
1754         } else {
1755                 new_node = gen_unop(node, op, new_bd_ia32_Neg, match_mode_neutral);
1756         }
1757
1758         SET_IA32_ORIG_NODE(new_node, node);
1759
1760         return new_node;
1761 }
1762
1763 /**
1764  * Transforms a Not node.
1765  *
1766  * @return The created ia32 Not node
1767  */
1768 static ir_node *gen_Not(ir_node *node)
1769 {
1770         ir_node *op   = get_Not_op(node);
1771
1772         assert(get_irn_mode(node) != mode_b); /* should be lowered already */
1773         assert (! mode_is_float(get_irn_mode(node)));
1774
1775         return gen_unop(node, op, new_bd_ia32_Not, match_mode_neutral);
1776 }
1777
1778
1779
1780 /**
1781  * Transforms an Abs node.
1782  *
1783  * @return The created ia32 Abs node
1784  */
1785 static ir_node *gen_Abs(ir_node *node)
1786 {
1787         ir_node   *block     = get_nodes_block(node);
1788         ir_node   *new_block = be_transform_node(block);
1789         ir_node   *op        = get_Abs_op(node);
1790         dbg_info  *dbgi      = get_irn_dbg_info(node);
1791         ir_mode   *mode      = get_irn_mode(node);
1792         ir_node   *noreg_gp  = ia32_new_NoReg_gp(env_cg);
1793         ir_node   *nomem     = new_NoMem();
1794         ir_node   *new_op;
1795         ir_node   *new_node;
1796         int        size;
1797         ir_entity *ent;
1798
1799         if (mode_is_float(mode)) {
1800                 new_op = be_transform_node(op);
1801
1802                 if (ia32_cg_config.use_sse2) {
1803                         ir_node *noreg_fp = ia32_new_NoReg_xmm(env_cg);
1804                         new_node = new_bd_ia32_xAnd(dbgi, new_block, noreg_gp, noreg_gp,
1805                                                     nomem, new_op, noreg_fp);
1806
1807                         size = get_mode_size_bits(mode);
1808                         ent  = ia32_gen_fp_known_const(size == 32 ? ia32_SABS : ia32_DABS);
1809
1810                         set_ia32_am_sc(new_node, ent);
1811
1812                         SET_IA32_ORIG_NODE(new_node, node);
1813
1814                         set_ia32_op_type(new_node, ia32_AddrModeS);
1815                         set_ia32_ls_mode(new_node, mode);
1816                 } else {
1817                         new_node = new_bd_ia32_vfabs(dbgi, new_block, new_op);
1818                         SET_IA32_ORIG_NODE(new_node, node);
1819                 }
1820         } else {
1821                 ir_node *xor, *sign_extension;
1822
1823                 if (get_mode_size_bits(mode) == 32) {
1824                         new_op = be_transform_node(op);
1825                 } else {
1826                         new_op = create_I2I_Conv(mode, mode_Is, dbgi, block, op, node);
1827                 }
1828
1829                 sign_extension = create_sex_32_64(dbgi, new_block, new_op, node);
1830
1831                 xor = new_bd_ia32_Xor(dbgi, new_block, noreg_gp, noreg_gp,
1832                                       nomem, new_op, sign_extension);
1833                 SET_IA32_ORIG_NODE(xor, node);
1834
1835                 new_node = new_bd_ia32_Sub(dbgi, new_block, noreg_gp, noreg_gp,
1836                                            nomem, xor, sign_extension);
1837                 SET_IA32_ORIG_NODE(new_node, node);
1838         }
1839
1840         return new_node;
1841 }
1842
1843 /**
1844  * Create a bt instruction for x & (1 << n) and place it into the block of cmp.
1845  */
1846 static ir_node *gen_bt(ir_node *cmp, ir_node *x, ir_node *n)
1847 {
1848         dbg_info *dbgi      = get_irn_dbg_info(cmp);
1849         ir_node  *block     = get_nodes_block(cmp);
1850         ir_node  *new_block = be_transform_node(block);
1851         ir_node  *op1       = be_transform_node(x);
1852         ir_node  *op2       = be_transform_node(n);
1853
1854         return new_bd_ia32_Bt(dbgi, new_block, op1, op2);
1855 }
1856
1857 /**
1858  * Transform a node returning a "flag" result.
1859  *
1860  * @param node     the node to transform
1861  * @param pnc_out  the compare mode to use
1862  */
1863 static ir_node *get_flags_node(ir_node *node, pn_Cmp *pnc_out)
1864 {
1865         ir_node  *flags;
1866         ir_node  *new_op;
1867         ir_node  *noreg;
1868         ir_node  *nomem;
1869         ir_node  *new_block;
1870         dbg_info *dbgi;
1871
1872         /* we have a Cmp as input */
1873         if (is_Proj(node)) {
1874                 ir_node *pred = get_Proj_pred(node);
1875                 if (is_Cmp(pred)) {
1876                         pn_Cmp pnc = get_Proj_proj(node);
1877                         if (ia32_cg_config.use_bt && (pnc == pn_Cmp_Lg || pnc == pn_Cmp_Eq)) {
1878                                 ir_node *l = get_Cmp_left(pred);
1879                                 ir_node *r = get_Cmp_right(pred);
1880                                 if (is_And(l)) {
1881                                         ir_node *la = get_And_left(l);
1882                                         ir_node *ra = get_And_right(l);
1883                                         if (is_Shl(la)) {
1884                                                 ir_node *c = get_Shl_left(la);
1885                                                 if (is_Const_1(c) && (is_Const_0(r) || r == la)) {
1886                                                         /* (1 << n) & ra) */
1887                                                         ir_node *n = get_Shl_right(la);
1888                                                         flags    = gen_bt(pred, ra, n);
1889                                                         /* we must generate a Jc/Jnc jump */
1890                                                         pnc = pnc == pn_Cmp_Lg ? pn_Cmp_Lt : pn_Cmp_Ge;
1891                                                         if (r == la)
1892                                                                 pnc ^= pn_Cmp_Leg;
1893                                                         *pnc_out = ia32_pn_Cmp_unsigned | pnc;
1894                                                         return flags;
1895                                                 }
1896                                         }
1897                                         if (is_Shl(ra)) {
1898                                                 ir_node *c = get_Shl_left(ra);
1899                                                 if (is_Const_1(c) && (is_Const_0(r) || r == ra)) {
1900                                                         /* la & (1 << n)) */
1901                                                         ir_node *n = get_Shl_right(ra);
1902                                                         flags    = gen_bt(pred, la, n);
1903                                                         /* we must generate a Jc/Jnc jump */
1904                                                         pnc = pnc == pn_Cmp_Lg ? pn_Cmp_Lt : pn_Cmp_Ge;
1905                                                         if (r == ra)
1906                                                                 pnc ^= pn_Cmp_Leg;
1907                                                         *pnc_out = ia32_pn_Cmp_unsigned | pnc;
1908                                                         return flags;
1909                                                 }
1910                                         }
1911                                 }
1912                         }
1913                         flags    = be_transform_node(pred);
1914                         *pnc_out = pnc;
1915                         return flags;
1916                 }
1917         }
1918
1919         /* a mode_b value, we have to compare it against 0 */
1920         dbgi      = get_irn_dbg_info(node);
1921         new_block = be_transform_node(get_nodes_block(node));
1922         new_op    = be_transform_node(node);
1923         noreg     = ia32_new_NoReg_gp(env_cg);
1924         nomem     = new_NoMem();
1925         flags     = new_bd_ia32_Test(dbgi, new_block, noreg, noreg, nomem, new_op,
1926                         new_op, /*is_permuted=*/0, /*cmp_unsigned=*/0);
1927         *pnc_out  = pn_Cmp_Lg;
1928         return flags;
1929 }
1930
1931 /**
1932  * Transforms a Load.
1933  *
1934  * @return the created ia32 Load node
1935  */
1936 static ir_node *gen_Load(ir_node *node)
1937 {
1938         ir_node  *old_block = get_nodes_block(node);
1939         ir_node  *block   = be_transform_node(old_block);
1940         ir_node  *ptr     = get_Load_ptr(node);
1941         ir_node  *mem     = get_Load_mem(node);
1942         ir_node  *new_mem = be_transform_node(mem);
1943         ir_node  *base;
1944         ir_node  *index;
1945         dbg_info *dbgi    = get_irn_dbg_info(node);
1946         ir_node  *noreg   = ia32_new_NoReg_gp(env_cg);
1947         ir_mode  *mode    = get_Load_mode(node);
1948         ir_mode  *res_mode;
1949         ir_node  *new_node;
1950         ia32_address_t addr;
1951
1952         /* construct load address */
1953         memset(&addr, 0, sizeof(addr));
1954         ia32_create_address_mode(&addr, ptr, 0);
1955         base  = addr.base;
1956         index = addr.index;
1957
1958         if (base == NULL) {
1959                 base = noreg;
1960         } else {
1961                 base = be_transform_node(base);
1962         }
1963
1964         if (index == NULL) {
1965                 index = noreg;
1966         } else {
1967                 index = be_transform_node(index);
1968         }
1969
1970         if (mode_is_float(mode)) {
1971                 if (ia32_cg_config.use_sse2) {
1972                         new_node = new_bd_ia32_xLoad(dbgi, block, base, index, new_mem,
1973                                                      mode);
1974                         res_mode = mode_xmm;
1975                 } else {
1976                         new_node = new_bd_ia32_vfld(dbgi, block, base, index, new_mem,
1977                                                     mode);
1978                         res_mode = mode_vfp;
1979                 }
1980         } else {
1981                 assert(mode != mode_b);
1982
1983                 /* create a conv node with address mode for smaller modes */
1984                 if (get_mode_size_bits(mode) < 32) {
1985                         new_node = new_bd_ia32_Conv_I2I(dbgi, block, base, index,
1986                                                         new_mem, noreg, mode);
1987                 } else {
1988                         new_node = new_bd_ia32_Load(dbgi, block, base, index, new_mem);
1989                 }
1990                 res_mode = mode_Iu;
1991         }
1992
1993         set_irn_pinned(new_node, get_irn_pinned(node));
1994         set_ia32_op_type(new_node, ia32_AddrModeS);
1995         set_ia32_ls_mode(new_node, mode);
1996         set_address(new_node, &addr);
1997
1998         if (get_irn_pinned(node) == op_pin_state_floats) {
1999                 assert(pn_ia32_xLoad_res == pn_ia32_vfld_res
2000                                 && pn_ia32_vfld_res == pn_ia32_Load_res
2001                                 && pn_ia32_Load_res == pn_ia32_res);
2002                 arch_irn_add_flags(new_node, arch_irn_flags_rematerializable);
2003         }
2004
2005         SET_IA32_ORIG_NODE(new_node, node);
2006
2007         be_dep_on_frame(new_node);
2008         return new_node;
2009 }
2010
2011 static int use_dest_am(ir_node *block, ir_node *node, ir_node *mem,
2012                        ir_node *ptr, ir_node *other)
2013 {
2014         ir_node *load;
2015
2016         if (!is_Proj(node))
2017                 return 0;
2018
2019         /* we only use address mode if we're the only user of the load */
2020         if (get_irn_n_edges(node) > 1)
2021                 return 0;
2022
2023         load = get_Proj_pred(node);
2024         if (!is_Load(load))
2025                 return 0;
2026         if (get_nodes_block(load) != block)
2027                 return 0;
2028
2029         /* store should have the same pointer as the load */
2030         if (get_Load_ptr(load) != ptr)
2031                 return 0;
2032
2033         /* don't do AM if other node inputs depend on the load (via mem-proj) */
2034         if (other != NULL                   &&
2035             get_nodes_block(other) == block &&
2036             heights_reachable_in_block(heights, other, load)) {
2037                 return 0;
2038         }
2039
2040         if (prevents_AM(block, load, mem))
2041                 return 0;
2042         /* Store should be attached to the load via mem */
2043         assert(heights_reachable_in_block(heights, mem, load));
2044
2045         return 1;
2046 }
2047
2048 static ir_node *dest_am_binop(ir_node *node, ir_node *op1, ir_node *op2,
2049                               ir_node *mem, ir_node *ptr, ir_mode *mode,
2050                               construct_binop_dest_func *func,
2051                               construct_binop_dest_func *func8bit,
2052                                                           match_flags_t flags)
2053 {
2054         ir_node  *src_block = get_nodes_block(node);
2055         ir_node  *block;
2056         ir_node  *noreg_gp  = ia32_new_NoReg_gp(env_cg);
2057         dbg_info *dbgi;
2058         ir_node  *new_mem;
2059         ir_node  *new_node;
2060         ir_node  *new_op;
2061         ir_node  *mem_proj;
2062         int       commutative;
2063         ia32_address_mode_t  am;
2064         ia32_address_t      *addr = &am.addr;
2065         memset(&am, 0, sizeof(am));
2066
2067         assert(flags & match_immediate); /* there is no destam node without... */
2068         commutative = (flags & match_commutative) != 0;
2069
2070         if (use_dest_am(src_block, op1, mem, ptr, op2)) {
2071                 build_address(&am, op1, ia32_create_am_double_use);
2072                 new_op = create_immediate_or_transform(op2, 0);
2073         } else if (commutative && use_dest_am(src_block, op2, mem, ptr, op1)) {
2074                 build_address(&am, op2, ia32_create_am_double_use);
2075                 new_op = create_immediate_or_transform(op1, 0);
2076         } else {
2077                 return NULL;
2078         }
2079
2080         if (addr->base == NULL)
2081                 addr->base = noreg_gp;
2082         if (addr->index == NULL)
2083                 addr->index = noreg_gp;
2084         if (addr->mem == NULL)
2085                 addr->mem = new_NoMem();
2086
2087         dbgi    = get_irn_dbg_info(node);
2088         block   = be_transform_node(src_block);
2089         new_mem = transform_AM_mem(current_ir_graph, block, am.am_node, mem, addr->mem);
2090
2091         if (get_mode_size_bits(mode) == 8) {
2092                 new_node = func8bit(dbgi, block, addr->base, addr->index, new_mem, new_op);
2093         } else {
2094                 new_node = func(dbgi, block, addr->base, addr->index, new_mem, new_op);
2095         }
2096         set_address(new_node, addr);
2097         set_ia32_op_type(new_node, ia32_AddrModeD);
2098         set_ia32_ls_mode(new_node, mode);
2099         SET_IA32_ORIG_NODE(new_node, node);
2100
2101         be_set_transformed_node(get_Proj_pred(am.mem_proj), new_node);
2102         mem_proj = be_transform_node(am.mem_proj);
2103         be_set_transformed_node(mem_proj ? mem_proj : am.mem_proj, new_node);
2104
2105         return new_node;
2106 }
2107
2108 static ir_node *dest_am_unop(ir_node *node, ir_node *op, ir_node *mem,
2109                              ir_node *ptr, ir_mode *mode,
2110                              construct_unop_dest_func *func)
2111 {
2112         ir_node  *src_block = get_nodes_block(node);
2113         ir_node  *block;
2114         dbg_info *dbgi;
2115         ir_node  *new_mem;
2116         ir_node  *new_node;
2117         ir_node  *mem_proj;
2118         ia32_address_mode_t  am;
2119         ia32_address_t *addr = &am.addr;
2120
2121         if (!use_dest_am(src_block, op, mem, ptr, NULL))
2122                 return NULL;
2123
2124         memset(&am, 0, sizeof(am));
2125         build_address(&am, op, ia32_create_am_double_use);
2126
2127         dbgi     = get_irn_dbg_info(node);
2128         block    = be_transform_node(src_block);
2129         new_mem  = transform_AM_mem(current_ir_graph, block, am.am_node, mem, addr->mem);
2130         new_node = func(dbgi, block, addr->base, addr->index, new_mem);
2131         set_address(new_node, addr);
2132         set_ia32_op_type(new_node, ia32_AddrModeD);
2133         set_ia32_ls_mode(new_node, mode);
2134         SET_IA32_ORIG_NODE(new_node, node);
2135
2136         be_set_transformed_node(get_Proj_pred(am.mem_proj), new_node);
2137         mem_proj = be_transform_node(am.mem_proj);
2138         be_set_transformed_node(mem_proj ? mem_proj : am.mem_proj, new_node);
2139
2140         return new_node;
2141 }
2142
2143 static ir_node *try_create_SetMem(ir_node *node, ir_node *ptr, ir_node *mem)
2144 {
2145         ir_mode  *mode        = get_irn_mode(node);
2146         ir_node  *mux_true    = get_Mux_true(node);
2147         ir_node  *mux_false   = get_Mux_false(node);
2148         ir_node  *cond;
2149         ir_node  *new_mem;
2150         dbg_info *dbgi;
2151         ir_node  *block;
2152         ir_node  *new_block;
2153         ir_node  *flags;
2154         ir_node  *new_node;
2155         int       negated;
2156         pn_Cmp    pnc;
2157         ia32_address_t addr;
2158
2159         if (get_mode_size_bits(mode) != 8)
2160                 return NULL;
2161
2162         if (is_Const_1(mux_true) && is_Const_0(mux_false)) {
2163                 negated = 0;
2164         } else if (is_Const_0(mux_true) && is_Const_1(mux_false)) {
2165                 negated = 1;
2166         } else {
2167                 return NULL;
2168         }
2169
2170         build_address_ptr(&addr, ptr, mem);
2171
2172         dbgi      = get_irn_dbg_info(node);
2173         block     = get_nodes_block(node);
2174         new_block = be_transform_node(block);
2175         cond      = get_Mux_sel(node);
2176         flags     = get_flags_node(cond, &pnc);
2177         new_mem   = be_transform_node(mem);
2178         new_node  = new_bd_ia32_SetMem(dbgi, new_block, addr.base,
2179                                        addr.index, addr.mem, flags, pnc, negated);
2180         set_address(new_node, &addr);
2181         set_ia32_op_type(new_node, ia32_AddrModeD);
2182         set_ia32_ls_mode(new_node, mode);
2183         SET_IA32_ORIG_NODE(new_node, node);
2184
2185         return new_node;
2186 }
2187
2188 static ir_node *try_create_dest_am(ir_node *node)
2189 {
2190         ir_node  *val  = get_Store_value(node);
2191         ir_node  *mem  = get_Store_mem(node);
2192         ir_node  *ptr  = get_Store_ptr(node);
2193         ir_mode  *mode = get_irn_mode(val);
2194         unsigned  bits = get_mode_size_bits(mode);
2195         ir_node  *op1;
2196         ir_node  *op2;
2197         ir_node  *new_node;
2198
2199         /* handle only GP modes for now... */
2200         if (!ia32_mode_needs_gp_reg(mode))
2201                 return NULL;
2202
2203         for (;;) {
2204                 /* store must be the only user of the val node */
2205                 if (get_irn_n_edges(val) > 1)
2206                         return NULL;
2207                 /* skip pointless convs */
2208                 if (is_Conv(val)) {
2209                         ir_node *conv_op   = get_Conv_op(val);
2210                         ir_mode *pred_mode = get_irn_mode(conv_op);
2211                         if (!ia32_mode_needs_gp_reg(pred_mode))
2212                                 break;
2213                         if (pred_mode == mode_b || bits <= get_mode_size_bits(pred_mode)) {
2214                                 val = conv_op;
2215                                 continue;
2216                         }
2217                 }
2218                 break;
2219         }
2220
2221         /* value must be in the same block */
2222         if (get_nodes_block(node) != get_nodes_block(val))
2223                 return NULL;
2224
2225         switch (get_irn_opcode(val)) {
2226         case iro_Add:
2227                 op1      = get_Add_left(val);
2228                 op2      = get_Add_right(val);
2229                 if (ia32_cg_config.use_incdec) {
2230                         if (is_Const_1(op2)) {
2231                                 new_node = dest_am_unop(val, op1, mem, ptr, mode, new_bd_ia32_IncMem);
2232                                 break;
2233                         } else if (is_Const_Minus_1(op2)) {
2234                                 new_node = dest_am_unop(val, op1, mem, ptr, mode, new_bd_ia32_DecMem);
2235                                 break;
2236                         }
2237                 }
2238                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2239                                          new_bd_ia32_AddMem, new_bd_ia32_AddMem8Bit,
2240                                          match_commutative | match_immediate);
2241                 break;
2242         case iro_Sub:
2243                 op1      = get_Sub_left(val);
2244                 op2      = get_Sub_right(val);
2245                 if (is_Const(op2)) {
2246                         ir_fprintf(stderr, "Optimisation warning: not-normalized sub ,C found\n");
2247                 }
2248                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2249                                          new_bd_ia32_SubMem, new_bd_ia32_SubMem8Bit,
2250                                          match_immediate);
2251                 break;
2252         case iro_And:
2253                 op1      = get_And_left(val);
2254                 op2      = get_And_right(val);
2255                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2256                                          new_bd_ia32_AndMem, new_bd_ia32_AndMem8Bit,
2257                                          match_commutative | match_immediate);
2258                 break;
2259         case iro_Or:
2260                 op1      = get_Or_left(val);
2261                 op2      = get_Or_right(val);
2262                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2263                                          new_bd_ia32_OrMem, new_bd_ia32_OrMem8Bit,
2264                                          match_commutative | match_immediate);
2265                 break;
2266         case iro_Eor:
2267                 op1      = get_Eor_left(val);
2268                 op2      = get_Eor_right(val);
2269                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2270                                          new_bd_ia32_XorMem, new_bd_ia32_XorMem8Bit,
2271                                          match_commutative | match_immediate);
2272                 break;
2273         case iro_Shl:
2274                 op1      = get_Shl_left(val);
2275                 op2      = get_Shl_right(val);
2276                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2277                                          new_bd_ia32_ShlMem, new_bd_ia32_ShlMem,
2278                                          match_immediate);
2279                 break;
2280         case iro_Shr:
2281                 op1      = get_Shr_left(val);
2282                 op2      = get_Shr_right(val);
2283                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2284                                          new_bd_ia32_ShrMem, new_bd_ia32_ShrMem,
2285                                          match_immediate);
2286                 break;
2287         case iro_Shrs:
2288                 op1      = get_Shrs_left(val);
2289                 op2      = get_Shrs_right(val);
2290                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2291                                          new_bd_ia32_SarMem, new_bd_ia32_SarMem,
2292                                          match_immediate);
2293                 break;
2294         case iro_Rotl:
2295                 op1      = get_Rotl_left(val);
2296                 op2      = get_Rotl_right(val);
2297                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2298                                          new_bd_ia32_RolMem, new_bd_ia32_RolMem,
2299                                          match_immediate);
2300                 break;
2301         /* TODO: match ROR patterns... */
2302         case iro_Mux:
2303                 new_node = try_create_SetMem(val, ptr, mem);
2304                 break;
2305         case iro_Minus:
2306                 op1      = get_Minus_op(val);
2307                 new_node = dest_am_unop(val, op1, mem, ptr, mode, new_bd_ia32_NegMem);
2308                 break;
2309         case iro_Not:
2310                 /* should be lowered already */
2311                 assert(mode != mode_b);
2312                 op1      = get_Not_op(val);
2313                 new_node = dest_am_unop(val, op1, mem, ptr, mode, new_bd_ia32_NotMem);
2314                 break;
2315         default:
2316                 return NULL;
2317         }
2318
2319         if (new_node != NULL) {
2320                 if (get_irn_pinned(new_node) != op_pin_state_pinned &&
2321                                 get_irn_pinned(node) == op_pin_state_pinned) {
2322                         set_irn_pinned(new_node, op_pin_state_pinned);
2323                 }
2324         }
2325
2326         return new_node;
2327 }
2328
2329 static bool possible_int_mode_for_fp(ir_mode *mode)
2330 {
2331         unsigned size;
2332
2333         if (!mode_is_signed(mode))
2334                 return false;
2335         size = get_mode_size_bits(mode);
2336         if (size != 16 && size != 32)
2337                 return false;
2338         return true;
2339 }
2340
2341 static int is_float_to_int_conv(const ir_node *node)
2342 {
2343         ir_mode  *mode = get_irn_mode(node);
2344         ir_node  *conv_op;
2345         ir_mode  *conv_mode;
2346
2347         if (!possible_int_mode_for_fp(mode))
2348                 return 0;
2349
2350         if (!is_Conv(node))
2351                 return 0;
2352         conv_op   = get_Conv_op(node);
2353         conv_mode = get_irn_mode(conv_op);
2354
2355         if (!mode_is_float(conv_mode))
2356                 return 0;
2357
2358         return 1;
2359 }
2360
2361 /**
2362  * Transform a Store(floatConst) into a sequence of
2363  * integer stores.
2364  *
2365  * @return the created ia32 Store node
2366  */
2367 static ir_node *gen_float_const_Store(ir_node *node, ir_node *cns)
2368 {
2369         ir_mode        *mode      = get_irn_mode(cns);
2370         unsigned        size      = get_mode_size_bytes(mode);
2371         tarval         *tv        = get_Const_tarval(cns);
2372         ir_node        *block     = get_nodes_block(node);
2373         ir_node        *new_block = be_transform_node(block);
2374         ir_node        *ptr       = get_Store_ptr(node);
2375         ir_node        *mem       = get_Store_mem(node);
2376         dbg_info       *dbgi      = get_irn_dbg_info(node);
2377         int             ofs       = 0;
2378         size_t          i         = 0;
2379         ir_node        *ins[4];
2380         ia32_address_t  addr;
2381
2382         assert(size % 4 ==  0);
2383         assert(size     <= 16);
2384
2385         build_address_ptr(&addr, ptr, mem);
2386
2387         do {
2388                 unsigned val =
2389                          get_tarval_sub_bits(tv, ofs)            |
2390                         (get_tarval_sub_bits(tv, ofs + 1) <<  8) |
2391                         (get_tarval_sub_bits(tv, ofs + 2) << 16) |
2392                         (get_tarval_sub_bits(tv, ofs + 3) << 24);
2393                 ir_node *imm = create_Immediate(NULL, 0, val);
2394
2395                 ir_node *new_node = new_bd_ia32_Store(dbgi, new_block, addr.base,
2396                         addr.index, addr.mem, imm);
2397
2398                 set_irn_pinned(new_node, get_irn_pinned(node));
2399                 set_ia32_op_type(new_node, ia32_AddrModeD);
2400                 set_ia32_ls_mode(new_node, mode_Iu);
2401                 set_address(new_node, &addr);
2402                 SET_IA32_ORIG_NODE(new_node, node);
2403
2404                 assert(i < 4);
2405                 ins[i++] = new_node;
2406
2407                 size        -= 4;
2408                 ofs         += 4;
2409                 addr.offset += 4;
2410         } while (size != 0);
2411
2412         if (i > 1) {
2413                 return new_rd_Sync(dbgi, current_ir_graph, new_block, i, ins);
2414         } else {
2415                 return ins[0];
2416         }
2417 }
2418
2419 /**
2420  * Generate a vfist or vfisttp instruction.
2421  */
2422 static ir_node *gen_vfist(dbg_info *dbgi, ir_graph *irg, ir_node *block, ir_node *base, ir_node *index,
2423                           ir_node *mem,  ir_node *val, ir_node **fist)
2424 {
2425         ir_node *new_node;
2426
2427         if (ia32_cg_config.use_fisttp) {
2428                 /* Note: fisttp ALWAYS pop the tos. We have to ensure here that the value is copied
2429                 if other users exists */
2430                 const arch_register_class_t *reg_class = &ia32_reg_classes[CLASS_ia32_vfp];
2431                 ir_node *vfisttp = new_bd_ia32_vfisttp(dbgi, block, base, index, mem, val);
2432                 ir_node *value   = new_r_Proj(irg, block, vfisttp, mode_E, pn_ia32_vfisttp_res);
2433                 be_new_Keep(reg_class, irg, block, 1, &value);
2434
2435                 new_node = new_r_Proj(irg, block, vfisttp, mode_M, pn_ia32_vfisttp_M);
2436                 *fist    = vfisttp;
2437         } else {
2438                 ir_node *trunc_mode = ia32_new_Fpu_truncate(env_cg);
2439
2440                 /* do a fist */
2441                 new_node = new_bd_ia32_vfist(dbgi, block, base, index, mem, val, trunc_mode);
2442                 *fist    = new_node;
2443         }
2444         return new_node;
2445 }
2446 /**
2447  * Transforms a general (no special case) Store.
2448  *
2449  * @return the created ia32 Store node
2450  */
2451 static ir_node *gen_general_Store(ir_node *node)
2452 {
2453         ir_node  *val       = get_Store_value(node);
2454         ir_mode  *mode      = get_irn_mode(val);
2455         ir_node  *block     = get_nodes_block(node);
2456         ir_node  *new_block = be_transform_node(block);
2457         ir_node  *ptr       = get_Store_ptr(node);
2458         ir_node  *mem       = get_Store_mem(node);
2459         dbg_info *dbgi      = get_irn_dbg_info(node);
2460         ir_node  *noreg     = ia32_new_NoReg_gp(env_cg);
2461         ir_node  *new_val, *new_node, *store;
2462         ia32_address_t addr;
2463
2464         /* check for destination address mode */
2465         new_node = try_create_dest_am(node);
2466         if (new_node != NULL)
2467                 return new_node;
2468
2469         /* construct store address */
2470         memset(&addr, 0, sizeof(addr));
2471         ia32_create_address_mode(&addr, ptr, 0);
2472
2473         if (addr.base == NULL) {
2474                 addr.base = noreg;
2475         } else {
2476                 addr.base = be_transform_node(addr.base);
2477         }
2478
2479         if (addr.index == NULL) {
2480                 addr.index = noreg;
2481         } else {
2482                 addr.index = be_transform_node(addr.index);
2483         }
2484         addr.mem = be_transform_node(mem);
2485
2486         if (mode_is_float(mode)) {
2487                 /* Convs (and strict-Convs) before stores are unnecessary if the mode
2488                    is the same. */
2489                 while (is_Conv(val) && mode == get_irn_mode(val)) {
2490                         ir_node *op = get_Conv_op(val);
2491                         if (!mode_is_float(get_irn_mode(op)))
2492                                 break;
2493                         val = op;
2494                 }
2495                 new_val = be_transform_node(val);
2496                 if (ia32_cg_config.use_sse2) {
2497                         new_node = new_bd_ia32_xStore(dbgi, new_block, addr.base,
2498                                                       addr.index, addr.mem, new_val);
2499                 } else {
2500                         new_node = new_bd_ia32_vfst(dbgi, new_block, addr.base,
2501                                                     addr.index, addr.mem, new_val, mode);
2502                 }
2503                 store = new_node;
2504         } else if (!ia32_cg_config.use_sse2 && is_float_to_int_conv(val)) {
2505                 val = get_Conv_op(val);
2506
2507                 /* TODO: is this optimisation still necessary at all (middleend)? */
2508                 /* We can skip ALL float->float up-Convs (and strict-up-Convs) before stores. */
2509                 while (is_Conv(val)) {
2510                         ir_node *op = get_Conv_op(val);
2511                         if (!mode_is_float(get_irn_mode(op)))
2512                                 break;
2513                         if (get_mode_size_bits(get_irn_mode(op)) > get_mode_size_bits(get_irn_mode(val)))
2514                                 break;
2515                         val = op;
2516                 }
2517                 new_val  = be_transform_node(val);
2518                 new_node = gen_vfist(dbgi, current_ir_graph, new_block, addr.base, addr.index, addr.mem, new_val, &store);
2519         } else {
2520                 new_val = create_immediate_or_transform(val, 0);
2521                 assert(mode != mode_b);
2522
2523                 if (get_mode_size_bits(mode) == 8) {
2524                         new_node = new_bd_ia32_Store8Bit(dbgi, new_block, addr.base,
2525                                                          addr.index, addr.mem, new_val);
2526                 } else {
2527                         new_node = new_bd_ia32_Store(dbgi, new_block, addr.base,
2528                                                      addr.index, addr.mem, new_val);
2529                 }
2530                 store = new_node;
2531         }
2532
2533         set_irn_pinned(store, get_irn_pinned(node));
2534         set_ia32_op_type(store, ia32_AddrModeD);
2535         set_ia32_ls_mode(store, mode);
2536
2537         set_address(store, &addr);
2538         SET_IA32_ORIG_NODE(store, node);
2539
2540         return new_node;
2541 }
2542
2543 /**
2544  * Transforms a Store.
2545  *
2546  * @return the created ia32 Store node
2547  */
2548 static ir_node *gen_Store(ir_node *node)
2549 {
2550         ir_node  *val  = get_Store_value(node);
2551         ir_mode  *mode = get_irn_mode(val);
2552
2553         if (mode_is_float(mode) && is_Const(val)) {
2554                 /* We can transform every floating const store
2555                    into a sequence of integer stores.
2556                    If the constant is already in a register,
2557                    it would be better to use it, but we don't
2558                    have this information here. */
2559                 return gen_float_const_Store(node, val);
2560         }
2561         return gen_general_Store(node);
2562 }
2563
2564 /**
2565  * Transforms a Switch.
2566  *
2567  * @return the created ia32 SwitchJmp node
2568  */
2569 static ir_node *create_Switch(ir_node *node)
2570 {
2571         dbg_info *dbgi       = get_irn_dbg_info(node);
2572         ir_node  *block      = be_transform_node(get_nodes_block(node));
2573         ir_node  *sel        = get_Cond_selector(node);
2574         ir_node  *new_sel    = be_transform_node(sel);
2575         long      switch_min = LONG_MAX;
2576         long      switch_max = LONG_MIN;
2577         long      default_pn = get_Cond_defaultProj(node);
2578         ir_node  *new_node;
2579         const ir_edge_t *edge;
2580
2581         assert(get_mode_size_bits(get_irn_mode(sel)) == 32);
2582
2583         /* determine the smallest switch case value */
2584         foreach_out_edge(node, edge) {
2585                 ir_node *proj = get_edge_src_irn(edge);
2586                 long     pn   = get_Proj_proj(proj);
2587                 if (pn == default_pn)
2588                         continue;
2589
2590                 if (pn < switch_min)
2591                         switch_min = pn;
2592                 if (pn > switch_max)
2593                         switch_max = pn;
2594         }
2595
2596         if ((unsigned long) (switch_max - switch_min) > 256000) {
2597                 panic("Size of switch %+F bigger than 256000", node);
2598         }
2599
2600         if (switch_min != 0) {
2601                 ir_node *noreg = ia32_new_NoReg_gp(env_cg);
2602
2603                 /* if smallest switch case is not 0 we need an additional sub */
2604                 new_sel = new_bd_ia32_Lea(dbgi, block, new_sel, noreg);
2605                 add_ia32_am_offs_int(new_sel, -switch_min);
2606                 set_ia32_op_type(new_sel, ia32_AddrModeS);
2607
2608                 SET_IA32_ORIG_NODE(new_sel, node);
2609         }
2610
2611         new_node = new_bd_ia32_SwitchJmp(dbgi, block, new_sel, default_pn);
2612         SET_IA32_ORIG_NODE(new_node, node);
2613
2614         return new_node;
2615 }
2616
2617 /**
2618  * Transform a Cond node.
2619  */
2620 static ir_node *gen_Cond(ir_node *node)
2621 {
2622         ir_node  *block     = get_nodes_block(node);
2623         ir_node  *new_block = be_transform_node(block);
2624         dbg_info *dbgi      = get_irn_dbg_info(node);
2625         ir_node  *sel       = get_Cond_selector(node);
2626         ir_mode  *sel_mode  = get_irn_mode(sel);
2627         ir_node  *flags     = NULL;
2628         ir_node  *new_node;
2629         pn_Cmp    pnc;
2630
2631         if (sel_mode != mode_b) {
2632                 return create_Switch(node);
2633         }
2634
2635         /* we get flags from a Cmp */
2636         flags = get_flags_node(sel, &pnc);
2637
2638         new_node = new_bd_ia32_Jcc(dbgi, new_block, flags, pnc);
2639         SET_IA32_ORIG_NODE(new_node, node);
2640
2641         return new_node;
2642 }
2643
2644 static ir_node *gen_be_Copy(ir_node *node)
2645 {
2646         ir_node *new_node = be_duplicate_node(node);
2647         ir_mode *mode     = get_irn_mode(new_node);
2648
2649         if (ia32_mode_needs_gp_reg(mode)) {
2650                 set_irn_mode(new_node, mode_Iu);
2651         }
2652
2653         return new_node;
2654 }
2655
2656 static ir_node *create_Fucom(ir_node *node)
2657 {
2658         dbg_info *dbgi      = get_irn_dbg_info(node);
2659         ir_node  *block     = get_nodes_block(node);
2660         ir_node  *new_block = be_transform_node(block);
2661         ir_node  *left      = get_Cmp_left(node);
2662         ir_node  *new_left  = be_transform_node(left);
2663         ir_node  *right     = get_Cmp_right(node);
2664         ir_node  *new_right;
2665         ir_node  *new_node;
2666
2667         if (ia32_cg_config.use_fucomi) {
2668                 new_right = be_transform_node(right);
2669                 new_node  = new_bd_ia32_vFucomi(dbgi, new_block, new_left,
2670                                                 new_right, 0);
2671                 set_ia32_commutative(new_node);
2672                 SET_IA32_ORIG_NODE(new_node, node);
2673         } else {
2674                 if (ia32_cg_config.use_ftst && is_Const_0(right)) {
2675                         new_node = new_bd_ia32_vFtstFnstsw(dbgi, new_block, new_left, 0);
2676                 } else {
2677                         new_right = be_transform_node(right);
2678                         new_node  = new_bd_ia32_vFucomFnstsw(dbgi, new_block, new_left, new_right, 0);
2679                 }
2680
2681                 set_ia32_commutative(new_node);
2682
2683                 SET_IA32_ORIG_NODE(new_node, node);
2684
2685                 new_node = new_bd_ia32_Sahf(dbgi, new_block, new_node);
2686                 SET_IA32_ORIG_NODE(new_node, node);
2687         }
2688
2689         return new_node;
2690 }
2691
2692 static ir_node *create_Ucomi(ir_node *node)
2693 {
2694         dbg_info *dbgi      = get_irn_dbg_info(node);
2695         ir_node  *src_block = get_nodes_block(node);
2696         ir_node  *new_block = be_transform_node(src_block);
2697         ir_node  *left      = get_Cmp_left(node);
2698         ir_node  *right     = get_Cmp_right(node);
2699         ir_node  *new_node;
2700         ia32_address_mode_t  am;
2701         ia32_address_t      *addr = &am.addr;
2702
2703         match_arguments(&am, src_block, left, right, NULL,
2704                         match_commutative | match_am);
2705
2706         new_node = new_bd_ia32_Ucomi(dbgi, new_block, addr->base, addr->index,
2707                                      addr->mem, am.new_op1, am.new_op2,
2708                                      am.ins_permuted);
2709         set_am_attributes(new_node, &am);
2710
2711         SET_IA32_ORIG_NODE(new_node, node);
2712
2713         new_node = fix_mem_proj(new_node, &am);
2714
2715         return new_node;
2716 }
2717
2718 /**
2719  * helper function: checks whether all Cmp projs are Lg or Eq which is needed
2720  * to fold an and into a test node
2721  */
2722 static bool can_fold_test_and(ir_node *node)
2723 {
2724         const ir_edge_t *edge;
2725
2726         /** we can only have eq and lg projs */
2727         foreach_out_edge(node, edge) {
2728                 ir_node *proj = get_edge_src_irn(edge);
2729                 pn_Cmp   pnc  = get_Proj_proj(proj);
2730                 if (pnc != pn_Cmp_Eq && pnc != pn_Cmp_Lg)
2731                         return false;
2732         }
2733
2734         return true;
2735 }
2736
2737 /**
2738  * returns true if it is assured, that the upper bits of a node are "clean"
2739  * which means for a 16 or 8 bit value, that the upper bits in the register
2740  * are 0 for unsigned and a copy of the last significant bit for signed
2741  * numbers.
2742  */
2743 static bool upper_bits_clean(ir_node *transformed_node, ir_mode *mode)
2744 {
2745         assert(ia32_mode_needs_gp_reg(mode));
2746         if (get_mode_size_bits(mode) >= 32)
2747                 return true;
2748
2749         if (is_Proj(transformed_node))
2750                 return upper_bits_clean(get_Proj_pred(transformed_node), mode);
2751
2752         switch (get_ia32_irn_opcode(transformed_node)) {
2753                 case iro_ia32_Conv_I2I:
2754                 case iro_ia32_Conv_I2I8Bit: {
2755                         ir_mode *smaller_mode = get_ia32_ls_mode(transformed_node);
2756                         if (mode_is_signed(smaller_mode) != mode_is_signed(mode))
2757                                 return false;
2758                         if (get_mode_size_bits(smaller_mode) > get_mode_size_bits(mode))
2759                                 return false;
2760
2761                         return true;
2762                 }
2763
2764                 case iro_ia32_Shr:
2765                         if (mode_is_signed(mode)) {
2766                                 return false; /* TODO handle signed modes */
2767                         } else {
2768                                 ir_node *right = get_irn_n(transformed_node, n_ia32_Shr_count);
2769                                 if (is_ia32_Immediate(right) || is_ia32_Const(right)) {
2770                                         const ia32_immediate_attr_t *attr
2771                                                 = get_ia32_immediate_attr_const(right);
2772                                         if (attr->symconst == 0 &&
2773                                                         (unsigned)attr->offset >= 32 - get_mode_size_bits(mode)) {
2774                                                 return true;
2775                                         }
2776                                 }
2777                                 return upper_bits_clean(get_irn_n(transformed_node, n_ia32_Shr_val), mode);
2778                         }
2779
2780                 case iro_ia32_Sar:
2781                         /* TODO too conservative if shift amount is constant */
2782                         return upper_bits_clean(get_irn_n(transformed_node, n_ia32_Sar_val), mode);
2783
2784                 case iro_ia32_And:
2785                         if (!mode_is_signed(mode)) {
2786                                 return
2787                                         upper_bits_clean(get_irn_n(transformed_node, n_ia32_And_right), mode) ||
2788                                         upper_bits_clean(get_irn_n(transformed_node, n_ia32_And_left),  mode);
2789                         }
2790                         /* TODO if one is known to be zero extended, then || is sufficient */
2791                         /* FALLTHROUGH */
2792                 case iro_ia32_Or:
2793                 case iro_ia32_Xor:
2794                         return
2795                                 upper_bits_clean(get_irn_n(transformed_node, n_ia32_binary_right), mode) &&
2796                                 upper_bits_clean(get_irn_n(transformed_node, n_ia32_binary_left),  mode);
2797
2798                 case iro_ia32_Const:
2799                 case iro_ia32_Immediate: {
2800                         const ia32_immediate_attr_t *attr =
2801                                 get_ia32_immediate_attr_const(transformed_node);
2802                         if (mode_is_signed(mode)) {
2803                                 long shifted = attr->offset >> (get_mode_size_bits(mode) - 1);
2804                                 return shifted == 0 || shifted == -1;
2805                         } else {
2806                                 unsigned long shifted = (unsigned long)attr->offset;
2807                                 shifted >>= get_mode_size_bits(mode);
2808                                 return shifted == 0;
2809                         }
2810                 }
2811
2812                 default:
2813                         return false;
2814         }
2815 }
2816
2817 /**
2818  * Generate code for a Cmp.
2819  */
2820 static ir_node *gen_Cmp(ir_node *node)
2821 {
2822         dbg_info *dbgi      = get_irn_dbg_info(node);
2823         ir_node  *block     = get_nodes_block(node);
2824         ir_node  *new_block = be_transform_node(block);
2825         ir_node  *left      = get_Cmp_left(node);
2826         ir_node  *right     = get_Cmp_right(node);
2827         ir_mode  *cmp_mode  = get_irn_mode(left);
2828         ir_node  *new_node;
2829         ia32_address_mode_t  am;
2830         ia32_address_t      *addr = &am.addr;
2831         int                  cmp_unsigned;
2832
2833         if (mode_is_float(cmp_mode)) {
2834                 if (ia32_cg_config.use_sse2) {
2835                         return create_Ucomi(node);
2836                 } else {
2837                         return create_Fucom(node);
2838                 }
2839         }
2840
2841         assert(ia32_mode_needs_gp_reg(cmp_mode));
2842
2843         /* Prefer the Test instruction, when encountering (x & y) ==/!= 0 */
2844         cmp_unsigned = !mode_is_signed(cmp_mode);
2845         if (is_Const_0(right)          &&
2846             is_And(left)               &&
2847             get_irn_n_edges(left) == 1 &&
2848             can_fold_test_and(node)) {
2849                 /* Test(and_left, and_right) */
2850                 ir_node *and_left  = get_And_left(left);
2851                 ir_node *and_right = get_And_right(left);
2852
2853                 /* matze: code here used mode instead of cmd_mode, I think it is always
2854                  * the same as cmp_mode, but I leave this here to see if this is really
2855                  * true...
2856                  */
2857                 assert(get_irn_mode(and_left) == cmp_mode);
2858
2859                 match_arguments(&am, block, and_left, and_right, NULL,
2860                                                                                 match_commutative |
2861                                                                                 match_am | match_8bit_am | match_16bit_am |
2862                                                                                 match_am_and_immediates | match_immediate);
2863
2864                 /* use 32bit compare mode if possible since the opcode is smaller */
2865                 if (upper_bits_clean(am.new_op1, cmp_mode) &&
2866                     upper_bits_clean(am.new_op2, cmp_mode)) {
2867                         cmp_mode = mode_is_signed(cmp_mode) ? mode_Is : mode_Iu;
2868                 }
2869
2870                 if (get_mode_size_bits(cmp_mode) == 8) {
2871                         new_node = new_bd_ia32_Test8Bit(dbgi, new_block, addr->base,
2872                                         addr->index, addr->mem, am.new_op1, am.new_op2, am.ins_permuted,
2873                                         cmp_unsigned);
2874                 } else {
2875                         new_node = new_bd_ia32_Test(dbgi, new_block, addr->base, addr->index,
2876                                         addr->mem, am.new_op1, am.new_op2, am.ins_permuted, cmp_unsigned);
2877                 }
2878         } else {
2879                 /* Cmp(left, right) */
2880                 match_arguments(&am, block, left, right, NULL,
2881                                 match_commutative | match_am | match_8bit_am |
2882                                 match_16bit_am | match_am_and_immediates |
2883                                 match_immediate);
2884                 /* use 32bit compare mode if possible since the opcode is smaller */
2885                 if (upper_bits_clean(am.new_op1, cmp_mode) &&
2886                     upper_bits_clean(am.new_op2, cmp_mode)) {
2887                         cmp_mode = mode_is_signed(cmp_mode) ? mode_Is : mode_Iu;
2888                 }
2889
2890                 if (get_mode_size_bits(cmp_mode) == 8) {
2891                         new_node = new_bd_ia32_Cmp8Bit(dbgi, new_block, addr->base,
2892                                                        addr->index, addr->mem, am.new_op1,
2893                                                        am.new_op2, am.ins_permuted,
2894                                                        cmp_unsigned);
2895                 } else {
2896                         new_node = new_bd_ia32_Cmp(dbgi, new_block, addr->base, addr->index,
2897                                         addr->mem, am.new_op1, am.new_op2, am.ins_permuted, cmp_unsigned);
2898                 }
2899         }
2900         set_am_attributes(new_node, &am);
2901         set_ia32_ls_mode(new_node, cmp_mode);
2902
2903         SET_IA32_ORIG_NODE(new_node, node);
2904
2905         new_node = fix_mem_proj(new_node, &am);
2906
2907         return new_node;
2908 }
2909
2910 static ir_node *create_CMov(ir_node *node, ir_node *flags, ir_node *new_flags,
2911                             pn_Cmp pnc)
2912 {
2913         dbg_info            *dbgi          = get_irn_dbg_info(node);
2914         ir_node             *block         = get_nodes_block(node);
2915         ir_node             *new_block     = be_transform_node(block);
2916         ir_node             *val_true      = get_Mux_true(node);
2917         ir_node             *val_false     = get_Mux_false(node);
2918         ir_node             *new_node;
2919         ia32_address_mode_t  am;
2920         ia32_address_t      *addr;
2921
2922         assert(ia32_cg_config.use_cmov);
2923         assert(ia32_mode_needs_gp_reg(get_irn_mode(val_true)));
2924
2925         addr = &am.addr;
2926
2927         match_arguments(&am, block, val_false, val_true, flags,
2928                         match_commutative | match_am | match_16bit_am | match_mode_neutral);
2929
2930         new_node = new_bd_ia32_CMov(dbgi, new_block, addr->base, addr->index,
2931                                     addr->mem, am.new_op1, am.new_op2, new_flags,
2932                                     am.ins_permuted, pnc);
2933         set_am_attributes(new_node, &am);
2934
2935         SET_IA32_ORIG_NODE(new_node, node);
2936
2937         new_node = fix_mem_proj(new_node, &am);
2938
2939         return new_node;
2940 }
2941
2942 /**
2943  * Creates a ia32 Setcc instruction.
2944  */
2945 static ir_node *create_set_32bit(dbg_info *dbgi, ir_node *new_block,
2946                                  ir_node *flags, pn_Cmp pnc, ir_node *orig_node,
2947                                  int ins_permuted)
2948 {
2949         ir_node *noreg = ia32_new_NoReg_gp(env_cg);
2950         ir_node *nomem = new_NoMem();
2951         ir_mode *mode  = get_irn_mode(orig_node);
2952         ir_node *new_node;
2953
2954         new_node = new_bd_ia32_Set(dbgi, new_block, flags, pnc, ins_permuted);
2955         SET_IA32_ORIG_NODE(new_node, orig_node);
2956
2957         /* we might need to conv the result up */
2958         if (get_mode_size_bits(mode) > 8) {
2959                 new_node = new_bd_ia32_Conv_I2I8Bit(dbgi, new_block, noreg, noreg,
2960                                                     nomem, new_node, mode_Bu);
2961                 SET_IA32_ORIG_NODE(new_node, orig_node);
2962         }
2963
2964         return new_node;
2965 }
2966
2967 /**
2968  * Create instruction for an unsigned Difference or Zero.
2969  */
2970 static ir_node *create_Doz(ir_node *psi, ir_node *a, ir_node *b)
2971 {
2972         ir_graph *irg   = current_ir_graph;
2973         ir_mode  *mode  = get_irn_mode(psi);
2974         ir_node  *nomem = new_NoMem();
2975         ir_node  *new_node, *sub, *sbb, *eflags, *block, *noreg;
2976
2977         dbg_info *dbgi;
2978
2979         new_node = gen_binop(psi, a, b, new_bd_ia32_Sub,
2980                 match_mode_neutral | match_am | match_immediate | match_two_users);
2981
2982         block = get_nodes_block(new_node);
2983
2984         if (is_Proj(new_node)) {
2985                 sub = get_Proj_pred(new_node);
2986                 assert(is_ia32_Sub(sub));
2987         } else {
2988                 sub = new_node;
2989                 set_irn_mode(sub, mode_T);
2990                 new_node = new_rd_Proj(NULL, irg, block, sub, mode, pn_ia32_res);
2991         }
2992         eflags = new_rd_Proj(NULL, irg, block, sub, mode_Iu, pn_ia32_Sub_flags);
2993
2994         dbgi   = get_irn_dbg_info(psi);
2995         sbb    = new_bd_ia32_Sbb0(dbgi, block, eflags);
2996
2997         noreg    = ia32_new_NoReg_gp(env_cg);
2998         new_node = new_bd_ia32_And(dbgi, block, noreg, noreg, nomem, new_node, sbb);
2999         set_ia32_commutative(new_node);
3000         return new_node;
3001 }
3002
3003 /**
3004  * Create an const array of two float consts.
3005  *
3006  * @param c0        the first constant
3007  * @param c1        the second constant
3008  * @param new_mode  IN/OUT for the mode of the constants, if NULL
3009  *                  smallest possible mode will be used
3010  */
3011 static ir_entity *ia32_create_const_array(ir_node *c0, ir_node *c1, ir_mode **new_mode) {
3012         ir_entity        *ent;
3013         ir_mode          *mode = *new_mode;
3014         ir_type          *tp;
3015         ir_initializer_t *initializer;
3016         tarval           *tv0 = get_Const_tarval(c0);
3017         tarval           *tv1 = get_Const_tarval(c1);
3018
3019         if (mode == NULL) {
3020                 /* detect the best mode for the constants */
3021                 mode = get_tarval_mode(tv0);
3022
3023                 if (mode != mode_F) {
3024                         if (tarval_ieee754_can_conv_lossless(tv0, mode_F) &&
3025                             tarval_ieee754_can_conv_lossless(tv1, mode_F)) {
3026                                 mode = mode_F;
3027                                 tv0 = tarval_convert_to(tv0, mode);
3028                                 tv1 = tarval_convert_to(tv1, mode);
3029                         } else if (mode != mode_D) {
3030                                 if (tarval_ieee754_can_conv_lossless(tv0, mode_D) &&
3031                                     tarval_ieee754_can_conv_lossless(tv1, mode_D)) {
3032                                         mode = mode_D;
3033                                         tv0 = tarval_convert_to(tv0, mode);
3034                                         tv1 = tarval_convert_to(tv1, mode);
3035                                 }
3036                         }
3037                 }
3038
3039         }
3040
3041         tp = ia32_create_float_type(mode, 4);
3042         tp = ia32_create_float_array(tp);
3043
3044         ent = new_entity(get_glob_type(), ia32_unique_id(".LC%u"), tp);
3045
3046         set_entity_ld_ident(ent, get_entity_ident(ent));
3047         set_entity_visibility(ent, visibility_local);
3048         set_entity_variability(ent, variability_constant);
3049         set_entity_allocation(ent, allocation_static);
3050
3051         initializer = create_initializer_compound(2);
3052
3053         set_initializer_compound_value(initializer, 0, create_initializer_tarval(tv0));
3054         set_initializer_compound_value(initializer, 1, create_initializer_tarval(tv1));
3055
3056         set_entity_initializer(ent, initializer);
3057
3058         *new_mode = mode;
3059         return ent;
3060 }
3061
3062 /**
3063  * Transforms a Mux node into CMov.
3064  *
3065  * @return The transformed node.
3066  */
3067 static ir_node *gen_Mux(ir_node *node)
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  *mux_true    = get_Mux_true(node);
3073         ir_node  *mux_false   = get_Mux_false(node);
3074         ir_node  *cond        = get_Mux_sel(node);
3075         ir_mode  *mode        = get_irn_mode(node);
3076         ir_node  *flags;
3077         ir_node  *new_node;
3078         pn_Cmp   pnc;
3079
3080         assert(get_irn_mode(cond) == mode_b);
3081
3082         /* Note: a Mux node uses a Load two times IFF it's used in the compare AND in the result */
3083         if (mode_is_float(mode)) {
3084                 ir_node  *cmp         = get_Proj_pred(cond);
3085                 ir_node  *cmp_left    = get_Cmp_left(cmp);
3086                 ir_node  *cmp_right   = get_Cmp_right(cmp);
3087                 pn_Cmp   pnc          = get_Proj_proj(cond);
3088
3089                 if (ia32_cg_config.use_sse2) {
3090                         if (pnc == pn_Cmp_Lt || pnc == pn_Cmp_Le) {
3091                                 if (cmp_left == mux_true && cmp_right == mux_false) {
3092                                         /* Mux(a <= b, a, b) => MIN */
3093                                         return gen_binop(node, cmp_left, cmp_right, new_bd_ia32_xMin,
3094                                          match_commutative | match_am | match_two_users);
3095                                 } else if (cmp_left == mux_false && cmp_right == mux_true) {
3096                                         /* Mux(a <= b, b, a) => MAX */
3097                                         return gen_binop(node, cmp_left, cmp_right, new_bd_ia32_xMax,
3098                                          match_commutative | match_am | match_two_users);
3099                                 }
3100                         } else if (pnc == pn_Cmp_Gt || pnc == pn_Cmp_Ge) {
3101                                 if (cmp_left == mux_true && cmp_right == mux_false) {
3102                                         /* Mux(a >= b, a, b) => MAX */
3103                                         return gen_binop(node, cmp_left, cmp_right, new_bd_ia32_xMax,
3104                                          match_commutative | match_am | match_two_users);
3105                                 } else if (cmp_left == mux_false && cmp_right == mux_true) {
3106                                         /* Mux(a >= b, b, a) => MIN */
3107                                         return gen_binop(node, cmp_left, cmp_right, new_bd_ia32_xMin,
3108                                          match_commutative | match_am | match_two_users);
3109                                 }
3110                         }
3111                 }
3112                 if (is_Const(mux_true) && is_Const(mux_false)) {
3113                         ia32_address_mode_t am;
3114                         ir_node             *noreg = ia32_new_NoReg_gp(env_cg);
3115                         ir_node             *nomem = new_NoMem();
3116                         ir_node             *load;
3117                         ir_mode             *new_mode;
3118                         unsigned            scale;
3119
3120                         flags    = get_flags_node(cond, &pnc);
3121                         new_node = create_set_32bit(dbgi, new_block, flags, pnc, node, /*is_premuted=*/0);
3122
3123                         if (ia32_cg_config.use_sse2) {
3124                                 /* cannot load from different mode on SSE */
3125                                 new_mode = mode;
3126                         } else {
3127                                 /* x87 can load any mode */
3128                                 new_mode = NULL;
3129                         }
3130
3131                         am.addr.symconst_ent = ia32_create_const_array(mux_false, mux_true, &new_mode);
3132
3133                         switch (get_mode_size_bytes(new_mode)) {
3134                         case 4:
3135                                 scale = 2;
3136                                 break;
3137                         case 8:
3138                                 scale = 3;
3139                                 break;
3140                         case 10:
3141                                 /* use 2 * 5 */
3142                                 scale = 1;
3143                                 new_node = new_bd_ia32_Lea(dbgi, new_block, new_node, new_node);
3144                                 set_ia32_am_scale(new_node, 2);
3145                                 break;
3146                         case 12:
3147                                 /* use 4 * 3 */
3148                                 scale = 2;
3149                                 new_node = new_bd_ia32_Lea(dbgi, new_block, new_node, new_node);
3150                                 set_ia32_am_scale(new_node, 1);
3151                                 break;
3152                         case 16:
3153                                 /* arg, shift 16 NOT supported */
3154                                 scale = 3;
3155                                 new_node = new_bd_ia32_Add(dbgi, new_block, noreg, noreg, nomem, new_node, new_node);
3156                                 break;
3157                         default:
3158                                 panic("Unsupported constant size");
3159                         }
3160
3161                         am.ls_mode            = new_mode;
3162                         am.addr.base          = noreg;
3163                         am.addr.index         = new_node;
3164                         am.addr.mem           = nomem;
3165                         am.addr.offset        = 0;
3166                         am.addr.scale         = scale;
3167                         am.addr.use_frame     = 0;
3168                         am.addr.frame_entity  = NULL;
3169                         am.addr.symconst_sign = 0;
3170                         am.mem_proj           = am.addr.mem;
3171                         am.op_type            = ia32_AddrModeS;
3172                         am.new_op1            = NULL;
3173                         am.new_op2            = NULL;
3174                         am.pinned             = op_pin_state_floats;
3175                         am.commutative        = 1;
3176                         am.ins_permuted       = 0;
3177
3178                         if (ia32_cg_config.use_sse2)
3179                                 load = new_bd_ia32_xLoad(dbgi, block, am.addr.base, am.addr.index, am.addr.mem, new_mode);
3180                         else
3181                                 load = new_bd_ia32_vfld(dbgi, block, am.addr.base, am.addr.index, am.addr.mem, new_mode);
3182                         set_am_attributes(load, &am);
3183
3184                         return new_rd_Proj(NULL, current_ir_graph, block, load, mode_vfp, pn_ia32_res);
3185                 }
3186                 panic("cannot transform floating point Mux");
3187
3188         } else {
3189                 assert(ia32_mode_needs_gp_reg(mode));
3190
3191                 if (is_Proj(cond)) {
3192                         ir_node *cmp = get_Proj_pred(cond);
3193                         if (is_Cmp(cmp)) {
3194                                 ir_node  *cmp_left    = get_Cmp_left(cmp);
3195                                 ir_node  *cmp_right   = get_Cmp_right(cmp);
3196                                 pn_Cmp   pnc          = get_Proj_proj(cond);
3197
3198                                 /* check for unsigned Doz first */
3199                                 if ((pnc & pn_Cmp_Gt) && !mode_is_signed(mode) &&
3200                                         is_Const_0(mux_false) && is_Sub(mux_true) &&
3201                                         get_Sub_left(mux_true) == cmp_left && get_Sub_right(mux_true) == cmp_right) {
3202                                         /* Mux(a >=u b, a - b, 0) unsigned Doz */
3203                                         return create_Doz(node, cmp_left, cmp_right);
3204                                 } else if ((pnc & pn_Cmp_Lt) && !mode_is_signed(mode) &&
3205                                         is_Const_0(mux_true) && is_Sub(mux_false) &&
3206                                         get_Sub_left(mux_false) == cmp_left && get_Sub_right(mux_false) == cmp_right) {
3207                                         /* Mux(a <=u b, 0, a - b) unsigned Doz */
3208                                         return create_Doz(node, cmp_left, cmp_right);
3209                                 }
3210                         }
3211                 }
3212
3213                 flags = get_flags_node(cond, &pnc);
3214
3215                 if (is_Const(mux_true) && is_Const(mux_false)) {
3216                         /* both are const, good */
3217                         if (is_Const_1(mux_true) && is_Const_0(mux_false)) {
3218                                 new_node = create_set_32bit(dbgi, new_block, flags, pnc, node, /*is_premuted=*/0);
3219                         } else if (is_Const_0(mux_true) && is_Const_1(mux_false)) {
3220                                 new_node = create_set_32bit(dbgi, new_block, flags, pnc, node, /*is_premuted=*/1);
3221                         } else {
3222                                 /* Not that simple. */
3223                                 goto need_cmov;
3224                         }
3225                 } else {
3226 need_cmov:
3227                         new_node = create_CMov(node, cond, flags, pnc);
3228                 }
3229                 return new_node;
3230         }
3231 }
3232
3233
3234 /**
3235  * Create a conversion from x87 state register to general purpose.
3236  */
3237 static ir_node *gen_x87_fp_to_gp(ir_node *node)
3238 {
3239         ir_node         *block      = be_transform_node(get_nodes_block(node));
3240         ir_node         *op         = get_Conv_op(node);
3241         ir_node         *new_op     = be_transform_node(op);
3242         ia32_code_gen_t *cg         = env_cg;
3243         ir_graph        *irg        = current_ir_graph;
3244         dbg_info        *dbgi       = get_irn_dbg_info(node);
3245         ir_node         *noreg      = ia32_new_NoReg_gp(cg);
3246         ir_mode         *mode       = get_irn_mode(node);
3247         ir_node         *fist, *load, *mem;
3248
3249         mem = gen_vfist(dbgi, irg, block, get_irg_frame(irg), noreg, new_NoMem(), new_op, &fist);
3250         set_irn_pinned(fist, op_pin_state_floats);
3251         set_ia32_use_frame(fist);
3252         set_ia32_op_type(fist, ia32_AddrModeD);
3253
3254         assert(get_mode_size_bits(mode) <= 32);
3255         /* exception we can only store signed 32 bit integers, so for unsigned
3256            we store a 64bit (signed) integer and load the lower bits */
3257         if (get_mode_size_bits(mode) == 32 && !mode_is_signed(mode)) {
3258                 set_ia32_ls_mode(fist, mode_Ls);
3259         } else {
3260                 set_ia32_ls_mode(fist, mode_Is);
3261         }
3262         SET_IA32_ORIG_NODE(fist, node);
3263
3264         /* do a Load */
3265         load = new_bd_ia32_Load(dbgi, block, get_irg_frame(irg), noreg, mem);
3266
3267         set_irn_pinned(load, op_pin_state_floats);
3268         set_ia32_use_frame(load);
3269         set_ia32_op_type(load, ia32_AddrModeS);
3270         set_ia32_ls_mode(load, mode_Is);
3271         if (get_ia32_ls_mode(fist) == mode_Ls) {
3272                 ia32_attr_t *attr = get_ia32_attr(load);
3273                 attr->data.need_64bit_stackent = 1;
3274         } else {
3275                 ia32_attr_t *attr = get_ia32_attr(load);
3276                 attr->data.need_32bit_stackent = 1;
3277         }
3278         SET_IA32_ORIG_NODE(load, node);
3279
3280         return new_r_Proj(irg, block, load, mode_Iu, pn_ia32_Load_res);
3281 }
3282
3283 /**
3284  * Creates a x87 strict Conv by placing a Store and a Load
3285  */
3286 static ir_node *gen_x87_strict_conv(ir_mode *tgt_mode, ir_node *node)
3287 {
3288         ir_node  *block    = get_nodes_block(node);
3289         ir_graph *irg      = current_ir_graph;
3290         dbg_info *dbgi     = get_irn_dbg_info(node);
3291         ir_node  *noreg    = ia32_new_NoReg_gp(env_cg);
3292         ir_node  *nomem    = new_NoMem();
3293         ir_node  *frame    = get_irg_frame(irg);
3294         ir_node  *store, *load;
3295         ir_node  *new_node;
3296
3297         store = new_bd_ia32_vfst(dbgi, block, frame, noreg, nomem, node, tgt_mode);
3298         set_ia32_use_frame(store);
3299         set_ia32_op_type(store, ia32_AddrModeD);
3300         SET_IA32_ORIG_NODE(store, node);
3301
3302         load = new_bd_ia32_vfld(dbgi, block, frame, noreg, store, tgt_mode);
3303         set_ia32_use_frame(load);
3304         set_ia32_op_type(load, ia32_AddrModeS);
3305         SET_IA32_ORIG_NODE(load, node);
3306
3307         new_node = new_r_Proj(irg, block, load, mode_E, pn_ia32_vfld_res);
3308         return new_node;
3309 }
3310
3311 static ir_node *create_Conv_I2I(dbg_info *dbgi, ir_node *block, ir_node *base,
3312                 ir_node *index, ir_node *mem, ir_node *val, ir_mode *mode)
3313 {
3314         ir_node *(*func)(dbg_info*, ir_node*, ir_node*, ir_node*, ir_node*, ir_node*, ir_mode*);
3315
3316         func = get_mode_size_bits(mode) == 8 ?
3317                 new_bd_ia32_Conv_I2I8Bit : new_bd_ia32_Conv_I2I;
3318         return func(dbgi, block, base, index, mem, val, mode);
3319 }
3320
3321 /**
3322  * Create a conversion from general purpose to x87 register
3323  */
3324 static ir_node *gen_x87_gp_to_fp(ir_node *node, ir_mode *src_mode)
3325 {
3326         ir_node  *src_block = get_nodes_block(node);
3327         ir_node  *block     = be_transform_node(src_block);
3328         ir_graph *irg       = current_ir_graph;
3329         dbg_info *dbgi      = get_irn_dbg_info(node);
3330         ir_node  *op        = get_Conv_op(node);
3331         ir_node  *new_op    = NULL;
3332         ir_node  *noreg;
3333         ir_node  *nomem;
3334         ir_mode  *mode;
3335         ir_mode  *store_mode;
3336         ir_node  *fild;
3337         ir_node  *store;
3338         ir_node  *new_node;
3339
3340         /* fild can use source AM if the operand is a signed 16bit or 32bit integer */
3341         if (possible_int_mode_for_fp(src_mode)) {
3342                 ia32_address_mode_t am;
3343
3344                 match_arguments(&am, src_block, NULL, op, NULL, match_am | match_try_am | match_16bit_am);
3345                 if (am.op_type == ia32_AddrModeS) {
3346                         ia32_address_t *addr = &am.addr;
3347
3348                         fild     = new_bd_ia32_vfild(dbgi, block, addr->base, addr->index,
3349                                         addr->mem);
3350                         new_node = new_r_Proj(irg, block, fild, mode_vfp,
3351                                               pn_ia32_vfild_res);
3352
3353                         set_am_attributes(fild, &am);
3354                         SET_IA32_ORIG_NODE(fild, node);
3355
3356                         fix_mem_proj(fild, &am);
3357
3358                         return new_node;
3359                 }
3360         }
3361         if (new_op == NULL) {
3362                 new_op = be_transform_node(op);
3363         }
3364
3365         noreg  = ia32_new_NoReg_gp(env_cg);
3366         nomem  = new_NoMem();
3367         mode   = get_irn_mode(op);
3368
3369         /* first convert to 32 bit signed if necessary */
3370         if (get_mode_size_bits(src_mode) < 32) {
3371                 if (!upper_bits_clean(new_op, src_mode)) {
3372                         new_op = create_Conv_I2I(dbgi, block, noreg, noreg, nomem, new_op, src_mode);
3373                         SET_IA32_ORIG_NODE(new_op, node);
3374                 }
3375                 mode = mode_Is;
3376         }
3377
3378         assert(get_mode_size_bits(mode) == 32);
3379
3380         /* do a store */
3381         store = new_bd_ia32_Store(dbgi, block, get_irg_frame(irg), noreg, nomem,
3382                                   new_op);
3383
3384         set_ia32_use_frame(store);
3385         set_ia32_op_type(store, ia32_AddrModeD);
3386         set_ia32_ls_mode(store, mode_Iu);
3387
3388         /* exception for 32bit unsigned, do a 64bit spill+load */
3389         if (!mode_is_signed(mode)) {
3390                 ir_node *in[2];
3391                 /* store a zero */
3392                 ir_node *zero_const = create_Immediate(NULL, 0, 0);
3393
3394                 ir_node *zero_store = new_bd_ia32_Store(dbgi, block, get_irg_frame(irg),
3395                                 noreg, nomem, zero_const);
3396
3397                 set_ia32_use_frame(zero_store);
3398                 set_ia32_op_type(zero_store, ia32_AddrModeD);
3399                 add_ia32_am_offs_int(zero_store, 4);
3400                 set_ia32_ls_mode(zero_store, mode_Iu);
3401
3402                 in[0] = zero_store;
3403                 in[1] = store;
3404
3405                 store      = new_rd_Sync(dbgi, irg, block, 2, in);
3406                 store_mode = mode_Ls;
3407         } else {
3408                 store_mode = mode_Is;
3409         }
3410
3411         /* do a fild */
3412         fild = new_bd_ia32_vfild(dbgi, block, get_irg_frame(irg), noreg, store);
3413
3414         set_ia32_use_frame(fild);
3415         set_ia32_op_type(fild, ia32_AddrModeS);
3416         set_ia32_ls_mode(fild, store_mode);
3417
3418         new_node = new_r_Proj(irg, block, fild, mode_vfp, pn_ia32_vfild_res);
3419
3420         return new_node;
3421 }
3422
3423 /**
3424  * Create a conversion from one integer mode into another one
3425  */
3426 static ir_node *create_I2I_Conv(ir_mode *src_mode, ir_mode *tgt_mode,
3427                                 dbg_info *dbgi, ir_node *block, ir_node *op,
3428                                 ir_node *node)
3429 {
3430         ir_node             *new_block = be_transform_node(block);
3431         ir_node             *new_node;
3432         ir_mode             *smaller_mode;
3433         ia32_address_mode_t  am;
3434         ia32_address_t      *addr = &am.addr;
3435
3436         (void) node;
3437         if (get_mode_size_bits(src_mode) < get_mode_size_bits(tgt_mode)) {
3438                 smaller_mode = src_mode;
3439         } else {
3440                 smaller_mode = tgt_mode;
3441         }
3442
3443 #ifdef DEBUG_libfirm
3444         if (is_Const(op)) {
3445                 ir_fprintf(stderr, "Optimisation warning: conv after constant %+F\n",
3446                            op);
3447         }
3448 #endif
3449
3450         match_arguments(&am, block, NULL, op, NULL,
3451                         match_am | match_8bit_am | match_16bit_am);
3452
3453         if (upper_bits_clean(am.new_op2, smaller_mode)) {
3454                 /* unnecessary conv. in theory it shouldn't have been AM */
3455                 assert(is_ia32_NoReg_GP(addr->base));
3456                 assert(is_ia32_NoReg_GP(addr->index));
3457                 assert(is_NoMem(addr->mem));
3458                 assert(am.addr.offset == 0);
3459                 assert(am.addr.symconst_ent == NULL);
3460                 return am.new_op2;
3461         }
3462
3463         new_node = create_Conv_I2I(dbgi, new_block, addr->base, addr->index,
3464                         addr->mem, am.new_op2, smaller_mode);
3465         set_am_attributes(new_node, &am);
3466         /* match_arguments assume that out-mode = in-mode, this isn't true here
3467          * so fix it */
3468         set_ia32_ls_mode(new_node, smaller_mode);
3469         SET_IA32_ORIG_NODE(new_node, node);
3470         new_node = fix_mem_proj(new_node, &am);
3471         return new_node;
3472 }
3473
3474 /**
3475  * Transforms a Conv node.
3476  *
3477  * @return The created ia32 Conv node
3478  */
3479 static ir_node *gen_Conv(ir_node *node)
3480 {
3481         ir_node  *block     = get_nodes_block(node);
3482         ir_node  *new_block = be_transform_node(block);
3483         ir_node  *op        = get_Conv_op(node);
3484         ir_node  *new_op    = NULL;
3485         dbg_info *dbgi      = get_irn_dbg_info(node);
3486         ir_mode  *src_mode  = get_irn_mode(op);
3487         ir_mode  *tgt_mode  = get_irn_mode(node);
3488         int       src_bits  = get_mode_size_bits(src_mode);
3489         int       tgt_bits  = get_mode_size_bits(tgt_mode);
3490         ir_node  *noreg     = ia32_new_NoReg_gp(env_cg);
3491         ir_node  *nomem     = new_NoMem();
3492         ir_node  *res       = NULL;
3493
3494         assert(!mode_is_int(src_mode) || src_bits <= 32);
3495         assert(!mode_is_int(tgt_mode) || tgt_bits <= 32);
3496
3497         if (src_mode == mode_b) {
3498                 assert(mode_is_int(tgt_mode) || mode_is_reference(tgt_mode));
3499                 /* nothing to do, we already model bools as 0/1 ints */
3500                 return be_transform_node(op);
3501         }
3502
3503         if (src_mode == tgt_mode) {
3504                 if (get_Conv_strict(node)) {
3505                         if (ia32_cg_config.use_sse2) {
3506                                 /* when we are in SSE mode, we can kill all strict no-op conversion */
3507                                 return be_transform_node(op);
3508                         }
3509                 } else {
3510                         /* this should be optimized already, but who knows... */
3511                         DEBUG_ONLY(ir_fprintf(stderr, "Debug warning: conv %+F is pointless\n", node));
3512                         DB((dbg, LEVEL_1, "killed Conv(mode, mode) ..."));
3513                         return be_transform_node(op);
3514                 }
3515         }
3516
3517         if (mode_is_float(src_mode)) {
3518                 new_op = be_transform_node(op);
3519                 /* we convert from float ... */
3520                 if (mode_is_float(tgt_mode)) {
3521 #if 0
3522                         /* Matze: I'm a bit unsure what the following is for? seems wrong
3523                          * to me... */
3524                         if (src_mode == mode_E && tgt_mode == mode_D
3525                                         && !get_Conv_strict(node)) {
3526                                 DB((dbg, LEVEL_1, "killed Conv(mode, mode) ..."));
3527                                 return new_op;
3528                         }
3529 #endif
3530
3531                         /* ... to float */
3532                         if (ia32_cg_config.use_sse2) {
3533                                 DB((dbg, LEVEL_1, "create Conv(float, float) ..."));
3534                                 res = new_bd_ia32_Conv_FP2FP(dbgi, new_block, noreg, noreg,
3535                                                              nomem, new_op);
3536                                 set_ia32_ls_mode(res, tgt_mode);
3537                         } else {
3538                                 if (get_Conv_strict(node)) {
3539                                         /* if fp_no_float_fold is not set then we assume that we
3540                                          * don't have any float operations in a non
3541                                          * mode_float_arithmetic mode and can skip strict upconvs */
3542                                         if (src_bits < tgt_bits
3543                                                         && !(get_irg_fp_model(current_ir_graph) & fp_no_float_fold)) {
3544                                                 DB((dbg, LEVEL_1, "killed Conv(float, float) ..."));
3545                                                 return new_op;
3546                                         } else {
3547                                                 res = gen_x87_strict_conv(tgt_mode, new_op);
3548                                                 SET_IA32_ORIG_NODE(get_Proj_pred(res), node);
3549                                                 return res;
3550                                         }
3551                                 }
3552                                 DB((dbg, LEVEL_1, "killed Conv(float, float) ..."));
3553                                 return new_op;
3554                         }
3555                 } else {
3556                         /* ... to int */
3557                         DB((dbg, LEVEL_1, "create Conv(float, int) ..."));
3558                         if (ia32_cg_config.use_sse2) {
3559                                 res = new_bd_ia32_Conv_FP2I(dbgi, new_block, noreg, noreg,
3560                                                             nomem, new_op);
3561                                 set_ia32_ls_mode(res, src_mode);
3562                         } else {
3563                                 return gen_x87_fp_to_gp(node);
3564                         }
3565                 }
3566         } else {
3567                 /* we convert from int ... */
3568                 if (mode_is_float(tgt_mode)) {
3569                         /* ... to float */
3570                         DB((dbg, LEVEL_1, "create Conv(int, float) ..."));
3571                         if (ia32_cg_config.use_sse2) {
3572                                 new_op = be_transform_node(op);
3573                                 res = new_bd_ia32_Conv_I2FP(dbgi, new_block, noreg, noreg,
3574                                                             nomem, new_op);
3575                                 set_ia32_ls_mode(res, tgt_mode);
3576                         } else {
3577                                 res = gen_x87_gp_to_fp(node, src_mode);
3578
3579                                 /* we need a strict-Conv, if the int mode has more bits than the
3580                                  * float mantissa */
3581                                 size_t int_mantissa = get_mode_size_bits(src_mode) - (mode_is_signed(src_mode) ? 1 : 0);
3582                                 size_t float_mantissa;
3583                                 /* FIXME There is no way to get the mantissa size of a mode */
3584                                 switch (get_mode_size_bits(tgt_mode)) {
3585                                         case 32: float_mantissa = 23 + 1; break; // + 1 for implicit 1
3586                                         case 64: float_mantissa = 52 + 1; break;
3587                                         case 80:
3588                                         case 96: float_mantissa = 64;     break;
3589                                         default: float_mantissa = 0;      break;
3590                                 }
3591                                 if (float_mantissa < int_mantissa) {
3592                                         res = gen_x87_strict_conv(tgt_mode, res);
3593                                         SET_IA32_ORIG_NODE(get_Proj_pred(res), node);
3594                                 }
3595                                 return res;
3596                         }
3597                 } else if (tgt_mode == mode_b) {
3598                         /* mode_b lowering already took care that we only have 0/1 values */
3599                         DB((dbg, LEVEL_1, "omitting unnecessary Conv(%+F, %+F) ...",
3600                             src_mode, tgt_mode));
3601                         return be_transform_node(op);
3602                 } else {
3603                         /* to int */
3604                         if (src_bits == tgt_bits) {
3605                                 DB((dbg, LEVEL_1, "omitting unnecessary Conv(%+F, %+F) ...",
3606                                     src_mode, tgt_mode));
3607                                 return be_transform_node(op);
3608                         }
3609
3610                         res = create_I2I_Conv(src_mode, tgt_mode, dbgi, block, op, node);
3611                         return res;
3612                 }
3613         }
3614
3615         return res;
3616 }
3617
3618 static ir_node *create_immediate_or_transform(ir_node *node,
3619                                               char immediate_constraint_type)
3620 {
3621         ir_node *new_node = try_create_Immediate(node, immediate_constraint_type);
3622         if (new_node == NULL) {
3623                 new_node = be_transform_node(node);
3624         }
3625         return new_node;
3626 }
3627
3628 /**
3629  * Transforms a FrameAddr into an ia32 Add.
3630  */
3631 static ir_node *gen_be_FrameAddr(ir_node *node)
3632 {
3633         ir_node  *block  = be_transform_node(get_nodes_block(node));
3634         ir_node  *op     = be_get_FrameAddr_frame(node);
3635         ir_node  *new_op = be_transform_node(op);
3636         dbg_info *dbgi   = get_irn_dbg_info(node);
3637         ir_node  *noreg  = ia32_new_NoReg_gp(env_cg);
3638         ir_node  *new_node;
3639
3640         new_node = new_bd_ia32_Lea(dbgi, block, new_op, noreg);
3641         set_ia32_frame_ent(new_node, arch_get_frame_entity(node));
3642         set_ia32_use_frame(new_node);
3643
3644         SET_IA32_ORIG_NODE(new_node, node);
3645
3646         return new_node;
3647 }
3648
3649 /**
3650  * In case SSE is used we need to copy the result from XMM0 to FPU TOS before return.
3651  */
3652 static ir_node *gen_be_Return(ir_node *node)
3653 {
3654         ir_graph  *irg     = current_ir_graph;
3655         ir_node   *ret_val = get_irn_n(node, be_pos_Return_val);
3656         ir_node   *ret_mem = get_irn_n(node, be_pos_Return_mem);
3657         ir_entity *ent     = get_irg_entity(irg);
3658         ir_type   *tp      = get_entity_type(ent);
3659         dbg_info  *dbgi;
3660         ir_node   *block;
3661         ir_type   *res_type;
3662         ir_mode   *mode;
3663         ir_node   *frame, *sse_store, *fld, *mproj, *barrier;
3664         ir_node   *new_barrier, *new_ret_val, *new_ret_mem;
3665         ir_node   *noreg;
3666         ir_node   **in;
3667         int       pn_ret_val, pn_ret_mem, arity, i;
3668
3669         assert(ret_val != NULL);
3670         if (be_Return_get_n_rets(node) < 1 || ! ia32_cg_config.use_sse2) {
3671                 return be_duplicate_node(node);
3672         }
3673
3674         res_type = get_method_res_type(tp, 0);
3675
3676         if (! is_Primitive_type(res_type)) {
3677                 return be_duplicate_node(node);
3678         }
3679
3680         mode = get_type_mode(res_type);
3681         if (! mode_is_float(mode)) {
3682                 return be_duplicate_node(node);
3683         }
3684
3685         assert(get_method_n_ress(tp) == 1);
3686
3687         pn_ret_val = get_Proj_proj(ret_val);
3688         pn_ret_mem = get_Proj_proj(ret_mem);
3689
3690         /* get the Barrier */
3691         barrier = get_Proj_pred(ret_val);
3692
3693         /* get result input of the Barrier */
3694         ret_val     = get_irn_n(barrier, pn_ret_val);
3695         new_ret_val = be_transform_node(ret_val);
3696
3697         /* get memory input of the Barrier */
3698         ret_mem     = get_irn_n(barrier, pn_ret_mem);
3699         new_ret_mem = be_transform_node(ret_mem);
3700
3701         frame = get_irg_frame(irg);
3702
3703         dbgi  = get_irn_dbg_info(barrier);
3704         block = be_transform_node(get_nodes_block(barrier));
3705
3706         noreg = ia32_new_NoReg_gp(env_cg);
3707
3708         /* store xmm0 onto stack */
3709         sse_store = new_bd_ia32_xStoreSimple(dbgi, block, frame, noreg,
3710                                              new_ret_mem, new_ret_val);
3711         set_ia32_ls_mode(sse_store, mode);
3712         set_ia32_op_type(sse_store, ia32_AddrModeD);
3713         set_ia32_use_frame(sse_store);
3714
3715         /* load into x87 register */
3716         fld = new_bd_ia32_vfld(dbgi, block, frame, noreg, sse_store, mode);
3717         set_ia32_op_type(fld, ia32_AddrModeS);
3718         set_ia32_use_frame(fld);
3719
3720         mproj = new_r_Proj(irg, block, fld, mode_M, pn_ia32_vfld_M);
3721         fld   = new_r_Proj(irg, block, fld, mode_vfp, pn_ia32_vfld_res);
3722
3723         /* create a new barrier */
3724         arity = get_irn_arity(barrier);
3725         in    = ALLOCAN(ir_node*, arity);
3726         for (i = 0; i < arity; ++i) {
3727                 ir_node *new_in;
3728
3729                 if (i == pn_ret_val) {
3730                         new_in = fld;
3731                 } else if (i == pn_ret_mem) {
3732                         new_in = mproj;
3733                 } else {
3734                         ir_node *in = get_irn_n(barrier, i);
3735                         new_in = be_transform_node(in);
3736                 }
3737                 in[i] = new_in;
3738         }
3739
3740         new_barrier = new_ir_node(dbgi, irg, block,
3741                                   get_irn_op(barrier), get_irn_mode(barrier),
3742                                   arity, in);
3743         copy_node_attr(barrier, new_barrier);
3744         be_duplicate_deps(barrier, new_barrier);
3745         be_set_transformed_node(barrier, new_barrier);
3746
3747         /* transform normally */
3748         return be_duplicate_node(node);
3749 }
3750
3751 /**
3752  * Transform a be_AddSP into an ia32_SubSP.
3753  */
3754 static ir_node *gen_be_AddSP(ir_node *node)
3755 {
3756         ir_node  *sz = get_irn_n(node, be_pos_AddSP_size);
3757         ir_node  *sp = get_irn_n(node, be_pos_AddSP_old_sp);
3758
3759         return gen_binop(node, sp, sz, new_bd_ia32_SubSP,
3760                          match_am | match_immediate);
3761 }
3762
3763 /**
3764  * Transform a be_SubSP into an ia32_AddSP
3765  */
3766 static ir_node *gen_be_SubSP(ir_node *node)
3767 {
3768         ir_node  *sz = get_irn_n(node, be_pos_SubSP_size);
3769         ir_node  *sp = get_irn_n(node, be_pos_SubSP_old_sp);
3770
3771         return gen_binop(node, sp, sz, new_bd_ia32_AddSP,
3772                          match_am | match_immediate);
3773 }
3774
3775 /**
3776  * Change some phi modes
3777  */
3778 static ir_node *gen_Phi(ir_node *node)
3779 {
3780         ir_node  *block = be_transform_node(get_nodes_block(node));
3781         ir_graph *irg   = current_ir_graph;
3782         dbg_info *dbgi  = get_irn_dbg_info(node);
3783         ir_mode  *mode  = get_irn_mode(node);
3784         ir_node  *phi;
3785
3786         if (ia32_mode_needs_gp_reg(mode)) {
3787                 /* we shouldn't have any 64bit stuff around anymore */
3788                 assert(get_mode_size_bits(mode) <= 32);
3789                 /* all integer operations are on 32bit registers now */
3790                 mode = mode_Iu;
3791         } else if (mode_is_float(mode)) {
3792                 if (ia32_cg_config.use_sse2) {
3793                         mode = mode_xmm;
3794                 } else {
3795                         mode = mode_vfp;
3796                 }
3797         }
3798
3799         /* phi nodes allow loops, so we use the old arguments for now
3800          * and fix this later */
3801         phi = new_ir_node(dbgi, irg, block, op_Phi, mode, get_irn_arity(node),
3802                           get_irn_in(node) + 1);
3803         copy_node_attr(node, phi);
3804         be_duplicate_deps(node, phi);
3805
3806         be_enqueue_preds(node);
3807
3808         return phi;
3809 }
3810
3811 /**
3812  * Transform IJmp
3813  */
3814 static ir_node *gen_IJmp(ir_node *node)
3815 {
3816         ir_node  *block     = get_nodes_block(node);
3817         ir_node  *new_block = be_transform_node(block);
3818         dbg_info *dbgi      = get_irn_dbg_info(node);
3819         ir_node  *op        = get_IJmp_target(node);
3820         ir_node  *new_node;
3821         ia32_address_mode_t  am;
3822         ia32_address_t      *addr = &am.addr;
3823
3824         assert(get_irn_mode(op) == mode_P);
3825
3826         match_arguments(&am, block, NULL, op, NULL, match_am | match_immediate);
3827
3828         new_node = new_bd_ia32_IJmp(dbgi, new_block, addr->base, addr->index,
3829                         addr->mem, am.new_op2);
3830         set_am_attributes(new_node, &am);
3831         SET_IA32_ORIG_NODE(new_node, node);
3832
3833         new_node = fix_mem_proj(new_node, &am);
3834
3835         return new_node;
3836 }
3837
3838 /**
3839  * Transform a Bound node.
3840  */
3841 static ir_node *gen_Bound(ir_node *node)
3842 {
3843         ir_node  *new_node;
3844         ir_node  *lower = get_Bound_lower(node);
3845         dbg_info *dbgi  = get_irn_dbg_info(node);
3846
3847         if (is_Const_0(lower)) {
3848                 /* typical case for Java */
3849                 ir_node  *sub, *res, *flags, *block;
3850                 ir_graph *irg  = current_ir_graph;
3851
3852                 res = gen_binop(node, get_Bound_index(node), get_Bound_upper(node),
3853                         new_bd_ia32_Sub, match_mode_neutral     | match_am | match_immediate);
3854
3855                 block = get_nodes_block(res);
3856                 if (! is_Proj(res)) {
3857                         sub = res;
3858                         set_irn_mode(sub, mode_T);
3859                         res = new_rd_Proj(NULL, irg, block, sub, mode_Iu, pn_ia32_res);
3860                 } else {
3861                         sub = get_Proj_pred(res);
3862                 }
3863                 flags = new_rd_Proj(NULL, irg, block, sub, mode_Iu, pn_ia32_Sub_flags);
3864                 new_node = new_bd_ia32_Jcc(dbgi, block, flags, pn_Cmp_Lt | ia32_pn_Cmp_unsigned);
3865                 SET_IA32_ORIG_NODE(new_node, node);
3866         } else {
3867                 panic("generic Bound not supported in ia32 Backend");
3868         }
3869         return new_node;
3870 }
3871
3872
3873 static ir_node *gen_ia32_l_ShlDep(ir_node *node)
3874 {
3875         ir_node *left  = get_irn_n(node, n_ia32_l_ShlDep_val);
3876         ir_node *right = get_irn_n(node, n_ia32_l_ShlDep_count);
3877
3878         return gen_shift_binop(node, left, right, new_bd_ia32_Shl,
3879                                match_immediate | match_mode_neutral);
3880 }
3881
3882 static ir_node *gen_ia32_l_ShrDep(ir_node *node)
3883 {
3884         ir_node *left  = get_irn_n(node, n_ia32_l_ShrDep_val);
3885         ir_node *right = get_irn_n(node, n_ia32_l_ShrDep_count);
3886         return gen_shift_binop(node, left, right, new_bd_ia32_Shr,
3887                                match_immediate);
3888 }
3889
3890 static ir_node *gen_ia32_l_SarDep(ir_node *node)
3891 {
3892         ir_node *left  = get_irn_n(node, n_ia32_l_SarDep_val);
3893         ir_node *right = get_irn_n(node, n_ia32_l_SarDep_count);
3894         return gen_shift_binop(node, left, right, new_bd_ia32_Sar,
3895                                match_immediate);
3896 }
3897
3898 static ir_node *gen_ia32_l_Add(ir_node *node)
3899 {
3900         ir_node *left    = get_irn_n(node, n_ia32_l_Add_left);
3901         ir_node *right   = get_irn_n(node, n_ia32_l_Add_right);
3902         ir_node *lowered = gen_binop(node, left, right, new_bd_ia32_Add,
3903                         match_commutative | match_am | match_immediate |
3904                         match_mode_neutral);
3905
3906         if (is_Proj(lowered)) {
3907                 lowered = get_Proj_pred(lowered);
3908         } else {
3909                 assert(is_ia32_Add(lowered));
3910                 set_irn_mode(lowered, mode_T);
3911         }
3912
3913         return lowered;
3914 }
3915
3916 static ir_node *gen_ia32_l_Adc(ir_node *node)
3917 {
3918         return gen_binop_flags(node, new_bd_ia32_Adc,
3919                         match_commutative | match_am | match_immediate |
3920                         match_mode_neutral);
3921 }
3922
3923 /**
3924  * Transforms a l_MulS into a "real" MulS node.
3925  *
3926  * @return the created ia32 Mul node
3927  */
3928 static ir_node *gen_ia32_l_Mul(ir_node *node)
3929 {
3930         ir_node *left  = get_binop_left(node);
3931         ir_node *right = get_binop_right(node);
3932
3933         return gen_binop(node, left, right, new_bd_ia32_Mul,
3934                          match_commutative | match_am | match_mode_neutral);
3935 }
3936
3937 /**
3938  * Transforms a l_IMulS into a "real" IMul1OPS node.
3939  *
3940  * @return the created ia32 IMul1OP node
3941  */
3942 static ir_node *gen_ia32_l_IMul(ir_node *node)
3943 {
3944         ir_node  *left  = get_binop_left(node);
3945         ir_node  *right = get_binop_right(node);
3946
3947         return gen_binop(node, left, right, new_bd_ia32_IMul1OP,
3948                          match_commutative | match_am | match_mode_neutral);
3949 }
3950
3951 static ir_node *gen_ia32_l_Sub(ir_node *node)
3952 {
3953         ir_node *left    = get_irn_n(node, n_ia32_l_Sub_minuend);
3954         ir_node *right   = get_irn_n(node, n_ia32_l_Sub_subtrahend);
3955         ir_node *lowered = gen_binop(node, left, right, new_bd_ia32_Sub,
3956                         match_am | match_immediate | match_mode_neutral);
3957
3958         if (is_Proj(lowered)) {
3959                 lowered = get_Proj_pred(lowered);
3960         } else {
3961                 assert(is_ia32_Sub(lowered));
3962                 set_irn_mode(lowered, mode_T);
3963         }
3964
3965         return lowered;
3966 }
3967
3968 static ir_node *gen_ia32_l_Sbb(ir_node *node)
3969 {
3970         return gen_binop_flags(node, new_bd_ia32_Sbb,
3971                         match_am | match_immediate | match_mode_neutral);
3972 }
3973
3974 /**
3975  * Transforms a l_ShlD/l_ShrD into a ShlD/ShrD. Those nodes have 3 data inputs:
3976  * op1 - target to be shifted
3977  * op2 - contains bits to be shifted into target
3978  * op3 - shift count
3979  * Only op3 can be an immediate.
3980  */
3981 static ir_node *gen_lowered_64bit_shifts(ir_node *node, ir_node *high,
3982                                          ir_node *low, ir_node *count)
3983 {
3984         ir_node  *block     = get_nodes_block(node);
3985         ir_node  *new_block = be_transform_node(block);
3986         dbg_info *dbgi      = get_irn_dbg_info(node);
3987         ir_node  *new_high  = be_transform_node(high);
3988         ir_node  *new_low   = be_transform_node(low);
3989         ir_node  *new_count;
3990         ir_node  *new_node;
3991
3992         /* the shift amount can be any mode that is bigger than 5 bits, since all
3993          * other bits are ignored anyway */
3994         while (is_Conv(count)              &&
3995                get_irn_n_edges(count) == 1 &&
3996                mode_is_int(get_irn_mode(count))) {
3997                 assert(get_mode_size_bits(get_irn_mode(count)) >= 5);
3998                 count = get_Conv_op(count);
3999         }
4000         new_count = create_immediate_or_transform(count, 0);
4001
4002         if (is_ia32_l_ShlD(node)) {
4003                 new_node = new_bd_ia32_ShlD(dbgi, new_block, new_high, new_low,
4004                                             new_count);
4005         } else {
4006                 new_node = new_bd_ia32_ShrD(dbgi, new_block, new_high, new_low,
4007                                             new_count);
4008         }
4009         SET_IA32_ORIG_NODE(new_node, node);
4010
4011         return new_node;
4012 }
4013
4014 static ir_node *gen_ia32_l_ShlD(ir_node *node)
4015 {
4016         ir_node *high  = get_irn_n(node, n_ia32_l_ShlD_val_high);
4017         ir_node *low   = get_irn_n(node, n_ia32_l_ShlD_val_low);
4018         ir_node *count = get_irn_n(node, n_ia32_l_ShlD_count);
4019         return gen_lowered_64bit_shifts(node, high, low, count);
4020 }
4021
4022 static ir_node *gen_ia32_l_ShrD(ir_node *node)
4023 {
4024         ir_node *high  = get_irn_n(node, n_ia32_l_ShrD_val_high);
4025         ir_node *low   = get_irn_n(node, n_ia32_l_ShrD_val_low);
4026         ir_node *count = get_irn_n(node, n_ia32_l_ShrD_count);
4027         return gen_lowered_64bit_shifts(node, high, low, count);
4028 }
4029
4030 static ir_node *gen_ia32_l_LLtoFloat(ir_node *node)
4031 {
4032         ir_node  *src_block    = get_nodes_block(node);
4033         ir_node  *block        = be_transform_node(src_block);
4034         ir_graph *irg          = current_ir_graph;
4035         dbg_info *dbgi         = get_irn_dbg_info(node);
4036         ir_node  *frame        = get_irg_frame(irg);
4037         ir_node  *noreg        = ia32_new_NoReg_gp(env_cg);
4038         ir_node  *nomem        = new_NoMem();
4039         ir_node  *val_low      = get_irn_n(node, n_ia32_l_LLtoFloat_val_low);
4040         ir_node  *val_high     = get_irn_n(node, n_ia32_l_LLtoFloat_val_high);
4041         ir_node  *new_val_low  = be_transform_node(val_low);
4042         ir_node  *new_val_high = be_transform_node(val_high);
4043         ir_node  *in[2];
4044         ir_node  *sync, *fild, *res;
4045         ir_node  *store_low, *store_high;
4046
4047         if (ia32_cg_config.use_sse2) {
4048                 panic("ia32_l_LLtoFloat not implemented for SSE2");
4049         }
4050
4051         /* do a store */
4052         store_low = new_bd_ia32_Store(dbgi, block, frame, noreg, nomem,
4053                                       new_val_low);
4054         store_high = new_bd_ia32_Store(dbgi, block, frame, noreg, nomem,
4055                                        new_val_high);
4056         SET_IA32_ORIG_NODE(store_low,  node);
4057         SET_IA32_ORIG_NODE(store_high, node);
4058
4059         set_ia32_use_frame(store_low);
4060         set_ia32_use_frame(store_high);
4061         set_ia32_op_type(store_low, ia32_AddrModeD);
4062         set_ia32_op_type(store_high, ia32_AddrModeD);
4063         set_ia32_ls_mode(store_low, mode_Iu);
4064         set_ia32_ls_mode(store_high, mode_Is);
4065         add_ia32_am_offs_int(store_high, 4);
4066
4067         in[0] = store_low;
4068         in[1] = store_high;
4069         sync  = new_rd_Sync(dbgi, irg, block, 2, in);
4070
4071         /* do a fild */
4072         fild = new_bd_ia32_vfild(dbgi, block, frame, noreg, sync);
4073
4074         set_ia32_use_frame(fild);
4075         set_ia32_op_type(fild, ia32_AddrModeS);
4076         set_ia32_ls_mode(fild, mode_Ls);
4077
4078         SET_IA32_ORIG_NODE(fild, node);
4079
4080         res = new_r_Proj(irg, block, fild, mode_vfp, pn_ia32_vfild_res);
4081
4082         if (! mode_is_signed(get_irn_mode(val_high))) {
4083                 ia32_address_mode_t  am;
4084
4085                 ir_node *count = create_Immediate(NULL, 0, 31);
4086                 ir_node *fadd;
4087
4088                 am.addr.base          = ia32_new_NoReg_gp(env_cg);
4089                 am.addr.index         = new_bd_ia32_Shr(dbgi, block, new_val_high, count);
4090                 am.addr.mem           = nomem;
4091                 am.addr.offset        = 0;
4092                 am.addr.scale         = 2;
4093                 am.addr.symconst_ent  = ia32_gen_fp_known_const(ia32_ULLBIAS);
4094                 am.addr.use_frame     = 0;
4095                 am.addr.frame_entity  = NULL;
4096                 am.addr.symconst_sign = 0;
4097                 am.ls_mode            = mode_F;
4098                 am.mem_proj           = nomem;
4099                 am.op_type            = ia32_AddrModeS;
4100                 am.new_op1            = res;
4101                 am.new_op2            = ia32_new_NoReg_vfp(env_cg);
4102                 am.pinned             = op_pin_state_floats;
4103                 am.commutative        = 1;
4104                 am.ins_permuted       = 0;
4105
4106                 fadd  = new_bd_ia32_vfadd(dbgi, block, am.addr.base, am.addr.index, am.addr.mem,
4107                         am.new_op1, am.new_op2, get_fpcw());
4108                 set_am_attributes(fadd, &am);
4109
4110                 set_irn_mode(fadd, mode_T);
4111                 res = new_rd_Proj(NULL, irg, block, fadd, mode_vfp, pn_ia32_res);
4112         }
4113         return res;
4114 }
4115
4116 static ir_node *gen_ia32_l_FloattoLL(ir_node *node)
4117 {
4118         ir_node  *src_block  = get_nodes_block(node);
4119         ir_node  *block      = be_transform_node(src_block);
4120         ir_graph *irg        = current_ir_graph;
4121         dbg_info *dbgi       = get_irn_dbg_info(node);
4122         ir_node  *frame      = get_irg_frame(irg);
4123         ir_node  *noreg      = ia32_new_NoReg_gp(env_cg);
4124         ir_node  *nomem      = new_NoMem();
4125         ir_node  *val        = get_irn_n(node, n_ia32_l_FloattoLL_val);
4126         ir_node  *new_val    = be_transform_node(val);
4127         ir_node  *fist, *mem;
4128
4129         mem = gen_vfist(dbgi, irg, block, frame, noreg, nomem, new_val, &fist);
4130         SET_IA32_ORIG_NODE(fist, node);
4131         set_ia32_use_frame(fist);
4132         set_ia32_op_type(fist, ia32_AddrModeD);
4133         set_ia32_ls_mode(fist, mode_Ls);
4134
4135         return mem;
4136 }
4137
4138 /**
4139  * the BAD transformer.
4140  */
4141 static ir_node *bad_transform(ir_node *node)
4142 {
4143         panic("No transform function for %+F available.", node);
4144         return NULL;
4145 }
4146
4147 static ir_node *gen_Proj_l_FloattoLL(ir_node *node)
4148 {
4149         ir_graph *irg      = current_ir_graph;
4150         ir_node  *block    = be_transform_node(get_nodes_block(node));
4151         ir_node  *pred     = get_Proj_pred(node);
4152         ir_node  *new_pred = be_transform_node(pred);
4153         ir_node  *frame    = get_irg_frame(irg);
4154         ir_node  *noreg    = ia32_new_NoReg_gp(env_cg);
4155         dbg_info *dbgi     = get_irn_dbg_info(node);
4156         long      pn       = get_Proj_proj(node);
4157         ir_node  *load;
4158         ir_node  *proj;
4159         ia32_attr_t *attr;
4160
4161         load = new_bd_ia32_Load(dbgi, block, frame, noreg, new_pred);
4162         SET_IA32_ORIG_NODE(load, node);
4163         set_ia32_use_frame(load);
4164         set_ia32_op_type(load, ia32_AddrModeS);
4165         set_ia32_ls_mode(load, mode_Iu);
4166         /* we need a 64bit stackslot (fist stores 64bit) even though we only load
4167          * 32 bit from it with this particular load */
4168         attr = get_ia32_attr(load);
4169         attr->data.need_64bit_stackent = 1;
4170
4171         if (pn == pn_ia32_l_FloattoLL_res_high) {
4172                 add_ia32_am_offs_int(load, 4);
4173         } else {
4174                 assert(pn == pn_ia32_l_FloattoLL_res_low);
4175         }
4176
4177         proj = new_r_Proj(irg, block, load, mode_Iu, pn_ia32_Load_res);
4178
4179         return proj;
4180 }
4181
4182 /**
4183  * Transform the Projs of an AddSP.
4184  */
4185 static ir_node *gen_Proj_be_AddSP(ir_node *node)
4186 {
4187         ir_node  *block    = be_transform_node(get_nodes_block(node));
4188         ir_node  *pred     = get_Proj_pred(node);
4189         ir_node  *new_pred = be_transform_node(pred);
4190         ir_graph *irg      = current_ir_graph;
4191         dbg_info *dbgi     = get_irn_dbg_info(node);
4192         long     proj      = get_Proj_proj(node);
4193
4194         if (proj == pn_be_AddSP_sp) {
4195                 ir_node *res = new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu,
4196                                            pn_ia32_SubSP_stack);
4197                 arch_set_irn_register(res, &ia32_gp_regs[REG_ESP]);
4198                 return res;
4199         } else if (proj == pn_be_AddSP_res) {
4200                 return new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu,
4201                                    pn_ia32_SubSP_addr);
4202         } else if (proj == pn_be_AddSP_M) {
4203                 return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_SubSP_M);
4204         }
4205
4206         panic("No idea how to transform proj->AddSP");
4207 }
4208
4209 /**
4210  * Transform the Projs of a SubSP.
4211  */
4212 static ir_node *gen_Proj_be_SubSP(ir_node *node)
4213 {
4214         ir_node  *block    = be_transform_node(get_nodes_block(node));
4215         ir_node  *pred     = get_Proj_pred(node);
4216         ir_node  *new_pred = be_transform_node(pred);
4217         ir_graph *irg      = current_ir_graph;
4218         dbg_info *dbgi     = get_irn_dbg_info(node);
4219         long     proj      = get_Proj_proj(node);
4220
4221         if (proj == pn_be_SubSP_sp) {
4222                 ir_node *res = new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu,
4223                                            pn_ia32_AddSP_stack);
4224                 arch_set_irn_register(res, &ia32_gp_regs[REG_ESP]);
4225                 return res;
4226         } else if (proj == pn_be_SubSP_M) {
4227                 return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_AddSP_M);
4228         }
4229
4230         panic("No idea how to transform proj->SubSP");
4231 }
4232
4233 /**
4234  * Transform and renumber the Projs from a Load.
4235  */
4236 static ir_node *gen_Proj_Load(ir_node *node)
4237 {
4238         ir_node  *new_pred;
4239         ir_node  *block    = be_transform_node(get_nodes_block(node));
4240         ir_node  *pred     = get_Proj_pred(node);
4241         ir_graph *irg      = current_ir_graph;
4242         dbg_info *dbgi     = get_irn_dbg_info(node);
4243         long     proj      = get_Proj_proj(node);
4244
4245         /* loads might be part of source address mode matches, so we don't
4246          * transform the ProjMs yet (with the exception of loads whose result is
4247          * not used)
4248          */
4249         if (is_Load(pred) && proj == pn_Load_M && get_irn_n_edges(pred) > 1) {
4250                 ir_node *res;
4251
4252                 /* this is needed, because sometimes we have loops that are only
4253                    reachable through the ProjM */
4254                 be_enqueue_preds(node);
4255                 /* do it in 2 steps, to silence firm verifier */
4256                 res = new_rd_Proj(dbgi, irg, block, pred, mode_M, pn_Load_M);
4257                 set_Proj_proj(res, pn_ia32_mem);
4258                 return res;
4259         }
4260
4261         /* renumber the proj */
4262         new_pred = be_transform_node(pred);
4263         if (is_ia32_Load(new_pred)) {
4264                 switch (proj) {
4265                 case pn_Load_res:
4266                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu, pn_ia32_Load_res);
4267                 case pn_Load_M:
4268                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_Load_M);
4269                 case pn_Load_X_regular:
4270                         return new_rd_Jmp(dbgi, irg, block);
4271                 case pn_Load_X_except:
4272                         /* This Load might raise an exception. Mark it. */
4273                         set_ia32_exc_label(new_pred, 1);
4274                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_X, pn_ia32_Load_X_exc);
4275                 default:
4276                         break;
4277                 }
4278         } else if (is_ia32_Conv_I2I(new_pred) ||
4279                    is_ia32_Conv_I2I8Bit(new_pred)) {
4280                 set_irn_mode(new_pred, mode_T);
4281                 if (proj == pn_Load_res) {
4282                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu, pn_ia32_res);
4283                 } else if (proj == pn_Load_M) {
4284                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_mem);
4285                 }
4286         } else if (is_ia32_xLoad(new_pred)) {
4287                 switch (proj) {
4288                 case pn_Load_res:
4289                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_xmm, pn_ia32_xLoad_res);
4290                 case pn_Load_M:
4291                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_xLoad_M);
4292                 case pn_Load_X_regular:
4293                         return new_rd_Jmp(dbgi, irg, block);
4294                 case pn_Load_X_except:
4295                         /* This Load might raise an exception. Mark it. */
4296                         set_ia32_exc_label(new_pred, 1);
4297                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_X, pn_ia32_xLoad_X_exc);
4298                 default:
4299                         break;
4300                 }
4301         } else if (is_ia32_vfld(new_pred)) {
4302                 switch (proj) {
4303                 case pn_Load_res:
4304                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_vfp, pn_ia32_vfld_res);
4305                 case pn_Load_M:
4306                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_vfld_M);
4307                 case pn_Load_X_regular:
4308                         return new_rd_Jmp(dbgi, irg, block);
4309                 case pn_Load_X_except:
4310                         /* This Load might raise an exception. Mark it. */
4311                         set_ia32_exc_label(new_pred, 1);
4312                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_X, pn_ia32_xLoad_X_exc);
4313                 default:
4314                         break;
4315                 }
4316         } else {
4317                 /* can happen for ProJMs when source address mode happened for the
4318                    node */
4319
4320                 /* however it should not be the result proj, as that would mean the
4321                    load had multiple users and should not have been used for
4322                    SourceAM */
4323                 if (proj != pn_Load_M) {
4324                         panic("internal error: transformed node not a Load");
4325                 }
4326                 return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, 1);
4327         }
4328
4329         panic("No idea how to transform proj");
4330 }
4331
4332 /**
4333  * Transform and renumber the Projs from a DivMod like instruction.
4334  */
4335 static ir_node *gen_Proj_DivMod(ir_node *node)
4336 {
4337         ir_node  *block    = be_transform_node(get_nodes_block(node));
4338         ir_node  *pred     = get_Proj_pred(node);
4339         ir_node  *new_pred = be_transform_node(pred);
4340         ir_graph *irg      = current_ir_graph;
4341         dbg_info *dbgi     = get_irn_dbg_info(node);
4342         long     proj      = get_Proj_proj(node);
4343
4344         assert(is_ia32_Div(new_pred) || is_ia32_IDiv(new_pred));
4345
4346         switch (get_irn_opcode(pred)) {
4347         case iro_Div:
4348                 switch (proj) {
4349                 case pn_Div_M:
4350                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_Div_M);
4351                 case pn_Div_res:
4352                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu, pn_ia32_Div_div_res);
4353                 case pn_Div_X_regular:
4354                         return new_rd_Jmp(dbgi, irg, block);
4355                 case pn_Div_X_except:
4356                         set_ia32_exc_label(new_pred, 1);
4357                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_X, pn_ia32_Div_X_exc);
4358                 default:
4359                         break;
4360                 }
4361                 break;
4362         case iro_Mod:
4363                 switch (proj) {
4364                 case pn_Mod_M:
4365                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_Div_M);
4366                 case pn_Mod_res:
4367                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu, pn_ia32_Div_mod_res);
4368                 case pn_Mod_X_except:
4369                         set_ia32_exc_label(new_pred, 1);
4370                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_X, pn_ia32_Div_X_exc);
4371                 default:
4372                         break;
4373                 }
4374                 break;
4375         case iro_DivMod:
4376                 switch (proj) {
4377                 case pn_DivMod_M:
4378                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_Div_M);
4379                 case pn_DivMod_res_div:
4380                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu, pn_ia32_Div_div_res);
4381                 case pn_DivMod_res_mod:
4382                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu, pn_ia32_Div_mod_res);
4383                 case pn_DivMod_X_regular:
4384                         return new_rd_Jmp(dbgi, irg, block);
4385                 case pn_DivMod_X_except:
4386                         set_ia32_exc_label(new_pred, 1);
4387                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_X, pn_ia32_Div_X_exc);
4388                 default:
4389                         break;
4390                 }
4391                 break;
4392         default:
4393                 break;
4394         }
4395
4396         panic("No idea how to transform proj->DivMod");
4397 }
4398
4399 /**
4400  * Transform and renumber the Projs from a CopyB.
4401  */
4402 static ir_node *gen_Proj_CopyB(ir_node *node)
4403 {
4404         ir_node  *block    = be_transform_node(get_nodes_block(node));
4405         ir_node  *pred     = get_Proj_pred(node);
4406         ir_node  *new_pred = be_transform_node(pred);
4407         ir_graph *irg      = current_ir_graph;
4408         dbg_info *dbgi     = get_irn_dbg_info(node);
4409         long     proj      = get_Proj_proj(node);
4410
4411         switch (proj) {
4412         case pn_CopyB_M_regular:
4413                 if (is_ia32_CopyB_i(new_pred)) {
4414                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_CopyB_i_M);
4415                 } else if (is_ia32_CopyB(new_pred)) {
4416                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_CopyB_M);
4417                 }
4418                 break;
4419         default:
4420                 break;
4421         }
4422
4423         panic("No idea how to transform proj->CopyB");
4424 }
4425
4426 /**
4427  * Transform and renumber the Projs from a Quot.
4428  */
4429 static ir_node *gen_Proj_Quot(ir_node *node)
4430 {
4431         ir_node  *block    = be_transform_node(get_nodes_block(node));
4432         ir_node  *pred     = get_Proj_pred(node);
4433         ir_node  *new_pred = be_transform_node(pred);
4434         ir_graph *irg      = current_ir_graph;
4435         dbg_info *dbgi     = get_irn_dbg_info(node);
4436         long     proj      = get_Proj_proj(node);
4437
4438         switch (proj) {
4439         case pn_Quot_M:
4440                 if (is_ia32_xDiv(new_pred)) {
4441                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_xDiv_M);
4442                 } else if (is_ia32_vfdiv(new_pred)) {
4443                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_vfdiv_M);
4444                 }
4445                 break;
4446         case pn_Quot_res:
4447                 if (is_ia32_xDiv(new_pred)) {
4448                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_xmm, pn_ia32_xDiv_res);
4449                 } else if (is_ia32_vfdiv(new_pred)) {
4450                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_vfp, pn_ia32_vfdiv_res);
4451                 }
4452                 break;
4453         case pn_Quot_X_regular:
4454         case pn_Quot_X_except:
4455         default:
4456                 break;
4457         }
4458
4459         panic("No idea how to transform proj->Quot");
4460 }
4461
4462 static ir_node *gen_be_Call(ir_node *node)
4463 {
4464         dbg_info       *const dbgi      = get_irn_dbg_info(node);
4465         ir_graph       *const irg       = current_ir_graph;
4466         ir_node        *const src_block = get_nodes_block(node);
4467         ir_node        *const block     = be_transform_node(src_block);
4468         ir_node        *const src_mem   = get_irn_n(node, be_pos_Call_mem);
4469         ir_node        *const src_sp    = get_irn_n(node, be_pos_Call_sp);
4470         ir_node        *const sp        = be_transform_node(src_sp);
4471         ir_node        *const src_ptr   = get_irn_n(node, be_pos_Call_ptr);
4472         ir_node        *const noreg     = ia32_new_NoReg_gp(env_cg);
4473         ia32_address_mode_t   am;
4474         ia32_address_t *const addr      = &am.addr;
4475         ir_node        *      mem;
4476         ir_node        *      call;
4477         int                   i;
4478         ir_node        *      fpcw;
4479         ir_node        *      eax       = noreg;
4480         ir_node        *      ecx       = noreg;
4481         ir_node        *      edx       = noreg;
4482         unsigned        const pop       = be_Call_get_pop(node);
4483         ir_type        *const call_tp   = be_Call_get_type(node);
4484
4485         /* Run the x87 simulator if the call returns a float value */
4486         if (get_method_n_ress(call_tp) > 0) {
4487                 ir_type *const res_type = get_method_res_type(call_tp, 0);
4488                 ir_mode *const res_mode = get_type_mode(res_type);
4489
4490                 if (res_mode != NULL && mode_is_float(res_mode)) {
4491                         env_cg->do_x87_sim = 1;
4492                 }
4493         }
4494
4495         /* We do not want be_Call direct calls */
4496         assert(be_Call_get_entity(node) == NULL);
4497
4498         match_arguments(&am, src_block, NULL, src_ptr, src_mem,
4499                         match_am | match_immediate);
4500
4501         i    = get_irn_arity(node) - 1;
4502         fpcw = be_transform_node(get_irn_n(node, i--));
4503         for (; i >= be_pos_Call_first_arg; --i) {
4504                 arch_register_req_t const *const req = arch_get_register_req(node, i);
4505                 ir_node *const reg_parm = be_transform_node(get_irn_n(node, i));
4506
4507                 assert(req->type == arch_register_req_type_limited);
4508                 assert(req->cls == &ia32_reg_classes[CLASS_ia32_gp]);
4509
4510                 switch (*req->limited) {
4511                         case 1 << REG_EAX: assert(eax == noreg); eax = reg_parm; break;
4512                         case 1 << REG_ECX: assert(ecx == noreg); ecx = reg_parm; break;
4513                         case 1 << REG_EDX: assert(edx == noreg); edx = reg_parm; break;
4514                         default: panic("Invalid GP register for register parameter");
4515                 }
4516         }
4517
4518         mem  = transform_AM_mem(irg, block, src_ptr, src_mem, addr->mem);
4519         call = new_bd_ia32_Call(dbgi, block, addr->base, addr->index, mem,
4520                                 am.new_op2, sp, fpcw, eax, ecx, edx, pop, call_tp);
4521         set_am_attributes(call, &am);
4522         call = fix_mem_proj(call, &am);
4523
4524         if (get_irn_pinned(node) == op_pin_state_pinned)
4525                 set_irn_pinned(call, op_pin_state_pinned);
4526
4527         SET_IA32_ORIG_NODE(call, node);
4528         return call;
4529 }
4530
4531 static ir_node *gen_be_IncSP(ir_node *node)
4532 {
4533         ir_node *res = be_duplicate_node(node);
4534         arch_irn_add_flags(res, arch_irn_flags_modify_flags);
4535
4536         return res;
4537 }
4538
4539 /**
4540  * Transform the Projs from a be_Call.
4541  */
4542 static ir_node *gen_Proj_be_Call(ir_node *node)
4543 {
4544         ir_node  *block       = be_transform_node(get_nodes_block(node));
4545         ir_node  *call        = get_Proj_pred(node);
4546         ir_node  *new_call    = be_transform_node(call);
4547         ir_graph *irg         = current_ir_graph;
4548         dbg_info *dbgi        = get_irn_dbg_info(node);
4549         ir_type  *method_type = be_Call_get_type(call);
4550         int       n_res       = get_method_n_ress(method_type);
4551         long      proj        = get_Proj_proj(node);
4552         ir_mode  *mode        = get_irn_mode(node);
4553         ir_node  *sse_load;
4554         ir_node  *res;
4555
4556         /* The following is kinda tricky: If we're using SSE, then we have to
4557          * move the result value of the call in floating point registers to an
4558          * xmm register, we therefore construct a GetST0 -> xLoad sequence
4559          * after the call, we have to make sure to correctly make the
4560          * MemProj and the result Proj use these 2 nodes
4561          */
4562         if (proj == pn_be_Call_M_regular) {
4563                 // get new node for result, are we doing the sse load/store hack?
4564                 ir_node *call_res = be_get_Proj_for_pn(call, pn_be_Call_first_res);
4565                 ir_node *call_res_new;
4566                 ir_node *call_res_pred = NULL;
4567
4568                 if (call_res != NULL) {
4569                         call_res_new  = be_transform_node(call_res);
4570                         call_res_pred = get_Proj_pred(call_res_new);
4571                 }
4572
4573                 if (call_res_pred == NULL || is_ia32_Call(call_res_pred)) {
4574                         return new_rd_Proj(dbgi, irg, block, new_call, mode_M,
4575                                            n_ia32_Call_mem);
4576                 } else {
4577                         assert(is_ia32_xLoad(call_res_pred));
4578                         return new_rd_Proj(dbgi, irg, block, call_res_pred, mode_M,
4579                                            pn_ia32_xLoad_M);
4580                 }
4581         }
4582         if (ia32_cg_config.use_sse2 && proj >= pn_be_Call_first_res
4583                         && proj < (pn_be_Call_first_res + n_res) && mode_is_float(mode)) {
4584                 ir_node *fstp;
4585                 ir_node *frame = get_irg_frame(irg);
4586                 ir_node *noreg = ia32_new_NoReg_gp(env_cg);
4587                 //ir_node *p;
4588                 ir_node *call_mem = be_get_Proj_for_pn(call, pn_be_Call_M_regular);
4589                 ir_node *call_res;
4590
4591                 /* in case there is no memory output: create one to serialize the copy
4592                    FPU -> SSE */
4593                 call_mem = new_rd_Proj(dbgi, irg, block, new_call, mode_M,
4594                                        pn_be_Call_M_regular);
4595                 call_res = new_rd_Proj(dbgi, irg, block, new_call, mode,
4596                                        pn_be_Call_first_res);
4597
4598                 /* store st(0) onto stack */
4599                 fstp = new_bd_ia32_vfst(dbgi, block, frame, noreg, call_mem,
4600                                         call_res, mode);
4601                 set_ia32_op_type(fstp, ia32_AddrModeD);
4602                 set_ia32_use_frame(fstp);
4603
4604                 /* load into SSE register */
4605                 sse_load = new_bd_ia32_xLoad(dbgi, block, frame, noreg, fstp, mode);
4606                 set_ia32_op_type(sse_load, ia32_AddrModeS);
4607                 set_ia32_use_frame(sse_load);
4608
4609                 sse_load = new_rd_Proj(dbgi, irg, block, sse_load, mode_xmm,
4610                                        pn_ia32_xLoad_res);
4611
4612                 return sse_load;
4613         }
4614
4615         /* transform call modes */
4616         if (mode_is_data(mode)) {
4617                 const arch_register_class_t *cls = arch_get_irn_reg_class_out(node);
4618                 mode = cls->mode;
4619         }
4620
4621         /* Map from be_Call to ia32_Call proj number */
4622         if (proj == pn_be_Call_sp) {
4623                 proj = pn_ia32_Call_stack;
4624         } else if (proj == pn_be_Call_M_regular) {
4625                 proj = pn_ia32_Call_M;
4626         } else {
4627                 arch_register_req_t const *const req    = arch_get_register_req_out(node);
4628                 int                        const n_outs = arch_irn_get_n_outs(new_call);
4629                 int                              i;
4630
4631                 assert(proj      >= pn_be_Call_first_res);
4632                 assert(req->type & arch_register_req_type_limited);
4633
4634                 for (i = 0; i < n_outs; ++i) {
4635                         arch_register_req_t const *const new_req = get_ia32_out_req(new_call, i);
4636
4637                         if (!(new_req->type & arch_register_req_type_limited) ||
4638                             new_req->cls      != req->cls                     ||
4639                             *new_req->limited != *req->limited)
4640                                 continue;
4641
4642                         proj = i;
4643                         break;
4644                 }
4645                 assert(i < n_outs);
4646         }
4647
4648         res = new_rd_Proj(dbgi, irg, block, new_call, mode, proj);
4649
4650         /* TODO arch_set_irn_register() only operates on Projs, need variant with index */
4651         switch (proj) {
4652                 case pn_ia32_Call_stack:
4653                         arch_set_irn_register(res, &ia32_gp_regs[REG_ESP]);
4654                         break;
4655
4656                 case pn_ia32_Call_fpcw:
4657                         arch_set_irn_register(res, &ia32_fp_cw_regs[REG_FPCW]);
4658                         break;
4659         }
4660
4661         return res;
4662 }
4663
4664 /**
4665  * Transform the Projs from a Cmp.
4666  */
4667 static ir_node *gen_Proj_Cmp(ir_node *node)
4668 {
4669         /* this probably means not all mode_b nodes were lowered... */
4670         panic("trying to directly transform Proj_Cmp %+F (mode_b not lowered?)",
4671               node);
4672 }
4673
4674 /**
4675  * Transform the Projs from a Bound.
4676  */
4677 static ir_node *gen_Proj_Bound(ir_node *node)
4678 {
4679         ir_node *new_node, *block;
4680         ir_node *pred = get_Proj_pred(node);
4681
4682         switch (get_Proj_proj(node)) {
4683         case pn_Bound_M:
4684                 return be_transform_node(get_Bound_mem(pred));
4685         case pn_Bound_X_regular:
4686                 new_node = be_transform_node(pred);
4687                 block    = get_nodes_block(new_node);
4688                 return new_r_Proj(current_ir_graph, block, new_node, mode_X, pn_ia32_Jcc_true);
4689         case pn_Bound_X_except:
4690                 new_node = be_transform_node(pred);
4691                 block    = get_nodes_block(new_node);
4692                 return new_r_Proj(current_ir_graph, block, new_node, mode_X, pn_ia32_Jcc_false);
4693         case pn_Bound_res:
4694                 return be_transform_node(get_Bound_index(pred));
4695         default:
4696                 panic("unsupported Proj from Bound");
4697         }
4698 }
4699
4700 static ir_node *gen_Proj_ASM(ir_node *node)
4701 {
4702         ir_node *pred;
4703         ir_node *new_pred;
4704         ir_node *block;
4705
4706         if (get_irn_mode(node) != mode_M)
4707                 return be_duplicate_node(node);
4708
4709         pred     = get_Proj_pred(node);
4710         new_pred = be_transform_node(pred);
4711         block    = get_nodes_block(new_pred);
4712         return new_r_Proj(current_ir_graph, block, new_pred, mode_M,
4713                         arch_irn_get_n_outs(new_pred) + 1);
4714 }
4715
4716 /**
4717  * Transform and potentially renumber Proj nodes.
4718  */
4719 static ir_node *gen_Proj(ir_node *node)
4720 {
4721         ir_node *pred = get_Proj_pred(node);
4722         long    proj;
4723
4724         switch (get_irn_opcode(pred)) {
4725         case iro_Store:
4726                 proj = get_Proj_proj(node);
4727                 if (proj == pn_Store_M) {
4728                         return be_transform_node(pred);
4729                 } else {
4730                         panic("No idea how to transform proj->Store");
4731                 }
4732         case iro_Load:
4733                 return gen_Proj_Load(node);
4734         case iro_ASM:
4735                 return gen_Proj_ASM(node);
4736         case iro_Div:
4737         case iro_Mod:
4738         case iro_DivMod:
4739                 return gen_Proj_DivMod(node);
4740         case iro_CopyB:
4741                 return gen_Proj_CopyB(node);
4742         case iro_Quot:
4743                 return gen_Proj_Quot(node);
4744         case beo_SubSP:
4745                 return gen_Proj_be_SubSP(node);
4746         case beo_AddSP:
4747                 return gen_Proj_be_AddSP(node);
4748         case beo_Call:
4749                 return gen_Proj_be_Call(node);
4750         case iro_Cmp:
4751                 return gen_Proj_Cmp(node);
4752         case iro_Bound:
4753                 return gen_Proj_Bound(node);
4754         case iro_Start:
4755                 proj = get_Proj_proj(node);
4756                 switch (proj) {
4757                         case pn_Start_X_initial_exec: {
4758                                 ir_node  *block     = get_nodes_block(pred);
4759                                 ir_node  *new_block = be_transform_node(block);
4760                                 dbg_info *dbgi      = get_irn_dbg_info(node);
4761                                 /* we exchange the ProjX with a jump */
4762                                 ir_node  *jump      = new_rd_Jmp(dbgi, current_ir_graph, new_block);
4763
4764                                 return jump;
4765                         }
4766
4767                         case pn_Start_P_tls:
4768                                 return gen_Proj_tls(node);
4769                 }
4770                 break;
4771
4772         default:
4773                 if (is_ia32_l_FloattoLL(pred)) {
4774                         return gen_Proj_l_FloattoLL(node);
4775 #ifdef FIRM_EXT_GRS
4776                 } else if (!is_ia32_irn(pred)) { // Quick hack for SIMD optimization
4777 #else
4778                 } else {
4779 #endif
4780                         ir_mode *mode = get_irn_mode(node);
4781                         if (ia32_mode_needs_gp_reg(mode)) {
4782                                 ir_node *new_pred = be_transform_node(pred);
4783                                 ir_node *block    = be_transform_node(get_nodes_block(node));
4784                                 ir_node *new_proj = new_r_Proj(current_ir_graph, block, new_pred,
4785                                                                                            mode_Iu, get_Proj_proj(node));
4786 #ifdef DEBUG_libfirm
4787                                 new_proj->node_nr = node->node_nr;
4788 #endif
4789                                 return new_proj;
4790                         }
4791                 }
4792         }
4793         return be_duplicate_node(node);
4794 }
4795
4796 /**
4797  * Enters all transform functions into the generic pointer
4798  */
4799 static void register_transformers(void)
4800 {
4801         ir_op *op_Mulh;
4802
4803         /* first clear the generic function pointer for all ops */
4804         clear_irp_opcodes_generic_func();
4805
4806 #define GEN(a)   { be_transform_func *func = gen_##a; op_##a->ops.generic = (op_func) func; }
4807 #define BAD(a)   op_##a->ops.generic = (op_func)bad_transform
4808
4809         GEN(Add);
4810         GEN(Sub);
4811         GEN(Mul);
4812         GEN(And);
4813         GEN(Or);
4814         GEN(Eor);
4815
4816         GEN(Shl);
4817         GEN(Shr);
4818         GEN(Shrs);
4819         GEN(Rotl);
4820
4821         GEN(Quot);
4822
4823         GEN(Div);
4824         GEN(Mod);
4825         GEN(DivMod);
4826
4827         GEN(Minus);
4828         GEN(Conv);
4829         GEN(Abs);
4830         GEN(Not);
4831
4832         GEN(Load);
4833         GEN(Store);
4834         GEN(Cond);
4835
4836         GEN(Cmp);
4837         GEN(ASM);
4838         GEN(CopyB);
4839         GEN(Mux);
4840         GEN(Proj);
4841         GEN(Phi);
4842         GEN(IJmp);
4843         GEN(Bound);
4844
4845         /* transform ops from intrinsic lowering */
4846         GEN(ia32_l_Add);
4847         GEN(ia32_l_Adc);
4848         GEN(ia32_l_Mul);
4849         GEN(ia32_l_IMul);
4850         GEN(ia32_l_ShlDep);
4851         GEN(ia32_l_ShrDep);
4852         GEN(ia32_l_SarDep);
4853         GEN(ia32_l_ShlD);
4854         GEN(ia32_l_ShrD);
4855         GEN(ia32_l_Sub);
4856         GEN(ia32_l_Sbb);
4857         GEN(ia32_l_LLtoFloat);
4858         GEN(ia32_l_FloattoLL);
4859
4860         GEN(Const);
4861         GEN(SymConst);
4862         GEN(Unknown);
4863
4864         /* we should never see these nodes */
4865         BAD(Raise);
4866         BAD(Sel);
4867         BAD(InstOf);
4868         BAD(Cast);
4869         BAD(Free);
4870         BAD(Tuple);
4871         BAD(Id);
4872         //BAD(Bad);
4873         BAD(Confirm);
4874         BAD(Filter);
4875         BAD(CallBegin);
4876         BAD(EndReg);
4877         BAD(EndExcept);
4878
4879         /* handle generic backend nodes */
4880         GEN(be_FrameAddr);
4881         GEN(be_Call);
4882         GEN(be_IncSP);
4883         GEN(be_Return);
4884         GEN(be_AddSP);
4885         GEN(be_SubSP);
4886         GEN(be_Copy);
4887
4888         op_Mulh = get_op_Mulh();
4889         if (op_Mulh)
4890                 GEN(Mulh);
4891
4892 #undef GEN
4893 #undef BAD
4894 }
4895
4896 /**
4897  * Pre-transform all unknown and noreg nodes.
4898  */
4899 static void ia32_pretransform_node(void)
4900 {
4901         ia32_code_gen_t *cg = env_cg;
4902
4903         cg->unknown_gp  = be_pre_transform_node(cg->unknown_gp);
4904         cg->unknown_vfp = be_pre_transform_node(cg->unknown_vfp);
4905         cg->unknown_xmm = be_pre_transform_node(cg->unknown_xmm);
4906         cg->noreg_gp    = be_pre_transform_node(cg->noreg_gp);
4907         cg->noreg_vfp   = be_pre_transform_node(cg->noreg_vfp);
4908         cg->noreg_xmm   = be_pre_transform_node(cg->noreg_xmm);
4909         get_fpcw();
4910 }
4911
4912 /**
4913  * Walker, checks if all ia32 nodes producing more than one result have their
4914  * Projs, otherwise creates new Projs and keeps them using a be_Keep node.
4915  */
4916 static void add_missing_keep_walker(ir_node *node, void *data)
4917 {
4918         int              n_outs, i;
4919         unsigned         found_projs = 0;
4920         const ir_edge_t *edge;
4921         ir_mode         *mode = get_irn_mode(node);
4922         ir_node         *last_keep;
4923         (void) data;
4924         if (mode != mode_T)
4925                 return;
4926         if (!is_ia32_irn(node))
4927                 return;
4928
4929         n_outs = arch_irn_get_n_outs(node);
4930         if (n_outs <= 0)
4931                 return;
4932         if (is_ia32_SwitchJmp(node))
4933                 return;
4934
4935         assert(n_outs < (int) sizeof(unsigned) * 8);
4936         foreach_out_edge(node, edge) {
4937                 ir_node *proj = get_edge_src_irn(edge);
4938                 int      pn;
4939
4940                 /* The node could be kept */
4941                 if (is_End(proj))
4942                         continue;
4943
4944                 if (get_irn_mode(proj) == mode_M)
4945                         continue;
4946
4947                 pn = get_Proj_proj(proj);
4948                 assert(pn < n_outs);
4949                 found_projs |= 1 << pn;
4950         }
4951
4952
4953         /* are keeps missing? */
4954         last_keep = NULL;
4955         for (i = 0; i < n_outs; ++i) {
4956                 ir_node                     *block;
4957                 ir_node                     *in[1];
4958                 const arch_register_req_t   *req;
4959                 const arch_register_class_t *cls;
4960
4961                 if (found_projs & (1 << i)) {
4962                         continue;
4963                 }
4964
4965                 req = get_ia32_out_req(node, i);
4966                 cls = req->cls;
4967                 if (cls == NULL) {
4968                         continue;
4969                 }
4970                 if (cls == &ia32_reg_classes[CLASS_ia32_flags]) {
4971                         continue;
4972                 }
4973
4974                 block = get_nodes_block(node);
4975                 in[0] = new_r_Proj(current_ir_graph, block, node,
4976                                    arch_register_class_mode(cls), i);
4977                 if (last_keep != NULL) {
4978                         be_Keep_add_node(last_keep, cls, in[0]);
4979                 } else {
4980                         last_keep = be_new_Keep(cls, current_ir_graph, block, 1, in);
4981                         if (sched_is_scheduled(node)) {
4982                                 sched_add_after(node, last_keep);
4983                         }
4984                 }
4985         }
4986 }
4987
4988 /**
4989  * Adds missing keeps to nodes. Adds missing Proj nodes for unused outputs
4990  * and keeps them.
4991  */
4992 void ia32_add_missing_keeps(ia32_code_gen_t *cg)
4993 {
4994         ir_graph *irg = be_get_birg_irg(cg->birg);
4995         irg_walk_graph(irg, add_missing_keep_walker, NULL, NULL);
4996 }
4997
4998 /* do the transformation */
4999 void ia32_transform_graph(ia32_code_gen_t *cg)
5000 {
5001         int cse_last;
5002
5003         register_transformers();
5004         env_cg       = cg;
5005         initial_fpcw = NULL;
5006
5007         BE_TIMER_PUSH(t_heights);
5008         heights      = heights_new(cg->irg);
5009         BE_TIMER_POP(t_heights);
5010         ia32_calculate_non_address_mode_nodes(cg->birg);
5011
5012         /* the transform phase is not safe for CSE (yet) because several nodes get
5013          * attributes set after their creation */
5014         cse_last = get_opt_cse();
5015         set_opt_cse(0);
5016
5017         be_transform_graph(cg->birg, ia32_pretransform_node);
5018
5019         set_opt_cse(cse_last);
5020
5021         ia32_free_non_address_mode_nodes();
5022         heights_free(heights);
5023         heights = NULL;
5024 }
5025
5026 void ia32_init_transform(void)
5027 {
5028         FIRM_DBG_REGISTER(dbg, "firm.be.ia32.transform");
5029 }