nsz Git - libfirm/blob - ir/be/ia32/ia32_transform.c

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