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