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