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