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