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

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