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