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