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