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