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

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