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                         if (mode_is_float(get_irn_mode(get_Cmp_left(pred))))
1954                                 *pnc_out |= ia32_pn_Cmp_float;
1955                         return flags;
1956                 }
1957         }
1958
1959         /* a mode_b value, we have to compare it against 0 */
1960         dbgi      = get_irn_dbg_info(node);
1961         new_block = be_transform_node(get_nodes_block(node));
1962         new_op    = be_transform_node(node);
1963         flags     = new_bd_ia32_Test(dbgi, new_block, noreg_GP, noreg_GP, nomem, new_op,
1964                                      new_op, /*is_permuted=*/0, /*cmp_unsigned=*/0);
1965         *pnc_out  = pn_Cmp_Lg;
1966         return flags;
1967 }
1968
1969 /**
1970  * Transforms a Load.
1971  *
1972  * @return the created ia32 Load node
1973  */
1974 static ir_node *gen_Load(ir_node *node)
1975 {
1976         ir_node  *old_block = get_nodes_block(node);
1977         ir_node  *block   = be_transform_node(old_block);
1978         ir_node  *ptr     = get_Load_ptr(node);
1979         ir_node  *mem     = get_Load_mem(node);
1980         ir_node  *new_mem = be_transform_node(mem);
1981         ir_node  *base;
1982         ir_node  *index;
1983         dbg_info *dbgi    = get_irn_dbg_info(node);
1984         ir_mode  *mode    = get_Load_mode(node);
1985         ir_mode  *res_mode;
1986         ir_node  *new_node;
1987         ia32_address_t addr;
1988
1989         /* construct load address */
1990         memset(&addr, 0, sizeof(addr));
1991         ia32_create_address_mode(&addr, ptr, 0);
1992         base  = addr.base;
1993         index = addr.index;
1994
1995         if (base == NULL) {
1996                 base = noreg_GP;
1997         } else {
1998                 base = be_transform_node(base);
1999         }
2000
2001         if (index == NULL) {
2002                 index = noreg_GP;
2003         } else {
2004                 index = be_transform_node(index);
2005         }
2006
2007         if (mode_is_float(mode)) {
2008                 if (ia32_cg_config.use_sse2) {
2009                         new_node = new_bd_ia32_xLoad(dbgi, block, base, index, new_mem,
2010                                                      mode);
2011                         res_mode = mode_xmm;
2012                 } else {
2013                         new_node = new_bd_ia32_vfld(dbgi, block, base, index, new_mem,
2014                                                     mode);
2015                         res_mode = mode_vfp;
2016                 }
2017         } else {
2018                 assert(mode != mode_b);
2019
2020                 /* create a conv node with address mode for smaller modes */
2021                 if (get_mode_size_bits(mode) < 32) {
2022                         new_node = new_bd_ia32_Conv_I2I(dbgi, block, base, index,
2023                                                         new_mem, noreg_GP, mode);
2024                 } else {
2025                         new_node = new_bd_ia32_Load(dbgi, block, base, index, new_mem);
2026                 }
2027                 res_mode = mode_Iu;
2028         }
2029
2030         set_irn_pinned(new_node, get_irn_pinned(node));
2031         set_ia32_op_type(new_node, ia32_AddrModeS);
2032         set_ia32_ls_mode(new_node, mode);
2033         set_address(new_node, &addr);
2034
2035         if (get_irn_pinned(node) == op_pin_state_floats) {
2036                 assert(pn_ia32_xLoad_res == pn_ia32_vfld_res
2037                                 && pn_ia32_vfld_res == pn_ia32_Load_res
2038                                 && pn_ia32_Load_res == pn_ia32_res);
2039                 arch_irn_add_flags(new_node, arch_irn_flags_rematerializable);
2040         }
2041
2042         SET_IA32_ORIG_NODE(new_node, node);
2043
2044         be_dep_on_frame(new_node);
2045         return new_node;
2046 }
2047
2048 static int use_dest_am(ir_node *block, ir_node *node, ir_node *mem,
2049                        ir_node *ptr, ir_node *other)
2050 {
2051         ir_node *load;
2052
2053         if (!is_Proj(node))
2054                 return 0;
2055
2056         /* we only use address mode if we're the only user of the load */
2057         if (get_irn_n_edges(node) > 1)
2058                 return 0;
2059
2060         load = get_Proj_pred(node);
2061         if (!is_Load(load))
2062                 return 0;
2063         if (get_nodes_block(load) != block)
2064                 return 0;
2065
2066         /* store should have the same pointer as the load */
2067         if (get_Load_ptr(load) != ptr)
2068                 return 0;
2069
2070         /* don't do AM if other node inputs depend on the load (via mem-proj) */
2071         if (other != NULL                   &&
2072             get_nodes_block(other) == block &&
2073             heights_reachable_in_block(heights, other, load)) {
2074                 return 0;
2075         }
2076
2077         if (prevents_AM(block, load, mem))
2078                 return 0;
2079         /* Store should be attached to the load via mem */
2080         assert(heights_reachable_in_block(heights, mem, load));
2081
2082         return 1;
2083 }
2084
2085 static ir_node *dest_am_binop(ir_node *node, ir_node *op1, ir_node *op2,
2086                               ir_node *mem, ir_node *ptr, ir_mode *mode,
2087                               construct_binop_dest_func *func,
2088                               construct_binop_dest_func *func8bit,
2089                                                           match_flags_t flags)
2090 {
2091         ir_node  *src_block = get_nodes_block(node);
2092         ir_node  *block;
2093         dbg_info *dbgi;
2094         ir_node  *new_mem;
2095         ir_node  *new_node;
2096         ir_node  *new_op;
2097         ir_node  *mem_proj;
2098         int       commutative;
2099         ia32_address_mode_t  am;
2100         ia32_address_t      *addr = &am.addr;
2101         memset(&am, 0, sizeof(am));
2102
2103         assert(flags & match_immediate); /* there is no destam node without... */
2104         commutative = (flags & match_commutative) != 0;
2105
2106         if (use_dest_am(src_block, op1, mem, ptr, op2)) {
2107                 build_address(&am, op1, ia32_create_am_double_use);
2108                 new_op = create_immediate_or_transform(op2, 0);
2109         } else if (commutative && use_dest_am(src_block, op2, mem, ptr, op1)) {
2110                 build_address(&am, op2, ia32_create_am_double_use);
2111                 new_op = create_immediate_or_transform(op1, 0);
2112         } else {
2113                 return NULL;
2114         }
2115
2116         if (addr->base == NULL)
2117                 addr->base = noreg_GP;
2118         if (addr->index == NULL)
2119                 addr->index = noreg_GP;
2120         if (addr->mem == NULL)
2121                 addr->mem = nomem;
2122
2123         dbgi    = get_irn_dbg_info(node);
2124         block   = be_transform_node(src_block);
2125         new_mem = transform_AM_mem(block, am.am_node, mem, addr->mem);
2126
2127         if (get_mode_size_bits(mode) == 8) {
2128                 new_node = func8bit(dbgi, block, addr->base, addr->index, new_mem, new_op);
2129         } else {
2130                 new_node = func(dbgi, block, addr->base, addr->index, new_mem, new_op);
2131         }
2132         set_address(new_node, addr);
2133         set_ia32_op_type(new_node, ia32_AddrModeD);
2134         set_ia32_ls_mode(new_node, mode);
2135         SET_IA32_ORIG_NODE(new_node, node);
2136
2137         be_set_transformed_node(get_Proj_pred(am.mem_proj), new_node);
2138         mem_proj = be_transform_node(am.mem_proj);
2139         be_set_transformed_node(mem_proj ? mem_proj : am.mem_proj, new_node);
2140
2141         return new_node;
2142 }
2143
2144 static ir_node *dest_am_unop(ir_node *node, ir_node *op, ir_node *mem,
2145                              ir_node *ptr, ir_mode *mode,
2146                              construct_unop_dest_func *func)
2147 {
2148         ir_node  *src_block = get_nodes_block(node);
2149         ir_node  *block;
2150         dbg_info *dbgi;
2151         ir_node  *new_mem;
2152         ir_node  *new_node;
2153         ir_node  *mem_proj;
2154         ia32_address_mode_t  am;
2155         ia32_address_t *addr = &am.addr;
2156
2157         if (!use_dest_am(src_block, op, mem, ptr, NULL))
2158                 return NULL;
2159
2160         memset(&am, 0, sizeof(am));
2161         build_address(&am, op, ia32_create_am_double_use);
2162
2163         dbgi     = get_irn_dbg_info(node);
2164         block    = be_transform_node(src_block);
2165         new_mem  = transform_AM_mem(block, am.am_node, mem, addr->mem);
2166         new_node = func(dbgi, block, addr->base, addr->index, new_mem);
2167         set_address(new_node, addr);
2168         set_ia32_op_type(new_node, ia32_AddrModeD);
2169         set_ia32_ls_mode(new_node, mode);
2170         SET_IA32_ORIG_NODE(new_node, node);
2171
2172         be_set_transformed_node(get_Proj_pred(am.mem_proj), new_node);
2173         mem_proj = be_transform_node(am.mem_proj);
2174         be_set_transformed_node(mem_proj ? mem_proj : am.mem_proj, new_node);
2175
2176         return new_node;
2177 }
2178
2179 static pn_Cmp ia32_get_negated_pnc(pn_Cmp pnc)
2180 {
2181         ir_mode *mode = pnc & ia32_pn_Cmp_float ? mode_F : mode_Iu;
2182         return get_negated_pnc(pnc, mode);
2183 }
2184
2185 static ir_node *try_create_SetMem(ir_node *node, ir_node *ptr, ir_node *mem)
2186 {
2187         ir_mode        *mode      = get_irn_mode(node);
2188         ir_node        *mux_true  = get_Mux_true(node);
2189         ir_node        *mux_false = get_Mux_false(node);
2190         ir_node        *cond;
2191         ir_node        *new_mem;
2192         dbg_info       *dbgi;
2193         ir_node        *block;
2194         ir_node        *new_block;
2195         ir_node        *flags;
2196         ir_node        *new_node;
2197         bool            negated;
2198         pn_Cmp          pnc;
2199         ia32_address_t  addr;
2200
2201         if (get_mode_size_bits(mode) != 8)
2202                 return NULL;
2203
2204         if (is_Const_1(mux_true) && is_Const_0(mux_false)) {
2205                 negated = false;
2206         } else if (is_Const_0(mux_true) && is_Const_1(mux_false)) {
2207                 negated = true;
2208         } else {
2209                 return NULL;
2210         }
2211
2212         cond  = get_Mux_sel(node);
2213         flags = get_flags_node(cond, &pnc);
2214         /* we can't handle the float special cases with SetM */
2215         if (pnc & ia32_pn_Cmp_float)
2216                 return NULL;
2217         if (negated)
2218                 pnc = ia32_get_negated_pnc(pnc);
2219
2220         build_address_ptr(&addr, ptr, mem);
2221
2222         dbgi      = get_irn_dbg_info(node);
2223         block     = get_nodes_block(node);
2224         new_block = be_transform_node(block);
2225         new_mem   = be_transform_node(mem);
2226         new_node  = new_bd_ia32_SetccMem(dbgi, new_block, addr.base,
2227                                          addr.index, addr.mem, flags, pnc);
2228         set_address(new_node, &addr);
2229         set_ia32_op_type(new_node, ia32_AddrModeD);
2230         set_ia32_ls_mode(new_node, mode);
2231         SET_IA32_ORIG_NODE(new_node, node);
2232
2233         return new_node;
2234 }
2235
2236 static ir_node *try_create_dest_am(ir_node *node)
2237 {
2238         ir_node  *val  = get_Store_value(node);
2239         ir_node  *mem  = get_Store_mem(node);
2240         ir_node  *ptr  = get_Store_ptr(node);
2241         ir_mode  *mode = get_irn_mode(val);
2242         unsigned  bits = get_mode_size_bits(mode);
2243         ir_node  *op1;
2244         ir_node  *op2;
2245         ir_node  *new_node;
2246
2247         /* handle only GP modes for now... */
2248         if (!ia32_mode_needs_gp_reg(mode))
2249                 return NULL;
2250
2251         for (;;) {
2252                 /* store must be the only user of the val node */
2253                 if (get_irn_n_edges(val) > 1)
2254                         return NULL;
2255                 /* skip pointless convs */
2256                 if (is_Conv(val)) {
2257                         ir_node *conv_op   = get_Conv_op(val);
2258                         ir_mode *pred_mode = get_irn_mode(conv_op);
2259                         if (!ia32_mode_needs_gp_reg(pred_mode))
2260                                 break;
2261                         if (pred_mode == mode_b || bits <= get_mode_size_bits(pred_mode)) {
2262                                 val = conv_op;
2263                                 continue;
2264                         }
2265                 }
2266                 break;
2267         }
2268
2269         /* value must be in the same block */
2270         if (get_nodes_block(node) != get_nodes_block(val))
2271                 return NULL;
2272
2273         switch (get_irn_opcode(val)) {
2274         case iro_Add:
2275                 op1      = get_Add_left(val);
2276                 op2      = get_Add_right(val);
2277                 if (ia32_cg_config.use_incdec) {
2278                         if (is_Const_1(op2)) {
2279                                 new_node = dest_am_unop(val, op1, mem, ptr, mode, new_bd_ia32_IncMem);
2280                                 break;
2281                         } else if (is_Const_Minus_1(op2)) {
2282                                 new_node = dest_am_unop(val, op1, mem, ptr, mode, new_bd_ia32_DecMem);
2283                                 break;
2284                         }
2285                 }
2286                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2287                                          new_bd_ia32_AddMem, new_bd_ia32_AddMem8Bit,
2288                                          match_commutative | match_immediate);
2289                 break;
2290         case iro_Sub:
2291                 op1      = get_Sub_left(val);
2292                 op2      = get_Sub_right(val);
2293                 if (is_Const(op2)) {
2294                         ir_fprintf(stderr, "Optimisation warning: not-normalized sub ,C found\n");
2295                 }
2296                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2297                                          new_bd_ia32_SubMem, new_bd_ia32_SubMem8Bit,
2298                                          match_immediate);
2299                 break;
2300         case iro_And:
2301                 op1      = get_And_left(val);
2302                 op2      = get_And_right(val);
2303                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2304                                          new_bd_ia32_AndMem, new_bd_ia32_AndMem8Bit,
2305                                          match_commutative | match_immediate);
2306                 break;
2307         case iro_Or:
2308                 op1      = get_Or_left(val);
2309                 op2      = get_Or_right(val);
2310                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2311                                          new_bd_ia32_OrMem, new_bd_ia32_OrMem8Bit,
2312                                          match_commutative | match_immediate);
2313                 break;
2314         case iro_Eor:
2315                 op1      = get_Eor_left(val);
2316                 op2      = get_Eor_right(val);
2317                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2318                                          new_bd_ia32_XorMem, new_bd_ia32_XorMem8Bit,
2319                                          match_commutative | match_immediate);
2320                 break;
2321         case iro_Shl:
2322                 op1      = get_Shl_left(val);
2323                 op2      = get_Shl_right(val);
2324                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2325                                          new_bd_ia32_ShlMem, new_bd_ia32_ShlMem,
2326                                          match_immediate);
2327                 break;
2328         case iro_Shr:
2329                 op1      = get_Shr_left(val);
2330                 op2      = get_Shr_right(val);
2331                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2332                                          new_bd_ia32_ShrMem, new_bd_ia32_ShrMem,
2333                                          match_immediate);
2334                 break;
2335         case iro_Shrs:
2336                 op1      = get_Shrs_left(val);
2337                 op2      = get_Shrs_right(val);
2338                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2339                                          new_bd_ia32_SarMem, new_bd_ia32_SarMem,
2340                                          match_immediate);
2341                 break;
2342         case iro_Rotl:
2343                 op1      = get_Rotl_left(val);
2344                 op2      = get_Rotl_right(val);
2345                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2346                                          new_bd_ia32_RolMem, new_bd_ia32_RolMem,
2347                                          match_immediate);
2348                 break;
2349         /* TODO: match ROR patterns... */
2350         case iro_Mux:
2351                 new_node = try_create_SetMem(val, ptr, mem);
2352                 break;
2353
2354         case iro_Minus:
2355                 op1      = get_Minus_op(val);
2356                 new_node = dest_am_unop(val, op1, mem, ptr, mode, new_bd_ia32_NegMem);
2357                 break;
2358         case iro_Not:
2359                 /* should be lowered already */
2360                 assert(mode != mode_b);
2361                 op1      = get_Not_op(val);
2362                 new_node = dest_am_unop(val, op1, mem, ptr, mode, new_bd_ia32_NotMem);
2363                 break;
2364         default:
2365                 return NULL;
2366         }
2367
2368         if (new_node != NULL) {
2369                 if (get_irn_pinned(new_node) != op_pin_state_pinned &&
2370                                 get_irn_pinned(node) == op_pin_state_pinned) {
2371                         set_irn_pinned(new_node, op_pin_state_pinned);
2372                 }
2373         }
2374
2375         return new_node;
2376 }
2377
2378 static bool possible_int_mode_for_fp(ir_mode *mode)
2379 {
2380         unsigned size;
2381
2382         if (!mode_is_signed(mode))
2383                 return false;
2384         size = get_mode_size_bits(mode);
2385         if (size != 16 && size != 32)
2386                 return false;
2387         return true;
2388 }
2389
2390 static int is_float_to_int_conv(const ir_node *node)
2391 {
2392         ir_mode  *mode = get_irn_mode(node);
2393         ir_node  *conv_op;
2394         ir_mode  *conv_mode;
2395
2396         if (!possible_int_mode_for_fp(mode))
2397                 return 0;
2398
2399         if (!is_Conv(node))
2400                 return 0;
2401         conv_op   = get_Conv_op(node);
2402         conv_mode = get_irn_mode(conv_op);
2403
2404         if (!mode_is_float(conv_mode))
2405                 return 0;
2406
2407         return 1;
2408 }
2409
2410 /**
2411  * Transform a Store(floatConst) into a sequence of
2412  * integer stores.
2413  *
2414  * @return the created ia32 Store node
2415  */
2416 static ir_node *gen_float_const_Store(ir_node *node, ir_node *cns)
2417 {
2418         ir_mode        *mode      = get_irn_mode(cns);
2419         unsigned        size      = get_mode_size_bytes(mode);
2420         tarval         *tv        = get_Const_tarval(cns);
2421         ir_node        *block     = get_nodes_block(node);
2422         ir_node        *new_block = be_transform_node(block);
2423         ir_node        *ptr       = get_Store_ptr(node);
2424         ir_node        *mem       = get_Store_mem(node);
2425         dbg_info       *dbgi      = get_irn_dbg_info(node);
2426         int             ofs       = 0;
2427         size_t          i         = 0;
2428         ir_node        *ins[4];
2429         ia32_address_t  addr;
2430
2431         assert(size % 4 ==  0);
2432         assert(size     <= 16);
2433
2434         build_address_ptr(&addr, ptr, mem);
2435
2436         do {
2437                 unsigned val =
2438                          get_tarval_sub_bits(tv, ofs)            |
2439                         (get_tarval_sub_bits(tv, ofs + 1) <<  8) |
2440                         (get_tarval_sub_bits(tv, ofs + 2) << 16) |
2441                         (get_tarval_sub_bits(tv, ofs + 3) << 24);
2442                 ir_node *imm = ia32_create_Immediate(NULL, 0, val);
2443
2444                 ir_node *new_node = new_bd_ia32_Store(dbgi, new_block, addr.base,
2445                         addr.index, addr.mem, imm);
2446
2447                 set_irn_pinned(new_node, get_irn_pinned(node));
2448                 set_ia32_op_type(new_node, ia32_AddrModeD);
2449                 set_ia32_ls_mode(new_node, mode_Iu);
2450                 set_address(new_node, &addr);
2451                 SET_IA32_ORIG_NODE(new_node, node);
2452
2453                 assert(i < 4);
2454                 ins[i++] = new_node;
2455
2456                 size        -= 4;
2457                 ofs         += 4;
2458                 addr.offset += 4;
2459         } while (size != 0);
2460
2461         if (i > 1) {
2462                 return new_rd_Sync(dbgi, new_block, i, ins);
2463         } else {
2464                 return ins[0];
2465         }
2466 }
2467
2468 /**
2469  * Generate a vfist or vfisttp instruction.
2470  */
2471 static ir_node *gen_vfist(dbg_info *dbgi, ir_node *block, ir_node *base, ir_node *index,
2472                           ir_node *mem,  ir_node *val, ir_node **fist)
2473 {
2474         ir_node *new_node;
2475
2476         if (ia32_cg_config.use_fisttp) {
2477                 /* Note: fisttp ALWAYS pop the tos. We have to ensure here that the value is copied
2478                 if other users exists */
2479                 ir_node *vfisttp = new_bd_ia32_vfisttp(dbgi, block, base, index, mem, val);
2480                 ir_node *value   = new_r_Proj(block, vfisttp, mode_E, pn_ia32_vfisttp_res);
2481                 be_new_Keep(block, 1, &value);
2482
2483                 new_node = new_r_Proj(block, vfisttp, mode_M, pn_ia32_vfisttp_M);
2484                 *fist    = vfisttp;
2485         } else {
2486                 ir_node *trunc_mode = ia32_new_Fpu_truncate(env_cg);
2487
2488                 /* do a fist */
2489                 new_node = new_bd_ia32_vfist(dbgi, block, base, index, mem, val, trunc_mode);
2490                 *fist    = new_node;
2491         }
2492         return new_node;
2493 }
2494 /**
2495  * Transforms a general (no special case) Store.
2496  *
2497  * @return the created ia32 Store node
2498  */
2499 static ir_node *gen_general_Store(ir_node *node)
2500 {
2501         ir_node  *val       = get_Store_value(node);
2502         ir_mode  *mode      = get_irn_mode(val);
2503         ir_node  *block     = get_nodes_block(node);
2504         ir_node  *new_block = be_transform_node(block);
2505         ir_node  *ptr       = get_Store_ptr(node);
2506         ir_node  *mem       = get_Store_mem(node);
2507         dbg_info *dbgi      = get_irn_dbg_info(node);
2508         ir_node  *new_val, *new_node, *store;
2509         ia32_address_t addr;
2510
2511         /* check for destination address mode */
2512         new_node = try_create_dest_am(node);
2513         if (new_node != NULL)
2514                 return new_node;
2515
2516         /* construct store address */
2517         memset(&addr, 0, sizeof(addr));
2518         ia32_create_address_mode(&addr, ptr, 0);
2519
2520         if (addr.base == NULL) {
2521                 addr.base = noreg_GP;
2522         } else {
2523                 addr.base = be_transform_node(addr.base);
2524         }
2525
2526         if (addr.index == NULL) {
2527                 addr.index = noreg_GP;
2528         } else {
2529                 addr.index = be_transform_node(addr.index);
2530         }
2531         addr.mem = be_transform_node(mem);
2532
2533         if (mode_is_float(mode)) {
2534                 /* Convs (and strict-Convs) before stores are unnecessary if the mode
2535                    is the same. */
2536                 while (is_Conv(val) && mode == get_irn_mode(val)) {
2537                         ir_node *op = get_Conv_op(val);
2538                         if (!mode_is_float(get_irn_mode(op)))
2539                                 break;
2540                         val = op;
2541                 }
2542                 new_val = be_transform_node(val);
2543                 if (ia32_cg_config.use_sse2) {
2544                         new_node = new_bd_ia32_xStore(dbgi, new_block, addr.base,
2545                                                       addr.index, addr.mem, new_val);
2546                 } else {
2547                         new_node = new_bd_ia32_vfst(dbgi, new_block, addr.base,
2548                                                     addr.index, addr.mem, new_val, mode);
2549                 }
2550                 store = new_node;
2551         } else if (!ia32_cg_config.use_sse2 && is_float_to_int_conv(val)) {
2552                 val = get_Conv_op(val);
2553
2554                 /* TODO: is this optimisation still necessary at all (middleend)? */
2555                 /* We can skip ALL float->float up-Convs (and strict-up-Convs) before stores. */
2556                 while (is_Conv(val)) {
2557                         ir_node *op = get_Conv_op(val);
2558                         if (!mode_is_float(get_irn_mode(op)))
2559                                 break;
2560                         if (get_mode_size_bits(get_irn_mode(op)) > get_mode_size_bits(get_irn_mode(val)))
2561                                 break;
2562                         val = op;
2563                 }
2564                 new_val  = be_transform_node(val);
2565                 new_node = gen_vfist(dbgi, new_block, addr.base, addr.index, addr.mem, new_val, &store);
2566         } else {
2567                 new_val = create_immediate_or_transform(val, 0);
2568                 assert(mode != mode_b);
2569
2570                 if (get_mode_size_bits(mode) == 8) {
2571                         new_node = new_bd_ia32_Store8Bit(dbgi, new_block, addr.base,
2572                                                          addr.index, addr.mem, new_val);
2573                 } else {
2574                         new_node = new_bd_ia32_Store(dbgi, new_block, addr.base,
2575                                                      addr.index, addr.mem, new_val);
2576                 }
2577                 store = new_node;
2578         }
2579
2580         set_irn_pinned(store, get_irn_pinned(node));
2581         set_ia32_op_type(store, ia32_AddrModeD);
2582         set_ia32_ls_mode(store, mode);
2583
2584         set_address(store, &addr);
2585         SET_IA32_ORIG_NODE(store, node);
2586
2587         return new_node;
2588 }
2589
2590 /**
2591  * Transforms a Store.
2592  *
2593  * @return the created ia32 Store node
2594  */
2595 static ir_node *gen_Store(ir_node *node)
2596 {
2597         ir_node  *val  = get_Store_value(node);
2598         ir_mode  *mode = get_irn_mode(val);
2599
2600         if (mode_is_float(mode) && is_Const(val)) {
2601                 /* We can transform every floating const store
2602                    into a sequence of integer stores.
2603                    If the constant is already in a register,
2604                    it would be better to use it, but we don't
2605                    have this information here. */
2606                 return gen_float_const_Store(node, val);
2607         }
2608         return gen_general_Store(node);
2609 }
2610
2611 /**
2612  * Transforms a Switch.
2613  *
2614  * @return the created ia32 SwitchJmp node
2615  */
2616 static ir_node *create_Switch(ir_node *node)
2617 {
2618         dbg_info *dbgi       = get_irn_dbg_info(node);
2619         ir_node  *block      = be_transform_node(get_nodes_block(node));
2620         ir_node  *sel        = get_Cond_selector(node);
2621         ir_node  *new_sel    = be_transform_node(sel);
2622         long      switch_min = LONG_MAX;
2623         long      switch_max = LONG_MIN;
2624         long      default_pn = get_Cond_default_proj(node);
2625         ir_node  *new_node;
2626         const ir_edge_t *edge;
2627
2628         assert(get_mode_size_bits(get_irn_mode(sel)) == 32);
2629
2630         /* determine the smallest switch case value */
2631         foreach_out_edge(node, edge) {
2632                 ir_node *proj = get_edge_src_irn(edge);
2633                 long     pn   = get_Proj_proj(proj);
2634                 if (pn == default_pn)
2635                         continue;
2636
2637                 if (pn < switch_min)
2638                         switch_min = pn;
2639                 if (pn > switch_max)
2640                         switch_max = pn;
2641         }
2642
2643         if ((unsigned long) (switch_max - switch_min) > 128000) {
2644                 panic("Size of switch %+F bigger than 128000", node);
2645         }
2646
2647         if (switch_min != 0) {
2648                 /* if smallest switch case is not 0 we need an additional sub */
2649                 new_sel = new_bd_ia32_Lea(dbgi, block, new_sel, noreg_GP);
2650                 add_ia32_am_offs_int(new_sel, -switch_min);
2651                 set_ia32_op_type(new_sel, ia32_AddrModeS);
2652
2653                 SET_IA32_ORIG_NODE(new_sel, node);
2654         }
2655
2656         new_node = new_bd_ia32_SwitchJmp(dbgi, block, new_sel, default_pn);
2657         SET_IA32_ORIG_NODE(new_node, node);
2658
2659         return new_node;
2660 }
2661
2662 /**
2663  * Transform a Cond node.
2664  */
2665 static ir_node *gen_Cond(ir_node *node)
2666 {
2667         ir_node  *block     = get_nodes_block(node);
2668         ir_node  *new_block = be_transform_node(block);
2669         dbg_info *dbgi      = get_irn_dbg_info(node);
2670         ir_node  *sel       = get_Cond_selector(node);
2671         ir_mode  *sel_mode  = get_irn_mode(sel);
2672         ir_node  *flags     = NULL;
2673         ir_node  *new_node;
2674         pn_Cmp    pnc;
2675
2676         if (sel_mode != mode_b) {
2677                 return create_Switch(node);
2678         }
2679
2680         /* we get flags from a Cmp */
2681         flags = get_flags_node(sel, &pnc);
2682
2683         new_node = new_bd_ia32_Jcc(dbgi, new_block, flags, pnc);
2684         SET_IA32_ORIG_NODE(new_node, node);
2685
2686         return new_node;
2687 }
2688
2689 /**
2690  * Transform a be_Copy.
2691  */
2692 static ir_node *gen_be_Copy(ir_node *node)
2693 {
2694         ir_node *new_node = be_duplicate_node(node);
2695         ir_mode *mode     = get_irn_mode(new_node);
2696
2697         if (ia32_mode_needs_gp_reg(mode)) {
2698                 set_irn_mode(new_node, mode_Iu);
2699         }
2700
2701         return new_node;
2702 }
2703
2704 static ir_node *create_Fucom(ir_node *node)
2705 {
2706         dbg_info *dbgi      = get_irn_dbg_info(node);
2707         ir_node  *block     = get_nodes_block(node);
2708         ir_node  *new_block = be_transform_node(block);
2709         ir_node  *left      = get_Cmp_left(node);
2710         ir_node  *new_left  = be_transform_node(left);
2711         ir_node  *right     = get_Cmp_right(node);
2712         ir_node  *new_right;
2713         ir_node  *new_node;
2714
2715         if (ia32_cg_config.use_fucomi) {
2716                 new_right = be_transform_node(right);
2717                 new_node  = new_bd_ia32_vFucomi(dbgi, new_block, new_left,
2718                                                 new_right, 0);
2719                 set_ia32_commutative(new_node);
2720                 SET_IA32_ORIG_NODE(new_node, node);
2721         } else {
2722                 if (ia32_cg_config.use_ftst && is_Const_0(right)) {
2723                         new_node = new_bd_ia32_vFtstFnstsw(dbgi, new_block, new_left, 0);
2724                 } else {
2725                         new_right = be_transform_node(right);
2726                         new_node  = new_bd_ia32_vFucomFnstsw(dbgi, new_block, new_left, new_right, 0);
2727                 }
2728
2729                 set_ia32_commutative(new_node);
2730
2731                 SET_IA32_ORIG_NODE(new_node, node);
2732
2733                 new_node = new_bd_ia32_Sahf(dbgi, new_block, new_node);
2734                 SET_IA32_ORIG_NODE(new_node, node);
2735         }
2736
2737         return new_node;
2738 }
2739
2740 static ir_node *create_Ucomi(ir_node *node)
2741 {
2742         dbg_info *dbgi      = get_irn_dbg_info(node);
2743         ir_node  *src_block = get_nodes_block(node);
2744         ir_node  *new_block = be_transform_node(src_block);
2745         ir_node  *left      = get_Cmp_left(node);
2746         ir_node  *right     = get_Cmp_right(node);
2747         ir_node  *new_node;
2748         ia32_address_mode_t  am;
2749         ia32_address_t      *addr = &am.addr;
2750
2751         match_arguments(&am, src_block, left, right, NULL,
2752                         match_commutative | match_am);
2753
2754         new_node = new_bd_ia32_Ucomi(dbgi, new_block, addr->base, addr->index,
2755                                      addr->mem, am.new_op1, am.new_op2,
2756                                      am.ins_permuted);
2757         set_am_attributes(new_node, &am);
2758
2759         SET_IA32_ORIG_NODE(new_node, node);
2760
2761         new_node = fix_mem_proj(new_node, &am);
2762
2763         return new_node;
2764 }
2765
2766 /**
2767  * helper function: checks whether all Cmp projs are Lg or Eq which is needed
2768  * to fold an and into a test node
2769  */
2770 static bool can_fold_test_and(ir_node *node)
2771 {
2772         const ir_edge_t *edge;
2773
2774         /** we can only have eq and lg projs */
2775         foreach_out_edge(node, edge) {
2776                 ir_node *proj = get_edge_src_irn(edge);
2777                 pn_Cmp   pnc  = get_Proj_proj(proj);
2778                 if (pnc != pn_Cmp_Eq && pnc != pn_Cmp_Lg)
2779                         return false;
2780         }
2781
2782         return true;
2783 }
2784
2785 /**
2786  * returns true if it is assured, that the upper bits of a node are "clean"
2787  * which means for a 16 or 8 bit value, that the upper bits in the register
2788  * are 0 for unsigned and a copy of the last significant bit for signed
2789  * numbers.
2790  */
2791 static bool upper_bits_clean(ir_node *transformed_node, ir_mode *mode)
2792 {
2793         assert(ia32_mode_needs_gp_reg(mode));
2794         if (get_mode_size_bits(mode) >= 32)
2795                 return true;
2796
2797         if (is_Proj(transformed_node))
2798                 return upper_bits_clean(get_Proj_pred(transformed_node), mode);
2799
2800         switch (get_ia32_irn_opcode(transformed_node)) {
2801                 case iro_ia32_Conv_I2I:
2802                 case iro_ia32_Conv_I2I8Bit: {
2803                         ir_mode *smaller_mode = get_ia32_ls_mode(transformed_node);
2804                         if (mode_is_signed(smaller_mode) != mode_is_signed(mode))
2805                                 return false;
2806                         if (get_mode_size_bits(smaller_mode) > get_mode_size_bits(mode))
2807                                 return false;
2808
2809                         return true;
2810                 }
2811
2812                 case iro_ia32_Shr:
2813                         if (mode_is_signed(mode)) {
2814                                 return false; /* TODO handle signed modes */
2815                         } else {
2816                                 ir_node *right = get_irn_n(transformed_node, n_ia32_Shr_count);
2817                                 if (is_ia32_Immediate(right) || is_ia32_Const(right)) {
2818                                         const ia32_immediate_attr_t *attr
2819                                                 = get_ia32_immediate_attr_const(right);
2820                                         if (attr->symconst == 0 &&
2821                                                         (unsigned)attr->offset >= 32 - get_mode_size_bits(mode)) {
2822                                                 return true;
2823                                         }
2824                                 }
2825                                 return upper_bits_clean(get_irn_n(transformed_node, n_ia32_Shr_val), mode);
2826                         }
2827
2828                 case iro_ia32_Sar:
2829                         /* TODO too conservative if shift amount is constant */
2830                         return upper_bits_clean(get_irn_n(transformed_node, n_ia32_Sar_val), mode);
2831
2832                 case iro_ia32_And:
2833                         if (!mode_is_signed(mode)) {
2834                                 return
2835                                         upper_bits_clean(get_irn_n(transformed_node, n_ia32_And_right), mode) ||
2836                                         upper_bits_clean(get_irn_n(transformed_node, n_ia32_And_left),  mode);
2837                         }
2838                         /* TODO if one is known to be zero extended, then || is sufficient */
2839                         /* FALLTHROUGH */
2840                 case iro_ia32_Or:
2841                 case iro_ia32_Xor:
2842                         return
2843                                 upper_bits_clean(get_irn_n(transformed_node, n_ia32_binary_right), mode) &&
2844                                 upper_bits_clean(get_irn_n(transformed_node, n_ia32_binary_left),  mode);
2845
2846                 case iro_ia32_Const:
2847                 case iro_ia32_Immediate: {
2848                         const ia32_immediate_attr_t *attr =
2849                                 get_ia32_immediate_attr_const(transformed_node);
2850                         if (mode_is_signed(mode)) {
2851                                 long shifted = attr->offset >> (get_mode_size_bits(mode) - 1);
2852                                 return shifted == 0 || shifted == -1;
2853                         } else {
2854                                 unsigned long shifted = (unsigned long)attr->offset;
2855                                 shifted >>= get_mode_size_bits(mode);
2856                                 return shifted == 0;
2857                         }
2858                 }
2859
2860                 default:
2861                         return false;
2862         }
2863 }
2864
2865 /**
2866  * Generate code for a Cmp.
2867  */
2868 static ir_node *gen_Cmp(ir_node *node)
2869 {
2870         dbg_info *dbgi      = get_irn_dbg_info(node);
2871         ir_node  *block     = get_nodes_block(node);
2872         ir_node  *new_block = be_transform_node(block);
2873         ir_node  *left      = get_Cmp_left(node);
2874         ir_node  *right     = get_Cmp_right(node);
2875         ir_mode  *cmp_mode  = get_irn_mode(left);
2876         ir_node  *new_node;
2877         ia32_address_mode_t  am;
2878         ia32_address_t      *addr = &am.addr;
2879         int                  cmp_unsigned;
2880
2881         if (mode_is_float(cmp_mode)) {
2882                 if (ia32_cg_config.use_sse2) {
2883                         return create_Ucomi(node);
2884                 } else {
2885                         return create_Fucom(node);
2886                 }
2887         }
2888
2889         assert(ia32_mode_needs_gp_reg(cmp_mode));
2890
2891         /* Prefer the Test instruction, when encountering (x & y) ==/!= 0 */
2892         cmp_unsigned = !mode_is_signed(cmp_mode);
2893         if (is_Const_0(right)          &&
2894             is_And(left)               &&
2895             get_irn_n_edges(left) == 1 &&
2896             can_fold_test_and(node)) {
2897                 /* Test(and_left, and_right) */
2898                 ir_node *and_left  = get_And_left(left);
2899                 ir_node *and_right = get_And_right(left);
2900
2901                 /* matze: code here used mode instead of cmd_mode, I think it is always
2902                  * the same as cmp_mode, but I leave this here to see if this is really
2903                  * true...
2904                  */
2905                 assert(get_irn_mode(and_left) == cmp_mode);
2906
2907                 match_arguments(&am, block, and_left, and_right, NULL,
2908                                                                                 match_commutative |
2909                                                                                 match_am | match_8bit_am | match_16bit_am |
2910                                                                                 match_am_and_immediates | match_immediate);
2911
2912                 /* use 32bit compare mode if possible since the opcode is smaller */
2913                 if (upper_bits_clean(am.new_op1, cmp_mode) &&
2914                     upper_bits_clean(am.new_op2, cmp_mode)) {
2915                         cmp_mode = mode_is_signed(cmp_mode) ? mode_Is : mode_Iu;
2916                 }
2917
2918                 if (get_mode_size_bits(cmp_mode) == 8) {
2919                         new_node = new_bd_ia32_Test8Bit(dbgi, new_block, addr->base,
2920                                         addr->index, addr->mem, am.new_op1, am.new_op2, am.ins_permuted,
2921                                         cmp_unsigned);
2922                 } else {
2923                         new_node = new_bd_ia32_Test(dbgi, new_block, addr->base, addr->index,
2924                                         addr->mem, am.new_op1, am.new_op2, am.ins_permuted, cmp_unsigned);
2925                 }
2926         } else {
2927                 /* Cmp(left, right) */
2928                 match_arguments(&am, block, left, right, NULL,
2929                                 match_commutative | match_am | match_8bit_am |
2930                                 match_16bit_am | match_am_and_immediates |
2931                                 match_immediate);
2932                 /* use 32bit compare mode if possible since the opcode is smaller */
2933                 if (upper_bits_clean(am.new_op1, cmp_mode) &&
2934                     upper_bits_clean(am.new_op2, cmp_mode)) {
2935                         cmp_mode = mode_is_signed(cmp_mode) ? mode_Is : mode_Iu;
2936                 }
2937
2938                 if (get_mode_size_bits(cmp_mode) == 8) {
2939                         new_node = new_bd_ia32_Cmp8Bit(dbgi, new_block, addr->base,
2940                                                        addr->index, addr->mem, am.new_op1,
2941                                                        am.new_op2, am.ins_permuted,
2942                                                        cmp_unsigned);
2943                 } else {
2944                         new_node = new_bd_ia32_Cmp(dbgi, new_block, addr->base, addr->index,
2945                                         addr->mem, am.new_op1, am.new_op2, am.ins_permuted, cmp_unsigned);
2946                 }
2947         }
2948         set_am_attributes(new_node, &am);
2949         set_ia32_ls_mode(new_node, cmp_mode);
2950
2951         SET_IA32_ORIG_NODE(new_node, node);
2952
2953         new_node = fix_mem_proj(new_node, &am);
2954
2955         return new_node;
2956 }
2957
2958 static ir_node *create_CMov(ir_node *node, ir_node *flags, ir_node *new_flags,
2959                             pn_Cmp pnc)
2960 {
2961         dbg_info            *dbgi          = get_irn_dbg_info(node);
2962         ir_node             *block         = get_nodes_block(node);
2963         ir_node             *new_block     = be_transform_node(block);
2964         ir_node             *val_true      = get_Mux_true(node);
2965         ir_node             *val_false     = get_Mux_false(node);
2966         ir_node             *new_node;
2967         ia32_address_mode_t  am;
2968         ia32_address_t      *addr;
2969
2970         assert(ia32_cg_config.use_cmov);
2971         assert(ia32_mode_needs_gp_reg(get_irn_mode(val_true)));
2972
2973         addr = &am.addr;
2974
2975         match_arguments(&am, block, val_false, val_true, flags,
2976                         match_commutative | match_am | match_16bit_am | match_mode_neutral);
2977
2978         if (am.ins_permuted)
2979                 pnc = ia32_get_negated_pnc(pnc);
2980
2981         new_node = new_bd_ia32_CMovcc(dbgi, new_block, addr->base, addr->index,
2982                                       addr->mem, am.new_op1, am.new_op2, new_flags,
2983                                       pnc);
2984         set_am_attributes(new_node, &am);
2985
2986         SET_IA32_ORIG_NODE(new_node, node);
2987
2988         new_node = fix_mem_proj(new_node, &am);
2989
2990         return new_node;
2991 }
2992
2993 /**
2994  * Creates a ia32 Setcc instruction.
2995  */
2996 static ir_node *create_set_32bit(dbg_info *dbgi, ir_node *new_block,
2997                                  ir_node *flags, pn_Cmp pnc,
2998                                  ir_node *orig_node)
2999 {
3000         ir_mode *mode  = get_irn_mode(orig_node);
3001         ir_node *new_node;
3002
3003         new_node = new_bd_ia32_Setcc(dbgi, new_block, flags, pnc);
3004         SET_IA32_ORIG_NODE(new_node, orig_node);
3005
3006         /* we might need to conv the result up */
3007         if (get_mode_size_bits(mode) > 8) {
3008                 new_node = new_bd_ia32_Conv_I2I8Bit(dbgi, new_block, noreg_GP, noreg_GP,
3009                                                     nomem, new_node, mode_Bu);
3010                 SET_IA32_ORIG_NODE(new_node, orig_node);
3011         }
3012
3013         return new_node;
3014 }
3015
3016 /**
3017  * Create instruction for an unsigned Difference or Zero.
3018  */
3019 static ir_node *create_doz(ir_node *psi, ir_node *a, ir_node *b)
3020 {
3021         ir_mode *mode  = get_irn_mode(psi);
3022         ir_node *new_node;
3023         ir_node *sub;
3024         ir_node *sbb;
3025         ir_node *not;
3026         ir_node *eflags;
3027         ir_node *block;
3028
3029         dbg_info *dbgi;
3030
3031         new_node = gen_binop(psi, a, b, new_bd_ia32_Sub,
3032                 match_mode_neutral | match_am | match_immediate | match_two_users);
3033
3034         block = get_nodes_block(new_node);
3035
3036         if (is_Proj(new_node)) {
3037                 sub = get_Proj_pred(new_node);
3038                 assert(is_ia32_Sub(sub));
3039         } else {
3040                 sub = new_node;
3041                 set_irn_mode(sub, mode_T);
3042                 new_node = new_rd_Proj(NULL, block, sub, mode, pn_ia32_res);
3043         }
3044         eflags = new_rd_Proj(NULL, block, sub, mode_Iu, pn_ia32_Sub_flags);
3045
3046         dbgi   = get_irn_dbg_info(psi);
3047         sbb    = new_bd_ia32_Sbb0(dbgi, block, eflags);
3048         not    = new_bd_ia32_Not(dbgi, block, sbb);
3049
3050         new_node = new_bd_ia32_And(dbgi, block, noreg_GP, noreg_GP, nomem, new_node, not);
3051         set_ia32_commutative(new_node);
3052         return new_node;
3053 }
3054
3055 /**
3056  * Create an const array of two float consts.
3057  *
3058  * @param c0        the first constant
3059  * @param c1        the second constant
3060  * @param new_mode  IN/OUT for the mode of the constants, if NULL
3061  *                  smallest possible mode will be used
3062  */
3063 static ir_entity *ia32_create_const_array(ir_node *c0, ir_node *c1, ir_mode **new_mode) {
3064         ir_entity        *ent;
3065         ir_mode          *mode = *new_mode;
3066         ir_type          *tp;
3067         ir_initializer_t *initializer;
3068         tarval           *tv0 = get_Const_tarval(c0);
3069         tarval           *tv1 = get_Const_tarval(c1);
3070
3071         if (mode == NULL) {
3072                 /* detect the best mode for the constants */
3073                 mode = get_tarval_mode(tv0);
3074
3075                 if (mode != mode_F) {
3076                         if (tarval_ieee754_can_conv_lossless(tv0, mode_F) &&
3077                             tarval_ieee754_can_conv_lossless(tv1, mode_F)) {
3078                                 mode = mode_F;
3079                                 tv0 = tarval_convert_to(tv0, mode);
3080                                 tv1 = tarval_convert_to(tv1, mode);
3081                         } else if (mode != mode_D) {
3082                                 if (tarval_ieee754_can_conv_lossless(tv0, mode_D) &&
3083                                     tarval_ieee754_can_conv_lossless(tv1, mode_D)) {
3084                                         mode = mode_D;
3085                                         tv0 = tarval_convert_to(tv0, mode);
3086                                         tv1 = tarval_convert_to(tv1, mode);
3087                                 }
3088                         }
3089                 }
3090
3091         }
3092
3093         tp = ia32_create_float_type(mode, 4);
3094         tp = ia32_create_float_array(tp);
3095
3096         ent = new_entity(get_glob_type(), ia32_unique_id(".LC%u"), tp);
3097
3098         set_entity_ld_ident(ent, get_entity_ident(ent));
3099         set_entity_visibility(ent, visibility_local);
3100         set_entity_variability(ent, variability_constant);
3101         set_entity_allocation(ent, allocation_static);
3102
3103         initializer = create_initializer_compound(2);
3104
3105         set_initializer_compound_value(initializer, 0, create_initializer_tarval(tv0));
3106         set_initializer_compound_value(initializer, 1, create_initializer_tarval(tv1));
3107
3108         set_entity_initializer(ent, initializer);
3109
3110         *new_mode = mode;
3111         return ent;
3112 }
3113
3114 /**
3115  * Transforms a Mux node into some code sequence.
3116  *
3117  * @return The transformed node.
3118  */
3119 static ir_node *gen_Mux(ir_node *node)
3120 {
3121         dbg_info *dbgi        = get_irn_dbg_info(node);
3122         ir_node  *block       = get_nodes_block(node);
3123         ir_node  *new_block   = be_transform_node(block);
3124         ir_node  *mux_true    = get_Mux_true(node);
3125         ir_node  *mux_false   = get_Mux_false(node);
3126         ir_node  *cond        = get_Mux_sel(node);
3127         ir_mode  *mode        = get_irn_mode(node);
3128         ir_node  *flags;
3129         ir_node  *new_node;
3130         pn_Cmp   pnc;
3131
3132         assert(get_irn_mode(cond) == mode_b);
3133
3134         /* Note: a Mux node uses a Load two times IFF it's used in the compare AND in the result */
3135         if (mode_is_float(mode)) {
3136                 ir_node  *cmp         = get_Proj_pred(cond);
3137                 ir_node  *cmp_left    = get_Cmp_left(cmp);
3138                 ir_node  *cmp_right   = get_Cmp_right(cmp);
3139                 pn_Cmp   pnc          = get_Proj_proj(cond);
3140
3141                 if (ia32_cg_config.use_sse2) {
3142                         if (pnc == pn_Cmp_Lt || pnc == pn_Cmp_Le) {
3143                                 if (cmp_left == mux_true && cmp_right == mux_false) {
3144                                         /* Mux(a <= b, a, b) => MIN */
3145                                         return gen_binop(node, cmp_left, cmp_right, new_bd_ia32_xMin,
3146                                          match_commutative | match_am | match_two_users);
3147                                 } else if (cmp_left == mux_false && cmp_right == mux_true) {
3148                                         /* Mux(a <= b, b, a) => MAX */
3149                                         return gen_binop(node, cmp_left, cmp_right, new_bd_ia32_xMax,
3150                                          match_commutative | match_am | match_two_users);
3151                                 }
3152                         } else if (pnc == pn_Cmp_Gt || pnc == pn_Cmp_Ge) {
3153                                 if (cmp_left == mux_true && cmp_right == mux_false) {
3154                                         /* Mux(a >= b, a, b) => MAX */
3155                                         return gen_binop(node, cmp_left, cmp_right, new_bd_ia32_xMax,
3156                                          match_commutative | match_am | match_two_users);
3157                                 } else if (cmp_left == mux_false && cmp_right == mux_true) {
3158                                         /* Mux(a >= b, b, a) => MIN */
3159                                         return gen_binop(node, cmp_left, cmp_right, new_bd_ia32_xMin,
3160                                          match_commutative | match_am | match_two_users);
3161                                 }
3162                         }
3163                 }
3164
3165                 if (is_Const(mux_true) && is_Const(mux_false)) {
3166                         ia32_address_mode_t am;
3167                         ir_node             *load;
3168                         ir_mode             *new_mode;
3169                         unsigned            scale;
3170
3171                         flags    = get_flags_node(cond, &pnc);
3172                         new_node = create_set_32bit(dbgi, new_block, flags, pnc, node);
3173
3174                         if (ia32_cg_config.use_sse2) {
3175                                 /* cannot load from different mode on SSE */
3176                                 new_mode = mode;
3177                         } else {
3178                                 /* x87 can load any mode */
3179                                 new_mode = NULL;
3180                         }
3181
3182                         am.addr.symconst_ent = ia32_create_const_array(mux_false, mux_true, &new_mode);
3183
3184                         switch (get_mode_size_bytes(new_mode)) {
3185                         case 4:
3186                                 scale = 2;
3187                                 break;
3188                         case 8:
3189                                 scale = 3;
3190                                 break;
3191                         case 10:
3192                                 /* use 2 * 5 */
3193                                 scale = 1;
3194                                 new_node = new_bd_ia32_Lea(dbgi, new_block, new_node, new_node);
3195                                 set_ia32_am_scale(new_node, 2);
3196                                 break;
3197                         case 12:
3198                                 /* use 4 * 3 */
3199                                 scale = 2;
3200                                 new_node = new_bd_ia32_Lea(dbgi, new_block, new_node, new_node);
3201                                 set_ia32_am_scale(new_node, 1);
3202                                 break;
3203                         case 16:
3204                                 /* arg, shift 16 NOT supported */
3205                                 scale = 3;
3206                                 new_node = new_bd_ia32_Add(dbgi, new_block, noreg_GP, noreg_GP, nomem, new_node, new_node);
3207                                 break;
3208                         default:
3209                                 panic("Unsupported constant size");
3210                         }
3211
3212                         am.ls_mode            = new_mode;
3213                         am.addr.base          = noreg_GP;
3214                         am.addr.index         = new_node;
3215                         am.addr.mem           = nomem;
3216                         am.addr.offset        = 0;
3217                         am.addr.scale         = scale;
3218                         am.addr.use_frame     = 0;
3219                         am.addr.frame_entity  = NULL;
3220                         am.addr.symconst_sign = 0;
3221                         am.mem_proj           = am.addr.mem;
3222                         am.op_type            = ia32_AddrModeS;
3223                         am.new_op1            = NULL;
3224                         am.new_op2            = NULL;
3225                         am.pinned             = op_pin_state_floats;
3226                         am.commutative        = 1;
3227                         am.ins_permuted       = 0;
3228
3229                         if (ia32_cg_config.use_sse2)
3230                                 load = new_bd_ia32_xLoad(dbgi, block, am.addr.base, am.addr.index, am.addr.mem, new_mode);
3231                         else
3232                                 load = new_bd_ia32_vfld(dbgi, block, am.addr.base, am.addr.index, am.addr.mem, new_mode);
3233                         set_am_attributes(load, &am);
3234
3235                         return new_rd_Proj(NULL, block, load, mode_vfp, pn_ia32_res);
3236                 }
3237                 panic("cannot transform floating point Mux");
3238
3239         } else {
3240                 assert(ia32_mode_needs_gp_reg(mode));
3241
3242                 if (is_Proj(cond)) {
3243                         ir_node *cmp = get_Proj_pred(cond);
3244                         if (is_Cmp(cmp)) {
3245                                 ir_node  *cmp_left    = get_Cmp_left(cmp);
3246                                 ir_node  *cmp_right   = get_Cmp_right(cmp);
3247                                 pn_Cmp   pnc          = get_Proj_proj(cond);
3248
3249                                 /* check for unsigned Doz first */
3250                                 if ((pnc & pn_Cmp_Gt) && !mode_is_signed(mode) &&
3251                                         is_Const_0(mux_false) && is_Sub(mux_true) &&
3252                                         get_Sub_left(mux_true) == cmp_left && get_Sub_right(mux_true) == cmp_right) {
3253                                         /* Mux(a >=u b, a - b, 0) unsigned Doz */
3254                                         return create_doz(node, cmp_left, cmp_right);
3255                                 } else if ((pnc & pn_Cmp_Lt) && !mode_is_signed(mode) &&
3256                                         is_Const_0(mux_true) && is_Sub(mux_false) &&
3257                                         get_Sub_left(mux_false) == cmp_left && get_Sub_right(mux_false) == cmp_right) {
3258                                         /* Mux(a <=u b, 0, a - b) unsigned Doz */
3259                                         return create_doz(node, cmp_left, cmp_right);
3260                                 }
3261                         }
3262                 }
3263
3264                 flags = get_flags_node(cond, &pnc);
3265
3266                 if (is_Const(mux_true) && is_Const(mux_false)) {
3267                         /* both are const, good */
3268                         if (is_Const_1(mux_true) && is_Const_0(mux_false)) {
3269                                 new_node = create_set_32bit(dbgi, new_block, flags, pnc, node);
3270                         } else if (is_Const_0(mux_true) && is_Const_1(mux_false)) {
3271                                 pnc = ia32_get_negated_pnc(pnc);
3272                                 new_node = create_set_32bit(dbgi, new_block, flags, pnc, node);
3273                         } else {
3274                                 /* Not that simple. */
3275                                 goto need_cmov;
3276                         }
3277                 } else {
3278 need_cmov:
3279                         new_node = create_CMov(node, cond, flags, pnc);
3280                 }
3281                 return new_node;
3282         }
3283 }
3284
3285
3286 /**
3287  * Create a conversion from x87 state register to general purpose.
3288  */
3289 static ir_node *gen_x87_fp_to_gp(ir_node *node)
3290 {
3291         ir_node         *block      = be_transform_node(get_nodes_block(node));
3292         ir_node         *op         = get_Conv_op(node);
3293         ir_node         *new_op     = be_transform_node(op);
3294         ir_graph        *irg        = current_ir_graph;
3295         dbg_info        *dbgi       = get_irn_dbg_info(node);
3296         ir_mode         *mode       = get_irn_mode(node);
3297         ir_node         *fist, *load, *mem;
3298
3299         mem = gen_vfist(dbgi, block, get_irg_frame(irg), noreg_GP, nomem, new_op, &fist);
3300         set_irn_pinned(fist, op_pin_state_floats);
3301         set_ia32_use_frame(fist);
3302         set_ia32_op_type(fist, ia32_AddrModeD);
3303
3304         assert(get_mode_size_bits(mode) <= 32);
3305         /* exception we can only store signed 32 bit integers, so for unsigned
3306            we store a 64bit (signed) integer and load the lower bits */
3307         if (get_mode_size_bits(mode) == 32 && !mode_is_signed(mode)) {
3308                 set_ia32_ls_mode(fist, mode_Ls);
3309         } else {
3310                 set_ia32_ls_mode(fist, mode_Is);
3311         }
3312         SET_IA32_ORIG_NODE(fist, node);
3313
3314         /* do a Load */
3315         load = new_bd_ia32_Load(dbgi, block, get_irg_frame(irg), noreg_GP, mem);
3316
3317         set_irn_pinned(load, op_pin_state_floats);
3318         set_ia32_use_frame(load);
3319         set_ia32_op_type(load, ia32_AddrModeS);
3320         set_ia32_ls_mode(load, mode_Is);
3321         if (get_ia32_ls_mode(fist) == mode_Ls) {
3322                 ia32_attr_t *attr = get_ia32_attr(load);
3323                 attr->data.need_64bit_stackent = 1;
3324         } else {
3325                 ia32_attr_t *attr = get_ia32_attr(load);
3326                 attr->data.need_32bit_stackent = 1;
3327         }
3328         SET_IA32_ORIG_NODE(load, node);
3329
3330         return new_r_Proj(block, load, mode_Iu, pn_ia32_Load_res);
3331 }
3332
3333 /**
3334  * Creates a x87 strict Conv by placing a Store and a Load
3335  */
3336 static ir_node *gen_x87_strict_conv(ir_mode *tgt_mode, ir_node *node)
3337 {
3338         ir_node  *block    = get_nodes_block(node);
3339         ir_graph *irg      = get_Block_irg(block);
3340         dbg_info *dbgi     = get_irn_dbg_info(node);
3341         ir_node  *frame    = get_irg_frame(irg);
3342         ir_node  *store, *load;
3343         ir_node  *new_node;
3344
3345         store = new_bd_ia32_vfst(dbgi, block, frame, noreg_GP, nomem, node, tgt_mode);
3346         set_ia32_use_frame(store);
3347         set_ia32_op_type(store, ia32_AddrModeD);
3348         SET_IA32_ORIG_NODE(store, node);
3349
3350         load = new_bd_ia32_vfld(dbgi, block, frame, noreg_GP, store, tgt_mode);
3351         set_ia32_use_frame(load);
3352         set_ia32_op_type(load, ia32_AddrModeS);
3353         SET_IA32_ORIG_NODE(load, node);
3354
3355         new_node = new_r_Proj(block, load, mode_E, pn_ia32_vfld_res);
3356         return new_node;
3357 }
3358
3359 static ir_node *create_Conv_I2I(dbg_info *dbgi, ir_node *block, ir_node *base,
3360                 ir_node *index, ir_node *mem, ir_node *val, ir_mode *mode)
3361 {
3362         ir_node *(*func)(dbg_info*, ir_node*, ir_node*, ir_node*, ir_node*, ir_node*, ir_mode*);
3363
3364         func = get_mode_size_bits(mode) == 8 ?
3365                 new_bd_ia32_Conv_I2I8Bit : new_bd_ia32_Conv_I2I;
3366         return func(dbgi, block, base, index, mem, val, mode);
3367 }
3368
3369 /**
3370  * Create a conversion from general purpose to x87 register
3371  */
3372 static ir_node *gen_x87_gp_to_fp(ir_node *node, ir_mode *src_mode)
3373 {
3374         ir_node  *src_block = get_nodes_block(node);
3375         ir_node  *block     = be_transform_node(src_block);
3376         ir_graph *irg       = get_Block_irg(block);
3377         dbg_info *dbgi      = get_irn_dbg_info(node);
3378         ir_node  *op        = get_Conv_op(node);
3379         ir_node  *new_op    = NULL;
3380         ir_mode  *mode;
3381         ir_mode  *store_mode;
3382         ir_node  *fild;
3383         ir_node  *store;
3384         ir_node  *new_node;
3385
3386         /* fild can use source AM if the operand is a signed 16bit or 32bit integer */
3387         if (possible_int_mode_for_fp(src_mode)) {
3388                 ia32_address_mode_t am;
3389
3390                 match_arguments(&am, src_block, NULL, op, NULL, match_am | match_try_am | match_16bit_am);
3391                 if (am.op_type == ia32_AddrModeS) {
3392                         ia32_address_t *addr = &am.addr;
3393
3394                         fild     = new_bd_ia32_vfild(dbgi, block, addr->base, addr->index, addr->mem);
3395                         new_node = new_r_Proj(block, fild, mode_vfp, pn_ia32_vfild_res);
3396
3397                         set_am_attributes(fild, &am);
3398                         SET_IA32_ORIG_NODE(fild, node);
3399
3400                         fix_mem_proj(fild, &am);
3401
3402                         return new_node;
3403                 }
3404         }
3405         if (new_op == NULL) {
3406                 new_op = be_transform_node(op);
3407         }
3408
3409         mode = get_irn_mode(op);
3410
3411         /* first convert to 32 bit signed if necessary */
3412         if (get_mode_size_bits(src_mode) < 32) {
3413                 if (!upper_bits_clean(new_op, src_mode)) {
3414                         new_op = create_Conv_I2I(dbgi, block, noreg_GP, noreg_GP, nomem, new_op, src_mode);
3415                         SET_IA32_ORIG_NODE(new_op, node);
3416                 }
3417                 mode = mode_Is;
3418         }
3419
3420         assert(get_mode_size_bits(mode) == 32);
3421
3422         /* do a store */
3423         store = new_bd_ia32_Store(dbgi, block, get_irg_frame(irg), noreg_GP, nomem, new_op);
3424
3425         set_ia32_use_frame(store);
3426         set_ia32_op_type(store, ia32_AddrModeD);
3427         set_ia32_ls_mode(store, mode_Iu);
3428
3429         /* exception for 32bit unsigned, do a 64bit spill+load */
3430         if (!mode_is_signed(mode)) {
3431                 ir_node *in[2];
3432                 /* store a zero */
3433                 ir_node *zero_const = ia32_create_Immediate(NULL, 0, 0);
3434
3435                 ir_node *zero_store = new_bd_ia32_Store(dbgi, block, get_irg_frame(irg),
3436                                                         noreg_GP, nomem, zero_const);
3437
3438                 set_ia32_use_frame(zero_store);
3439                 set_ia32_op_type(zero_store, ia32_AddrModeD);
3440                 add_ia32_am_offs_int(zero_store, 4);
3441                 set_ia32_ls_mode(zero_store, mode_Iu);
3442
3443                 in[0] = zero_store;
3444                 in[1] = store;
3445
3446                 store      = new_rd_Sync(dbgi, block, 2, in);
3447                 store_mode = mode_Ls;
3448         } else {
3449                 store_mode = mode_Is;
3450         }
3451
3452         /* do a fild */
3453         fild = new_bd_ia32_vfild(dbgi, block, get_irg_frame(irg), noreg_GP, store);
3454
3455         set_ia32_use_frame(fild);
3456         set_ia32_op_type(fild, ia32_AddrModeS);
3457         set_ia32_ls_mode(fild, store_mode);
3458
3459         new_node = new_r_Proj(block, fild, mode_vfp, pn_ia32_vfild_res);
3460
3461         return new_node;
3462 }
3463
3464 /**
3465  * Create a conversion from one integer mode into another one
3466  */
3467 static ir_node *create_I2I_Conv(ir_mode *src_mode, ir_mode *tgt_mode,
3468                                 dbg_info *dbgi, ir_node *block, ir_node *op,
3469                                 ir_node *node)
3470 {
3471         ir_node             *new_block = be_transform_node(block);
3472         ir_node             *new_node;
3473         ir_mode             *smaller_mode;
3474         ia32_address_mode_t  am;
3475         ia32_address_t      *addr = &am.addr;
3476
3477         (void) node;
3478         if (get_mode_size_bits(src_mode) < get_mode_size_bits(tgt_mode)) {
3479                 smaller_mode = src_mode;
3480         } else {
3481                 smaller_mode = tgt_mode;
3482         }
3483
3484 #ifdef DEBUG_libfirm
3485         if (is_Const(op)) {
3486                 ir_fprintf(stderr, "Optimisation warning: conv after constant %+F\n",
3487                            op);
3488         }
3489 #endif
3490
3491         match_arguments(&am, block, NULL, op, NULL,
3492                         match_am | match_8bit_am | match_16bit_am);
3493
3494         if (upper_bits_clean(am.new_op2, smaller_mode)) {
3495                 /* unnecessary conv. in theory it shouldn't have been AM */
3496                 assert(is_ia32_NoReg_GP(addr->base));
3497                 assert(is_ia32_NoReg_GP(addr->index));
3498                 assert(is_NoMem(addr->mem));
3499                 assert(am.addr.offset == 0);
3500                 assert(am.addr.symconst_ent == NULL);
3501                 return am.new_op2;
3502         }
3503
3504         new_node = create_Conv_I2I(dbgi, new_block, addr->base, addr->index,
3505                         addr->mem, am.new_op2, smaller_mode);
3506         set_am_attributes(new_node, &am);
3507         /* match_arguments assume that out-mode = in-mode, this isn't true here
3508          * so fix it */
3509         set_ia32_ls_mode(new_node, smaller_mode);
3510         SET_IA32_ORIG_NODE(new_node, node);
3511         new_node = fix_mem_proj(new_node, &am);
3512         return new_node;
3513 }
3514
3515 /**
3516  * Transforms a Conv node.
3517  *
3518  * @return The created ia32 Conv node
3519  */
3520 static ir_node *gen_Conv(ir_node *node)
3521 {
3522         ir_node  *block     = get_nodes_block(node);
3523         ir_node  *new_block = be_transform_node(block);
3524         ir_node  *op        = get_Conv_op(node);
3525         ir_node  *new_op    = NULL;
3526         dbg_info *dbgi      = get_irn_dbg_info(node);
3527         ir_mode  *src_mode  = get_irn_mode(op);
3528         ir_mode  *tgt_mode  = get_irn_mode(node);
3529         int       src_bits  = get_mode_size_bits(src_mode);
3530         int       tgt_bits  = get_mode_size_bits(tgt_mode);
3531         ir_node  *res       = NULL;
3532
3533         assert(!mode_is_int(src_mode) || src_bits <= 32);
3534         assert(!mode_is_int(tgt_mode) || tgt_bits <= 32);
3535
3536         /* modeB -> X should already be lowered by the lower_mode_b pass */
3537         if (src_mode == mode_b) {
3538                 panic("ConvB not lowered %+F", node);
3539         }
3540
3541         if (src_mode == tgt_mode) {
3542                 if (get_Conv_strict(node)) {
3543                         if (ia32_cg_config.use_sse2) {
3544                                 /* when we are in SSE mode, we can kill all strict no-op conversion */
3545                                 return be_transform_node(op);
3546                         }
3547                 } else {
3548                         /* this should be optimized already, but who knows... */
3549                         DEBUG_ONLY(ir_fprintf(stderr, "Debug warning: conv %+F is pointless\n", node));
3550                         DB((dbg, LEVEL_1, "killed Conv(mode, mode) ..."));
3551                         return be_transform_node(op);
3552                 }
3553         }
3554
3555         if (mode_is_float(src_mode)) {
3556                 new_op = be_transform_node(op);
3557                 /* we convert from float ... */
3558                 if (mode_is_float(tgt_mode)) {
3559                         /* ... to float */
3560                         if (ia32_cg_config.use_sse2) {
3561                                 DB((dbg, LEVEL_1, "create Conv(float, float) ..."));
3562                                 res = new_bd_ia32_Conv_FP2FP(dbgi, new_block, noreg_GP, noreg_GP,
3563                                                              nomem, new_op);
3564                                 set_ia32_ls_mode(res, tgt_mode);
3565                         } else {
3566                                 if (get_Conv_strict(node)) {
3567                                         /* if fp_no_float_fold is not set then we assume that we
3568                                          * don't have any float operations in a non
3569                                          * mode_float_arithmetic mode and can skip strict upconvs */
3570                                         if (src_bits < tgt_bits
3571                                                         && !(get_irg_fp_model(current_ir_graph) & fp_no_float_fold)) {
3572                                                 DB((dbg, LEVEL_1, "killed Conv(float, float) ..."));
3573                                                 return new_op;
3574                                         } else {
3575                                                 res = gen_x87_strict_conv(tgt_mode, new_op);
3576                                                 SET_IA32_ORIG_NODE(get_Proj_pred(res), node);
3577                                                 return res;
3578                                         }
3579                                 }
3580                                 DB((dbg, LEVEL_1, "killed Conv(float, float) ..."));
3581                                 return new_op;
3582                         }
3583                 } else {
3584                         /* ... to int */
3585                         DB((dbg, LEVEL_1, "create Conv(float, int) ..."));
3586                         if (ia32_cg_config.use_sse2) {
3587                                 res = new_bd_ia32_Conv_FP2I(dbgi, new_block, noreg_GP, noreg_GP,
3588                                                             nomem, new_op);
3589                                 set_ia32_ls_mode(res, src_mode);
3590                         } else {
3591                                 return gen_x87_fp_to_gp(node);
3592                         }
3593                 }
3594         } else {
3595                 /* we convert from int ... */
3596                 if (mode_is_float(tgt_mode)) {
3597                         /* ... to float */
3598                         DB((dbg, LEVEL_1, "create Conv(int, float) ..."));
3599                         if (ia32_cg_config.use_sse2) {
3600                                 new_op = be_transform_node(op);
3601                                 res = new_bd_ia32_Conv_I2FP(dbgi, new_block, noreg_GP, noreg_GP,
3602                                                             nomem, new_op);
3603                                 set_ia32_ls_mode(res, tgt_mode);
3604                         } else {
3605                                 unsigned int_mantissa   = get_mode_size_bits(src_mode) - (mode_is_signed(src_mode) ? 1 : 0);
3606                                 unsigned float_mantissa = tarval_ieee754_get_mantissa_size(tgt_mode);
3607                                 res = gen_x87_gp_to_fp(node, src_mode);
3608
3609                                 /* we need a strict-Conv, if the int mode has more bits than the
3610                                  * float mantissa */
3611                                 if (float_mantissa < int_mantissa) {
3612                                         res = gen_x87_strict_conv(tgt_mode, res);
3613                                         SET_IA32_ORIG_NODE(get_Proj_pred(res), node);
3614                                 }
3615                                 return res;
3616                         }
3617                 } else if (tgt_mode == mode_b) {
3618                         /* mode_b lowering already took care that we only have 0/1 values */
3619                         DB((dbg, LEVEL_1, "omitting unnecessary Conv(%+F, %+F) ...",
3620                             src_mode, tgt_mode));
3621                         return be_transform_node(op);
3622                 } else {
3623                         /* to int */
3624                         if (src_bits == tgt_bits) {
3625                                 DB((dbg, LEVEL_1, "omitting unnecessary Conv(%+F, %+F) ...",
3626                                     src_mode, tgt_mode));
3627                                 return be_transform_node(op);
3628                         }
3629
3630                         res = create_I2I_Conv(src_mode, tgt_mode, dbgi, block, op, node);
3631                         return res;
3632                 }
3633         }
3634
3635         return res;
3636 }
3637
3638 static ir_node *create_immediate_or_transform(ir_node *node,
3639                                               char immediate_constraint_type)
3640 {
3641         ir_node *new_node = try_create_Immediate(node, immediate_constraint_type);
3642         if (new_node == NULL) {
3643                 new_node = be_transform_node(node);
3644         }
3645         return new_node;
3646 }
3647
3648 /**
3649  * Transforms a FrameAddr into an ia32 Add.
3650  */
3651 static ir_node *gen_be_FrameAddr(ir_node *node)
3652 {
3653         ir_node  *block  = be_transform_node(get_nodes_block(node));
3654         ir_node  *op     = be_get_FrameAddr_frame(node);
3655         ir_node  *new_op = be_transform_node(op);
3656         dbg_info *dbgi   = get_irn_dbg_info(node);
3657         ir_node  *new_node;
3658
3659         new_node = new_bd_ia32_Lea(dbgi, block, new_op, noreg_GP);
3660         set_ia32_frame_ent(new_node, arch_get_frame_entity(node));
3661         set_ia32_use_frame(new_node);
3662
3663         SET_IA32_ORIG_NODE(new_node, node);
3664
3665         return new_node;
3666 }
3667
3668 /**
3669  * In case SSE is used we need to copy the result from XMM0 to FPU TOS before return.
3670  */
3671 static ir_node *gen_be_Return(ir_node *node)
3672 {
3673         ir_graph  *irg     = current_ir_graph;
3674         ir_node   *ret_val = get_irn_n(node, be_pos_Return_val);
3675         ir_node   *ret_mem = get_irn_n(node, be_pos_Return_mem);
3676         ir_entity *ent     = get_irg_entity(irg);
3677         ir_type   *tp      = get_entity_type(ent);
3678         dbg_info  *dbgi;
3679         ir_node   *block;
3680         ir_type   *res_type;
3681         ir_mode   *mode;
3682         ir_node   *frame, *sse_store, *fld, *mproj, *barrier;
3683         ir_node   *new_barrier, *new_ret_val, *new_ret_mem;
3684         ir_node   **in;
3685         int       pn_ret_val, pn_ret_mem, arity, i;
3686
3687         assert(ret_val != NULL);
3688         if (be_Return_get_n_rets(node) < 1 || ! ia32_cg_config.use_sse2) {
3689                 return be_duplicate_node(node);
3690         }
3691
3692         res_type = get_method_res_type(tp, 0);
3693
3694         if (! is_Primitive_type(res_type)) {
3695                 return be_duplicate_node(node);
3696         }
3697
3698         mode = get_type_mode(res_type);
3699         if (! mode_is_float(mode)) {
3700                 return be_duplicate_node(node);
3701         }
3702
3703         assert(get_method_n_ress(tp) == 1);
3704
3705         pn_ret_val = get_Proj_proj(ret_val);
3706         pn_ret_mem = get_Proj_proj(ret_mem);
3707
3708         /* get the Barrier */
3709         barrier = get_Proj_pred(ret_val);
3710
3711         /* get result input of the Barrier */
3712         ret_val     = get_irn_n(barrier, pn_ret_val);
3713         new_ret_val = be_transform_node(ret_val);
3714
3715         /* get memory input of the Barrier */
3716         ret_mem     = get_irn_n(barrier, pn_ret_mem);
3717         new_ret_mem = be_transform_node(ret_mem);
3718
3719         frame = get_irg_frame(irg);
3720
3721         dbgi  = get_irn_dbg_info(barrier);
3722         block = be_transform_node(get_nodes_block(barrier));
3723
3724         /* store xmm0 onto stack */
3725         sse_store = new_bd_ia32_xStoreSimple(dbgi, block, frame, noreg_GP,
3726                                              new_ret_mem, new_ret_val);
3727         set_ia32_ls_mode(sse_store, mode);
3728         set_ia32_op_type(sse_store, ia32_AddrModeD);
3729         set_ia32_use_frame(sse_store);
3730
3731         /* load into x87 register */
3732         fld = new_bd_ia32_vfld(dbgi, block, frame, noreg_GP, sse_store, mode);
3733         set_ia32_op_type(fld, ia32_AddrModeS);
3734         set_ia32_use_frame(fld);
3735
3736         mproj = new_r_Proj(block, fld, mode_M, pn_ia32_vfld_M);
3737         fld   = new_r_Proj(block, fld, mode_vfp, pn_ia32_vfld_res);
3738
3739         /* create a new barrier */
3740         arity = get_irn_arity(barrier);
3741         in    = ALLOCAN(ir_node*, arity);
3742         for (i = 0; i < arity; ++i) {
3743                 ir_node *new_in;
3744
3745                 if (i == pn_ret_val) {
3746                         new_in = fld;
3747                 } else if (i == pn_ret_mem) {
3748                         new_in = mproj;
3749                 } else {
3750                         ir_node *in = get_irn_n(barrier, i);
3751                         new_in = be_transform_node(in);
3752                 }
3753                 in[i] = new_in;
3754         }
3755
3756         new_barrier = new_ir_node(dbgi, irg, block,
3757                                   get_irn_op(barrier), get_irn_mode(barrier),
3758                                   arity, in);
3759         copy_node_attr(barrier, new_barrier);
3760         be_duplicate_deps(barrier, new_barrier);
3761         be_set_transformed_node(barrier, new_barrier);
3762
3763         /* transform normally */
3764         return be_duplicate_node(node);
3765 }
3766
3767 /**
3768  * Transform a be_AddSP into an ia32_SubSP.
3769  */
3770 static ir_node *gen_be_AddSP(ir_node *node)
3771 {
3772         ir_node  *sz = get_irn_n(node, be_pos_AddSP_size);
3773         ir_node  *sp = get_irn_n(node, be_pos_AddSP_old_sp);
3774
3775         return gen_binop(node, sp, sz, new_bd_ia32_SubSP,
3776                          match_am | match_immediate);
3777 }
3778
3779 /**
3780  * Transform a be_SubSP into an ia32_AddSP
3781  */
3782 static ir_node *gen_be_SubSP(ir_node *node)
3783 {
3784         ir_node  *sz = get_irn_n(node, be_pos_SubSP_size);
3785         ir_node  *sp = get_irn_n(node, be_pos_SubSP_old_sp);
3786
3787         return gen_binop(node, sp, sz, new_bd_ia32_AddSP,
3788                          match_am | match_immediate);
3789 }
3790
3791 /**
3792  * Change some phi modes
3793  */
3794 static ir_node *gen_Phi(ir_node *node)
3795 {
3796         const arch_register_req_t *req;
3797         ir_node  *block = be_transform_node(get_nodes_block(node));
3798         ir_graph *irg   = current_ir_graph;
3799         dbg_info *dbgi  = get_irn_dbg_info(node);
3800         ir_mode  *mode  = get_irn_mode(node);
3801         ir_node  *phi;
3802
3803         if (ia32_mode_needs_gp_reg(mode)) {
3804                 /* we shouldn't have any 64bit stuff around anymore */
3805                 assert(get_mode_size_bits(mode) <= 32);
3806                 /* all integer operations are on 32bit registers now */
3807                 mode = mode_Iu;
3808                 req  = ia32_reg_classes[CLASS_ia32_gp].class_req;
3809         } else if (mode_is_float(mode)) {
3810                 if (ia32_cg_config.use_sse2) {
3811                         mode = mode_xmm;
3812                         req  = ia32_reg_classes[CLASS_ia32_xmm].class_req;
3813                 } else {
3814                         mode = mode_vfp;
3815                         req  = ia32_reg_classes[CLASS_ia32_vfp].class_req;
3816                 }
3817         } else {
3818                 req = arch_no_register_req;
3819         }
3820
3821         /* phi nodes allow loops, so we use the old arguments for now
3822          * and fix this later */
3823         phi = new_ir_node(dbgi, irg, block, op_Phi, mode, get_irn_arity(node),
3824                           get_irn_in(node) + 1);
3825         copy_node_attr(node, phi);
3826         be_duplicate_deps(node, phi);
3827
3828         arch_set_out_register_req(phi, 0, req);
3829
3830         be_enqueue_preds(node);
3831
3832         return phi;
3833 }
3834
3835 static ir_node *gen_Jmp(ir_node *node)
3836 {
3837         ir_node  *block     = get_nodes_block(node);
3838         ir_node  *new_block = be_transform_node(block);
3839         dbg_info *dbgi      = get_irn_dbg_info(node);
3840         ir_node  *new_node;
3841
3842         new_node = new_bd_ia32_Jmp(dbgi, new_block);
3843         SET_IA32_ORIG_NODE(new_node, node);
3844
3845         return new_node;
3846 }
3847
3848 /**
3849  * Transform IJmp
3850  */
3851 static ir_node *gen_IJmp(ir_node *node)
3852 {
3853         ir_node  *block     = get_nodes_block(node);
3854         ir_node  *new_block = be_transform_node(block);
3855         dbg_info *dbgi      = get_irn_dbg_info(node);
3856         ir_node  *op        = get_IJmp_target(node);
3857         ir_node  *new_node;
3858         ia32_address_mode_t  am;
3859         ia32_address_t      *addr = &am.addr;
3860
3861         assert(get_irn_mode(op) == mode_P);
3862
3863         match_arguments(&am, block, NULL, op, NULL, match_am | match_immediate);
3864
3865         new_node = new_bd_ia32_IJmp(dbgi, new_block, addr->base, addr->index,
3866                         addr->mem, am.new_op2);
3867         set_am_attributes(new_node, &am);
3868         SET_IA32_ORIG_NODE(new_node, node);
3869
3870         new_node = fix_mem_proj(new_node, &am);
3871
3872         return new_node;
3873 }
3874
3875 /**
3876  * Transform a Bound node.
3877  */
3878 static ir_node *gen_Bound(ir_node *node)
3879 {
3880         ir_node  *new_node;
3881         ir_node  *lower = get_Bound_lower(node);
3882         dbg_info *dbgi  = get_irn_dbg_info(node);
3883
3884         if (is_Const_0(lower)) {
3885                 /* typical case for Java */
3886                 ir_node  *sub, *res, *flags, *block;
3887
3888                 res = gen_binop(node, get_Bound_index(node), get_Bound_upper(node),
3889                         new_bd_ia32_Sub, match_mode_neutral     | match_am | match_immediate);
3890
3891                 block = get_nodes_block(res);
3892                 if (! is_Proj(res)) {
3893                         sub = res;
3894                         set_irn_mode(sub, mode_T);
3895                         res = new_rd_Proj(NULL, block, sub, mode_Iu, pn_ia32_res);
3896                 } else {
3897                         sub = get_Proj_pred(res);
3898                 }
3899                 flags = new_rd_Proj(NULL, block, sub, mode_Iu, pn_ia32_Sub_flags);
3900                 new_node = new_bd_ia32_Jcc(dbgi, block, flags, pn_Cmp_Lt | ia32_pn_Cmp_unsigned);
3901                 SET_IA32_ORIG_NODE(new_node, node);
3902         } else {
3903                 panic("generic Bound not supported in ia32 Backend");
3904         }
3905         return new_node;
3906 }
3907
3908
3909 static ir_node *gen_ia32_l_ShlDep(ir_node *node)
3910 {
3911         ir_node *left  = get_irn_n(node, n_ia32_l_ShlDep_val);
3912         ir_node *right = get_irn_n(node, n_ia32_l_ShlDep_count);
3913
3914         return gen_shift_binop(node, left, right, new_bd_ia32_Shl,
3915                                match_immediate | match_mode_neutral);
3916 }
3917
3918 static ir_node *gen_ia32_l_ShrDep(ir_node *node)
3919 {
3920         ir_node *left  = get_irn_n(node, n_ia32_l_ShrDep_val);
3921         ir_node *right = get_irn_n(node, n_ia32_l_ShrDep_count);
3922         return gen_shift_binop(node, left, right, new_bd_ia32_Shr,
3923                                match_immediate);
3924 }
3925
3926 static ir_node *gen_ia32_l_SarDep(ir_node *node)
3927 {
3928         ir_node *left  = get_irn_n(node, n_ia32_l_SarDep_val);
3929         ir_node *right = get_irn_n(node, n_ia32_l_SarDep_count);
3930         return gen_shift_binop(node, left, right, new_bd_ia32_Sar,
3931                                match_immediate);
3932 }
3933
3934 static ir_node *gen_ia32_l_Add(ir_node *node)
3935 {
3936         ir_node *left    = get_irn_n(node, n_ia32_l_Add_left);
3937         ir_node *right   = get_irn_n(node, n_ia32_l_Add_right);
3938         ir_node *lowered = gen_binop(node, left, right, new_bd_ia32_Add,
3939                         match_commutative | match_am | match_immediate |
3940                         match_mode_neutral);
3941
3942         if (is_Proj(lowered)) {
3943                 lowered = get_Proj_pred(lowered);
3944         } else {
3945                 assert(is_ia32_Add(lowered));
3946                 set_irn_mode(lowered, mode_T);
3947         }
3948
3949         return lowered;
3950 }
3951
3952 static ir_node *gen_ia32_l_Adc(ir_node *node)
3953 {
3954         return gen_binop_flags(node, new_bd_ia32_Adc,
3955                         match_commutative | match_am | match_immediate |
3956                         match_mode_neutral);
3957 }
3958
3959 /**
3960  * Transforms a l_MulS into a "real" MulS node.
3961  *
3962  * @return the created ia32 Mul node
3963  */
3964 static ir_node *gen_ia32_l_Mul(ir_node *node)
3965 {
3966         ir_node *left  = get_binop_left(node);
3967         ir_node *right = get_binop_right(node);
3968
3969         return gen_binop(node, left, right, new_bd_ia32_Mul,
3970                          match_commutative | match_am | match_mode_neutral);
3971 }
3972
3973 /**
3974  * Transforms a l_IMulS into a "real" IMul1OPS node.
3975  *
3976  * @return the created ia32 IMul1OP node
3977  */
3978 static ir_node *gen_ia32_l_IMul(ir_node *node)
3979 {
3980         ir_node  *left  = get_binop_left(node);
3981         ir_node  *right = get_binop_right(node);
3982
3983         return gen_binop(node, left, right, new_bd_ia32_IMul1OP,
3984                          match_commutative | match_am | match_mode_neutral);
3985 }
3986
3987 static ir_node *gen_ia32_l_Sub(ir_node *node)
3988 {
3989         ir_node *left    = get_irn_n(node, n_ia32_l_Sub_minuend);
3990         ir_node *right   = get_irn_n(node, n_ia32_l_Sub_subtrahend);
3991         ir_node *lowered = gen_binop(node, left, right, new_bd_ia32_Sub,
3992                         match_am | match_immediate | match_mode_neutral);
3993
3994         if (is_Proj(lowered)) {
3995                 lowered = get_Proj_pred(lowered);
3996         } else {
3997                 assert(is_ia32_Sub(lowered));
3998                 set_irn_mode(lowered, mode_T);
3999         }
4000
4001         return lowered;
4002 }
4003
4004 static ir_node *gen_ia32_l_Sbb(ir_node *node)
4005 {
4006         return gen_binop_flags(node, new_bd_ia32_Sbb,
4007                         match_am | match_immediate | match_mode_neutral);
4008 }
4009
4010 /**
4011  * Transforms a l_ShlD/l_ShrD into a ShlD/ShrD. Those nodes have 3 data inputs:
4012  * op1 - target to be shifted
4013  * op2 - contains bits to be shifted into target
4014  * op3 - shift count
4015  * Only op3 can be an immediate.
4016  */
4017 static ir_node *gen_lowered_64bit_shifts(ir_node *node, ir_node *high,
4018                                          ir_node *low, ir_node *count)
4019 {
4020         ir_node  *block     = get_nodes_block(node);
4021         ir_node  *new_block = be_transform_node(block);
4022         dbg_info *dbgi      = get_irn_dbg_info(node);
4023         ir_node  *new_high  = be_transform_node(high);
4024         ir_node  *new_low   = be_transform_node(low);
4025         ir_node  *new_count;
4026         ir_node  *new_node;
4027
4028         /* the shift amount can be any mode that is bigger than 5 bits, since all
4029          * other bits are ignored anyway */
4030         while (is_Conv(count)              &&
4031                get_irn_n_edges(count) == 1 &&
4032                mode_is_int(get_irn_mode(count))) {
4033                 assert(get_mode_size_bits(get_irn_mode(count)) >= 5);
4034                 count = get_Conv_op(count);
4035         }
4036         new_count = create_immediate_or_transform(count, 0);
4037
4038         if (is_ia32_l_ShlD(node)) {
4039                 new_node = new_bd_ia32_ShlD(dbgi, new_block, new_high, new_low,
4040                                             new_count);
4041         } else {
4042                 new_node = new_bd_ia32_ShrD(dbgi, new_block, new_high, new_low,
4043                                             new_count);
4044         }
4045         SET_IA32_ORIG_NODE(new_node, node);
4046
4047         return new_node;
4048 }
4049
4050 static ir_node *gen_ia32_l_ShlD(ir_node *node)
4051 {
4052         ir_node *high  = get_irn_n(node, n_ia32_l_ShlD_val_high);
4053         ir_node *low   = get_irn_n(node, n_ia32_l_ShlD_val_low);
4054         ir_node *count = get_irn_n(node, n_ia32_l_ShlD_count);
4055         return gen_lowered_64bit_shifts(node, high, low, count);
4056 }
4057
4058 static ir_node *gen_ia32_l_ShrD(ir_node *node)
4059 {
4060         ir_node *high  = get_irn_n(node, n_ia32_l_ShrD_val_high);
4061         ir_node *low   = get_irn_n(node, n_ia32_l_ShrD_val_low);
4062         ir_node *count = get_irn_n(node, n_ia32_l_ShrD_count);
4063         return gen_lowered_64bit_shifts(node, high, low, count);
4064 }
4065
4066 static ir_node *gen_ia32_l_LLtoFloat(ir_node *node)
4067 {
4068         ir_node  *src_block    = get_nodes_block(node);
4069         ir_node  *block        = be_transform_node(src_block);
4070         ir_graph *irg          = current_ir_graph;
4071         dbg_info *dbgi         = get_irn_dbg_info(node);
4072         ir_node  *frame        = get_irg_frame(irg);
4073         ir_node  *val_low      = get_irn_n(node, n_ia32_l_LLtoFloat_val_low);
4074         ir_node  *val_high     = get_irn_n(node, n_ia32_l_LLtoFloat_val_high);
4075         ir_node  *new_val_low  = be_transform_node(val_low);
4076         ir_node  *new_val_high = be_transform_node(val_high);
4077         ir_node  *in[2];
4078         ir_node  *sync, *fild, *res;
4079         ir_node  *store_low, *store_high;
4080
4081         if (ia32_cg_config.use_sse2) {
4082                 panic("ia32_l_LLtoFloat not implemented for SSE2");
4083         }
4084
4085         /* do a store */
4086         store_low = new_bd_ia32_Store(dbgi, block, frame, noreg_GP, nomem,
4087                                       new_val_low);
4088         store_high = new_bd_ia32_Store(dbgi, block, frame, noreg_GP, nomem,
4089                                        new_val_high);
4090         SET_IA32_ORIG_NODE(store_low,  node);
4091         SET_IA32_ORIG_NODE(store_high, node);
4092
4093         set_ia32_use_frame(store_low);
4094         set_ia32_use_frame(store_high);
4095         set_ia32_op_type(store_low, ia32_AddrModeD);
4096         set_ia32_op_type(store_high, ia32_AddrModeD);
4097         set_ia32_ls_mode(store_low, mode_Iu);
4098         set_ia32_ls_mode(store_high, mode_Is);
4099         add_ia32_am_offs_int(store_high, 4);
4100
4101         in[0] = store_low;
4102         in[1] = store_high;
4103         sync  = new_rd_Sync(dbgi, block, 2, in);
4104
4105         /* do a fild */
4106         fild = new_bd_ia32_vfild(dbgi, block, frame, noreg_GP, sync);
4107
4108         set_ia32_use_frame(fild);
4109         set_ia32_op_type(fild, ia32_AddrModeS);
4110         set_ia32_ls_mode(fild, mode_Ls);
4111
4112         SET_IA32_ORIG_NODE(fild, node);
4113
4114         res = new_r_Proj(block, fild, mode_vfp, pn_ia32_vfild_res);
4115
4116         if (! mode_is_signed(get_irn_mode(val_high))) {
4117                 ia32_address_mode_t  am;
4118
4119                 ir_node *count = ia32_create_Immediate(NULL, 0, 31);
4120                 ir_node *fadd;
4121
4122                 am.addr.base          = noreg_GP;
4123                 am.addr.index         = new_bd_ia32_Shr(dbgi, block, new_val_high, count);
4124                 am.addr.mem           = nomem;
4125                 am.addr.offset        = 0;
4126                 am.addr.scale         = 2;
4127                 am.addr.symconst_ent  = ia32_gen_fp_known_const(ia32_ULLBIAS);
4128                 am.addr.use_frame     = 0;
4129                 am.addr.frame_entity  = NULL;
4130                 am.addr.symconst_sign = 0;
4131                 am.ls_mode            = mode_F;
4132                 am.mem_proj           = nomem;
4133                 am.op_type            = ia32_AddrModeS;
4134                 am.new_op1            = res;
4135                 am.new_op2            = ia32_new_NoReg_vfp(env_cg);
4136                 am.pinned             = op_pin_state_floats;
4137                 am.commutative        = 1;
4138                 am.ins_permuted       = 0;
4139
4140                 fadd  = new_bd_ia32_vfadd(dbgi, block, am.addr.base, am.addr.index, am.addr.mem,
4141                         am.new_op1, am.new_op2, get_fpcw());
4142                 set_am_attributes(fadd, &am);
4143
4144                 set_irn_mode(fadd, mode_T);
4145                 res = new_rd_Proj(NULL, block, fadd, mode_vfp, pn_ia32_res);
4146         }
4147         return res;
4148 }
4149
4150 static ir_node *gen_ia32_l_FloattoLL(ir_node *node)
4151 {
4152         ir_node  *src_block  = get_nodes_block(node);
4153         ir_node  *block      = be_transform_node(src_block);
4154         ir_graph *irg        = get_Block_irg(block);
4155         dbg_info *dbgi       = get_irn_dbg_info(node);
4156         ir_node  *frame      = get_irg_frame(irg);
4157         ir_node  *val        = get_irn_n(node, n_ia32_l_FloattoLL_val);
4158         ir_node  *new_val    = be_transform_node(val);
4159         ir_node  *fist, *mem;
4160
4161         mem = gen_vfist(dbgi, block, frame, noreg_GP, nomem, new_val, &fist);
4162         SET_IA32_ORIG_NODE(fist, node);
4163         set_ia32_use_frame(fist);
4164         set_ia32_op_type(fist, ia32_AddrModeD);
4165         set_ia32_ls_mode(fist, mode_Ls);
4166
4167         return mem;
4168 }
4169
4170 /**
4171  * the BAD transformer.
4172  */
4173 static ir_node *bad_transform(ir_node *node)
4174 {
4175         panic("No transform function for %+F available.", node);
4176         return NULL;
4177 }
4178
4179 static ir_node *gen_Proj_l_FloattoLL(ir_node *node)
4180 {
4181         ir_node  *block    = be_transform_node(get_nodes_block(node));
4182         ir_graph *irg      = get_Block_irg(block);
4183         ir_node  *pred     = get_Proj_pred(node);
4184         ir_node  *new_pred = be_transform_node(pred);
4185         ir_node  *frame    = get_irg_frame(irg);
4186         dbg_info *dbgi     = get_irn_dbg_info(node);
4187         long      pn       = get_Proj_proj(node);
4188         ir_node  *load;
4189         ir_node  *proj;
4190         ia32_attr_t *attr;
4191
4192         load = new_bd_ia32_Load(dbgi, block, frame, noreg_GP, new_pred);
4193         SET_IA32_ORIG_NODE(load, node);
4194         set_ia32_use_frame(load);
4195         set_ia32_op_type(load, ia32_AddrModeS);
4196         set_ia32_ls_mode(load, mode_Iu);
4197         /* we need a 64bit stackslot (fist stores 64bit) even though we only load
4198          * 32 bit from it with this particular load */
4199         attr = get_ia32_attr(load);
4200         attr->data.need_64bit_stackent = 1;
4201
4202         if (pn == pn_ia32_l_FloattoLL_res_high) {
4203                 add_ia32_am_offs_int(load, 4);
4204         } else {
4205                 assert(pn == pn_ia32_l_FloattoLL_res_low);
4206         }
4207
4208         proj = new_r_Proj(block, load, mode_Iu, pn_ia32_Load_res);
4209
4210         return proj;
4211 }
4212
4213 /**
4214  * Transform the Projs of an AddSP.
4215  */
4216 static ir_node *gen_Proj_be_AddSP(ir_node *node)
4217 {
4218         ir_node  *block    = be_transform_node(get_nodes_block(node));
4219         ir_node  *pred     = get_Proj_pred(node);
4220         ir_node  *new_pred = be_transform_node(pred);
4221         dbg_info *dbgi     = get_irn_dbg_info(node);
4222         long     proj      = get_Proj_proj(node);
4223
4224         if (proj == pn_be_AddSP_sp) {
4225                 ir_node *res = new_rd_Proj(dbgi, block, new_pred, mode_Iu,
4226                                            pn_ia32_SubSP_stack);
4227                 arch_set_irn_register(res, &ia32_gp_regs[REG_ESP]);
4228                 return res;
4229         } else if (proj == pn_be_AddSP_res) {
4230                 return new_rd_Proj(dbgi, block, new_pred, mode_Iu,
4231                                    pn_ia32_SubSP_addr);
4232         } else if (proj == pn_be_AddSP_M) {
4233                 return new_rd_Proj(dbgi, block, new_pred, mode_M, pn_ia32_SubSP_M);
4234         }
4235
4236         panic("No idea how to transform proj->AddSP");
4237 }
4238
4239 /**
4240  * Transform the Projs of a SubSP.
4241  */
4242 static ir_node *gen_Proj_be_SubSP(ir_node *node)
4243 {
4244         ir_node  *block    = be_transform_node(get_nodes_block(node));
4245         ir_node  *pred     = get_Proj_pred(node);
4246         ir_node  *new_pred = be_transform_node(pred);
4247         dbg_info *dbgi     = get_irn_dbg_info(node);
4248         long     proj      = get_Proj_proj(node);
4249
4250         if (proj == pn_be_SubSP_sp) {
4251                 ir_node *res = new_rd_Proj(dbgi, block, new_pred, mode_Iu,
4252                                            pn_ia32_AddSP_stack);
4253                 arch_set_irn_register(res, &ia32_gp_regs[REG_ESP]);
4254                 return res;
4255         } else if (proj == pn_be_SubSP_M) {
4256                 return new_rd_Proj(dbgi, block, new_pred, mode_M, pn_ia32_AddSP_M);
4257         }
4258
4259         panic("No idea how to transform proj->SubSP");
4260 }
4261
4262 /**
4263  * Transform and renumber the Projs from a Load.
4264  */
4265 static ir_node *gen_Proj_Load(ir_node *node)
4266 {
4267         ir_node  *new_pred;
4268         ir_node  *block    = be_transform_node(get_nodes_block(node));
4269         ir_node  *pred     = get_Proj_pred(node);
4270         dbg_info *dbgi     = get_irn_dbg_info(node);
4271         long     proj      = get_Proj_proj(node);
4272
4273         /* loads might be part of source address mode matches, so we don't
4274          * transform the ProjMs yet (with the exception of loads whose result is
4275          * not used)
4276          */
4277         if (is_Load(pred) && proj == pn_Load_M && get_irn_n_edges(pred) > 1) {
4278                 ir_node *res;
4279                 ir_node *old_block = get_nodes_block(node);
4280
4281                 /* this is needed, because sometimes we have loops that are only
4282                    reachable through the ProjM */
4283                 be_enqueue_preds(node);
4284                 /* do it in 2 steps, to silence firm verifier */
4285                 res = new_rd_Proj(dbgi, old_block, pred, mode_M, pn_Load_M);
4286                 set_Proj_proj(res, pn_ia32_mem);
4287                 return res;
4288         }
4289
4290         /* renumber the proj */
4291         new_pred = be_transform_node(pred);
4292         if (is_ia32_Load(new_pred)) {
4293                 switch (proj) {
4294                 case pn_Load_res:
4295                         return new_rd_Proj(dbgi, block, new_pred, mode_Iu, pn_ia32_Load_res);
4296                 case pn_Load_M:
4297                         return new_rd_Proj(dbgi, block, new_pred, mode_M, pn_ia32_Load_M);
4298                 case pn_Load_X_regular:
4299                         return new_rd_Jmp(dbgi, block);
4300                 case pn_Load_X_except:
4301                         /* This Load might raise an exception. Mark it. */
4302                         set_ia32_exc_label(new_pred, 1);
4303                         return new_rd_Proj(dbgi, block, new_pred, mode_X, pn_ia32_Load_X_exc);
4304                 default:
4305                         break;
4306                 }
4307         } else if (is_ia32_Conv_I2I(new_pred) ||
4308                    is_ia32_Conv_I2I8Bit(new_pred)) {
4309                 set_irn_mode(new_pred, mode_T);
4310                 if (proj == pn_Load_res) {
4311                         return new_rd_Proj(dbgi, block, new_pred, mode_Iu, pn_ia32_res);
4312                 } else if (proj == pn_Load_M) {
4313                         return new_rd_Proj(dbgi, block, new_pred, mode_M, pn_ia32_mem);
4314                 }
4315         } else if (is_ia32_xLoad(new_pred)) {
4316                 switch (proj) {
4317                 case pn_Load_res:
4318                         return new_rd_Proj(dbgi, block, new_pred, mode_xmm, pn_ia32_xLoad_res);
4319                 case pn_Load_M:
4320                         return new_rd_Proj(dbgi, block, new_pred, mode_M, pn_ia32_xLoad_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_xLoad_X_exc);
4327                 default:
4328                         break;
4329                 }
4330         } else if (is_ia32_vfld(new_pred)) {
4331                 switch (proj) {
4332                 case pn_Load_res:
4333                         return new_rd_Proj(dbgi, block, new_pred, mode_vfp, pn_ia32_vfld_res);
4334                 case pn_Load_M:
4335                         return new_rd_Proj(dbgi, block, new_pred, mode_M, pn_ia32_vfld_M);
4336                 case pn_Load_X_regular:
4337                         return new_rd_Jmp(dbgi, block);
4338                 case pn_Load_X_except:
4339                         /* This Load might raise an exception. Mark it. */
4340                         set_ia32_exc_label(new_pred, 1);
4341                         return new_rd_Proj(dbgi, block, new_pred, mode_X, pn_ia32_vfld_X_exc);
4342                 default:
4343                         break;
4344                 }
4345         } else {
4346                 /* can happen for ProJMs when source address mode happened for the
4347                    node */
4348
4349                 /* however it should not be the result proj, as that would mean the
4350                    load had multiple users and should not have been used for
4351                    SourceAM */
4352                 if (proj != pn_Load_M) {
4353                         panic("internal error: transformed node not a Load");
4354                 }
4355                 return new_rd_Proj(dbgi, block, new_pred, mode_M, 1);
4356         }
4357
4358         panic("No idea how to transform proj");
4359 }
4360
4361 /**
4362  * Transform and renumber the Projs from a DivMod like instruction.
4363  */
4364 static ir_node *gen_Proj_DivMod(ir_node *node)
4365 {
4366         ir_node  *block    = be_transform_node(get_nodes_block(node));
4367         ir_node  *pred     = get_Proj_pred(node);
4368         ir_node  *new_pred = be_transform_node(pred);
4369         dbg_info *dbgi     = get_irn_dbg_info(node);
4370         long     proj      = get_Proj_proj(node);
4371
4372         assert(is_ia32_Div(new_pred) || is_ia32_IDiv(new_pred));
4373
4374         switch (get_irn_opcode(pred)) {
4375         case iro_Div:
4376                 switch (proj) {
4377                 case pn_Div_M:
4378                         return new_rd_Proj(dbgi, block, new_pred, mode_M, pn_ia32_Div_M);
4379                 case pn_Div_res:
4380                         return new_rd_Proj(dbgi, block, new_pred, mode_Iu, pn_ia32_Div_div_res);
4381                 case pn_Div_X_regular:
4382                         return new_rd_Jmp(dbgi, block);
4383                 case pn_Div_X_except:
4384                         set_ia32_exc_label(new_pred, 1);
4385                         return new_rd_Proj(dbgi, block, new_pred, mode_X, pn_ia32_Div_X_exc);
4386                 default:
4387                         break;
4388                 }
4389                 break;
4390         case iro_Mod:
4391                 switch (proj) {
4392                 case pn_Mod_M:
4393                         return new_rd_Proj(dbgi, block, new_pred, mode_M, pn_ia32_Div_M);
4394                 case pn_Mod_res:
4395                         return new_rd_Proj(dbgi, block, new_pred, mode_Iu, pn_ia32_Div_mod_res);
4396                 case pn_Mod_X_except:
4397                         set_ia32_exc_label(new_pred, 1);
4398                         return new_rd_Proj(dbgi, block, new_pred, mode_X, pn_ia32_Div_X_exc);
4399                 default:
4400                         break;
4401                 }
4402                 break;
4403         case iro_DivMod:
4404                 switch (proj) {
4405                 case pn_DivMod_M:
4406                         return new_rd_Proj(dbgi, block, new_pred, mode_M, pn_ia32_Div_M);
4407                 case pn_DivMod_res_div:
4408                         return new_rd_Proj(dbgi, block, new_pred, mode_Iu, pn_ia32_Div_div_res);
4409                 case pn_DivMod_res_mod:
4410                         return new_rd_Proj(dbgi, block, new_pred, mode_Iu, pn_ia32_Div_mod_res);
4411                 case pn_DivMod_X_regular:
4412                         return new_rd_Jmp(dbgi, block);
4413                 case pn_DivMod_X_except:
4414                         set_ia32_exc_label(new_pred, 1);
4415                         return new_rd_Proj(dbgi, block, new_pred, mode_X, pn_ia32_Div_X_exc);
4416                 default:
4417                         break;
4418                 }
4419                 break;
4420         default:
4421                 break;
4422         }
4423
4424         panic("No idea how to transform proj->DivMod");
4425 }
4426
4427 /**
4428  * Transform and renumber the Projs from a CopyB.
4429  */
4430 static ir_node *gen_Proj_CopyB(ir_node *node)
4431 {
4432         ir_node  *block    = be_transform_node(get_nodes_block(node));
4433         ir_node  *pred     = get_Proj_pred(node);
4434         ir_node  *new_pred = be_transform_node(pred);
4435         dbg_info *dbgi     = get_irn_dbg_info(node);
4436         long     proj      = get_Proj_proj(node);
4437
4438         switch (proj) {
4439         case pn_CopyB_M_regular:
4440                 if (is_ia32_CopyB_i(new_pred)) {
4441                         return new_rd_Proj(dbgi, block, new_pred, mode_M, pn_ia32_CopyB_i_M);
4442                 } else if (is_ia32_CopyB(new_pred)) {
4443                         return new_rd_Proj(dbgi, block, new_pred, mode_M, pn_ia32_CopyB_M);
4444                 }
4445                 break;
4446         default:
4447                 break;
4448         }
4449
4450         panic("No idea how to transform proj->CopyB");
4451 }
4452
4453 /**
4454  * Transform and renumber the Projs from a Quot.
4455  */
4456 static ir_node *gen_Proj_Quot(ir_node *node)
4457 {
4458         ir_node  *block    = be_transform_node(get_nodes_block(node));
4459         ir_node  *pred     = get_Proj_pred(node);
4460         ir_node  *new_pred = be_transform_node(pred);
4461         dbg_info *dbgi     = get_irn_dbg_info(node);
4462         long     proj      = get_Proj_proj(node);
4463
4464         switch (proj) {
4465         case pn_Quot_M:
4466                 if (is_ia32_xDiv(new_pred)) {
4467                         return new_rd_Proj(dbgi, block, new_pred, mode_M, pn_ia32_xDiv_M);
4468                 } else if (is_ia32_vfdiv(new_pred)) {
4469                         return new_rd_Proj(dbgi, block, new_pred, mode_M, pn_ia32_vfdiv_M);
4470                 }
4471                 break;
4472         case pn_Quot_res:
4473                 if (is_ia32_xDiv(new_pred)) {
4474                         return new_rd_Proj(dbgi, block, new_pred, mode_xmm, pn_ia32_xDiv_res);
4475                 } else if (is_ia32_vfdiv(new_pred)) {
4476                         return new_rd_Proj(dbgi, block, new_pred, mode_vfp, pn_ia32_vfdiv_res);
4477                 }
4478                 break;
4479         case pn_Quot_X_regular:
4480         case pn_Quot_X_except:
4481         default:
4482                 break;
4483         }
4484
4485         panic("No idea how to transform proj->Quot");
4486 }
4487
4488 static ir_node *gen_be_Call(ir_node *node)
4489 {
4490         dbg_info       *const dbgi      = get_irn_dbg_info(node);
4491         ir_node        *const src_block = get_nodes_block(node);
4492         ir_node        *const block     = be_transform_node(src_block);
4493         ir_node        *const src_mem   = get_irn_n(node, be_pos_Call_mem);
4494         ir_node        *const src_sp    = get_irn_n(node, be_pos_Call_sp);
4495         ir_node        *const sp        = be_transform_node(src_sp);
4496         ir_node        *const src_ptr   = get_irn_n(node, be_pos_Call_ptr);
4497         ia32_address_mode_t   am;
4498         ia32_address_t *const addr      = &am.addr;
4499         ir_node        *      mem;
4500         ir_node        *      call;
4501         int                   i;
4502         ir_node        *      fpcw;
4503         ir_node        *      eax       = noreg_GP;
4504         ir_node        *      ecx       = noreg_GP;
4505         ir_node        *      edx       = noreg_GP;
4506         unsigned        const pop       = be_Call_get_pop(node);
4507         ir_type        *const call_tp   = be_Call_get_type(node);
4508         int                   old_no_pic_adjust;
4509
4510         /* Run the x87 simulator if the call returns a float value */
4511         if (get_method_n_ress(call_tp) > 0) {
4512                 ir_type *const res_type = get_method_res_type(call_tp, 0);
4513                 ir_mode *const res_mode = get_type_mode(res_type);
4514
4515                 if (res_mode != NULL && mode_is_float(res_mode)) {
4516                         env_cg->do_x87_sim = 1;
4517                 }
4518         }
4519
4520         /* We do not want be_Call direct calls */
4521         assert(be_Call_get_entity(node) == NULL);
4522
4523         /* special case for PIC trampoline calls */
4524         old_no_pic_adjust = no_pic_adjust;
4525         no_pic_adjust     = env_cg->birg->main_env->options->pic;
4526
4527         match_arguments(&am, src_block, NULL, src_ptr, src_mem,
4528                         match_am | match_immediate);
4529
4530         no_pic_adjust = old_no_pic_adjust;
4531
4532         i    = get_irn_arity(node) - 1;
4533         fpcw = be_transform_node(get_irn_n(node, i--));
4534         for (; i >= be_pos_Call_first_arg; --i) {
4535                 arch_register_req_t const *const req = arch_get_register_req(node, i);
4536                 ir_node *const reg_parm = be_transform_node(get_irn_n(node, i));
4537
4538                 assert(req->type == arch_register_req_type_limited);
4539                 assert(req->cls == &ia32_reg_classes[CLASS_ia32_gp]);
4540
4541                 switch (*req->limited) {
4542                         case 1 << REG_EAX: assert(eax == noreg_GP); eax = reg_parm; break;
4543                         case 1 << REG_ECX: assert(ecx == noreg_GP); ecx = reg_parm; break;
4544                         case 1 << REG_EDX: assert(edx == noreg_GP); edx = reg_parm; break;
4545                         default: panic("Invalid GP register for register parameter");
4546                 }
4547         }
4548
4549         mem  = transform_AM_mem(block, src_ptr, src_mem, addr->mem);
4550         call = new_bd_ia32_Call(dbgi, block, addr->base, addr->index, mem,
4551                                 am.new_op2, sp, fpcw, eax, ecx, edx, pop, call_tp);
4552         set_am_attributes(call, &am);
4553         call = fix_mem_proj(call, &am);
4554
4555         if (get_irn_pinned(node) == op_pin_state_pinned)
4556                 set_irn_pinned(call, op_pin_state_pinned);
4557
4558         SET_IA32_ORIG_NODE(call, node);
4559
4560         if (ia32_cg_config.use_sse2) {
4561                 /* remember this call for post-processing */
4562                 ARR_APP1(ir_node *, call_list, call);
4563                 ARR_APP1(ir_type *, call_types, be_Call_get_type(node));
4564         }
4565
4566         return call;
4567 }
4568
4569 /**
4570  * Transform Builtin trap
4571  */
4572 static ir_node *gen_trap(ir_node *node) {
4573         dbg_info *dbgi  = get_irn_dbg_info(node);
4574         ir_node *block  = be_transform_node(get_nodes_block(node));
4575         ir_node *mem    = be_transform_node(get_Builtin_mem(node));
4576
4577         return new_bd_ia32_UD2(dbgi, block, mem);
4578 }
4579
4580 /**
4581  * Transform Builtin debugbreak
4582  */
4583 static ir_node *gen_debugbreak(ir_node *node) {
4584         dbg_info *dbgi  = get_irn_dbg_info(node);
4585         ir_node *block  = be_transform_node(get_nodes_block(node));
4586         ir_node *mem    = be_transform_node(get_Builtin_mem(node));
4587
4588         return new_bd_ia32_Breakpoint(dbgi, block, mem);
4589 }
4590
4591 /**
4592  * Transform Builtin return_address
4593  */
4594 static ir_node *gen_return_address(ir_node *node) {
4595         ir_node *param      = get_Builtin_param(node, 0);
4596         ir_node *frame      = get_Builtin_param(node, 1);
4597         dbg_info *dbgi      = get_irn_dbg_info(node);
4598         tarval  *tv         = get_Const_tarval(param);
4599         unsigned long value = get_tarval_long(tv);
4600
4601         ir_node *block  = be_transform_node(get_nodes_block(node));
4602         ir_node *ptr    = be_transform_node(frame);
4603         ir_node *load;
4604
4605         if (value > 0) {
4606                 ir_node *cnt = new_bd_ia32_ProduceVal(dbgi, block);
4607                 ir_node *res = new_bd_ia32_ProduceVal(dbgi, block);
4608                 ptr = new_bd_ia32_ClimbFrame(dbgi, block, ptr, cnt, res, value);
4609         }
4610
4611         /* load the return address from this frame */
4612         load = new_bd_ia32_Load(dbgi, block, ptr, noreg_GP, nomem);
4613
4614         set_irn_pinned(load, get_irn_pinned(node));
4615         set_ia32_op_type(load, ia32_AddrModeS);
4616         set_ia32_ls_mode(load, mode_Iu);
4617
4618         set_ia32_am_offs_int(load, 0);
4619         set_ia32_use_frame(load);
4620         set_ia32_frame_ent(load, ia32_get_return_address_entity());
4621
4622         if (get_irn_pinned(node) == op_pin_state_floats) {
4623                 assert(pn_ia32_xLoad_res == pn_ia32_vfld_res
4624                                 && pn_ia32_vfld_res == pn_ia32_Load_res
4625                                 && pn_ia32_Load_res == pn_ia32_res);
4626                 arch_irn_add_flags(load, arch_irn_flags_rematerializable);
4627         }
4628
4629         SET_IA32_ORIG_NODE(load, node);
4630         return new_r_Proj(block, load, mode_Iu, pn_ia32_Load_res);
4631 }
4632
4633 /**
4634  * Transform Builtin frame_address
4635  */
4636 static ir_node *gen_frame_address(ir_node *node) {
4637         ir_node *param      = get_Builtin_param(node, 0);
4638         ir_node *frame      = get_Builtin_param(node, 1);
4639         dbg_info *dbgi      = get_irn_dbg_info(node);
4640         tarval  *tv         = get_Const_tarval(param);
4641         unsigned long value = get_tarval_long(tv);
4642
4643         ir_node *block  = be_transform_node(get_nodes_block(node));
4644         ir_node *ptr    = be_transform_node(frame);
4645         ir_node *load;
4646         ir_entity *ent;
4647
4648         if (value > 0) {
4649                 ir_node *cnt = new_bd_ia32_ProduceVal(dbgi, block);
4650                 ir_node *res = new_bd_ia32_ProduceVal(dbgi, block);
4651                 ptr = new_bd_ia32_ClimbFrame(dbgi, block, ptr, cnt, res, value);
4652         }
4653
4654         /* load the frame address from this frame */
4655         load = new_bd_ia32_Load(dbgi, block, ptr, noreg_GP, nomem);
4656
4657         set_irn_pinned(load, get_irn_pinned(node));
4658         set_ia32_op_type(load, ia32_AddrModeS);
4659         set_ia32_ls_mode(load, mode_Iu);
4660
4661         ent = ia32_get_frame_address_entity();
4662         if (ent != NULL) {
4663                 set_ia32_am_offs_int(load, 0);
4664                 set_ia32_use_frame(load);
4665                 set_ia32_frame_ent(load, ent);
4666         } else {
4667                 /* will fail anyway, but gcc does this: */
4668                 set_ia32_am_offs_int(load, 0);
4669         }
4670
4671         if (get_irn_pinned(node) == op_pin_state_floats) {
4672                 assert(pn_ia32_xLoad_res == pn_ia32_vfld_res
4673                                 && pn_ia32_vfld_res == pn_ia32_Load_res
4674                                 && pn_ia32_Load_res == pn_ia32_res);
4675                 arch_irn_add_flags(load, arch_irn_flags_rematerializable);
4676         }
4677
4678         SET_IA32_ORIG_NODE(load, node);
4679         return new_r_Proj(block, load, mode_Iu, pn_ia32_Load_res);
4680 }
4681
4682 /**
4683  * Transform Builtin frame_address
4684  */
4685 static ir_node *gen_prefetch(ir_node *node) {
4686         dbg_info       *dbgi;
4687         ir_node        *ptr, *block, *mem, *base, *index;
4688         ir_node        *param,  *new_node;
4689         long           rw, locality;
4690         tarval         *tv;
4691         ia32_address_t addr;
4692
4693         if (!ia32_cg_config.use_sse_prefetch && !ia32_cg_config.use_3dnow_prefetch) {
4694                 /* no prefetch at all, route memory */
4695                 return be_transform_node(get_Builtin_mem(node));
4696         }
4697
4698         param = get_Builtin_param(node, 1);
4699         tv    = get_Const_tarval(param);
4700         rw    = get_tarval_long(tv);
4701
4702         /* construct load address */
4703         memset(&addr, 0, sizeof(addr));
4704         ptr = get_Builtin_param(node, 0);
4705         ia32_create_address_mode(&addr, ptr, 0);
4706         base  = addr.base;
4707         index = addr.index;
4708
4709         if (base == NULL) {
4710                 base = noreg_GP;
4711         } else {
4712                 base = be_transform_node(base);
4713         }
4714
4715         if (index == NULL) {
4716                 index = noreg_GP;
4717         } else {
4718                 index = be_transform_node(index);
4719         }
4720
4721         dbgi     = get_irn_dbg_info(node);
4722         block    = be_transform_node(get_nodes_block(node));
4723         mem      = be_transform_node(get_Builtin_mem(node));
4724
4725         if (rw == 1 && ia32_cg_config.use_3dnow_prefetch) {
4726                 /* we have 3DNow!, this was already checked above */
4727                 new_node = new_bd_ia32_PrefetchW(dbgi, block, base, index, mem);
4728         } else if (ia32_cg_config.use_sse_prefetch) {
4729                 /* note: rw == 1 is IGNORED in that case */
4730                 param    = get_Builtin_param(node, 2);
4731                 tv       = get_Const_tarval(param);
4732                 locality = get_tarval_long(tv);
4733
4734                 /* SSE style prefetch */
4735                 switch (locality) {
4736                 case 0:
4737                         new_node = new_bd_ia32_PrefetchNTA(dbgi, block, base, index, mem);
4738                         break;
4739                 case 1:
4740                         new_node = new_bd_ia32_Prefetch2(dbgi, block, base, index, mem);
4741                         break;
4742                 case 2:
4743                         new_node = new_bd_ia32_Prefetch1(dbgi, block, base, index, mem);
4744                         break;
4745                 default:
4746                         new_node = new_bd_ia32_Prefetch0(dbgi, block, base, index, mem);
4747                         break;
4748                 }
4749         } else {
4750                 assert(ia32_cg_config.use_3dnow_prefetch);
4751                 /* 3DNow! style prefetch */
4752                 new_node = new_bd_ia32_Prefetch(dbgi, block, base, index, mem);
4753         }
4754
4755         set_irn_pinned(new_node, get_irn_pinned(node));
4756         set_ia32_op_type(new_node, ia32_AddrModeS);
4757         set_ia32_ls_mode(new_node, mode_Bu);
4758         set_address(new_node, &addr);
4759
4760         SET_IA32_ORIG_NODE(new_node, node);
4761
4762         be_dep_on_frame(new_node);
4763         return new_r_Proj(block, new_node, mode_M, pn_ia32_Prefetch_M);
4764 }
4765
4766 /**
4767  * Transform bsf like node
4768  */
4769 static ir_node *gen_unop_AM(ir_node *node, construct_binop_dest_func *func)
4770 {
4771         ir_node *param     = get_Builtin_param(node, 0);
4772         dbg_info *dbgi     = get_irn_dbg_info(node);
4773
4774         ir_node *block     = get_nodes_block(node);
4775         ir_node *new_block = be_transform_node(block);
4776
4777         ia32_address_mode_t  am;
4778         ia32_address_t      *addr = &am.addr;
4779         ir_node             *cnt;
4780
4781         match_arguments(&am, block, NULL, param, NULL, match_am);
4782
4783         cnt = func(dbgi, new_block, addr->base, addr->index, addr->mem, am.new_op2);
4784         set_am_attributes(cnt, &am);
4785         set_ia32_ls_mode(cnt, get_irn_mode(param));
4786
4787         SET_IA32_ORIG_NODE(cnt, node);
4788         return fix_mem_proj(cnt, &am);
4789 }
4790
4791 /**
4792  * Transform builtin ffs.
4793  */
4794 static ir_node *gen_ffs(ir_node *node)
4795 {
4796         ir_node  *bsf   = gen_unop_AM(node, new_bd_ia32_Bsf);
4797         ir_node  *real  = skip_Proj(bsf);
4798         dbg_info *dbgi  = get_irn_dbg_info(real);
4799         ir_node  *block = get_nodes_block(real);
4800         ir_node  *flag, *set, *conv, *neg, *or;
4801
4802         /* bsf x */
4803         if (get_irn_mode(real) != mode_T) {
4804                 set_irn_mode(real, mode_T);
4805                 bsf = new_r_Proj(block, real, mode_Iu, pn_ia32_res);
4806         }
4807
4808         flag = new_r_Proj(block, real, mode_b, pn_ia32_flags);
4809
4810         /* sete */
4811         set = new_bd_ia32_Setcc(dbgi, block, flag, pn_Cmp_Eq);
4812         SET_IA32_ORIG_NODE(set, node);
4813
4814         /* conv to 32bit */
4815         conv = new_bd_ia32_Conv_I2I8Bit(dbgi, block, noreg_GP, noreg_GP, nomem, set, mode_Bu);
4816         SET_IA32_ORIG_NODE(conv, node);
4817
4818         /* neg */
4819         neg = new_bd_ia32_Neg(dbgi, block, conv);
4820
4821         /* or */
4822         or = new_bd_ia32_Or(dbgi, block, noreg_GP, noreg_GP, nomem, bsf, neg);
4823         set_ia32_commutative(or);
4824
4825         /* add 1 */
4826         return new_bd_ia32_Add(dbgi, block, noreg_GP, noreg_GP, nomem, or, ia32_create_Immediate(NULL, 0, 1));
4827 }
4828
4829 /**
4830  * Transform builtin clz.
4831  */
4832 static ir_node *gen_clz(ir_node *node)
4833 {
4834         ir_node  *bsr   = gen_unop_AM(node, new_bd_ia32_Bsr);
4835         ir_node  *real  = skip_Proj(bsr);
4836         dbg_info *dbgi  = get_irn_dbg_info(real);
4837         ir_node  *block = get_nodes_block(real);
4838         ir_node  *imm   = ia32_create_Immediate(NULL, 0, 31);
4839
4840         return new_bd_ia32_Xor(dbgi, block, noreg_GP, noreg_GP, nomem, bsr, imm);
4841 }
4842
4843 /**
4844  * Transform builtin ctz.
4845  */
4846 static ir_node *gen_ctz(ir_node *node)
4847 {
4848         return gen_unop_AM(node, new_bd_ia32_Bsf);
4849 }
4850
4851 /**
4852  * Transform builtin parity.
4853  */
4854 static ir_node *gen_parity(ir_node *node)
4855 {
4856         ir_node *param      = get_Builtin_param(node, 0);
4857         dbg_info *dbgi      = get_irn_dbg_info(node);
4858
4859         ir_node *block      = get_nodes_block(node);
4860
4861         ir_node *new_block  = be_transform_node(block);
4862         ir_node *imm, *cmp, *new_node;
4863
4864         ia32_address_mode_t am;
4865         ia32_address_t      *addr = &am.addr;
4866
4867
4868         /* cmp param, 0 */
4869         match_arguments(&am, block, NULL, param, NULL, match_am);
4870         imm = ia32_create_Immediate(NULL, 0, 0);
4871         cmp = new_bd_ia32_Cmp(dbgi, new_block, addr->base, addr->index,
4872                               addr->mem, imm, am.new_op2, am.ins_permuted, 0);
4873         set_am_attributes(cmp, &am);
4874         set_ia32_ls_mode(cmp, mode_Iu);
4875
4876         SET_IA32_ORIG_NODE(cmp, node);
4877
4878         cmp = fix_mem_proj(cmp, &am);
4879
4880         /* setp */
4881         new_node = new_bd_ia32_Setcc(dbgi, new_block, cmp, ia32_pn_Cmp_parity);
4882         SET_IA32_ORIG_NODE(new_node, node);
4883
4884         /* conv to 32bit */
4885         new_node = new_bd_ia32_Conv_I2I8Bit(dbgi, new_block, noreg_GP, noreg_GP,
4886                                             nomem, new_node, mode_Bu);
4887         SET_IA32_ORIG_NODE(new_node, node);
4888         return new_node;
4889 }
4890
4891 /**
4892  * Transform builtin popcount
4893  */
4894 static ir_node *gen_popcount(ir_node *node) {
4895         ir_node *param     = get_Builtin_param(node, 0);
4896         dbg_info *dbgi     = get_irn_dbg_info(node);
4897
4898         ir_node *block     = get_nodes_block(node);
4899         ir_node *new_block = be_transform_node(block);
4900
4901         ir_node *new_param;
4902         ir_node *imm, *simm, *m1, *s1, *s2, *s3, *s4, *s5, *m2, *m3, *m4, *m5, *m6, *m7, *m8, *m9, *m10, *m11, *m12, *m13;
4903
4904         /* check for SSE4.2 or SSE4a and use the popcnt instruction */
4905         if (ia32_cg_config.use_popcnt) {
4906                 ia32_address_mode_t am;
4907                 ia32_address_t      *addr = &am.addr;
4908                 ir_node             *cnt;
4909
4910                 match_arguments(&am, block, NULL, param, NULL, match_am | match_16bit_am);
4911
4912                 cnt = new_bd_ia32_Popcnt(dbgi, new_block, addr->base, addr->index, addr->mem, am.new_op2);
4913                 set_am_attributes(cnt, &am);
4914                 set_ia32_ls_mode(cnt, get_irn_mode(param));
4915
4916                 SET_IA32_ORIG_NODE(cnt, node);
4917                 return fix_mem_proj(cnt, &am);
4918         }
4919
4920         new_param = be_transform_node(param);
4921
4922         /* do the standard popcount algo */
4923
4924         /* m1 = x & 0x55555555 */
4925         imm = ia32_create_Immediate(NULL, 0, 0x55555555);
4926         m1 = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, new_param, imm);
4927
4928         /* s1 = x >> 1 */
4929         simm = ia32_create_Immediate(NULL, 0, 1);
4930         s1 = new_bd_ia32_Shl(dbgi, new_block, new_param, simm);
4931
4932         /* m2 = s1 & 0x55555555 */
4933         m2 = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, s1, imm);
4934
4935         /* m3 = m1 + m2 */
4936         m3 = new_bd_ia32_Lea(dbgi, new_block, m2, m1);
4937
4938         /* m4 = m3 & 0x33333333 */
4939         imm = ia32_create_Immediate(NULL, 0, 0x33333333);
4940         m4 = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, m3, imm);
4941
4942         /* s2 = m3 >> 2 */
4943         simm = ia32_create_Immediate(NULL, 0, 2);
4944         s2 = new_bd_ia32_Shl(dbgi, new_block, m3, simm);
4945
4946         /* m5 = s2 & 0x33333333 */
4947         m5 = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, s2, imm);
4948
4949         /* m6 = m4 + m5 */
4950         m6 = new_bd_ia32_Lea(dbgi, new_block, m4, m5);
4951
4952         /* m7 = m6 & 0x0F0F0F0F */
4953         imm = ia32_create_Immediate(NULL, 0, 0x0F0F0F0F);
4954         m7 = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, m6, imm);
4955
4956         /* s3 = m6 >> 4 */
4957         simm = ia32_create_Immediate(NULL, 0, 4);
4958         s3 = new_bd_ia32_Shl(dbgi, new_block, m6, simm);
4959
4960         /* m8 = s3 & 0x0F0F0F0F */
4961         m8 = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, s3, imm);
4962
4963         /* m9 = m7 + m8 */
4964         m9 = new_bd_ia32_Lea(dbgi, new_block, m7, m8);
4965
4966         /* m10 = m9 & 0x00FF00FF */
4967         imm = ia32_create_Immediate(NULL, 0, 0x00FF00FF);
4968         m10 = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, m9, imm);
4969
4970         /* s4 = m9 >> 8 */
4971         simm = ia32_create_Immediate(NULL, 0, 8);
4972         s4 = new_bd_ia32_Shl(dbgi, new_block, m9, simm);
4973
4974         /* m11 = s4 & 0x00FF00FF */
4975         m11 = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, s4, imm);
4976
4977         /* m12 = m10 + m11 */
4978         m12 = new_bd_ia32_Lea(dbgi, new_block, m10, m11);
4979
4980         /* m13 = m12 & 0x0000FFFF */
4981         imm = ia32_create_Immediate(NULL, 0, 0x0000FFFF);
4982         m13 = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, m12, imm);
4983
4984         /* s5 = m12 >> 16 */
4985         simm = ia32_create_Immediate(NULL, 0, 16);
4986         s5 = new_bd_ia32_Shl(dbgi, new_block, m12, simm);
4987
4988         /* res = m13 + s5 */
4989         return new_bd_ia32_Lea(dbgi, new_block, m13, s5);
4990 }
4991
4992 /**
4993  * Transform builtin byte swap.
4994  */
4995 static ir_node *gen_bswap(ir_node *node) {
4996         ir_node *param     = be_transform_node(get_Builtin_param(node, 0));
4997         dbg_info *dbgi     = get_irn_dbg_info(node);
4998
4999         ir_node *block     = get_nodes_block(node);
5000         ir_node *new_block = be_transform_node(block);
5001         ir_mode *mode      = get_irn_mode(param);
5002         unsigned size      = get_mode_size_bits(mode);
5003         ir_node  *m1, *m2, *m3, *m4, *s1, *s2, *s3, *s4;
5004
5005         switch (size) {
5006         case 32:
5007                 if (ia32_cg_config.use_i486) {
5008                         /* swap available */
5009                         return new_bd_ia32_Bswap(dbgi, new_block, param);
5010                 }
5011                 s1 = new_bd_ia32_Shl(dbgi, new_block, param, ia32_create_Immediate(NULL, 0, 24));
5012                 s2 = new_bd_ia32_Shl(dbgi, new_block, param, ia32_create_Immediate(NULL, 0, 8));
5013
5014                 m1 = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, s2, ia32_create_Immediate(NULL, 0, 0xFF00));
5015                 m2 = new_bd_ia32_Lea(dbgi, new_block, s1, m1);
5016
5017                 s3 = new_bd_ia32_Shr(dbgi, new_block, param, ia32_create_Immediate(NULL, 0, 8));
5018
5019                 m3 = new_bd_ia32_And(dbgi, new_block, noreg_GP, noreg_GP, nomem, s3, ia32_create_Immediate(NULL, 0, 0xFF0000));
5020                 m4 = new_bd_ia32_Lea(dbgi, new_block, m2, m3);
5021
5022                 s4 = new_bd_ia32_Shr(dbgi, new_block, param, ia32_create_Immediate(NULL, 0, 24));
5023                 return new_bd_ia32_Lea(dbgi, new_block, m4, s4);
5024
5025         case 16:
5026                 /* swap16 always available */
5027                 return new_bd_ia32_Bswap16(dbgi, new_block, param);
5028
5029         default:
5030                 panic("Invalid bswap size (%d)", size);
5031         }
5032 }
5033
5034 /**
5035  * Transform builtin outport.
5036  */
5037 static ir_node *gen_outport(ir_node *node) {
5038         ir_node *port  = create_immediate_or_transform(get_Builtin_param(node, 0), 0);
5039         ir_node *oldv  = get_Builtin_param(node, 1);
5040         ir_mode *mode  = get_irn_mode(oldv);
5041         ir_node *value = be_transform_node(oldv);
5042         ir_node *block = be_transform_node(get_nodes_block(node));
5043         ir_node *mem   = be_transform_node(get_Builtin_mem(node));
5044         dbg_info *dbgi = get_irn_dbg_info(node);
5045
5046         ir_node *res = new_bd_ia32_Outport(dbgi, block, port, value, mem);
5047         set_ia32_ls_mode(res, mode);
5048         return res;
5049 }
5050
5051 /**
5052  * Transform builtin inport.
5053  */
5054 static ir_node *gen_inport(ir_node *node) {
5055         ir_type *tp    = get_Builtin_type(node);
5056         ir_type *rstp  = get_method_res_type(tp, 0);
5057         ir_mode *mode  = get_type_mode(rstp);
5058         ir_node *port  = create_immediate_or_transform(get_Builtin_param(node, 0), 0);
5059         ir_node *block = be_transform_node(get_nodes_block(node));
5060         ir_node *mem   = be_transform_node(get_Builtin_mem(node));
5061         dbg_info *dbgi = get_irn_dbg_info(node);
5062
5063         ir_node *res = new_bd_ia32_Inport(dbgi, block, port, mem);
5064         set_ia32_ls_mode(res, mode);
5065
5066         /* check for missing Result Proj */
5067         return res;
5068 }
5069
5070 /**
5071  * Transform a builtin inner trampoline
5072  */
5073 static ir_node *gen_inner_trampoline(ir_node *node) {
5074         ir_node  *ptr       = get_Builtin_param(node, 0);
5075         ir_node  *callee    = get_Builtin_param(node, 1);
5076         ir_node  *env       = be_transform_node(get_Builtin_param(node, 2));
5077         ir_node  *mem       = get_Builtin_mem(node);
5078         ir_node  *block     = get_nodes_block(node);
5079         ir_node  *new_block = be_transform_node(block);
5080         ir_node  *val;
5081         ir_node  *store;
5082         ir_node  *rel;
5083         ir_node  *trampoline;
5084         ir_node  *in[2];
5085         dbg_info *dbgi      = get_irn_dbg_info(node);
5086         ia32_address_t addr;
5087
5088         /* construct store address */
5089         memset(&addr, 0, sizeof(addr));
5090         ia32_create_address_mode(&addr, ptr, 0);
5091
5092         if (addr.base == NULL) {
5093                 addr.base = noreg_GP;
5094         } else {
5095                 addr.base = be_transform_node(addr.base);
5096         }
5097
5098         if (addr.index == NULL) {
5099                 addr.index = noreg_GP;
5100         } else {
5101                 addr.index = be_transform_node(addr.index);
5102         }
5103         addr.mem = be_transform_node(mem);
5104
5105         /* mov  ecx, <env> */
5106         val   = ia32_create_Immediate(NULL, 0, 0xB9);
5107         store = new_bd_ia32_Store8Bit(dbgi, new_block, addr.base,
5108                                       addr.index, addr.mem, val);
5109         set_irn_pinned(store, get_irn_pinned(node));
5110         set_ia32_op_type(store, ia32_AddrModeD);
5111         set_ia32_ls_mode(store, mode_Bu);
5112         set_address(store, &addr);
5113         addr.mem = store;
5114         addr.offset += 1;
5115
5116         store = new_bd_ia32_Store(dbgi, new_block, addr.base,
5117                                   addr.index, addr.mem, env);
5118         set_irn_pinned(store, get_irn_pinned(node));
5119         set_ia32_op_type(store, ia32_AddrModeD);
5120         set_ia32_ls_mode(store, mode_Iu);
5121         set_address(store, &addr);
5122         addr.mem = store;
5123         addr.offset += 4;
5124
5125         /* jmp rel <callee> */
5126         val   = ia32_create_Immediate(NULL, 0, 0xE9);
5127         store = new_bd_ia32_Store8Bit(dbgi, new_block, addr.base,
5128                                      addr.index, addr.mem, val);
5129         set_irn_pinned(store, get_irn_pinned(node));
5130         set_ia32_op_type(store, ia32_AddrModeD);
5131         set_ia32_ls_mode(store, mode_Bu);
5132         set_address(store, &addr);
5133         addr.mem = store;
5134         addr.offset += 1;
5135
5136         trampoline = be_transform_node(ptr);
5137
5138         /* the callee is typically an immediate */
5139         if (is_SymConst(callee)) {
5140                 rel = new_bd_ia32_Const(dbgi, new_block, get_SymConst_entity(callee), 0, 0, -10);
5141         } else {
5142                 rel = new_bd_ia32_Lea(dbgi, new_block, be_transform_node(callee), ia32_create_Immediate(NULL, 0, -10));
5143         }
5144         rel = new_bd_ia32_Sub(dbgi, new_block, noreg_GP, noreg_GP, nomem, rel, trampoline);
5145
5146         store = new_bd_ia32_Store(dbgi, new_block, addr.base,
5147                                   addr.index, addr.mem, rel);
5148         set_irn_pinned(store, get_irn_pinned(node));
5149         set_ia32_op_type(store, ia32_AddrModeD);
5150         set_ia32_ls_mode(store, mode_Iu);
5151         set_address(store, &addr);
5152
5153         in[0] = store;
5154         in[1] = trampoline;
5155
5156         return new_r_Tuple(new_block, 2, in);
5157 }
5158
5159 /**
5160  * Transform Builtin node.
5161  */
5162 static ir_node *gen_Builtin(ir_node *node) {
5163         ir_builtin_kind kind = get_Builtin_kind(node);
5164
5165         switch (kind) {
5166         case ir_bk_trap:
5167                 return gen_trap(node);
5168         case ir_bk_debugbreak:
5169                 return gen_debugbreak(node);
5170         case ir_bk_return_address:
5171                 return gen_return_address(node);
5172         case ir_bk_frame_address:
5173                 return gen_frame_address(node);
5174         case ir_bk_prefetch:
5175                 return gen_prefetch(node);
5176         case ir_bk_ffs:
5177                 return gen_ffs(node);
5178         case ir_bk_clz:
5179                 return gen_clz(node);
5180         case ir_bk_ctz:
5181                 return gen_ctz(node);
5182         case ir_bk_parity:
5183                 return gen_parity(node);
5184         case ir_bk_popcount:
5185                 return gen_popcount(node);
5186         case ir_bk_bswap:
5187                 return gen_bswap(node);
5188         case ir_bk_outport:
5189                 return gen_outport(node);
5190         case ir_bk_inport:
5191                 return gen_inport(node);
5192         case ir_bk_inner_trampoline:
5193                 return gen_inner_trampoline(node);
5194         }
5195         panic("Builtin %s not implemented in IA32", get_builtin_kind_name(kind));
5196 }
5197
5198 /**
5199  * Transform Proj(Builtin) node.
5200  */
5201 static ir_node *gen_Proj_Builtin(ir_node *proj) {
5202         ir_node         *node     = get_Proj_pred(proj);
5203         ir_node         *new_node = be_transform_node(node);
5204         ir_builtin_kind kind      = get_Builtin_kind(node);
5205
5206         switch (kind) {
5207         case ir_bk_return_address:
5208         case ir_bk_frame_address:
5209         case ir_bk_ffs:
5210         case ir_bk_clz:
5211         case ir_bk_ctz:
5212         case ir_bk_parity:
5213         case ir_bk_popcount:
5214         case ir_bk_bswap:
5215                 assert(get_Proj_proj(proj) == pn_Builtin_1_result);
5216                 return new_node;
5217         case ir_bk_trap:
5218         case ir_bk_debugbreak:
5219         case ir_bk_prefetch:
5220         case ir_bk_outport:
5221                 assert(get_Proj_proj(proj) == pn_Builtin_M);
5222                 return new_node;
5223         case ir_bk_inport:
5224                 if (get_Proj_proj(proj) == pn_Builtin_1_result) {
5225                         return new_r_Proj(get_nodes_block(new_node),
5226                                           new_node, get_irn_mode(proj), pn_ia32_Inport_res);
5227                 } else {
5228                         assert(get_Proj_proj(proj) == pn_Builtin_M);
5229                         return new_r_Proj(get_nodes_block(new_node),
5230                                 new_node, mode_M, pn_ia32_Inport_M);
5231                 }
5232         case ir_bk_inner_trampoline:
5233                 if (get_Proj_proj(proj) == pn_Builtin_1_result) {
5234                         return get_Tuple_pred(new_node, 1);
5235                 } else {
5236                         assert(get_Proj_proj(proj) == pn_Builtin_M);
5237                         return get_Tuple_pred(new_node, 0);
5238                 }
5239         }
5240         panic("Builtin %s not implemented in IA32", get_builtin_kind_name(kind));
5241 }
5242
5243 static ir_node *gen_be_IncSP(ir_node *node)
5244 {
5245         ir_node *res = be_duplicate_node(node);
5246         arch_irn_add_flags(res, arch_irn_flags_modify_flags);
5247
5248         return res;
5249 }
5250
5251 /**
5252  * Transform the Projs from a be_Call.
5253  */
5254 static ir_node *gen_Proj_be_Call(ir_node *node)
5255 {
5256         ir_node  *block       = be_transform_node(get_nodes_block(node));
5257         ir_node  *call        = get_Proj_pred(node);
5258         ir_node  *new_call    = be_transform_node(call);
5259         dbg_info *dbgi        = get_irn_dbg_info(node);
5260         long      proj        = get_Proj_proj(node);
5261         ir_mode  *mode        = get_irn_mode(node);
5262         ir_node  *res;
5263
5264         if (proj == pn_be_Call_M_regular) {
5265                 return new_rd_Proj(dbgi, block, new_call, mode_M, n_ia32_Call_mem);
5266         }
5267         /* transform call modes */
5268         if (mode_is_data(mode)) {
5269                 const arch_register_class_t *cls = arch_get_irn_reg_class_out(node);
5270                 mode = cls->mode;
5271         }
5272
5273         /* Map from be_Call to ia32_Call proj number */
5274         if (proj == pn_be_Call_sp) {
5275                 proj = pn_ia32_Call_stack;
5276         } else if (proj == pn_be_Call_M_regular) {
5277                 proj = pn_ia32_Call_M;
5278         } else {
5279                 arch_register_req_t const *const req    = arch_get_register_req_out(node);
5280                 int                        const n_outs = arch_irn_get_n_outs(new_call);
5281                 int                              i;
5282
5283                 assert(proj      >= pn_be_Call_first_res);
5284                 assert(req->type & arch_register_req_type_limited);
5285
5286                 for (i = 0; i < n_outs; ++i) {
5287                         arch_register_req_t const *const new_req
5288                                 = arch_get_out_register_req(new_call, i);
5289
5290                         if (!(new_req->type & arch_register_req_type_limited) ||
5291                             new_req->cls      != req->cls                     ||
5292                             *new_req->limited != *req->limited)
5293                                 continue;
5294
5295                         proj = i;
5296                         break;
5297                 }
5298                 assert(i < n_outs);
5299         }
5300
5301         res = new_rd_Proj(dbgi, block, new_call, mode, proj);
5302
5303         /* TODO arch_set_irn_register() only operates on Projs, need variant with index */
5304         switch (proj) {
5305                 case pn_ia32_Call_stack:
5306                         arch_set_irn_register(res, &ia32_gp_regs[REG_ESP]);
5307                         break;
5308
5309                 case pn_ia32_Call_fpcw:
5310                         arch_set_irn_register(res, &ia32_fp_cw_regs[REG_FPCW]);
5311                         break;
5312         }
5313
5314         return res;
5315 }
5316
5317 /**
5318  * Transform the Projs from a Cmp.
5319  */
5320 static ir_node *gen_Proj_Cmp(ir_node *node)
5321 {
5322         /* this probably means not all mode_b nodes were lowered... */
5323         panic("trying to directly transform Proj_Cmp %+F (mode_b not lowered?)",
5324               node);
5325 }
5326
5327 /**
5328  * Transform the Projs from a Bound.
5329  */
5330 static ir_node *gen_Proj_Bound(ir_node *node)
5331 {
5332         ir_node *new_node, *block;
5333         ir_node *pred = get_Proj_pred(node);
5334
5335         switch (get_Proj_proj(node)) {
5336         case pn_Bound_M:
5337                 return be_transform_node(get_Bound_mem(pred));
5338         case pn_Bound_X_regular:
5339                 new_node = be_transform_node(pred);
5340                 block    = get_nodes_block(new_node);
5341                 return new_r_Proj(block, new_node, mode_X, pn_ia32_Jcc_true);
5342         case pn_Bound_X_except:
5343                 new_node = be_transform_node(pred);
5344                 block    = get_nodes_block(new_node);
5345                 return new_r_Proj(block, new_node, mode_X, pn_ia32_Jcc_false);
5346         case pn_Bound_res:
5347                 return be_transform_node(get_Bound_index(pred));
5348         default:
5349                 panic("unsupported Proj from Bound");
5350         }
5351 }
5352
5353 static ir_node *gen_Proj_ASM(ir_node *node)
5354 {
5355         ir_mode *mode     = get_irn_mode(node);
5356         ir_node *pred     = get_Proj_pred(node);
5357         ir_node *new_pred = be_transform_node(pred);
5358         ir_node *block    = get_nodes_block(new_pred);
5359         long     pos      = get_Proj_proj(node);
5360
5361         if (mode == mode_M) {
5362                 pos = arch_irn_get_n_outs(new_pred)-1;
5363         } else if (mode_is_int(mode) || mode_is_reference(mode)) {
5364                 mode = mode_Iu;
5365         } else if (mode_is_float(mode)) {
5366                 mode = mode_E;
5367         } else {
5368                 panic("unexpected proj mode at ASM");
5369         }
5370
5371         return new_r_Proj(block, new_pred, mode, pos);
5372 }
5373
5374 /**
5375  * Transform and potentially renumber Proj nodes.
5376  */
5377 static ir_node *gen_Proj(ir_node *node)
5378 {
5379         ir_node *pred = get_Proj_pred(node);
5380         long    proj;
5381
5382         switch (get_irn_opcode(pred)) {
5383         case iro_Store:
5384                 proj = get_Proj_proj(node);
5385                 if (proj == pn_Store_M) {
5386                         return be_transform_node(pred);
5387                 } else {
5388                         panic("No idea how to transform proj->Store");
5389                 }
5390         case iro_Load:
5391                 return gen_Proj_Load(node);
5392         case iro_ASM:
5393                 return gen_Proj_ASM(node);
5394         case iro_Builtin:
5395                 return gen_Proj_Builtin(node);
5396         case iro_Div:
5397         case iro_Mod:
5398         case iro_DivMod:
5399                 return gen_Proj_DivMod(node);
5400         case iro_CopyB:
5401                 return gen_Proj_CopyB(node);
5402         case iro_Quot:
5403                 return gen_Proj_Quot(node);
5404         case beo_SubSP:
5405                 return gen_Proj_be_SubSP(node);
5406         case beo_AddSP:
5407                 return gen_Proj_be_AddSP(node);
5408         case beo_Call:
5409                 return gen_Proj_be_Call(node);
5410         case iro_Cmp:
5411                 return gen_Proj_Cmp(node);
5412         case iro_Bound:
5413                 return gen_Proj_Bound(node);
5414         case iro_Start:
5415                 proj = get_Proj_proj(node);
5416                 switch (proj) {
5417                         case pn_Start_X_initial_exec: {
5418                                 ir_node  *block     = get_nodes_block(pred);
5419                                 ir_node  *new_block = be_transform_node(block);
5420                                 dbg_info *dbgi      = get_irn_dbg_info(node);
5421                                 /* we exchange the ProjX with a jump */
5422                                 ir_node  *jump      = new_rd_Jmp(dbgi, new_block);
5423
5424                                 return jump;
5425                         }
5426
5427                         case pn_Start_P_tls:
5428                                 return gen_Proj_tls(node);
5429                 }
5430                 break;
5431
5432         default:
5433                 if (is_ia32_l_FloattoLL(pred)) {
5434                         return gen_Proj_l_FloattoLL(node);
5435 #ifdef FIRM_EXT_GRS
5436                 } else if (!is_ia32_irn(pred)) { // Quick hack for SIMD optimization
5437 #else
5438                 } else {
5439 #endif
5440                         ir_mode *mode = get_irn_mode(node);
5441                         if (ia32_mode_needs_gp_reg(mode)) {
5442                                 ir_node *new_pred = be_transform_node(pred);
5443                                 ir_node *block    = be_transform_node(get_nodes_block(node));
5444                                 ir_node *new_proj = new_r_Proj(block, new_pred,
5445                                                                                            mode_Iu, get_Proj_proj(node));
5446                                 new_proj->node_nr = node->node_nr;
5447                                 return new_proj;
5448                         }
5449                 }
5450         }
5451         return be_duplicate_node(node);
5452 }
5453
5454 /**
5455  * Enters all transform functions into the generic pointer
5456  */
5457 static void register_transformers(void)
5458 {
5459         /* first clear the generic function pointer for all ops */
5460         clear_irp_opcodes_generic_func();
5461
5462 #define GEN(a)   { be_transform_func *func = gen_##a; op_##a->ops.generic = (op_func) func; }
5463 #define BAD(a)   op_##a->ops.generic = (op_func)bad_transform
5464
5465         GEN(Add);
5466         GEN(Sub);
5467         GEN(Mul);
5468         GEN(Mulh);
5469         GEN(And);
5470         GEN(Or);
5471         GEN(Eor);
5472
5473         GEN(Shl);
5474         GEN(Shr);
5475         GEN(Shrs);
5476         GEN(Rotl);
5477
5478         GEN(Quot);
5479
5480         GEN(Div);
5481         GEN(Mod);
5482         GEN(DivMod);
5483
5484         GEN(Minus);
5485         GEN(Conv);
5486         GEN(Abs);
5487         GEN(Not);
5488
5489         GEN(Load);
5490         GEN(Store);
5491         GEN(Cond);
5492
5493         GEN(Cmp);
5494         GEN(ASM);
5495         GEN(CopyB);
5496         GEN(Mux);
5497         GEN(Proj);
5498         GEN(Phi);
5499         GEN(Jmp);
5500         GEN(IJmp);
5501         GEN(Bound);
5502
5503         /* transform ops from intrinsic lowering */
5504         GEN(ia32_l_Add);
5505         GEN(ia32_l_Adc);
5506         GEN(ia32_l_Mul);
5507         GEN(ia32_l_IMul);
5508         GEN(ia32_l_ShlDep);
5509         GEN(ia32_l_ShrDep);
5510         GEN(ia32_l_SarDep);
5511         GEN(ia32_l_ShlD);
5512         GEN(ia32_l_ShrD);
5513         GEN(ia32_l_Sub);
5514         GEN(ia32_l_Sbb);
5515         GEN(ia32_l_LLtoFloat);
5516         GEN(ia32_l_FloattoLL);
5517
5518         GEN(Const);
5519         GEN(SymConst);
5520         GEN(Unknown);
5521
5522         /* we should never see these nodes */
5523         BAD(Raise);
5524         BAD(Sel);
5525         BAD(InstOf);
5526         BAD(Cast);
5527         BAD(Free);
5528         BAD(Tuple);
5529         BAD(Id);
5530         //BAD(Bad);
5531         BAD(Confirm);
5532         BAD(Filter);
5533         BAD(CallBegin);
5534         BAD(EndReg);
5535         BAD(EndExcept);
5536
5537         /* handle builtins */
5538         GEN(Builtin);
5539
5540         /* handle generic backend nodes */
5541         GEN(be_FrameAddr);
5542         GEN(be_Call);
5543         GEN(be_IncSP);
5544         GEN(be_Return);
5545         GEN(be_AddSP);
5546         GEN(be_SubSP);
5547         GEN(be_Copy);
5548
5549 #undef GEN
5550 #undef BAD
5551 }
5552
5553 /**
5554  * Pre-transform all unknown and noreg nodes.
5555  */
5556 static void ia32_pretransform_node(void)
5557 {
5558         ia32_code_gen_t *cg = env_cg;
5559
5560         cg->unknown_gp  = be_pre_transform_node(cg->unknown_gp);
5561         cg->unknown_vfp = be_pre_transform_node(cg->unknown_vfp);
5562         cg->unknown_xmm = be_pre_transform_node(cg->unknown_xmm);
5563         cg->noreg_gp    = be_pre_transform_node(cg->noreg_gp);
5564         cg->noreg_vfp   = be_pre_transform_node(cg->noreg_vfp);
5565         cg->noreg_xmm   = be_pre_transform_node(cg->noreg_xmm);
5566
5567         nomem    = get_irg_no_mem(current_ir_graph);
5568         noreg_GP = ia32_new_NoReg_gp(cg);
5569
5570         get_fpcw();
5571 }
5572
5573 /**
5574  * Walker, checks if all ia32 nodes producing more than one result have their
5575  * Projs, otherwise creates new Projs and keeps them using a be_Keep node.
5576  */
5577 static void add_missing_keep_walker(ir_node *node, void *data)
5578 {
5579         int              n_outs, i;
5580         unsigned         found_projs = 0;
5581         const ir_edge_t *edge;
5582         ir_mode         *mode = get_irn_mode(node);
5583         ir_node         *last_keep;
5584         (void) data;
5585         if (mode != mode_T)
5586                 return;
5587         if (!is_ia32_irn(node))
5588                 return;
5589
5590         n_outs = arch_irn_get_n_outs(node);
5591         if (n_outs <= 0)
5592                 return;
5593         if (is_ia32_SwitchJmp(node))
5594                 return;
5595
5596         assert(n_outs < (int) sizeof(unsigned) * 8);
5597         foreach_out_edge(node, edge) {
5598                 ir_node *proj = get_edge_src_irn(edge);
5599                 int      pn;
5600
5601                 /* The node could be kept */
5602                 if (is_End(proj))
5603                         continue;
5604
5605                 if (get_irn_mode(proj) == mode_M)
5606                         continue;
5607
5608                 pn = get_Proj_proj(proj);
5609                 assert(pn < n_outs);
5610                 found_projs |= 1 << pn;
5611         }
5612
5613
5614         /* are keeps missing? */
5615         last_keep = NULL;
5616         for (i = 0; i < n_outs; ++i) {
5617                 ir_node                     *block;
5618                 ir_node                     *in[1];
5619                 const arch_register_req_t   *req;
5620                 const arch_register_class_t *cls;
5621
5622                 if (found_projs & (1 << i)) {
5623                         continue;
5624                 }
5625
5626                 req = arch_get_out_register_req(node, i);
5627                 cls = req->cls;
5628                 if (cls == NULL) {
5629                         continue;
5630                 }
5631                 if (cls == &ia32_reg_classes[CLASS_ia32_flags]) {
5632                         continue;
5633                 }
5634
5635                 block = get_nodes_block(node);
5636                 in[0] = new_r_Proj(block, node, arch_register_class_mode(cls), i);
5637                 if (last_keep != NULL) {
5638                         be_Keep_add_node(last_keep, cls, in[0]);
5639                 } else {
5640                         last_keep = be_new_Keep(block, 1, in);
5641                         if (sched_is_scheduled(node)) {
5642                                 sched_add_after(node, last_keep);
5643                         }
5644                 }
5645         }
5646 }
5647
5648 /**
5649  * Adds missing keeps to nodes. Adds missing Proj nodes for unused outputs
5650  * and keeps them.
5651  */
5652 void ia32_add_missing_keeps(ia32_code_gen_t *cg)
5653 {
5654         ir_graph *irg = be_get_birg_irg(cg->birg);
5655         irg_walk_graph(irg, add_missing_keep_walker, NULL, NULL);
5656 }
5657
5658 /**
5659  * Post-process all calls if we are in SSE mode.
5660  * The ABI requires that the results are in st0, copy them
5661  * to a xmm register.
5662  */
5663 static void postprocess_fp_call_results(void) {
5664         int i;
5665
5666         for (i = ARR_LEN(call_list) - 1; i >= 0; --i) {
5667                 ir_node *call = call_list[i];
5668                 ir_type *mtp  = call_types[i];
5669                 int     j;
5670
5671                 for (j = get_method_n_ress(mtp) - 1; j >= 0; --j) {
5672                         ir_type *res_tp = get_method_res_type(mtp, j);
5673                         ir_node *res, *new_res;
5674                         const ir_edge_t *edge, *next;
5675                         ir_mode *mode;
5676
5677                         if (! is_atomic_type(res_tp)) {
5678                                 /* no floating point return */
5679                                 continue;
5680                         }
5681                         mode = get_type_mode(res_tp);
5682                         if (! mode_is_float(mode)) {
5683                                 /* no floating point return */
5684                                 continue;
5685                         }
5686
5687                         res     = be_get_Proj_for_pn(call, pn_ia32_Call_vf0 + j);
5688                         new_res = NULL;
5689
5690                         /* now patch the users */
5691                         foreach_out_edge_safe(res, edge, next) {
5692                                 ir_node *succ = get_edge_src_irn(edge);
5693
5694                                 /* ignore Keeps */
5695                                 if (be_is_Keep(succ))
5696                                         continue;
5697
5698                                 if (is_ia32_xStore(succ)) {
5699                                         /* an xStore can be patched into an vfst */
5700                                         dbg_info *db    = get_irn_dbg_info(succ);
5701                                         ir_node  *block = get_nodes_block(succ);
5702                                         ir_node  *base  = get_irn_n(succ, n_ia32_xStore_base);
5703                                         ir_node  *index = get_irn_n(succ, n_ia32_xStore_index);
5704                                         ir_node  *mem   = get_irn_n(succ, n_ia32_xStore_mem);
5705                                         ir_node  *value = get_irn_n(succ, n_ia32_xStore_val);
5706                                         ir_mode  *mode  = get_ia32_ls_mode(succ);
5707
5708                                         ir_node  *st = new_bd_ia32_vfst(db, block, base, index, mem, value, mode);
5709                                         set_ia32_am_offs_int(st, get_ia32_am_offs_int(succ));
5710                                         if (is_ia32_use_frame(succ))
5711                                                 set_ia32_use_frame(st);
5712                                         set_ia32_frame_ent(st, get_ia32_frame_ent(succ));
5713                                         set_irn_pinned(st, get_irn_pinned(succ));
5714                                         set_ia32_op_type(st, ia32_AddrModeD);
5715
5716                                         exchange(succ, st);
5717                                 } else {
5718                                         if (new_res == NULL) {
5719                                                 dbg_info *db       = get_irn_dbg_info(call);
5720                                                 ir_node  *block    = get_nodes_block(call);
5721                                                 ir_node  *frame    = get_irg_frame(current_ir_graph);
5722                                                 ir_node  *old_mem  = be_get_Proj_for_pn(call, pn_ia32_Call_M);
5723                                                 ir_node  *call_mem = new_r_Proj(block, call, mode_M, pn_ia32_Call_M);
5724                                                 ir_node  *vfst, *xld, *new_mem;
5725
5726                                                 /* store st(0) on stack */
5727                                                 vfst = new_bd_ia32_vfst(db, block, frame, noreg_GP, call_mem, res, mode);
5728                                                 set_ia32_op_type(vfst, ia32_AddrModeD);
5729                                                 set_ia32_use_frame(vfst);
5730
5731                                                 /* load into SSE register */
5732                                                 xld = new_bd_ia32_xLoad(db, block, frame, noreg_GP, vfst, mode);
5733                                                 set_ia32_op_type(xld, ia32_AddrModeS);
5734                                                 set_ia32_use_frame(xld);
5735
5736                                                 new_res = new_r_Proj(block, xld, mode, pn_ia32_xLoad_res);
5737                                                 new_mem = new_r_Proj(block, xld, mode_M, pn_ia32_xLoad_M);
5738
5739                                                 if (old_mem != NULL) {
5740                                                         edges_reroute(old_mem, new_mem, current_ir_graph);
5741                                                         kill_node(old_mem);
5742                                                 }
5743                                         }
5744                                         set_irn_n(succ, get_edge_src_pos(edge), new_res);
5745                                 }
5746                         }
5747                 }
5748         }
5749 }
5750
5751 /* do the transformation */
5752 void ia32_transform_graph(ia32_code_gen_t *cg)
5753 {
5754         int cse_last;
5755
5756         register_transformers();
5757         env_cg        = cg;
5758         initial_fpcw  = NULL;
5759         no_pic_adjust = 0;
5760
5761         be_timer_push(T_HEIGHTS);
5762         heights      = heights_new(cg->irg);
5763         be_timer_pop(T_HEIGHTS);
5764         ia32_calculate_non_address_mode_nodes(cg->birg);
5765
5766         /* the transform phase is not safe for CSE (yet) because several nodes get
5767          * attributes set after their creation */
5768         cse_last = get_opt_cse();
5769         set_opt_cse(0);
5770
5771         call_list  = NEW_ARR_F(ir_node *, 0);
5772         call_types = NEW_ARR_F(ir_type *, 0);
5773         be_transform_graph(cg->birg, ia32_pretransform_node);
5774
5775         if (ia32_cg_config.use_sse2)
5776                 postprocess_fp_call_results();
5777         DEL_ARR_F(call_types);
5778         DEL_ARR_F(call_list);
5779
5780         set_opt_cse(cse_last);
5781
5782         ia32_free_non_address_mode_nodes();
5783         heights_free(heights);
5784         heights = NULL;
5785 }
5786
5787 void ia32_init_transform(void)
5788 {
5789         FIRM_DBG_REGISTER(dbg, "firm.be.ia32.transform");
5790 }