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