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