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

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