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

   1 /*
   2  * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   6  * This file may be distributed and/or modified under the terms of the
   7  * GNU General Public License version 2 as published by the Free Software
   8  * Foundation and appearing in the file LICENSE.GPL included in the
   9  * packaging of this file.
  10  *
  11  * Licensees holding valid libFirm Professional Edition licenses may use
  12  * this file in accordance with the libFirm Commercial License.
  13  * Agreement provided with the Software.
  14  *
  15  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief       This file implements the IR transformation from firm into
  23  *              ia32-Firm.
  24  * @author      Christian Wuerdig, Matthias Braun
  25  * @version     $Id$
  26  */
  27 #include "config.h"
  28
  29 #include <limits.h>
  30 #include <stdbool.h>
  31
  32 #include "irargs_t.h"
  33 #include "irnode_t.h"
  34 #include "irgraph_t.h"
  35 #include "irmode_t.h"
  36 #include "iropt_t.h"
  37 #include "irop_t.h"
  38 #include "irprog_t.h"
  39 #include "iredges_t.h"
  40 #include "irgmod.h"
  41 #include "irvrfy.h"
  42 #include "ircons.h"
  43 #include "irgwalk.h"
  44 #include "irprintf.h"
  45 #include "debug.h"
  46 #include "irdom.h"
  47 #include "archop.h"
  48 #include "error.h"
  49 #include "array_t.h"
  50 #include "height.h"
  51
  52 #include "../benode_t.h"
  53 #include "../besched.h"
  54 #include "../beabi.h"
  55 #include "../beutil.h"
  56 #include "../beirg_t.h"
  57 #include "../betranshlp.h"
  58 #include "../be_t.h"
  59
  60 #include "bearch_ia32_t.h"
  61 #include "ia32_common_transform.h"
  62 #include "ia32_nodes_attr.h"
  63 #include "ia32_transform.h"
  64 #include "ia32_new_nodes.h"
  65 #include "ia32_map_regs.h"
  66 #include "ia32_dbg_stat.h"
  67 #include "ia32_optimize.h"
  68 #include "ia32_util.h"
  69 #include "ia32_address_mode.h"
  70 #include "ia32_architecture.h"
  71
  72 #include "gen_ia32_regalloc_if.h"
  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
  80 #define TP_SFP_SIGN "ia32_sfp_sign"
  81 #define TP_DFP_SIGN "ia32_dfp_sign"
  82 #define TP_SFP_ABS  "ia32_sfp_abs"
  83 #define TP_DFP_ABS  "ia32_dfp_abs"
  84 #define TP_INT_MAX  "ia32_int_max"
  85
  86 #define ENT_SFP_SIGN "IA32_SFP_SIGN"
  87 #define ENT_DFP_SIGN "IA32_DFP_SIGN"
  88 #define ENT_SFP_ABS  "IA32_SFP_ABS"
  89 #define ENT_DFP_ABS  "IA32_DFP_ABS"
  90 #define ENT_INT_MAX  "IA32_INT_MAX"
  91
  92 #define mode_vfp        (ia32_reg_classes[CLASS_ia32_vfp].mode)
  93 #define mode_xmm    (ia32_reg_classes[CLASS_ia32_xmm].mode)
  94
  95 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
  96
  97 static ir_node         *initial_fpcw = NULL;
  98
  99 extern ir_op *get_op_Mulh(void);
 100
 101 typedef ir_node *construct_binop_func(dbg_info *db, ir_node *block,
 102         ir_node *base, ir_node *index, ir_node *mem, ir_node *op1,
 103         ir_node *op2);
 104
 105 typedef ir_node *construct_binop_flags_func(dbg_info *db, ir_node *block,
 106         ir_node *base, ir_node *index, ir_node *mem, ir_node *op1, ir_node *op2,
 107         ir_node *flags);
 108
 109 typedef ir_node *construct_shift_func(dbg_info *db, ir_node *block,
 110         ir_node *op1, ir_node *op2);
 111
 112 typedef ir_node *construct_binop_dest_func(dbg_info *db, ir_node *block,
 113         ir_node *base, ir_node *index, ir_node *mem, ir_node *op);
 114
 115 typedef ir_node *construct_unop_dest_func(dbg_info *db, ir_node *block,
 116         ir_node *base, ir_node *index, ir_node *mem);
 117
 118 typedef ir_node *construct_binop_float_func(dbg_info *db, ir_node *block,
 119         ir_node *base, ir_node *index, ir_node *mem, ir_node *op1, ir_node *op2,
 120         ir_node *fpcw);
 121
 122 typedef ir_node *construct_unop_func(dbg_info *db, ir_node *block, ir_node *op);
 123
 124 static ir_node *create_immediate_or_transform(ir_node *node,
 125                                               char immediate_constraint_type);
 126
 127 static ir_node *create_I2I_Conv(ir_mode *src_mode, ir_mode *tgt_mode,
 128                                 dbg_info *dbgi, ir_node *block,
 129                                 ir_node *op, ir_node *orig_node);
 130
 131 /** Return non-zero is a node represents the 0 constant. */
 132 static bool is_Const_0(ir_node *node)
 133 {
 134         return is_Const(node) && is_Const_null(node);
 135 }
 136
 137 /** Return non-zero is a node represents the 1 constant. */
 138 static bool is_Const_1(ir_node *node)
 139 {
 140         return is_Const(node) && is_Const_one(node);
 141 }
 142
 143 /** Return non-zero is a node represents the -1 constant. */
 144 static bool is_Const_Minus_1(ir_node *node)
 145 {
 146         return is_Const(node) && is_Const_all_one(node);
 147 }
 148
 149 /**
 150  * returns true if constant can be created with a simple float command
 151  */
 152 static bool is_simple_x87_Const(ir_node *node)
 153 {
 154         tarval *tv = get_Const_tarval(node);
 155         if (tarval_is_null(tv) || tarval_is_one(tv))
 156                 return true;
 157
 158         /* TODO: match all the other float constants */
 159         return false;
 160 }
 161
 162 /**
 163  * returns true if constant can be created with a simple float command
 164  */
 165 static bool is_simple_sse_Const(ir_node *node)
 166 {
 167         tarval  *tv   = get_Const_tarval(node);
 168         ir_mode *mode = get_tarval_mode(tv);
 169
 170         if (mode == mode_F)
 171                 return true;
 172
 173         if (tarval_is_null(tv) || tarval_is_one(tv))
 174                 return true;
 175
 176         if (mode == mode_D) {
 177                 unsigned val = get_tarval_sub_bits(tv, 0) |
 178                         (get_tarval_sub_bits(tv, 1) << 8) |
 179                         (get_tarval_sub_bits(tv, 2) << 16) |
 180                         (get_tarval_sub_bits(tv, 3) << 24);
 181                 if (val == 0)
 182                         /* lower 32bit are zero, really a 32bit constant */
 183                         return true;
 184         }
 185
 186         /* TODO: match all the other float constants */
 187         return false;
 188 }
 189
 190 /**
 191  * Transforms a Const.
 192  */
 193 static ir_node *gen_Const(ir_node *node)
 194 {
 195         ir_node  *old_block = get_nodes_block(node);
 196         ir_node  *block     = be_transform_node(old_block);
 197         dbg_info *dbgi      = get_irn_dbg_info(node);
 198         ir_mode  *mode      = get_irn_mode(node);
 199
 200         assert(is_Const(node));
 201
 202         if (mode_is_float(mode)) {
 203                 ir_node   *res   = NULL;
 204                 ir_node   *noreg = ia32_new_NoReg_gp(env_cg);
 205                 ir_node   *nomem = new_NoMem();
 206                 ir_node   *load;
 207                 ir_entity *floatent;
 208
 209                 if (ia32_cg_config.use_sse2) {
 210                         tarval *tv = get_Const_tarval(node);
 211                         if (tarval_is_null(tv)) {
 212                                 load = new_bd_ia32_xZero(dbgi, block);
 213                                 set_ia32_ls_mode(load, mode);
 214                                 res  = load;
 215                         } else if (tarval_is_one(tv)) {
 216                                 int     cnst  = mode == mode_F ? 26 : 55;
 217                                 ir_node *imm1 = create_Immediate(NULL, 0, cnst);
 218                                 ir_node *imm2 = create_Immediate(NULL, 0, 2);
 219                                 ir_node *pslld, *psrld;
 220
 221                                 load = new_bd_ia32_xAllOnes(dbgi, block);
 222                                 set_ia32_ls_mode(load, mode);
 223                                 pslld = new_bd_ia32_xPslld(dbgi, block, load, imm1);
 224                                 set_ia32_ls_mode(pslld, mode);
 225                                 psrld = new_bd_ia32_xPsrld(dbgi, block, pslld, imm2);
 226                                 set_ia32_ls_mode(psrld, mode);
 227                                 res = psrld;
 228                         } else if (mode == mode_F) {
 229                                 /* we can place any 32bit constant by using a movd gp, sse */
 230                                 unsigned val = get_tarval_sub_bits(tv, 0) |
 231                                                (get_tarval_sub_bits(tv, 1) << 8) |
 232                                                (get_tarval_sub_bits(tv, 2) << 16) |
 233                                                (get_tarval_sub_bits(tv, 3) << 24);
 234                                 ir_node *cnst = new_bd_ia32_Const(dbgi, block, NULL, 0, val);
 235                                 load = new_bd_ia32_xMovd(dbgi, block, cnst);
 236                                 set_ia32_ls_mode(load, mode);
 237                                 res = load;
 238                         } else {
 239                                 if (mode == mode_D) {
 240                                         unsigned val = get_tarval_sub_bits(tv, 0) |
 241                                                 (get_tarval_sub_bits(tv, 1) << 8) |
 242                                                 (get_tarval_sub_bits(tv, 2) << 16) |
 243                                                 (get_tarval_sub_bits(tv, 3) << 24);
 244                                         if (val == 0) {
 245                                                 ir_node *imm32 = create_Immediate(NULL, 0, 32);
 246                                                 ir_node *cnst, *psllq;
 247
 248                                                 /* fine, lower 32bit are zero, produce 32bit value */
 249                                                 val = get_tarval_sub_bits(tv, 4) |
 250                                                         (get_tarval_sub_bits(tv, 5) << 8) |
 251                                                         (get_tarval_sub_bits(tv, 6) << 16) |
 252                                                         (get_tarval_sub_bits(tv, 7) << 24);
 253                                                 cnst = new_bd_ia32_Const(dbgi, block, NULL, 0, val);
 254                                                 load = new_bd_ia32_xMovd(dbgi, block, cnst);
 255                                                 set_ia32_ls_mode(load, mode);
 256                                                 psllq = new_bd_ia32_xPsllq(dbgi, block, load, imm32);
 257                                                 set_ia32_ls_mode(psllq, mode);
 258                                                 res = psllq;
 259                                                 goto end;
 260                                         }
 261                                 }
 262                                 floatent = create_float_const_entity(node);
 263
 264                                 load     = new_bd_ia32_xLoad(dbgi, block, noreg, noreg, nomem,
 265                                                              mode);
 266                                 set_ia32_op_type(load, ia32_AddrModeS);
 267                                 set_ia32_am_sc(load, floatent);
 268                                 arch_irn_add_flags(load, arch_irn_flags_rematerializable);
 269                                 res = new_r_Proj(current_ir_graph, block, load, mode_xmm, pn_ia32_xLoad_res);
 270                         }
 271                 } else {
 272                         if (is_Const_null(node)) {
 273                                 load = new_bd_ia32_vfldz(dbgi, block);
 274                                 res  = load;
 275                                 set_ia32_ls_mode(load, mode);
 276                         } else if (is_Const_one(node)) {
 277                                 load = new_bd_ia32_vfld1(dbgi, block);
 278                                 res  = load;
 279                                 set_ia32_ls_mode(load, mode);
 280                         } else {
 281                                 floatent = create_float_const_entity(node);
 282
 283                                 load     = new_bd_ia32_vfld(dbgi, block, noreg, noreg, nomem, mode);
 284                                 set_ia32_op_type(load, ia32_AddrModeS);
 285                                 set_ia32_am_sc(load, floatent);
 286                                 arch_irn_add_flags(load, arch_irn_flags_rematerializable);
 287                                 res = new_r_Proj(current_ir_graph, block, load, mode_vfp, pn_ia32_vfld_res);
 288                                 /* take the mode from the entity */
 289                                 set_ia32_ls_mode(load, get_type_mode(get_entity_type(floatent)));
 290                         }
 291                 }
 292 end:
 293                 SET_IA32_ORIG_NODE(load, node);
 294
 295                 be_dep_on_frame(load);
 296                 return res;
 297         } else { /* non-float mode */
 298                 ir_node *cnst;
 299                 tarval  *tv = get_Const_tarval(node);
 300                 long     val;
 301
 302                 tv = tarval_convert_to(tv, mode_Iu);
 303
 304                 if (tv == get_tarval_bad() || tv == get_tarval_undefined() ||
 305                     tv == NULL) {
 306                         panic("couldn't convert constant tarval (%+F)", node);
 307                 }
 308                 val = get_tarval_long(tv);
 309
 310                 cnst = new_bd_ia32_Const(dbgi, block, NULL, 0, val);
 311                 SET_IA32_ORIG_NODE(cnst, node);
 312
 313                 be_dep_on_frame(cnst);
 314                 return cnst;
 315         }
 316 }
 317
 318 /**
 319  * Transforms a SymConst.
 320  */
 321 static ir_node *gen_SymConst(ir_node *node)
 322 {
 323         ir_node  *old_block = get_nodes_block(node);
 324         ir_node  *block = be_transform_node(old_block);
 325         dbg_info *dbgi  = get_irn_dbg_info(node);
 326         ir_mode  *mode  = get_irn_mode(node);
 327         ir_node  *cnst;
 328
 329         if (mode_is_float(mode)) {
 330                 ir_node *noreg = ia32_new_NoReg_gp(env_cg);
 331                 ir_node *nomem = new_NoMem();
 332
 333                 if (ia32_cg_config.use_sse2)
 334                         cnst = new_bd_ia32_xLoad(dbgi, block, noreg, noreg, nomem, mode_E);
 335                 else
 336                         cnst = new_bd_ia32_vfld(dbgi, block, noreg, noreg, nomem, mode_E);
 337                 set_ia32_am_sc(cnst, get_SymConst_entity(node));
 338                 set_ia32_use_frame(cnst);
 339         } else {
 340                 ir_entity *entity;
 341
 342                 if (get_SymConst_kind(node) != symconst_addr_ent) {
 343                         panic("backend only support symconst_addr_ent (at %+F)", node);
 344                 }
 345                 entity = get_SymConst_entity(node);
 346                 cnst = new_bd_ia32_Const(dbgi, block, entity, 0, 0);
 347         }
 348
 349         SET_IA32_ORIG_NODE(cnst, node);
 350
 351         be_dep_on_frame(cnst);
 352         return cnst;
 353 }
 354
 355 /* Generates an entity for a known FP const (used for FP Neg + Abs) */
 356 ir_entity *ia32_gen_fp_known_const(ia32_known_const_t kct)
 357 {
 358         static const struct {
 359                 const char *tp_name;
 360                 const char *ent_name;
 361                 const char *cnst_str;
 362                 char mode;
 363                 char align;
 364         } names [ia32_known_const_max] = {
 365                 { TP_SFP_SIGN, ENT_SFP_SIGN, SFP_SIGN,   0, 16 },       /* ia32_SSIGN */
 366                 { TP_DFP_SIGN, ENT_DFP_SIGN, DFP_SIGN,   1, 16 },       /* ia32_DSIGN */
 367                 { TP_SFP_ABS,  ENT_SFP_ABS,  SFP_ABS,    0, 16 },       /* ia32_SABS */
 368                 { TP_DFP_ABS,  ENT_DFP_ABS,  DFP_ABS,    1, 16 },       /* ia32_DABS */
 369                 { TP_INT_MAX,  ENT_INT_MAX,  DFP_INTMAX, 2, 4 }         /* ia32_INTMAX */
 370         };
 371         static ir_entity *ent_cache[ia32_known_const_max];
 372
 373         const char    *tp_name, *ent_name, *cnst_str;
 374         ir_type       *tp;
 375         ir_node       *cnst;
 376         ir_graph      *rem;
 377         ir_entity     *ent;
 378         tarval        *tv;
 379         ir_mode       *mode;
 380
 381         ent_name = names[kct].ent_name;
 382         if (! ent_cache[kct]) {
 383                 tp_name  = names[kct].tp_name;
 384                 cnst_str = names[kct].cnst_str;
 385
 386                 switch (names[kct].mode) {
 387                 case 0:  mode = mode_Iu; break;
 388                 case 1:  mode = mode_Lu; break;
 389                 default: mode = mode_F; break;
 390                 }
 391                 tv  = new_tarval_from_str(cnst_str, strlen(cnst_str), mode);
 392                 tp  = new_type_primitive(new_id_from_str(tp_name), mode);
 393                 /* set the specified alignment */
 394                 set_type_alignment_bytes(tp, names[kct].align);
 395
 396                 ent = new_entity(get_glob_type(), new_id_from_str(ent_name), tp);
 397
 398                 set_entity_ld_ident(ent, get_entity_ident(ent));
 399                 set_entity_visibility(ent, visibility_local);
 400                 set_entity_variability(ent, variability_constant);
 401                 set_entity_allocation(ent, allocation_static);
 402
 403                 /* we create a new entity here: It's initialization must resist on the
 404                     const code irg */
 405                 rem = current_ir_graph;
 406                 current_ir_graph = get_const_code_irg();
 407                 cnst = new_Const(mode, tv);
 408                 current_ir_graph = rem;
 409
 410                 set_atomic_ent_value(ent, cnst);
 411
 412                 /* cache the entry */
 413                 ent_cache[kct] = ent;
 414         }
 415
 416         return ent_cache[kct];
 417 }
 418
 419 /**
 420  * return true if the node is a Proj(Load) and could be used in source address
 421  * mode for another node. Will return only true if the @p other node is not
 422  * dependent on the memory of the Load (for binary operations use the other
 423  * input here, for unary operations use NULL).
 424  */
 425 static int ia32_use_source_address_mode(ir_node *block, ir_node *node,
 426                                         ir_node *other, ir_node *other2, match_flags_t flags)
 427 {
 428         ir_node *load;
 429         long     pn;
 430
 431         /* float constants are always available */
 432         if (is_Const(node)) {
 433                 ir_mode *mode = get_irn_mode(node);
 434                 if (mode_is_float(mode)) {
 435                         if (ia32_cg_config.use_sse2) {
 436                                 if (is_simple_sse_Const(node))
 437                                         return 0;
 438                         } else {
 439                                 if (is_simple_x87_Const(node))
 440                                         return 0;
 441                         }
 442                         if (get_irn_n_edges(node) > 1)
 443                                 return 0;
 444                         return 1;
 445                 }
 446         }
 447
 448         if (!is_Proj(node))
 449                 return 0;
 450         load = get_Proj_pred(node);
 451         pn   = get_Proj_proj(node);
 452         if (!is_Load(load) || pn != pn_Load_res)
 453                 return 0;
 454         if (get_nodes_block(load) != block)
 455                 return 0;
 456         /* we only use address mode if we're the only user of the load */
 457         if (get_irn_n_edges(node) != (flags & match_two_users ? 2 : 1))
 458                 return 0;
 459         /* in some edge cases with address mode we might reach the load normally
 460          * and through some AM sequence, if it is already materialized then we
 461          * can't create an AM node from it */
 462         if (be_is_transformed(node))
 463                 return 0;
 464
 465         /* don't do AM if other node inputs depend on the load (via mem-proj) */
 466         if (other != NULL && prevents_AM(block, load, other))
 467                 return 0;
 468
 469         if (other2 != NULL && prevents_AM(block, load, other2))
 470                 return 0;
 471
 472         return 1;
 473 }
 474
 475 typedef struct ia32_address_mode_t ia32_address_mode_t;
 476 struct ia32_address_mode_t {
 477         ia32_address_t  addr;
 478         ir_mode        *ls_mode;
 479         ir_node        *mem_proj;
 480         ir_node        *am_node;
 481         ia32_op_type_t  op_type;
 482         ir_node        *new_op1;
 483         ir_node        *new_op2;
 484         op_pin_state    pinned;
 485         unsigned        commutative  : 1;
 486         unsigned        ins_permuted : 1;
 487 };
 488
 489 static void build_address_ptr(ia32_address_t *addr, ir_node *ptr, ir_node *mem)
 490 {
 491         ir_node *noreg_gp;
 492
 493         /* construct load address */
 494         memset(addr, 0, sizeof(addr[0]));
 495         ia32_create_address_mode(addr, ptr, 0);
 496
 497         noreg_gp    = ia32_new_NoReg_gp(env_cg);
 498         addr->base  = addr->base  ? be_transform_node(addr->base)  : noreg_gp;
 499         addr->index = addr->index ? be_transform_node(addr->index) : noreg_gp;
 500         addr->mem   = be_transform_node(mem);
 501 }
 502
 503 static void build_address(ia32_address_mode_t *am, ir_node *node,
 504                           ia32_create_am_flags_t flags)
 505 {
 506         ir_node        *noreg_gp = ia32_new_NoReg_gp(env_cg);
 507         ia32_address_t *addr     = &am->addr;
 508         ir_node        *load;
 509         ir_node        *ptr;
 510         ir_node        *mem;
 511         ir_node        *new_mem;
 512
 513         if (is_Const(node)) {
 514                 ir_entity *entity  = create_float_const_entity(node);
 515                 addr->base         = noreg_gp;
 516                 addr->index        = noreg_gp;
 517                 addr->mem          = new_NoMem();
 518                 addr->symconst_ent = entity;
 519                 addr->use_frame    = 1;
 520                 am->ls_mode        = get_type_mode(get_entity_type(entity));
 521                 am->pinned         = op_pin_state_floats;
 522                 return;
 523         }
 524
 525         load         = get_Proj_pred(node);
 526         ptr          = get_Load_ptr(load);
 527         mem          = get_Load_mem(load);
 528         new_mem      = be_transform_node(mem);
 529         am->pinned   = get_irn_pinned(load);
 530         am->ls_mode  = get_Load_mode(load);
 531         am->mem_proj = be_get_Proj_for_pn(load, pn_Load_M);
 532         am->am_node  = node;
 533
 534         /* construct load address */
 535         ia32_create_address_mode(addr, ptr, flags);
 536
 537         addr->base  = addr->base  ? be_transform_node(addr->base)  : noreg_gp;
 538         addr->index = addr->index ? be_transform_node(addr->index) : noreg_gp;
 539         addr->mem   = new_mem;
 540 }
 541
 542 static void set_address(ir_node *node, const ia32_address_t *addr)
 543 {
 544         set_ia32_am_scale(node, addr->scale);
 545         set_ia32_am_sc(node, addr->symconst_ent);
 546         set_ia32_am_offs_int(node, addr->offset);
 547         if (addr->symconst_sign)
 548                 set_ia32_am_sc_sign(node);
 549         if (addr->use_frame)
 550                 set_ia32_use_frame(node);
 551         set_ia32_frame_ent(node, addr->frame_entity);
 552 }
 553
 554 /**
 555  * Apply attributes of a given address mode to a node.
 556  */
 557 static void set_am_attributes(ir_node *node, const ia32_address_mode_t *am)
 558 {
 559         set_address(node, &am->addr);
 560
 561         set_ia32_op_type(node, am->op_type);
 562         set_ia32_ls_mode(node, am->ls_mode);
 563         if (am->pinned == op_pin_state_pinned) {
 564                 /* beware: some nodes are already pinned and did not allow to change the state */
 565                 if (get_irn_pinned(node) != op_pin_state_pinned)
 566                         set_irn_pinned(node, op_pin_state_pinned);
 567         }
 568         if (am->commutative)
 569                 set_ia32_commutative(node);
 570 }
 571
 572 /**
 573  * Check, if a given node is a Down-Conv, ie. a integer Conv
 574  * from a mode with a mode with more bits to a mode with lesser bits.
 575  * Moreover, we return only true if the node has not more than 1 user.
 576  *
 577  * @param node   the node
 578  * @return non-zero if node is a Down-Conv
 579  */
 580 static int is_downconv(const ir_node *node)
 581 {
 582         ir_mode *src_mode;
 583         ir_mode *dest_mode;
 584
 585         if (!is_Conv(node))
 586                 return 0;
 587
 588         /* we only want to skip the conv when we're the only user
 589          * (not optimal but for now...)
 590          */
 591         if (get_irn_n_edges(node) > 1)
 592                 return 0;
 593
 594         src_mode  = get_irn_mode(get_Conv_op(node));
 595         dest_mode = get_irn_mode(node);
 596         return ia32_mode_needs_gp_reg(src_mode)
 597                 && ia32_mode_needs_gp_reg(dest_mode)
 598                 && get_mode_size_bits(dest_mode) < get_mode_size_bits(src_mode);
 599 }
 600
 601 /* Skip all Down-Conv's on a given node and return the resulting node. */
 602 ir_node *ia32_skip_downconv(ir_node *node)
 603 {
 604         while (is_downconv(node))
 605                 node = get_Conv_op(node);
 606
 607         return node;
 608 }
 609
 610 static ir_node *create_upconv(ir_node *node, ir_node *orig_node)
 611 {
 612         ir_mode  *mode = get_irn_mode(node);
 613         ir_node  *block;
 614         ir_mode  *tgt_mode;
 615         dbg_info *dbgi;
 616
 617         if (mode_is_signed(mode)) {
 618                 tgt_mode = mode_Is;
 619         } else {
 620                 tgt_mode = mode_Iu;
 621         }
 622         block = get_nodes_block(node);
 623         dbgi  = get_irn_dbg_info(node);
 624
 625         return create_I2I_Conv(mode, tgt_mode, dbgi, block, node, orig_node);
 626 }
 627
 628 /**
 629  * matches operands of a node into ia32 addressing/operand modes. This covers
 630  * usage of source address mode, immediates, operations with non 32-bit modes,
 631  * ...
 632  * The resulting data is filled into the @p am struct. block is the block
 633  * of the node whose arguments are matched. op1, op2 are the first and second
 634  * input that are matched (op1 may be NULL). other_op is another unrelated
 635  * input that is not matched! but which is needed sometimes to check if AM
 636  * for op1/op2 is legal.
 637  * @p flags describes the supported modes of the operation in detail.
 638  */
 639 static void match_arguments(ia32_address_mode_t *am, ir_node *block,
 640                             ir_node *op1, ir_node *op2, ir_node *other_op,
 641                             match_flags_t flags)
 642 {
 643         ia32_address_t *addr      = &am->addr;
 644         ir_mode        *mode      = get_irn_mode(op2);
 645         int             mode_bits = get_mode_size_bits(mode);
 646         ir_node        *noreg_gp, *new_op1, *new_op2;
 647         int             use_am;
 648         unsigned        commutative;
 649         int             use_am_and_immediates;
 650         int             use_immediate;
 651
 652         memset(am, 0, sizeof(am[0]));
 653
 654         commutative           = (flags & match_commutative) != 0;
 655         use_am_and_immediates = (flags & match_am_and_immediates) != 0;
 656         use_am                = (flags & match_am) != 0;
 657         use_immediate         = (flags & match_immediate) != 0;
 658         assert(!use_am_and_immediates || use_immediate);
 659
 660         assert(op2 != NULL);
 661         assert(!commutative || op1 != NULL);
 662         assert(use_am || !(flags & match_8bit_am));
 663         assert(use_am || !(flags & match_16bit_am));
 664
 665         if (mode_bits == 8) {
 666                 if (!(flags & match_8bit_am))
 667                         use_am = 0;
 668                 /* we don't automatically add upconvs yet */
 669                 assert((flags & match_mode_neutral) || (flags & match_8bit));
 670         } else if (mode_bits == 16) {
 671                 if (!(flags & match_16bit_am))
 672                         use_am = 0;
 673                 /* we don't automatically add upconvs yet */
 674                 assert((flags & match_mode_neutral) || (flags & match_16bit));
 675         }
 676
 677         /* we can simply skip downconvs for mode neutral nodes: the upper bits
 678          * can be random for these operations */
 679         if (flags & match_mode_neutral) {
 680                 op2 = ia32_skip_downconv(op2);
 681                 if (op1 != NULL) {
 682                         op1 = ia32_skip_downconv(op1);
 683                 }
 684         }
 685
 686         /* match immediates. firm nodes are normalized: constants are always on the
 687          * op2 input */
 688         new_op2 = NULL;
 689         if (!(flags & match_try_am) && use_immediate) {
 690                 new_op2 = try_create_Immediate(op2, 0);
 691         }
 692
 693         noreg_gp = ia32_new_NoReg_gp(env_cg);
 694         if (new_op2 == NULL &&
 695             use_am && ia32_use_source_address_mode(block, op2, op1, other_op, flags)) {
 696                 build_address(am, op2, 0);
 697                 new_op1     = (op1 == NULL ? NULL : be_transform_node(op1));
 698                 if (mode_is_float(mode)) {
 699                         new_op2 = ia32_new_NoReg_vfp(env_cg);
 700                 } else {
 701                         new_op2 = noreg_gp;
 702                 }
 703                 am->op_type = ia32_AddrModeS;
 704         } else if (commutative && (new_op2 == NULL || use_am_and_immediates) &&
 705                        use_am &&
 706                        ia32_use_source_address_mode(block, op1, op2, other_op, flags)) {
 707                 ir_node *noreg;
 708                 build_address(am, op1, 0);
 709
 710                 if (mode_is_float(mode)) {
 711                         noreg = ia32_new_NoReg_vfp(env_cg);
 712                 } else {
 713                         noreg = noreg_gp;
 714                 }
 715
 716                 if (new_op2 != NULL) {
 717                         new_op1 = noreg;
 718                 } else {
 719                         new_op1 = be_transform_node(op2);
 720                         new_op2 = noreg;
 721                         am->ins_permuted = 1;
 722                 }
 723                 am->op_type = ia32_AddrModeS;
 724         } else {
 725                 am->op_type = ia32_Normal;
 726
 727                 if (flags & match_try_am) {
 728                         am->new_op1 = NULL;
 729                         am->new_op2 = NULL;
 730                         return;
 731                 }
 732
 733                 new_op1 = (op1 == NULL ? NULL : be_transform_node(op1));
 734                 if (new_op2 == NULL)
 735                         new_op2 = be_transform_node(op2);
 736                 am->ls_mode =
 737                         (flags & match_mode_neutral ? mode_Iu : get_irn_mode(op2));
 738         }
 739         if (addr->base == NULL)
 740                 addr->base = noreg_gp;
 741         if (addr->index == NULL)
 742                 addr->index = noreg_gp;
 743         if (addr->mem == NULL)
 744                 addr->mem = new_NoMem();
 745
 746         am->new_op1     = new_op1;
 747         am->new_op2     = new_op2;
 748         am->commutative = commutative;
 749 }
 750
 751 static ir_node *fix_mem_proj(ir_node *node, ia32_address_mode_t *am)
 752 {
 753         ir_mode  *mode;
 754         ir_node  *load;
 755
 756         if (am->mem_proj == NULL)
 757                 return node;
 758
 759         /* we have to create a mode_T so the old MemProj can attach to us */
 760         mode = get_irn_mode(node);
 761         load = get_Proj_pred(am->mem_proj);
 762
 763         be_set_transformed_node(load, node);
 764
 765         if (mode != mode_T) {
 766                 set_irn_mode(node, mode_T);
 767                 return new_rd_Proj(NULL, current_ir_graph, get_nodes_block(node), node, mode, pn_ia32_res);
 768         } else {
 769                 return node;
 770         }
 771 }
 772
 773 /**
 774  * Construct a standard binary operation, set AM and immediate if required.
 775  *
 776  * @param node  The original node for which the binop is created
 777  * @param op1   The first operand
 778  * @param op2   The second operand
 779  * @param func  The node constructor function
 780  * @return The constructed ia32 node.
 781  */
 782 static ir_node *gen_binop(ir_node *node, ir_node *op1, ir_node *op2,
 783                           construct_binop_func *func, match_flags_t flags)
 784 {
 785         dbg_info            *dbgi;
 786         ir_node             *block, *new_block, *new_node;
 787         ia32_address_mode_t  am;
 788         ia32_address_t      *addr = &am.addr;
 789
 790         block = get_nodes_block(node);
 791         match_arguments(&am, block, op1, op2, NULL, flags);
 792
 793         dbgi      = get_irn_dbg_info(node);
 794         new_block = be_transform_node(block);
 795         new_node  = func(dbgi, new_block, addr->base, addr->index, addr->mem,
 796                         am.new_op1, am.new_op2);
 797         set_am_attributes(new_node, &am);
 798         /* we can't use source address mode anymore when using immediates */
 799         if (!(flags & match_am_and_immediates) &&
 800             (is_ia32_Immediate(am.new_op1) || is_ia32_Immediate(am.new_op2)))
 801                 set_ia32_am_support(new_node, ia32_am_none);
 802         SET_IA32_ORIG_NODE(new_node, node);
 803
 804         new_node = fix_mem_proj(new_node, &am);
 805
 806         return new_node;
 807 }
 808
 809 enum {
 810         n_ia32_l_binop_left,
 811         n_ia32_l_binop_right,
 812         n_ia32_l_binop_eflags
 813 };
 814 COMPILETIME_ASSERT(n_ia32_l_binop_left   == n_ia32_l_Adc_left,       n_Adc_left)
 815 COMPILETIME_ASSERT(n_ia32_l_binop_right  == n_ia32_l_Adc_right,      n_Adc_right)
 816 COMPILETIME_ASSERT(n_ia32_l_binop_eflags == n_ia32_l_Adc_eflags,     n_Adc_eflags)
 817 COMPILETIME_ASSERT(n_ia32_l_binop_left   == n_ia32_l_Sbb_minuend,    n_Sbb_minuend)
 818 COMPILETIME_ASSERT(n_ia32_l_binop_right  == n_ia32_l_Sbb_subtrahend, n_Sbb_subtrahend)
 819 COMPILETIME_ASSERT(n_ia32_l_binop_eflags == n_ia32_l_Sbb_eflags,     n_Sbb_eflags)
 820
 821 /**
 822  * Construct a binary operation which also consumes the eflags.
 823  *
 824  * @param node  The node to transform
 825  * @param func  The node constructor function
 826  * @param flags The match flags
 827  * @return      The constructor ia32 node
 828  */
 829 static ir_node *gen_binop_flags(ir_node *node, construct_binop_flags_func *func,
 830                                 match_flags_t flags)
 831 {
 832         ir_node             *src_block  = get_nodes_block(node);
 833         ir_node             *op1        = get_irn_n(node, n_ia32_l_binop_left);
 834         ir_node             *op2        = get_irn_n(node, n_ia32_l_binop_right);
 835         ir_node             *eflags     = get_irn_n(node, n_ia32_l_binop_eflags);
 836         dbg_info            *dbgi;
 837         ir_node             *block, *new_node, *new_eflags;
 838         ia32_address_mode_t  am;
 839         ia32_address_t      *addr       = &am.addr;
 840
 841         match_arguments(&am, src_block, op1, op2, eflags, flags);
 842
 843         dbgi       = get_irn_dbg_info(node);
 844         block      = be_transform_node(src_block);
 845         new_eflags = be_transform_node(eflags);
 846         new_node   = func(dbgi, block, addr->base, addr->index, addr->mem,
 847                         am.new_op1, am.new_op2, new_eflags);
 848         set_am_attributes(new_node, &am);
 849         /* we can't use source address mode anymore when using immediates */
 850         if (!(flags & match_am_and_immediates) &&
 851             (is_ia32_Immediate(am.new_op1) || is_ia32_Immediate(am.new_op2)))
 852                 set_ia32_am_support(new_node, ia32_am_none);
 853         SET_IA32_ORIG_NODE(new_node, node);
 854
 855         new_node = fix_mem_proj(new_node, &am);
 856
 857         return new_node;
 858 }
 859
 860 static ir_node *get_fpcw(void)
 861 {
 862         ir_node *fpcw;
 863         if (initial_fpcw != NULL)
 864                 return initial_fpcw;
 865
 866         fpcw         = be_abi_get_ignore_irn(env_cg->birg->abi,
 867                                              &ia32_fp_cw_regs[REG_FPCW]);
 868         initial_fpcw = be_transform_node(fpcw);
 869
 870         return initial_fpcw;
 871 }
 872
 873 /**
 874  * Construct a standard binary operation, set AM and immediate if required.
 875  *
 876  * @param op1   The first operand
 877  * @param op2   The second operand
 878  * @param func  The node constructor function
 879  * @return The constructed ia32 node.
 880  */
 881 static ir_node *gen_binop_x87_float(ir_node *node, ir_node *op1, ir_node *op2,
 882                                     construct_binop_float_func *func)
 883 {
 884         ir_mode             *mode  = get_irn_mode(node);
 885         dbg_info            *dbgi;
 886         ir_node             *block, *new_block, *new_node;
 887         ia32_address_mode_t  am;
 888         ia32_address_t      *addr = &am.addr;
 889         ia32_x87_attr_t     *attr;
 890         /* All operations are considered commutative, because there are reverse
 891          * variants */
 892         match_flags_t        flags = match_commutative;
 893
 894         /* cannot use address mode with long double on x87 */
 895         if (get_mode_size_bits(mode) <= 64)
 896                 flags |= match_am;
 897
 898         block = get_nodes_block(node);
 899         match_arguments(&am, block, op1, op2, NULL, flags);
 900
 901         dbgi      = get_irn_dbg_info(node);
 902         new_block = be_transform_node(block);
 903         new_node  = func(dbgi, new_block, addr->base, addr->index, addr->mem,
 904                         am.new_op1, am.new_op2, get_fpcw());
 905         set_am_attributes(new_node, &am);
 906
 907         attr = get_ia32_x87_attr(new_node);
 908         attr->attr.data.ins_permuted = am.ins_permuted;
 909
 910         SET_IA32_ORIG_NODE(new_node, node);
 911
 912         new_node = fix_mem_proj(new_node, &am);
 913
 914         return new_node;
 915 }
 916
 917 /**
 918  * Construct a shift/rotate binary operation, sets AM and immediate if required.
 919  *
 920  * @param op1   The first operand
 921  * @param op2   The second operand
 922  * @param func  The node constructor function
 923  * @return The constructed ia32 node.
 924  */
 925 static ir_node *gen_shift_binop(ir_node *node, ir_node *op1, ir_node *op2,
 926                                 construct_shift_func *func,
 927                                 match_flags_t flags)
 928 {
 929         dbg_info *dbgi;
 930         ir_node  *block, *new_block, *new_op1, *new_op2, *new_node;
 931
 932         assert(! mode_is_float(get_irn_mode(node)));
 933         assert(flags & match_immediate);
 934         assert((flags & ~(match_mode_neutral | match_immediate)) == 0);
 935
 936         if (flags & match_mode_neutral) {
 937                 op1     = ia32_skip_downconv(op1);
 938                 new_op1 = be_transform_node(op1);
 939         } else if (get_mode_size_bits(get_irn_mode(node)) != 32) {
 940                 new_op1 = create_upconv(op1, node);
 941         } else {
 942                 new_op1 = be_transform_node(op1);
 943         }
 944
 945         /* the shift amount can be any mode that is bigger than 5 bits, since all
 946          * other bits are ignored anyway */
 947         while (is_Conv(op2) && get_irn_n_edges(op2) == 1) {
 948                 ir_node *const op = get_Conv_op(op2);
 949                 if (mode_is_float(get_irn_mode(op)))
 950                         break;
 951                 op2 = op;
 952                 assert(get_mode_size_bits(get_irn_mode(op2)) >= 5);
 953         }
 954         new_op2 = create_immediate_or_transform(op2, 0);
 955
 956         dbgi      = get_irn_dbg_info(node);
 957         block     = get_nodes_block(node);
 958         new_block = be_transform_node(block);
 959         new_node  = func(dbgi, new_block, new_op1, new_op2);
 960         SET_IA32_ORIG_NODE(new_node, node);
 961
 962         /* lowered shift instruction may have a dependency operand, handle it here */
 963         if (get_irn_arity(node) == 3) {
 964                 /* we have a dependency */
 965                 ir_node *new_dep = be_transform_node(get_irn_n(node, 2));
 966                 add_irn_dep(new_node, new_dep);
 967         }
 968
 969         return new_node;
 970 }
 971
 972
 973 /**
 974  * Construct a standard unary operation, set AM and immediate if required.
 975  *
 976  * @param op    The operand
 977  * @param func  The node constructor function
 978  * @return The constructed ia32 node.
 979  */
 980 static ir_node *gen_unop(ir_node *node, ir_node *op, construct_unop_func *func,
 981                          match_flags_t flags)
 982 {
 983         dbg_info *dbgi;
 984         ir_node  *block, *new_block, *new_op, *new_node;
 985
 986         assert(flags == 0 || flags == match_mode_neutral);
 987         if (flags & match_mode_neutral) {
 988                 op = ia32_skip_downconv(op);
 989         }
 990
 991         new_op    = be_transform_node(op);
 992         dbgi      = get_irn_dbg_info(node);
 993         block     = get_nodes_block(node);
 994         new_block = be_transform_node(block);
 995         new_node  = func(dbgi, new_block, new_op);
 996
 997         SET_IA32_ORIG_NODE(new_node, node);
 998
 999         return new_node;
1000 }
1001
1002 static ir_node *create_lea_from_address(dbg_info *dbgi, ir_node *block,
1003                                         ia32_address_t *addr)
1004 {
1005         ir_node *base, *index, *res;
1006
1007         base = addr->base;
1008         if (base == NULL) {
1009                 base = ia32_new_NoReg_gp(env_cg);
1010         } else {
1011                 base = be_transform_node(base);
1012         }
1013
1014         index = addr->index;
1015         if (index == NULL) {
1016                 index = ia32_new_NoReg_gp(env_cg);
1017         } else {
1018                 index = be_transform_node(index);
1019         }
1020
1021         res = new_bd_ia32_Lea(dbgi, block, base, index);
1022         set_address(res, addr);
1023
1024         return res;
1025 }
1026
1027 /**
1028  * Returns non-zero if a given address mode has a symbolic or
1029  * numerical offset != 0.
1030  */
1031 static int am_has_immediates(const ia32_address_t *addr)
1032 {
1033         return addr->offset != 0 || addr->symconst_ent != NULL
1034                 || addr->frame_entity || addr->use_frame;
1035 }
1036
1037 /**
1038  * Creates an ia32 Add.
1039  *
1040  * @return the created ia32 Add node
1041  */
1042 static ir_node *gen_Add(ir_node *node)
1043 {
1044         ir_mode  *mode = get_irn_mode(node);
1045         ir_node  *op1  = get_Add_left(node);
1046         ir_node  *op2  = get_Add_right(node);
1047         dbg_info *dbgi;
1048         ir_node  *block, *new_block, *new_node, *add_immediate_op;
1049         ia32_address_t       addr;
1050         ia32_address_mode_t  am;
1051
1052         if (mode_is_float(mode)) {
1053                 if (ia32_cg_config.use_sse2)
1054                         return gen_binop(node, op1, op2, new_bd_ia32_xAdd,
1055                                          match_commutative | match_am);
1056                 else
1057                         return gen_binop_x87_float(node, op1, op2, new_bd_ia32_vfadd);
1058         }
1059
1060         ia32_mark_non_am(node);
1061
1062         op2 = ia32_skip_downconv(op2);
1063         op1 = ia32_skip_downconv(op1);
1064
1065         /**
1066          * Rules for an Add:
1067          *   0. Immediate Trees (example Add(Symconst, Const) -> Const)
1068          *   1. Add with immediate -> Lea
1069          *   2. Add with possible source address mode -> Add
1070          *   3. Otherwise -> Lea
1071          */
1072         memset(&addr, 0, sizeof(addr));
1073         ia32_create_address_mode(&addr, node, ia32_create_am_force);
1074         add_immediate_op = NULL;
1075
1076         dbgi      = get_irn_dbg_info(node);
1077         block     = get_nodes_block(node);
1078         new_block = be_transform_node(block);
1079
1080         /* a constant? */
1081         if (addr.base == NULL && addr.index == NULL) {
1082                 new_node = new_bd_ia32_Const(dbgi, new_block, addr.symconst_ent,
1083                                              addr.symconst_sign, addr.offset);
1084                 be_dep_on_frame(new_node);
1085                 SET_IA32_ORIG_NODE(new_node, node);
1086                 return new_node;
1087         }
1088         /* add with immediate? */
1089         if (addr.index == NULL) {
1090                 add_immediate_op = addr.base;
1091         } else if (addr.base == NULL && addr.scale == 0) {
1092                 add_immediate_op = addr.index;
1093         }
1094
1095         if (add_immediate_op != NULL) {
1096                 if (!am_has_immediates(&addr)) {
1097 #ifdef DEBUG_libfirm
1098                         ir_fprintf(stderr, "Optimisation warning Add x,0 (%+F) found\n",
1099                                            node);
1100 #endif
1101                         return be_transform_node(add_immediate_op);
1102                 }
1103
1104                 new_node = create_lea_from_address(dbgi, new_block, &addr);
1105                 SET_IA32_ORIG_NODE(new_node, node);
1106                 return new_node;
1107         }
1108
1109         /* test if we can use source address mode */
1110         match_arguments(&am, block, op1, op2, NULL, match_commutative
1111                         | match_mode_neutral | match_am | match_immediate | match_try_am);
1112
1113         /* construct an Add with source address mode */
1114         if (am.op_type == ia32_AddrModeS) {
1115                 ia32_address_t *am_addr = &am.addr;
1116                 new_node = new_bd_ia32_Add(dbgi, new_block, am_addr->base,
1117                                          am_addr->index, am_addr->mem, am.new_op1,
1118                                          am.new_op2);
1119                 set_am_attributes(new_node, &am);
1120                 SET_IA32_ORIG_NODE(new_node, node);
1121
1122                 new_node = fix_mem_proj(new_node, &am);
1123
1124                 return new_node;
1125         }
1126
1127         /* otherwise construct a lea */
1128         new_node = create_lea_from_address(dbgi, new_block, &addr);
1129         SET_IA32_ORIG_NODE(new_node, node);
1130         return new_node;
1131 }
1132
1133 /**
1134  * Creates an ia32 Mul.
1135  *
1136  * @return the created ia32 Mul node
1137  */
1138 static ir_node *gen_Mul(ir_node *node)
1139 {
1140         ir_node *op1  = get_Mul_left(node);
1141         ir_node *op2  = get_Mul_right(node);
1142         ir_mode *mode = get_irn_mode(node);
1143
1144         if (mode_is_float(mode)) {
1145                 if (ia32_cg_config.use_sse2)
1146                         return gen_binop(node, op1, op2, new_bd_ia32_xMul,
1147                                          match_commutative | match_am);
1148                 else
1149                         return gen_binop_x87_float(node, op1, op2, new_bd_ia32_vfmul);
1150         }
1151         return gen_binop(node, op1, op2, new_bd_ia32_IMul,
1152                          match_commutative | match_am | match_mode_neutral |
1153                          match_immediate | match_am_and_immediates);
1154 }
1155
1156 /**
1157  * Creates an ia32 Mulh.
1158  * Note: Mul produces a 64Bit result and Mulh returns the upper 32 bit of
1159  * this result while Mul returns the lower 32 bit.
1160  *
1161  * @return the created ia32 Mulh node
1162  */
1163 static ir_node *gen_Mulh(ir_node *node)
1164 {
1165         ir_node              *block     = get_nodes_block(node);
1166         ir_node              *new_block = be_transform_node(block);
1167         dbg_info             *dbgi      = get_irn_dbg_info(node);
1168         ir_node              *op1       = get_Mulh_left(node);
1169         ir_node              *op2       = get_Mulh_right(node);
1170         ir_mode              *mode      = get_irn_mode(node);
1171         ir_node              *new_node;
1172         ir_node              *proj_res_high;
1173
1174         if (mode_is_signed(mode)) {
1175                 new_node = gen_binop(node, op1, op2, new_bd_ia32_IMul1OP, match_commutative | match_am);
1176                 proj_res_high = new_rd_Proj(dbgi, current_ir_graph, new_block, new_node,
1177                                     mode_Iu, pn_ia32_IMul1OP_res_high);
1178         } else {
1179                 new_node = gen_binop(node, op1, op2, new_bd_ia32_Mul, match_commutative | match_am);
1180                 proj_res_high = new_rd_Proj(dbgi, current_ir_graph, new_block, new_node,
1181                                     mode_Iu, pn_ia32_Mul_res_high);
1182         }
1183         return proj_res_high;
1184 }
1185
1186 /**
1187  * Creates an ia32 And.
1188  *
1189  * @return The created ia32 And node
1190  */
1191 static ir_node *gen_And(ir_node *node)
1192 {
1193         ir_node *op1 = get_And_left(node);
1194         ir_node *op2 = get_And_right(node);
1195         assert(! mode_is_float(get_irn_mode(node)));
1196
1197         /* is it a zero extension? */
1198         if (is_Const(op2)) {
1199                 tarval   *tv    = get_Const_tarval(op2);
1200                 long      v     = get_tarval_long(tv);
1201
1202                 if (v == 0xFF || v == 0xFFFF) {
1203                         dbg_info *dbgi   = get_irn_dbg_info(node);
1204                         ir_node  *block  = get_nodes_block(node);
1205                         ir_mode  *src_mode;
1206                         ir_node  *res;
1207
1208                         if (v == 0xFF) {
1209                                 src_mode = mode_Bu;
1210                         } else {
1211                                 assert(v == 0xFFFF);
1212                                 src_mode = mode_Hu;
1213                         }
1214                         res = create_I2I_Conv(src_mode, mode_Iu, dbgi, block, op1, node);
1215
1216                         return res;
1217                 }
1218         }
1219         return gen_binop(node, op1, op2, new_bd_ia32_And,
1220                         match_commutative | match_mode_neutral | match_am | match_immediate);
1221 }
1222
1223
1224
1225 /**
1226  * Creates an ia32 Or.
1227  *
1228  * @return The created ia32 Or node
1229  */
1230 static ir_node *gen_Or(ir_node *node)
1231 {
1232         ir_node *op1 = get_Or_left(node);
1233         ir_node *op2 = get_Or_right(node);
1234
1235         assert (! mode_is_float(get_irn_mode(node)));
1236         return gen_binop(node, op1, op2, new_bd_ia32_Or, match_commutative
1237                         | match_mode_neutral | match_am | match_immediate);
1238 }
1239
1240
1241
1242 /**
1243  * Creates an ia32 Eor.
1244  *
1245  * @return The created ia32 Eor node
1246  */
1247 static ir_node *gen_Eor(ir_node *node)
1248 {
1249         ir_node *op1 = get_Eor_left(node);
1250         ir_node *op2 = get_Eor_right(node);
1251
1252         assert(! mode_is_float(get_irn_mode(node)));
1253         return gen_binop(node, op1, op2, new_bd_ia32_Xor, match_commutative
1254                         | match_mode_neutral | match_am | match_immediate);
1255 }
1256
1257
1258 /**
1259  * Creates an ia32 Sub.
1260  *
1261  * @return The created ia32 Sub node
1262  */
1263 static ir_node *gen_Sub(ir_node *node)
1264 {
1265         ir_node  *op1  = get_Sub_left(node);
1266         ir_node  *op2  = get_Sub_right(node);
1267         ir_mode  *mode = get_irn_mode(node);
1268
1269         if (mode_is_float(mode)) {
1270                 if (ia32_cg_config.use_sse2)
1271                         return gen_binop(node, op1, op2, new_bd_ia32_xSub, match_am);
1272                 else
1273                         return gen_binop_x87_float(node, op1, op2, new_bd_ia32_vfsub);
1274         }
1275
1276         if (is_Const(op2)) {
1277                 ir_fprintf(stderr, "Optimisation warning: found sub with const (%+F)\n",
1278                            node);
1279         }
1280
1281         return gen_binop(node, op1, op2, new_bd_ia32_Sub, match_mode_neutral
1282                         | match_am | match_immediate);
1283 }
1284
1285 static ir_node *transform_AM_mem(ir_graph *const irg, ir_node *const block,
1286                                  ir_node  *const src_val,
1287                                  ir_node  *const src_mem,
1288                                  ir_node  *const am_mem)
1289 {
1290         if (is_NoMem(am_mem)) {
1291                 return be_transform_node(src_mem);
1292         } else if (is_Proj(src_val) &&
1293                    is_Proj(src_mem) &&
1294                    get_Proj_pred(src_val) == get_Proj_pred(src_mem)) {
1295                 /* avoid memory loop */
1296                 return am_mem;
1297         } else if (is_Proj(src_val) && is_Sync(src_mem)) {
1298                 ir_node  *const ptr_pred = get_Proj_pred(src_val);
1299                 int       const arity    = get_Sync_n_preds(src_mem);
1300                 int             n        = 0;
1301                 ir_node **      ins;
1302                 int             i;
1303
1304                 NEW_ARR_A(ir_node*, ins, arity + 1);
1305
1306                 /* NOTE: This sometimes produces dead-code because the old sync in
1307                  * src_mem might not be used anymore, we should detect this case
1308                  * and kill the sync... */
1309                 for (i = arity - 1; i >= 0; --i) {
1310                         ir_node *const pred = get_Sync_pred(src_mem, i);
1311
1312                         /* avoid memory loop */
1313                         if (is_Proj(pred) && get_Proj_pred(pred) == ptr_pred)
1314                                 continue;
1315
1316                         ins[n++] = be_transform_node(pred);
1317                 }
1318
1319                 ins[n++] = am_mem;
1320
1321                 return new_r_Sync(irg, block, n, ins);
1322         } else {
1323                 ir_node *ins[2];
1324
1325                 ins[0] = be_transform_node(src_mem);
1326                 ins[1] = am_mem;
1327                 return new_r_Sync(irg, block, 2, ins);
1328         }
1329 }
1330
1331 static ir_node *create_sex_32_64(dbg_info *dbgi, ir_node *block,
1332                                  ir_node *val, const ir_node *orig)
1333 {
1334         ir_node *res;
1335
1336         (void)orig;
1337         if (ia32_cg_config.use_short_sex_eax) {
1338                 ir_node *pval = new_bd_ia32_ProduceVal(dbgi, block);
1339                 be_dep_on_frame(pval);
1340                 res = new_bd_ia32_Cltd(dbgi, block, val, pval);
1341         } else {
1342                 ir_node *imm31 = create_Immediate(NULL, 0, 31);
1343                 res = new_bd_ia32_Sar(dbgi, block, val, imm31);
1344         }
1345         SET_IA32_ORIG_NODE(res, orig);
1346         return res;
1347 }
1348
1349 /**
1350  * Generates an ia32 DivMod with additional infrastructure for the
1351  * register allocator if needed.
1352  */
1353 static ir_node *create_Div(ir_node *node)
1354 {
1355         dbg_info *dbgi      = get_irn_dbg_info(node);
1356         ir_node  *block     = get_nodes_block(node);
1357         ir_node  *new_block = be_transform_node(block);
1358         ir_node  *mem;
1359         ir_node  *new_mem;
1360         ir_node  *op1;
1361         ir_node  *op2;
1362         ir_node  *new_node;
1363         ir_mode  *mode;
1364         ir_node  *sign_extension;
1365         ia32_address_mode_t  am;
1366         ia32_address_t      *addr = &am.addr;
1367
1368         /* the upper bits have random contents for smaller modes */
1369         switch (get_irn_opcode(node)) {
1370         case iro_Div:
1371                 op1     = get_Div_left(node);
1372                 op2     = get_Div_right(node);
1373                 mem     = get_Div_mem(node);
1374                 mode    = get_Div_resmode(node);
1375                 break;
1376         case iro_Mod:
1377                 op1     = get_Mod_left(node);
1378                 op2     = get_Mod_right(node);
1379                 mem     = get_Mod_mem(node);
1380                 mode    = get_Mod_resmode(node);
1381                 break;
1382         case iro_DivMod:
1383                 op1     = get_DivMod_left(node);
1384                 op2     = get_DivMod_right(node);
1385                 mem     = get_DivMod_mem(node);
1386                 mode    = get_DivMod_resmode(node);
1387                 break;
1388         default:
1389                 panic("invalid divmod node %+F", node);
1390         }
1391
1392         match_arguments(&am, block, op1, op2, NULL, match_am);
1393
1394         /* Beware: We don't need a Sync, if the memory predecessor of the Div node
1395            is the memory of the consumed address. We can have only the second op as address
1396            in Div nodes, so check only op2. */
1397         new_mem = transform_AM_mem(current_ir_graph, block, op2, mem, addr->mem);
1398
1399         if (mode_is_signed(mode)) {
1400                 sign_extension = create_sex_32_64(dbgi, new_block, am.new_op1, node);
1401                 new_node       = new_bd_ia32_IDiv(dbgi, new_block, addr->base,
1402                                 addr->index, new_mem, am.new_op2, am.new_op1, sign_extension);
1403         } else {
1404                 sign_extension = new_bd_ia32_Const(dbgi, new_block, NULL, 0, 0);
1405                 be_dep_on_frame(sign_extension);
1406
1407                 new_node = new_bd_ia32_Div(dbgi, new_block, addr->base,
1408                                            addr->index, new_mem, am.new_op2,
1409                                            am.new_op1, sign_extension);
1410         }
1411
1412         set_irn_pinned(new_node, get_irn_pinned(node));
1413
1414         set_am_attributes(new_node, &am);
1415         SET_IA32_ORIG_NODE(new_node, node);
1416
1417         new_node = fix_mem_proj(new_node, &am);
1418
1419         return new_node;
1420 }
1421
1422
1423 static ir_node *gen_Mod(ir_node *node)
1424 {
1425         return create_Div(node);
1426 }
1427
1428 static ir_node *gen_Div(ir_node *node)
1429 {
1430         return create_Div(node);
1431 }
1432
1433 static ir_node *gen_DivMod(ir_node *node)
1434 {
1435         return create_Div(node);
1436 }
1437
1438
1439
1440 /**
1441  * Creates an ia32 floating Div.
1442  *
1443  * @return The created ia32 xDiv node
1444  */
1445 static ir_node *gen_Quot(ir_node *node)
1446 {
1447         ir_node *op1 = get_Quot_left(node);
1448         ir_node *op2 = get_Quot_right(node);
1449
1450         if (ia32_cg_config.use_sse2) {
1451                 return gen_binop(node, op1, op2, new_bd_ia32_xDiv, match_am);
1452         } else {
1453                 return gen_binop_x87_float(node, op1, op2, new_bd_ia32_vfdiv);
1454         }
1455 }
1456
1457
1458 /**
1459  * Creates an ia32 Shl.
1460  *
1461  * @return The created ia32 Shl node
1462  */
1463 static ir_node *gen_Shl(ir_node *node)
1464 {
1465         ir_node *left  = get_Shl_left(node);
1466         ir_node *right = get_Shl_right(node);
1467
1468         return gen_shift_binop(node, left, right, new_bd_ia32_Shl,
1469                                match_mode_neutral | match_immediate);
1470 }
1471
1472 /**
1473  * Creates an ia32 Shr.
1474  *
1475  * @return The created ia32 Shr node
1476  */
1477 static ir_node *gen_Shr(ir_node *node)
1478 {
1479         ir_node *left  = get_Shr_left(node);
1480         ir_node *right = get_Shr_right(node);
1481
1482         return gen_shift_binop(node, left, right, new_bd_ia32_Shr, match_immediate);
1483 }
1484
1485
1486
1487 /**
1488  * Creates an ia32 Sar.
1489  *
1490  * @return The created ia32 Shrs node
1491  */
1492 static ir_node *gen_Shrs(ir_node *node)
1493 {
1494         ir_node *left  = get_Shrs_left(node);
1495         ir_node *right = get_Shrs_right(node);
1496         ir_mode *mode  = get_irn_mode(node);
1497
1498         if (is_Const(right) && mode == mode_Is) {
1499                 tarval *tv = get_Const_tarval(right);
1500                 long val = get_tarval_long(tv);
1501                 if (val == 31) {
1502                         /* this is a sign extension */
1503                         dbg_info *dbgi   = get_irn_dbg_info(node);
1504                         ir_node  *block  = be_transform_node(get_nodes_block(node));
1505                         ir_node  *new_op = be_transform_node(left);
1506
1507                         return create_sex_32_64(dbgi, block, new_op, node);
1508                 }
1509         }
1510
1511         /* 8 or 16 bit sign extension? */
1512         if (is_Const(right) && is_Shl(left) && mode == mode_Is) {
1513                 ir_node *shl_left  = get_Shl_left(left);
1514                 ir_node *shl_right = get_Shl_right(left);
1515                 if (is_Const(shl_right)) {
1516                         tarval *tv1 = get_Const_tarval(right);
1517                         tarval *tv2 = get_Const_tarval(shl_right);
1518                         if (tv1 == tv2 && tarval_is_long(tv1)) {
1519                                 long val = get_tarval_long(tv1);
1520                                 if (val == 16 || val == 24) {
1521                                         dbg_info *dbgi   = get_irn_dbg_info(node);
1522                                         ir_node  *block  = get_nodes_block(node);
1523                                         ir_mode  *src_mode;
1524                                         ir_node  *res;
1525
1526                                         if (val == 24) {
1527                                                 src_mode = mode_Bs;
1528                                         } else {
1529                                                 assert(val == 16);
1530                                                 src_mode = mode_Hs;
1531                                         }
1532                                         res = create_I2I_Conv(src_mode, mode_Is, dbgi, block,
1533                                                               shl_left, node);
1534
1535                                         return res;
1536                                 }
1537                         }
1538                 }
1539         }
1540
1541         return gen_shift_binop(node, left, right, new_bd_ia32_Sar, match_immediate);
1542 }
1543
1544
1545
1546 /**
1547  * Creates an ia32 Rol.
1548  *
1549  * @param op1   The first operator
1550  * @param op2   The second operator
1551  * @return The created ia32 RotL node
1552  */
1553 static ir_node *gen_Rol(ir_node *node, ir_node *op1, ir_node *op2)
1554 {
1555         return gen_shift_binop(node, op1, op2, new_bd_ia32_Rol, match_immediate);
1556 }
1557
1558
1559
1560 /**
1561  * Creates an ia32 Ror.
1562  * NOTE: There is no RotR with immediate because this would always be a RotL
1563  *       "imm-mode_size_bits" which can be pre-calculated.
1564  *
1565  * @param op1   The first operator
1566  * @param op2   The second operator
1567  * @return The created ia32 RotR node
1568  */
1569 static ir_node *gen_Ror(ir_node *node, ir_node *op1, ir_node *op2)
1570 {
1571         return gen_shift_binop(node, op1, op2, new_bd_ia32_Ror, match_immediate);
1572 }
1573
1574
1575
1576 /**
1577  * Creates an ia32 RotR or RotL (depending on the found pattern).
1578  *
1579  * @return The created ia32 RotL or RotR node
1580  */
1581 static ir_node *gen_Rotl(ir_node *node)
1582 {
1583         ir_node *rotate = NULL;
1584         ir_node *op1    = get_Rotl_left(node);
1585         ir_node *op2    = get_Rotl_right(node);
1586
1587         /* Firm has only RotL, so we are looking for a right (op2)
1588                  operand "-e+mode_size_bits" (it's an already modified "mode_size_bits-e",
1589                  that means we can create a RotR instead of an Add and a RotL */
1590
1591         if (is_Add(op2)) {
1592                 ir_node *add = op2;
1593                 ir_node *left = get_Add_left(add);
1594                 ir_node *right = get_Add_right(add);
1595                 if (is_Const(right)) {
1596                         tarval  *tv   = get_Const_tarval(right);
1597                         ir_mode *mode = get_irn_mode(node);
1598                         long     bits = get_mode_size_bits(mode);
1599
1600                         if (is_Minus(left) &&
1601                             tarval_is_long(tv)       &&
1602                             get_tarval_long(tv) == bits &&
1603                             bits                == 32)
1604                         {
1605                                 DB((dbg, LEVEL_1, "RotL into RotR ... "));
1606                                 rotate = gen_Ror(node, op1, get_Minus_op(left));
1607                         }
1608                 }
1609         }
1610
1611         if (rotate == NULL) {
1612                 rotate = gen_Rol(node, op1, op2);
1613         }
1614
1615         return rotate;
1616 }
1617
1618
1619
1620 /**
1621  * Transforms a Minus node.
1622  *
1623  * @return The created ia32 Minus node
1624  */
1625 static ir_node *gen_Minus(ir_node *node)
1626 {
1627         ir_node   *op    = get_Minus_op(node);
1628         ir_node   *block = be_transform_node(get_nodes_block(node));
1629         dbg_info  *dbgi  = get_irn_dbg_info(node);
1630         ir_mode   *mode  = get_irn_mode(node);
1631         ir_entity *ent;
1632         ir_node   *new_node;
1633         int        size;
1634
1635         if (mode_is_float(mode)) {
1636                 ir_node *new_op = be_transform_node(op);
1637                 if (ia32_cg_config.use_sse2) {
1638                         /* TODO: non-optimal... if we have many xXors, then we should
1639                          * rather create a load for the const and use that instead of
1640                          * several AM nodes... */
1641                         ir_node *noreg_gp  = ia32_new_NoReg_gp(env_cg);
1642                         ir_node *noreg_xmm = ia32_new_NoReg_xmm(env_cg);
1643                         ir_node *nomem     = new_NoMem();
1644
1645                         new_node = new_bd_ia32_xXor(dbgi, block, noreg_gp, noreg_gp,
1646                                                     nomem, new_op, noreg_xmm);
1647
1648                         size = get_mode_size_bits(mode);
1649                         ent  = ia32_gen_fp_known_const(size == 32 ? ia32_SSIGN : ia32_DSIGN);
1650
1651                         set_ia32_am_sc(new_node, ent);
1652                         set_ia32_op_type(new_node, ia32_AddrModeS);
1653                         set_ia32_ls_mode(new_node, mode);
1654                 } else {
1655                         new_node = new_bd_ia32_vfchs(dbgi, block, new_op);
1656                 }
1657         } else {
1658                 new_node = gen_unop(node, op, new_bd_ia32_Neg, match_mode_neutral);
1659         }
1660
1661         SET_IA32_ORIG_NODE(new_node, node);
1662
1663         return new_node;
1664 }
1665
1666 /**
1667  * Transforms a Not node.
1668  *
1669  * @return The created ia32 Not node
1670  */
1671 static ir_node *gen_Not(ir_node *node)
1672 {
1673         ir_node *op   = get_Not_op(node);
1674
1675         assert(get_irn_mode(node) != mode_b); /* should be lowered already */
1676         assert (! mode_is_float(get_irn_mode(node)));
1677
1678         return gen_unop(node, op, new_bd_ia32_Not, match_mode_neutral);
1679 }
1680
1681
1682
1683 /**
1684  * Transforms an Abs node.
1685  *
1686  * @return The created ia32 Abs node
1687  */
1688 static ir_node *gen_Abs(ir_node *node)
1689 {
1690         ir_node   *block     = get_nodes_block(node);
1691         ir_node   *new_block = be_transform_node(block);
1692         ir_node   *op        = get_Abs_op(node);
1693         dbg_info  *dbgi      = get_irn_dbg_info(node);
1694         ir_mode   *mode      = get_irn_mode(node);
1695         ir_node   *noreg_gp  = ia32_new_NoReg_gp(env_cg);
1696         ir_node   *nomem     = new_NoMem();
1697         ir_node   *new_op;
1698         ir_node   *new_node;
1699         int        size;
1700         ir_entity *ent;
1701
1702         if (mode_is_float(mode)) {
1703                 new_op = be_transform_node(op);
1704
1705                 if (ia32_cg_config.use_sse2) {
1706                         ir_node *noreg_fp = ia32_new_NoReg_xmm(env_cg);
1707                         new_node = new_bd_ia32_xAnd(dbgi, new_block, noreg_gp, noreg_gp,
1708                                                     nomem, new_op, noreg_fp);
1709
1710                         size = get_mode_size_bits(mode);
1711                         ent  = ia32_gen_fp_known_const(size == 32 ? ia32_SABS : ia32_DABS);
1712
1713                         set_ia32_am_sc(new_node, ent);
1714
1715                         SET_IA32_ORIG_NODE(new_node, node);
1716
1717                         set_ia32_op_type(new_node, ia32_AddrModeS);
1718                         set_ia32_ls_mode(new_node, mode);
1719                 } else {
1720                         new_node = new_bd_ia32_vfabs(dbgi, new_block, new_op);
1721                         SET_IA32_ORIG_NODE(new_node, node);
1722                 }
1723         } else {
1724                 ir_node *xor, *sign_extension;
1725
1726                 if (get_mode_size_bits(mode) == 32) {
1727                         new_op = be_transform_node(op);
1728                 } else {
1729                         new_op = create_I2I_Conv(mode, mode_Is, dbgi, block, op, node);
1730                 }
1731
1732                 sign_extension = create_sex_32_64(dbgi, new_block, new_op, node);
1733
1734                 xor = new_bd_ia32_Xor(dbgi, new_block, noreg_gp, noreg_gp,
1735                                       nomem, new_op, sign_extension);
1736                 SET_IA32_ORIG_NODE(xor, node);
1737
1738                 new_node = new_bd_ia32_Sub(dbgi, new_block, noreg_gp, noreg_gp,
1739                                            nomem, xor, sign_extension);
1740                 SET_IA32_ORIG_NODE(new_node, node);
1741         }
1742
1743         return new_node;
1744 }
1745
1746 /**
1747  * Create a bt instruction for x & (1 << n) and place it into the block of cmp.
1748  */
1749 static ir_node *gen_bt(ir_node *cmp, ir_node *x, ir_node *n)
1750 {
1751         dbg_info *dbgi      = get_irn_dbg_info(cmp);
1752         ir_node  *block     = get_nodes_block(cmp);
1753         ir_node  *new_block = be_transform_node(block);
1754         ir_node  *op1       = be_transform_node(x);
1755         ir_node  *op2       = be_transform_node(n);
1756
1757         return new_bd_ia32_Bt(dbgi, new_block, op1, op2);
1758 }
1759
1760 /**
1761  * Transform a node returning a "flag" result.
1762  *
1763  * @param node     the node to transform
1764  * @param pnc_out  the compare mode to use
1765  */
1766 static ir_node *get_flags_node(ir_node *node, pn_Cmp *pnc_out)
1767 {
1768         ir_node  *flags;
1769         ir_node  *new_op;
1770         ir_node  *noreg;
1771         ir_node  *nomem;
1772         ir_node  *new_block;
1773         dbg_info *dbgi;
1774
1775         /* we have a Cmp as input */
1776         if (is_Proj(node)) {
1777                 ir_node *pred = get_Proj_pred(node);
1778                 if (is_Cmp(pred)) {
1779                         pn_Cmp pnc = get_Proj_proj(node);
1780                         if (ia32_cg_config.use_bt && (pnc == pn_Cmp_Lg || pnc == pn_Cmp_Eq)) {
1781                                 ir_node *l = get_Cmp_left(pred);
1782                                 ir_node *r = get_Cmp_right(pred);
1783                                 if (is_And(l)) {
1784                                         ir_node *la = get_And_left(l);
1785                                         ir_node *ra = get_And_right(l);
1786                                         if (is_Shl(la)) {
1787                                                 ir_node *c = get_Shl_left(la);
1788                                                 if (is_Const_1(c) && (is_Const_0(r) || r == la)) {
1789                                                         /* (1 << n) & ra) */
1790                                                         ir_node *n = get_Shl_right(la);
1791                                                         flags    = gen_bt(pred, ra, n);
1792                                                         /* we must generate a Jc/Jnc jump */
1793                                                         pnc = pnc == pn_Cmp_Lg ? pn_Cmp_Lt : pn_Cmp_Ge;
1794                                                         if (r == la)
1795                                                                 pnc ^= pn_Cmp_Leg;
1796                                                         *pnc_out = ia32_pn_Cmp_unsigned | pnc;
1797                                                         return flags;
1798                                                 }
1799                                         }
1800                                         if (is_Shl(ra)) {
1801                                                 ir_node *c = get_Shl_left(ra);
1802                                                 if (is_Const_1(c) && (is_Const_0(r) || r == ra)) {
1803                                                         /* la & (1 << n)) */
1804                                                         ir_node *n = get_Shl_right(ra);
1805                                                         flags    = gen_bt(pred, la, n);
1806                                                         /* we must generate a Jc/Jnc jump */
1807                                                         pnc = pnc == pn_Cmp_Lg ? pn_Cmp_Lt : pn_Cmp_Ge;
1808                                                         if (r == ra)
1809                                                                 pnc ^= pn_Cmp_Leg;
1810                                                         *pnc_out = ia32_pn_Cmp_unsigned | pnc;
1811                                                         return flags;
1812                                                 }
1813                                         }
1814                                 }
1815                         }
1816                         flags    = be_transform_node(pred);
1817                         *pnc_out = pnc;
1818                         return flags;
1819                 }
1820         }
1821
1822         /* a mode_b value, we have to compare it against 0 */
1823         dbgi      = get_irn_dbg_info(node);
1824         new_block = be_transform_node(get_nodes_block(node));
1825         new_op    = be_transform_node(node);
1826         noreg     = ia32_new_NoReg_gp(env_cg);
1827         nomem     = new_NoMem();
1828         flags     = new_bd_ia32_Test(dbgi, new_block, noreg, noreg, nomem, new_op,
1829                         new_op, /*is_permuted=*/0, /*cmp_unsigned=*/0);
1830         *pnc_out  = pn_Cmp_Lg;
1831         return flags;
1832 }
1833
1834 /**
1835  * Transforms a Load.
1836  *
1837  * @return the created ia32 Load node
1838  */
1839 static ir_node *gen_Load(ir_node *node)
1840 {
1841         ir_node  *old_block = get_nodes_block(node);
1842         ir_node  *block   = be_transform_node(old_block);
1843         ir_node  *ptr     = get_Load_ptr(node);
1844         ir_node  *mem     = get_Load_mem(node);
1845         ir_node  *new_mem = be_transform_node(mem);
1846         ir_node  *base;
1847         ir_node  *index;
1848         dbg_info *dbgi    = get_irn_dbg_info(node);
1849         ir_node  *noreg   = ia32_new_NoReg_gp(env_cg);
1850         ir_mode  *mode    = get_Load_mode(node);
1851         ir_mode  *res_mode;
1852         ir_node  *new_node;
1853         ia32_address_t addr;
1854
1855         /* construct load address */
1856         memset(&addr, 0, sizeof(addr));
1857         ia32_create_address_mode(&addr, ptr, 0);
1858         base  = addr.base;
1859         index = addr.index;
1860
1861         if (base == NULL) {
1862                 base = noreg;
1863         } else {
1864                 base = be_transform_node(base);
1865         }
1866
1867         if (index == NULL) {
1868                 index = noreg;
1869         } else {
1870                 index = be_transform_node(index);
1871         }
1872
1873         if (mode_is_float(mode)) {
1874                 if (ia32_cg_config.use_sse2) {
1875                         new_node = new_bd_ia32_xLoad(dbgi, block, base, index, new_mem,
1876                                                      mode);
1877                         res_mode = mode_xmm;
1878                 } else {
1879                         new_node = new_bd_ia32_vfld(dbgi, block, base, index, new_mem,
1880                                                     mode);
1881                         res_mode = mode_vfp;
1882                 }
1883         } else {
1884                 assert(mode != mode_b);
1885
1886                 /* create a conv node with address mode for smaller modes */
1887                 if (get_mode_size_bits(mode) < 32) {
1888                         new_node = new_bd_ia32_Conv_I2I(dbgi, block, base, index,
1889                                                         new_mem, noreg, mode);
1890                 } else {
1891                         new_node = new_bd_ia32_Load(dbgi, block, base, index, new_mem);
1892                 }
1893                 res_mode = mode_Iu;
1894         }
1895
1896         set_irn_pinned(new_node, get_irn_pinned(node));
1897         set_ia32_op_type(new_node, ia32_AddrModeS);
1898         set_ia32_ls_mode(new_node, mode);
1899         set_address(new_node, &addr);
1900
1901         if (get_irn_pinned(node) == op_pin_state_floats) {
1902                 assert(pn_ia32_xLoad_res == pn_ia32_vfld_res
1903                                 && pn_ia32_vfld_res == pn_ia32_Load_res
1904                                 && pn_ia32_Load_res == pn_ia32_res);
1905                 arch_irn_add_flags(new_node, arch_irn_flags_rematerializable);
1906         }
1907
1908         SET_IA32_ORIG_NODE(new_node, node);
1909
1910         be_dep_on_frame(new_node);
1911         return new_node;
1912 }
1913
1914 static int use_dest_am(ir_node *block, ir_node *node, ir_node *mem,
1915                        ir_node *ptr, ir_node *other)
1916 {
1917         ir_node *load;
1918
1919         if (!is_Proj(node))
1920                 return 0;
1921
1922         /* we only use address mode if we're the only user of the load */
1923         if (get_irn_n_edges(node) > 1)
1924                 return 0;
1925
1926         load = get_Proj_pred(node);
1927         if (!is_Load(load))
1928                 return 0;
1929         if (get_nodes_block(load) != block)
1930                 return 0;
1931
1932         /* store should have the same pointer as the load */
1933         if (get_Load_ptr(load) != ptr)
1934                 return 0;
1935
1936         /* don't do AM if other node inputs depend on the load (via mem-proj) */
1937         if (other != NULL                   &&
1938             get_nodes_block(other) == block &&
1939             heights_reachable_in_block(heights, other, load)) {
1940                 return 0;
1941         }
1942
1943         if (prevents_AM(block, load, mem))
1944                 return 0;
1945         /* Store should be attached to the load via mem */
1946         assert(heights_reachable_in_block(heights, mem, load));
1947
1948         return 1;
1949 }
1950
1951 static ir_node *dest_am_binop(ir_node *node, ir_node *op1, ir_node *op2,
1952                               ir_node *mem, ir_node *ptr, ir_mode *mode,
1953                               construct_binop_dest_func *func,
1954                               construct_binop_dest_func *func8bit,
1955                                                           match_flags_t flags)
1956 {
1957         ir_node  *src_block = get_nodes_block(node);
1958         ir_node  *block;
1959         ir_node  *noreg_gp  = ia32_new_NoReg_gp(env_cg);
1960         dbg_info *dbgi;
1961         ir_node  *new_mem;
1962         ir_node  *new_node;
1963         ir_node  *new_op;
1964         ir_node  *mem_proj;
1965         int       commutative;
1966         ia32_address_mode_t  am;
1967         ia32_address_t      *addr = &am.addr;
1968         memset(&am, 0, sizeof(am));
1969
1970         assert(flags & match_dest_am);
1971         assert(flags & match_immediate); /* there is no destam node without... */
1972         commutative = (flags & match_commutative) != 0;
1973
1974         if (use_dest_am(src_block, op1, mem, ptr, op2)) {
1975                 build_address(&am, op1, ia32_create_am_double_use);
1976                 new_op = create_immediate_or_transform(op2, 0);
1977         } else if (commutative && use_dest_am(src_block, op2, mem, ptr, op1)) {
1978                 build_address(&am, op2, ia32_create_am_double_use);
1979                 new_op = create_immediate_or_transform(op1, 0);
1980         } else {
1981                 return NULL;
1982         }
1983
1984         if (addr->base == NULL)
1985                 addr->base = noreg_gp;
1986         if (addr->index == NULL)
1987                 addr->index = noreg_gp;
1988         if (addr->mem == NULL)
1989                 addr->mem = new_NoMem();
1990
1991         dbgi    = get_irn_dbg_info(node);
1992         block   = be_transform_node(src_block);
1993         new_mem = transform_AM_mem(current_ir_graph, block, am.am_node, mem, addr->mem);
1994
1995         if (get_mode_size_bits(mode) == 8) {
1996                 new_node = func8bit(dbgi, block, addr->base, addr->index, new_mem, new_op);
1997         } else {
1998                 new_node = func(dbgi, block, addr->base, addr->index, new_mem, new_op);
1999         }
2000         set_address(new_node, addr);
2001         set_ia32_op_type(new_node, ia32_AddrModeD);
2002         set_ia32_ls_mode(new_node, mode);
2003         SET_IA32_ORIG_NODE(new_node, node);
2004
2005         be_set_transformed_node(get_Proj_pred(am.mem_proj), new_node);
2006         mem_proj = be_transform_node(am.mem_proj);
2007         be_set_transformed_node(mem_proj ? mem_proj : am.mem_proj, new_node);
2008
2009         return new_node;
2010 }
2011
2012 static ir_node *dest_am_unop(ir_node *node, ir_node *op, ir_node *mem,
2013                              ir_node *ptr, ir_mode *mode,
2014                              construct_unop_dest_func *func)
2015 {
2016         ir_node  *src_block = get_nodes_block(node);
2017         ir_node  *block;
2018         dbg_info *dbgi;
2019         ir_node  *new_mem;
2020         ir_node  *new_node;
2021         ir_node  *mem_proj;
2022         ia32_address_mode_t  am;
2023         ia32_address_t *addr = &am.addr;
2024
2025         if (!use_dest_am(src_block, op, mem, ptr, NULL))
2026                 return NULL;
2027
2028         memset(&am, 0, sizeof(am));
2029         build_address(&am, op, ia32_create_am_double_use);
2030
2031         dbgi     = get_irn_dbg_info(node);
2032         block    = be_transform_node(src_block);
2033         new_mem  = transform_AM_mem(current_ir_graph, block, am.am_node, mem, addr->mem);
2034         new_node = func(dbgi, block, addr->base, addr->index, new_mem);
2035         set_address(new_node, addr);
2036         set_ia32_op_type(new_node, ia32_AddrModeD);
2037         set_ia32_ls_mode(new_node, mode);
2038         SET_IA32_ORIG_NODE(new_node, node);
2039
2040         be_set_transformed_node(get_Proj_pred(am.mem_proj), new_node);
2041         mem_proj = be_transform_node(am.mem_proj);
2042         be_set_transformed_node(mem_proj ? mem_proj : am.mem_proj, new_node);
2043
2044         return new_node;
2045 }
2046
2047 static ir_node *try_create_SetMem(ir_node *node, ir_node *ptr, ir_node *mem)
2048 {
2049         ir_mode  *mode        = get_irn_mode(node);
2050         ir_node  *mux_true    = get_Mux_true(node);
2051         ir_node  *mux_false   = get_Mux_false(node);
2052         ir_node  *cond;
2053         ir_node  *new_mem;
2054         dbg_info *dbgi;
2055         ir_node  *block;
2056         ir_node  *new_block;
2057         ir_node  *flags;
2058         ir_node  *new_node;
2059         int       negated;
2060         pn_Cmp    pnc;
2061         ia32_address_t addr;
2062
2063         if (get_mode_size_bits(mode) != 8)
2064                 return NULL;
2065
2066         if (is_Const_1(mux_true) && is_Const_0(mux_false)) {
2067                 negated = 0;
2068         } else if (is_Const_0(mux_true) && is_Const_1(mux_false)) {
2069                 negated = 1;
2070         } else {
2071                 return NULL;
2072         }
2073
2074         build_address_ptr(&addr, ptr, mem);
2075
2076         dbgi      = get_irn_dbg_info(node);
2077         block     = get_nodes_block(node);
2078         new_block = be_transform_node(block);
2079         cond      = get_Mux_sel(node);
2080         flags     = get_flags_node(cond, &pnc);
2081         new_mem   = be_transform_node(mem);
2082         new_node  = new_bd_ia32_SetMem(dbgi, new_block, addr.base,
2083                                        addr.index, addr.mem, flags, pnc, negated);
2084         set_address(new_node, &addr);
2085         set_ia32_op_type(new_node, ia32_AddrModeD);
2086         set_ia32_ls_mode(new_node, mode);
2087         SET_IA32_ORIG_NODE(new_node, node);
2088
2089         return new_node;
2090 }
2091
2092 static ir_node *try_create_dest_am(ir_node *node)
2093 {
2094         ir_node  *val  = get_Store_value(node);
2095         ir_node  *mem  = get_Store_mem(node);
2096         ir_node  *ptr  = get_Store_ptr(node);
2097         ir_mode  *mode = get_irn_mode(val);
2098         unsigned  bits = get_mode_size_bits(mode);
2099         ir_node  *op1;
2100         ir_node  *op2;
2101         ir_node  *new_node;
2102
2103         /* handle only GP modes for now... */
2104         if (!ia32_mode_needs_gp_reg(mode))
2105                 return NULL;
2106
2107         for (;;) {
2108                 /* store must be the only user of the val node */
2109                 if (get_irn_n_edges(val) > 1)
2110                         return NULL;
2111                 /* skip pointless convs */
2112                 if (is_Conv(val)) {
2113                         ir_node *conv_op   = get_Conv_op(val);
2114                         ir_mode *pred_mode = get_irn_mode(conv_op);
2115                         if (!ia32_mode_needs_gp_reg(pred_mode))
2116                                 break;
2117                         if (pred_mode == mode_b || bits <= get_mode_size_bits(pred_mode)) {
2118                                 val = conv_op;
2119                                 continue;
2120                         }
2121                 }
2122                 break;
2123         }
2124
2125         /* value must be in the same block */
2126         if (get_nodes_block(node) != get_nodes_block(val))
2127                 return NULL;
2128
2129         switch (get_irn_opcode(val)) {
2130         case iro_Add:
2131                 op1      = get_Add_left(val);
2132                 op2      = get_Add_right(val);
2133                 if (ia32_cg_config.use_incdec) {
2134                         if (is_Const_1(op2)) {
2135                                 new_node = dest_am_unop(val, op1, mem, ptr, mode, new_bd_ia32_IncMem);
2136                                 break;
2137                         } else if (is_Const_Minus_1(op2)) {
2138                                 new_node = dest_am_unop(val, op1, mem, ptr, mode, new_bd_ia32_DecMem);
2139                                 break;
2140                         }
2141                 }
2142                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2143                                          new_bd_ia32_AddMem, new_bd_ia32_AddMem8Bit,
2144                                          match_dest_am | match_commutative |
2145                                          match_immediate);
2146                 break;
2147         case iro_Sub:
2148                 op1      = get_Sub_left(val);
2149                 op2      = get_Sub_right(val);
2150                 if (is_Const(op2)) {
2151                         ir_fprintf(stderr, "Optimisation warning: not-normalized sub ,C found\n");
2152                 }
2153                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2154                                          new_bd_ia32_SubMem, new_bd_ia32_SubMem8Bit,
2155                                          match_dest_am | match_immediate);
2156                 break;
2157         case iro_And:
2158                 op1      = get_And_left(val);
2159                 op2      = get_And_right(val);
2160                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2161                                          new_bd_ia32_AndMem, new_bd_ia32_AndMem8Bit,
2162                                          match_dest_am | match_commutative |
2163                                          match_immediate);
2164                 break;
2165         case iro_Or:
2166                 op1      = get_Or_left(val);
2167                 op2      = get_Or_right(val);
2168                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2169                                          new_bd_ia32_OrMem, new_bd_ia32_OrMem8Bit,
2170                                          match_dest_am | match_commutative |
2171                                          match_immediate);
2172                 break;
2173         case iro_Eor:
2174                 op1      = get_Eor_left(val);
2175                 op2      = get_Eor_right(val);
2176                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2177                                          new_bd_ia32_XorMem, new_bd_ia32_XorMem8Bit,
2178                                          match_dest_am | match_commutative |
2179                                          match_immediate);
2180                 break;
2181         case iro_Shl:
2182                 op1      = get_Shl_left(val);
2183                 op2      = get_Shl_right(val);
2184                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2185                                          new_bd_ia32_ShlMem, new_bd_ia32_ShlMem,
2186                                          match_dest_am | match_immediate);
2187                 break;
2188         case iro_Shr:
2189                 op1      = get_Shr_left(val);
2190                 op2      = get_Shr_right(val);
2191                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2192                                          new_bd_ia32_ShrMem, new_bd_ia32_ShrMem,
2193                                          match_dest_am | match_immediate);
2194                 break;
2195         case iro_Shrs:
2196                 op1      = get_Shrs_left(val);
2197                 op2      = get_Shrs_right(val);
2198                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2199                                          new_bd_ia32_SarMem, new_bd_ia32_SarMem,
2200                                          match_dest_am | match_immediate);
2201                 break;
2202         case iro_Rotl:
2203                 op1      = get_Rotl_left(val);
2204                 op2      = get_Rotl_right(val);
2205                 new_node = dest_am_binop(val, op1, op2, mem, ptr, mode,
2206                                          new_bd_ia32_RolMem, new_bd_ia32_RolMem,
2207                                          match_dest_am | match_immediate);
2208                 break;
2209         /* TODO: match ROR patterns... */
2210         case iro_Mux:
2211                 new_node = try_create_SetMem(val, ptr, mem);
2212                 break;
2213         case iro_Minus:
2214                 op1      = get_Minus_op(val);
2215                 new_node = dest_am_unop(val, op1, mem, ptr, mode, new_bd_ia32_NegMem);
2216                 break;
2217         case iro_Not:
2218                 /* should be lowered already */
2219                 assert(mode != mode_b);
2220                 op1      = get_Not_op(val);
2221                 new_node = dest_am_unop(val, op1, mem, ptr, mode, new_bd_ia32_NotMem);
2222                 break;
2223         default:
2224                 return NULL;
2225         }
2226
2227         if (new_node != NULL) {
2228                 if (get_irn_pinned(new_node) != op_pin_state_pinned &&
2229                                 get_irn_pinned(node) == op_pin_state_pinned) {
2230                         set_irn_pinned(new_node, op_pin_state_pinned);
2231                 }
2232         }
2233
2234         return new_node;
2235 }
2236
2237 static int is_float_to_int_conv(const ir_node *node)
2238 {
2239         ir_mode  *mode = get_irn_mode(node);
2240         ir_node  *conv_op;
2241         ir_mode  *conv_mode;
2242
2243         if (mode != mode_Is && mode != mode_Hs)
2244                 return 0;
2245
2246         if (!is_Conv(node))
2247                 return 0;
2248         conv_op   = get_Conv_op(node);
2249         conv_mode = get_irn_mode(conv_op);
2250
2251         if (!mode_is_float(conv_mode))
2252                 return 0;
2253
2254         return 1;
2255 }
2256
2257 /**
2258  * Transform a Store(floatConst) into a sequence of
2259  * integer stores.
2260  *
2261  * @return the created ia32 Store node
2262  */
2263 static ir_node *gen_float_const_Store(ir_node *node, ir_node *cns)
2264 {
2265         ir_mode        *mode      = get_irn_mode(cns);
2266         unsigned        size      = get_mode_size_bytes(mode);
2267         tarval         *tv        = get_Const_tarval(cns);
2268         ir_node        *block     = get_nodes_block(node);
2269         ir_node        *new_block = be_transform_node(block);
2270         ir_node        *ptr       = get_Store_ptr(node);
2271         ir_node        *mem       = get_Store_mem(node);
2272         dbg_info       *dbgi      = get_irn_dbg_info(node);
2273         int             ofs       = 0;
2274         size_t          i         = 0;
2275         ir_node        *ins[4];
2276         ia32_address_t  addr;
2277
2278         assert(size % 4 ==  0);
2279         assert(size     <= 16);
2280
2281         build_address_ptr(&addr, ptr, mem);
2282
2283         do {
2284                 unsigned val =
2285                          get_tarval_sub_bits(tv, ofs)            |
2286                         (get_tarval_sub_bits(tv, ofs + 1) <<  8) |
2287                         (get_tarval_sub_bits(tv, ofs + 2) << 16) |
2288                         (get_tarval_sub_bits(tv, ofs + 3) << 24);
2289                 ir_node *imm = create_Immediate(NULL, 0, val);
2290
2291                 ir_node *new_node = new_bd_ia32_Store(dbgi, new_block, addr.base,
2292                         addr.index, addr.mem, imm);
2293
2294                 set_irn_pinned(new_node, get_irn_pinned(node));
2295                 set_ia32_op_type(new_node, ia32_AddrModeD);
2296                 set_ia32_ls_mode(new_node, mode_Iu);
2297                 set_address(new_node, &addr);
2298                 SET_IA32_ORIG_NODE(new_node, node);
2299
2300                 assert(i < 4);
2301                 ins[i++] = new_node;
2302
2303                 size        -= 4;
2304                 ofs         += 4;
2305                 addr.offset += 4;
2306         } while (size != 0);
2307
2308         if (i > 1) {
2309                 return new_rd_Sync(dbgi, current_ir_graph, new_block, i, ins);
2310         } else {
2311                 return ins[0];
2312         }
2313 }
2314
2315 /**
2316  * Generate a vfist or vfisttp instruction.
2317  */
2318 static ir_node *gen_vfist(dbg_info *dbgi, ir_graph *irg, ir_node *block, ir_node *base, ir_node *index,
2319                           ir_node *mem,  ir_node *val, ir_node **fist)
2320 {
2321         ir_node *new_node;
2322
2323         if (ia32_cg_config.use_fisttp) {
2324                 /* Note: fisttp ALWAYS pop the tos. We have to ensure here that the value is copied
2325                 if other users exists */
2326                 const arch_register_class_t *reg_class = &ia32_reg_classes[CLASS_ia32_vfp];
2327                 ir_node *vfisttp = new_bd_ia32_vfisttp(dbgi, block, base, index, mem, val);
2328                 ir_node *value   = new_r_Proj(irg, block, vfisttp, mode_E, pn_ia32_vfisttp_res);
2329                 be_new_Keep(reg_class, irg, block, 1, &value);
2330
2331                 new_node = new_r_Proj(irg, block, vfisttp, mode_M, pn_ia32_vfisttp_M);
2332                 *fist    = vfisttp;
2333         } else {
2334                 ir_node *trunc_mode = ia32_new_Fpu_truncate(env_cg);
2335
2336                 /* do a fist */
2337                 new_node = new_bd_ia32_vfist(dbgi, block, base, index, mem, val, trunc_mode);
2338                 *fist    = new_node;
2339         }
2340         return new_node;
2341 }
2342 /**
2343  * Transforms a general (no special case) Store.
2344  *
2345  * @return the created ia32 Store node
2346  */
2347 static ir_node *gen_general_Store(ir_node *node)
2348 {
2349         ir_node  *val       = get_Store_value(node);
2350         ir_mode  *mode      = get_irn_mode(val);
2351         ir_node  *block     = get_nodes_block(node);
2352         ir_node  *new_block = be_transform_node(block);
2353         ir_node  *ptr       = get_Store_ptr(node);
2354         ir_node  *mem       = get_Store_mem(node);
2355         dbg_info *dbgi      = get_irn_dbg_info(node);
2356         ir_node  *noreg     = ia32_new_NoReg_gp(env_cg);
2357         ir_node  *new_val, *new_node, *store;
2358         ia32_address_t addr;
2359
2360         /* check for destination address mode */
2361         new_node = try_create_dest_am(node);
2362         if (new_node != NULL)
2363                 return new_node;
2364
2365         /* construct store address */
2366         memset(&addr, 0, sizeof(addr));
2367         ia32_create_address_mode(&addr, ptr, 0);
2368
2369         if (addr.base == NULL) {
2370                 addr.base = noreg;
2371         } else {
2372                 addr.base = be_transform_node(addr.base);
2373         }
2374
2375         if (addr.index == NULL) {
2376                 addr.index = noreg;
2377         } else {
2378                 addr.index = be_transform_node(addr.index);
2379         }
2380         addr.mem = be_transform_node(mem);
2381
2382         if (mode_is_float(mode)) {
2383                 /* Convs (and strict-Convs) before stores are unnecessary if the mode
2384                    is the same. */
2385                 while (is_Conv(val) && mode == get_irn_mode(val)) {
2386                         ir_node *op = get_Conv_op(val);
2387                         if (!mode_is_float(get_irn_mode(op)))
2388                                 break;
2389                         val = op;
2390                 }
2391                 new_val = be_transform_node(val);
2392                 if (ia32_cg_config.use_sse2) {
2393                         new_node = new_bd_ia32_xStore(dbgi, new_block, addr.base,
2394                                                       addr.index, addr.mem, new_val);
2395                 } else {
2396                         new_node = new_bd_ia32_vfst(dbgi, new_block, addr.base,
2397                                                     addr.index, addr.mem, new_val, mode);
2398                 }
2399                 store = new_node;
2400         } else if (!ia32_cg_config.use_sse2 && is_float_to_int_conv(val)) {
2401                 val = get_Conv_op(val);
2402
2403                 /* TODO: is this optimisation still necessary at all (middleend)? */
2404                 /* We can skip ALL float->float up-Convs (and strict-up-Convs) before stores. */
2405                 while (is_Conv(val)) {
2406                         ir_node *op = get_Conv_op(val);
2407                         if (!mode_is_float(get_irn_mode(op)))
2408                                 break;
2409                         if (get_mode_size_bits(get_irn_mode(op)) > get_mode_size_bits(get_irn_mode(val)))
2410                                 break;
2411                         val = op;
2412                 }
2413                 new_val  = be_transform_node(val);
2414                 new_node = gen_vfist(dbgi, current_ir_graph, new_block, addr.base, addr.index, addr.mem, new_val, &store);
2415         } else {
2416                 new_val = create_immediate_or_transform(val, 0);
2417                 assert(mode != mode_b);
2418
2419                 if (get_mode_size_bits(mode) == 8) {
2420                         new_node = new_bd_ia32_Store8Bit(dbgi, new_block, addr.base,
2421                                                          addr.index, addr.mem, new_val);
2422                 } else {
2423                         new_node = new_bd_ia32_Store(dbgi, new_block, addr.base,
2424                                                      addr.index, addr.mem, new_val);
2425                 }
2426                 store = new_node;
2427         }
2428
2429         set_irn_pinned(store, get_irn_pinned(node));
2430         set_ia32_op_type(store, ia32_AddrModeD);
2431         set_ia32_ls_mode(store, mode);
2432
2433         set_address(store, &addr);
2434         SET_IA32_ORIG_NODE(store, node);
2435
2436         return new_node;
2437 }
2438
2439 /**
2440  * Transforms a Store.
2441  *
2442  * @return the created ia32 Store node
2443  */
2444 static ir_node *gen_Store(ir_node *node)
2445 {
2446         ir_node  *val  = get_Store_value(node);
2447         ir_mode  *mode = get_irn_mode(val);
2448
2449         if (mode_is_float(mode) && is_Const(val)) {
2450                 /* We can transform every floating const store
2451                    into a sequence of integer stores.
2452                    If the constant is already in a register,
2453                    it would be better to use it, but we don't
2454                    have this information here. */
2455                 return gen_float_const_Store(node, val);
2456         }
2457         return gen_general_Store(node);
2458 }
2459
2460 /**
2461  * Transforms a Switch.
2462  *
2463  * @return the created ia32 SwitchJmp node
2464  */
2465 static ir_node *create_Switch(ir_node *node)
2466 {
2467         dbg_info *dbgi       = get_irn_dbg_info(node);
2468         ir_node  *block      = be_transform_node(get_nodes_block(node));
2469         ir_node  *sel        = get_Cond_selector(node);
2470         ir_node  *new_sel    = be_transform_node(sel);
2471         int       switch_min = INT_MAX;
2472         int       switch_max = INT_MIN;
2473         long      default_pn = get_Cond_defaultProj(node);
2474         ir_node  *new_node;
2475         const ir_edge_t *edge;
2476
2477         assert(get_mode_size_bits(get_irn_mode(sel)) == 32);
2478
2479         /* determine the smallest switch case value */
2480         foreach_out_edge(node, edge) {
2481                 ir_node *proj = get_edge_src_irn(edge);
2482                 long     pn   = get_Proj_proj(proj);
2483                 if (pn == default_pn)
2484                         continue;
2485
2486                 if (pn < switch_min)
2487                         switch_min = pn;
2488                 if (pn > switch_max)
2489                         switch_max = pn;
2490         }
2491
2492         if ((unsigned) (switch_max - switch_min) > 256000) {
2493                 panic("Size of switch %+F bigger than 256000", node);
2494         }
2495
2496         if (switch_min != 0) {
2497                 ir_node *noreg = ia32_new_NoReg_gp(env_cg);
2498
2499                 /* if smallest switch case is not 0 we need an additional sub */
2500                 new_sel = new_bd_ia32_Lea(dbgi, block, new_sel, noreg);
2501                 add_ia32_am_offs_int(new_sel, -switch_min);
2502                 set_ia32_op_type(new_sel, ia32_AddrModeS);
2503
2504                 SET_IA32_ORIG_NODE(new_sel, node);
2505         }
2506
2507         new_node = new_bd_ia32_SwitchJmp(dbgi, block, new_sel, default_pn);
2508         SET_IA32_ORIG_NODE(new_node, node);
2509
2510         return new_node;
2511 }
2512
2513 /**
2514  * Transform a Cond node.
2515  */
2516 static ir_node *gen_Cond(ir_node *node)
2517 {
2518         ir_node  *block     = get_nodes_block(node);
2519         ir_node  *new_block = be_transform_node(block);
2520         dbg_info *dbgi      = get_irn_dbg_info(node);
2521         ir_node  *sel       = get_Cond_selector(node);
2522         ir_mode  *sel_mode  = get_irn_mode(sel);
2523         ir_node  *flags     = NULL;
2524         ir_node  *new_node;
2525         pn_Cmp    pnc;
2526
2527         if (sel_mode != mode_b) {
2528                 return create_Switch(node);
2529         }
2530
2531         /* we get flags from a Cmp */
2532         flags = get_flags_node(sel, &pnc);
2533
2534         new_node = new_bd_ia32_Jcc(dbgi, new_block, flags, pnc);
2535         SET_IA32_ORIG_NODE(new_node, node);
2536
2537         return new_node;
2538 }
2539
2540 static ir_node *gen_be_Copy(ir_node *node)
2541 {
2542         ir_node *new_node = be_duplicate_node(node);
2543         ir_mode *mode     = get_irn_mode(new_node);
2544
2545         if (ia32_mode_needs_gp_reg(mode)) {
2546                 set_irn_mode(new_node, mode_Iu);
2547         }
2548
2549         return new_node;
2550 }
2551
2552 static ir_node *create_Fucom(ir_node *node)
2553 {
2554         dbg_info *dbgi      = get_irn_dbg_info(node);
2555         ir_node  *block     = get_nodes_block(node);
2556         ir_node  *new_block = be_transform_node(block);
2557         ir_node  *left      = get_Cmp_left(node);
2558         ir_node  *new_left  = be_transform_node(left);
2559         ir_node  *right     = get_Cmp_right(node);
2560         ir_node  *new_right;
2561         ir_node  *new_node;
2562
2563         if (ia32_cg_config.use_fucomi) {
2564                 new_right = be_transform_node(right);
2565                 new_node  = new_bd_ia32_vFucomi(dbgi, new_block, new_left,
2566                                                 new_right, 0);
2567                 set_ia32_commutative(new_node);
2568                 SET_IA32_ORIG_NODE(new_node, node);
2569         } else {
2570                 if (ia32_cg_config.use_ftst && is_Const_0(right)) {
2571                         new_node = new_bd_ia32_vFtstFnstsw(dbgi, new_block, new_left, 0);
2572                 } else {
2573                         new_right = be_transform_node(right);
2574                         new_node  = new_bd_ia32_vFucomFnstsw(dbgi, new_block, new_left, new_right, 0);
2575                 }
2576
2577                 set_ia32_commutative(new_node);
2578
2579                 SET_IA32_ORIG_NODE(new_node, node);
2580
2581                 new_node = new_bd_ia32_Sahf(dbgi, new_block, new_node);
2582                 SET_IA32_ORIG_NODE(new_node, node);
2583         }
2584
2585         return new_node;
2586 }
2587
2588 static ir_node *create_Ucomi(ir_node *node)
2589 {
2590         dbg_info *dbgi      = get_irn_dbg_info(node);
2591         ir_node  *src_block = get_nodes_block(node);
2592         ir_node  *new_block = be_transform_node(src_block);
2593         ir_node  *left      = get_Cmp_left(node);
2594         ir_node  *right     = get_Cmp_right(node);
2595         ir_node  *new_node;
2596         ia32_address_mode_t  am;
2597         ia32_address_t      *addr = &am.addr;
2598
2599         match_arguments(&am, src_block, left, right, NULL,
2600                         match_commutative | match_am);
2601
2602         new_node = new_bd_ia32_Ucomi(dbgi, new_block, addr->base, addr->index,
2603                                      addr->mem, am.new_op1, am.new_op2,
2604                                      am.ins_permuted);
2605         set_am_attributes(new_node, &am);
2606
2607         SET_IA32_ORIG_NODE(new_node, node);
2608
2609         new_node = fix_mem_proj(new_node, &am);
2610
2611         return new_node;
2612 }
2613
2614 /**
2615  * helper function: checks whether all Cmp projs are Lg or Eq which is needed
2616  * to fold an and into a test node
2617  */
2618 static bool can_fold_test_and(ir_node *node)
2619 {
2620         const ir_edge_t *edge;
2621
2622         /** we can only have eq and lg projs */
2623         foreach_out_edge(node, edge) {
2624                 ir_node *proj = get_edge_src_irn(edge);
2625                 pn_Cmp   pnc  = get_Proj_proj(proj);
2626                 if (pnc != pn_Cmp_Eq && pnc != pn_Cmp_Lg)
2627                         return false;
2628         }
2629
2630         return true;
2631 }
2632
2633 /**
2634  * returns true if it is assured, that the upper bits of a node are "clean"
2635  * which means for a 16 or 8 bit value, that the upper bits in the register
2636  * are 0 for unsigned and a copy of the last significant bit for signed
2637  * numbers.
2638  */
2639 static bool upper_bits_clean(ir_node *transformed_node, ir_mode *mode)
2640 {
2641         assert(ia32_mode_needs_gp_reg(mode));
2642         if (get_mode_size_bits(mode) >= 32)
2643                 return true;
2644
2645         if (is_Proj(transformed_node))
2646                 return upper_bits_clean(get_Proj_pred(transformed_node), mode);
2647
2648         switch (get_ia32_irn_opcode(transformed_node)) {
2649                 case iro_ia32_Conv_I2I:
2650                 case iro_ia32_Conv_I2I8Bit: {
2651                         ir_mode *smaller_mode = get_ia32_ls_mode(transformed_node);
2652                         if (mode_is_signed(smaller_mode) != mode_is_signed(mode))
2653                                 return false;
2654                         if (get_mode_size_bits(smaller_mode) > get_mode_size_bits(mode))
2655                                 return false;
2656
2657                         return true;
2658                 }
2659
2660                 case iro_ia32_Shr:
2661                         if (mode_is_signed(mode)) {
2662                                 return false; /* TODO handle signed modes */
2663                         } else {
2664                                 ir_node *right = get_irn_n(transformed_node, n_ia32_Shr_count);
2665                                 if (is_ia32_Immediate(right) || is_ia32_Const(right)) {
2666                                         const ia32_immediate_attr_t *attr
2667                                                 = get_ia32_immediate_attr_const(right);
2668                                         if (attr->symconst == 0 &&
2669                                                         (unsigned)attr->offset >= 32 - get_mode_size_bits(mode)) {
2670                                                 return true;
2671                                         }
2672                                 }
2673                                 return upper_bits_clean(get_irn_n(transformed_node, n_ia32_Shr_val), mode);
2674                         }
2675
2676                 case iro_ia32_And:
2677                         if (mode_is_signed(mode))
2678                                 return false; /* TODO handle signed modes */
2679                         return
2680                                 upper_bits_clean(get_irn_n(transformed_node, n_ia32_And_right), mode) ||
2681                                 upper_bits_clean(get_irn_n(transformed_node, n_ia32_And_left),  mode);
2682
2683                 case iro_ia32_Const:
2684                 case iro_ia32_Immediate: {
2685                         const ia32_immediate_attr_t *attr =
2686                                 get_ia32_immediate_attr_const(transformed_node);
2687                         if (mode_is_signed(mode)) {
2688                                 long shifted = attr->offset >> (get_mode_size_bits(mode) - 1);
2689                                 return shifted == 0 || shifted == -1;
2690                         } else {
2691                                 unsigned long shifted = (unsigned long)attr->offset;
2692                                 shifted >>= get_mode_size_bits(mode);
2693                                 return shifted == 0;
2694                         }
2695                 }
2696
2697                 default:
2698                         /* TODO recurse on Or, Xor, ... if appropriate? */
2699                         return false;
2700         }
2701 }
2702
2703 /**
2704  * Generate code for a Cmp.
2705  */
2706 static ir_node *gen_Cmp(ir_node *node)
2707 {
2708         dbg_info *dbgi      = get_irn_dbg_info(node);
2709         ir_node  *block     = get_nodes_block(node);
2710         ir_node  *new_block = be_transform_node(block);
2711         ir_node  *left      = get_Cmp_left(node);
2712         ir_node  *right     = get_Cmp_right(node);
2713         ir_mode  *cmp_mode  = get_irn_mode(left);
2714         ir_node  *new_node;
2715         ia32_address_mode_t  am;
2716         ia32_address_t      *addr = &am.addr;
2717         int                  cmp_unsigned;
2718
2719         if (mode_is_float(cmp_mode)) {
2720                 if (ia32_cg_config.use_sse2) {
2721                         return create_Ucomi(node);
2722                 } else {
2723                         return create_Fucom(node);
2724                 }
2725         }
2726
2727         assert(ia32_mode_needs_gp_reg(cmp_mode));
2728
2729         /* Prefer the Test instruction, when encountering (x & y) ==/!= 0 */
2730         cmp_unsigned = !mode_is_signed(cmp_mode);
2731         if (is_Const_0(right)          &&
2732             is_And(left)               &&
2733             get_irn_n_edges(left) == 1 &&
2734             can_fold_test_and(node)) {
2735                 /* Test(and_left, and_right) */
2736                 ir_node *and_left  = get_And_left(left);
2737                 ir_node *and_right = get_And_right(left);
2738
2739                 /* matze: code here used mode instead of cmd_mode, I think it is always
2740                  * the same as cmp_mode, but I leave this here to see if this is really
2741                  * true...
2742                  */
2743                 assert(get_irn_mode(and_left) == cmp_mode);
2744
2745                 match_arguments(&am, block, and_left, and_right, NULL,
2746                                                                                 match_commutative |
2747                                                                                 match_am | match_8bit_am | match_16bit_am |
2748                                                                                 match_am_and_immediates | match_immediate |
2749                                                                                 match_8bit | match_16bit);
2750
2751                 /* use 32bit compare mode if possible since the opcode is smaller */
2752                 if (upper_bits_clean(am.new_op1, cmp_mode) &&
2753                     upper_bits_clean(am.new_op2, cmp_mode)) {
2754                         cmp_mode = mode_is_signed(cmp_mode) ? mode_Is : mode_Iu;
2755                 }
2756
2757                 if (get_mode_size_bits(cmp_mode) == 8) {
2758                         new_node = new_bd_ia32_Test8Bit(dbgi, new_block, addr->base,
2759                                         addr->index, addr->mem, am.new_op1, am.new_op2, am.ins_permuted,
2760                                         cmp_unsigned);
2761                 } else {
2762                         new_node = new_bd_ia32_Test(dbgi, new_block, addr->base, addr->index,
2763                                         addr->mem, am.new_op1, am.new_op2, am.ins_permuted, cmp_unsigned);
2764                 }
2765         } else {
2766                 /* Cmp(left, right) */
2767                 match_arguments(&am, block, left, right, NULL,
2768                                 match_commutative | match_am | match_8bit_am |
2769                                 match_16bit_am | match_am_and_immediates |
2770                                 match_immediate | match_8bit | match_16bit);
2771                 /* use 32bit compare mode if possible since the opcode is smaller */
2772                 if (upper_bits_clean(am.new_op1, cmp_mode) &&
2773                     upper_bits_clean(am.new_op2, cmp_mode)) {
2774                         cmp_mode = mode_is_signed(cmp_mode) ? mode_Is : mode_Iu;
2775                 }
2776
2777                 if (get_mode_size_bits(cmp_mode) == 8) {
2778                         new_node = new_bd_ia32_Cmp8Bit(dbgi, new_block, addr->base,
2779                                                        addr->index, addr->mem, am.new_op1,
2780                                                        am.new_op2, am.ins_permuted,
2781                                                        cmp_unsigned);
2782                 } else {
2783                         new_node = new_bd_ia32_Cmp(dbgi, new_block, addr->base, addr->index,
2784                                         addr->mem, am.new_op1, am.new_op2, am.ins_permuted, cmp_unsigned);
2785                 }
2786         }
2787         set_am_attributes(new_node, &am);
2788         set_ia32_ls_mode(new_node, cmp_mode);
2789
2790         SET_IA32_ORIG_NODE(new_node, node);
2791
2792         new_node = fix_mem_proj(new_node, &am);
2793
2794         return new_node;
2795 }
2796
2797 static ir_node *create_CMov(ir_node *node, ir_node *flags, ir_node *new_flags,
2798                             pn_Cmp pnc)
2799 {
2800         dbg_info            *dbgi          = get_irn_dbg_info(node);
2801         ir_node             *block         = get_nodes_block(node);
2802         ir_node             *new_block     = be_transform_node(block);
2803         ir_node             *val_true      = get_Mux_true(node);
2804         ir_node             *val_false     = get_Mux_false(node);
2805         ir_node             *new_node;
2806         match_flags_t        match_flags;
2807         ia32_address_mode_t  am;
2808         ia32_address_t      *addr;
2809
2810         assert(ia32_cg_config.use_cmov);
2811         assert(ia32_mode_needs_gp_reg(get_irn_mode(val_true)));
2812
2813         addr = &am.addr;
2814
2815         match_flags = match_commutative | match_am | match_16bit_am |
2816                       match_mode_neutral;
2817
2818         match_arguments(&am, block, val_false, val_true, flags, match_flags);
2819
2820         new_node = new_bd_ia32_CMov(dbgi, new_block, addr->base, addr->index,
2821                                     addr->mem, am.new_op1, am.new_op2, new_flags,
2822                                     am.ins_permuted, pnc);
2823         set_am_attributes(new_node, &am);
2824
2825         SET_IA32_ORIG_NODE(new_node, node);
2826
2827         new_node = fix_mem_proj(new_node, &am);
2828
2829         return new_node;
2830 }
2831
2832 /**
2833  * Creates a ia32 Setcc instruction.
2834  */
2835 static ir_node *create_set_32bit(dbg_info *dbgi, ir_node *new_block,
2836                                  ir_node *flags, pn_Cmp pnc, ir_node *orig_node,
2837                                  int ins_permuted)
2838 {
2839         ir_node *noreg = ia32_new_NoReg_gp(env_cg);
2840         ir_node *nomem = new_NoMem();
2841         ir_mode *mode  = get_irn_mode(orig_node);
2842         ir_node *new_node;
2843
2844         new_node = new_bd_ia32_Set(dbgi, new_block, flags, pnc, ins_permuted);
2845         SET_IA32_ORIG_NODE(new_node, orig_node);
2846
2847         /* we might need to conv the result up */
2848         if (get_mode_size_bits(mode) > 8) {
2849                 new_node = new_bd_ia32_Conv_I2I8Bit(dbgi, new_block, noreg, noreg,
2850                                                     nomem, new_node, mode_Bu);
2851                 SET_IA32_ORIG_NODE(new_node, orig_node);
2852         }
2853
2854         return new_node;
2855 }
2856
2857 /**
2858  * Create instruction for an unsigned Difference or Zero.
2859  */
2860 static ir_node *create_Doz(ir_node *psi, ir_node *a, ir_node *b)
2861 {
2862         ir_graph *irg   = current_ir_graph;
2863         ir_mode  *mode  = get_irn_mode(psi);
2864         ir_node  *new_node, *sub, *sbb, *eflags, *block, *noreg, *tmpreg, *nomem;
2865         dbg_info *dbgi;
2866
2867         new_node = gen_binop(psi, a, b, new_bd_ia32_Sub,
2868                 match_mode_neutral | match_am | match_immediate | match_two_users);
2869
2870         block = get_nodes_block(new_node);
2871
2872         if (is_Proj(new_node)) {
2873                 sub = get_Proj_pred(new_node);
2874                 assert(is_ia32_Sub(sub));
2875         } else {
2876                 sub = new_node;
2877                 set_irn_mode(sub, mode_T);
2878                 new_node = new_rd_Proj(NULL, irg, block, sub, mode, pn_ia32_res);
2879         }
2880         eflags = new_rd_Proj(NULL, irg, block, sub, mode_Iu, pn_ia32_Sub_flags);
2881
2882         dbgi   = get_irn_dbg_info(psi);
2883         noreg  = ia32_new_NoReg_gp(env_cg);
2884         tmpreg = new_bd_ia32_ProduceVal(dbgi, block);
2885         nomem  = new_NoMem();
2886         sbb    = new_bd_ia32_Sbb(dbgi, block, noreg, noreg, nomem, tmpreg, tmpreg, eflags);
2887
2888         new_node = new_bd_ia32_And(dbgi, block, noreg, noreg, nomem, new_node, sbb);
2889         set_ia32_commutative(new_node);
2890         return new_node;
2891 }
2892
2893 /**
2894  * Transforms a Mux node into CMov.
2895  *
2896  * @return The transformed node.
2897  */
2898 static ir_node *gen_Mux(ir_node *node)
2899 {
2900         dbg_info *dbgi        = get_irn_dbg_info(node);
2901         ir_node  *block       = get_nodes_block(node);
2902         ir_node  *new_block   = be_transform_node(block);
2903         ir_node  *mux_true    = get_Mux_true(node);
2904         ir_node  *mux_false   = get_Mux_false(node);
2905         ir_node  *cond        = get_Mux_sel(node);
2906         ir_mode  *mode        = get_irn_mode(node);
2907         pn_Cmp   pnc;
2908
2909         assert(get_irn_mode(cond) == mode_b);
2910
2911         /* Note: a Mux node uses a Load two times IFF it's used in the compare AND in the result */
2912         if (mode_is_float(mode)) {
2913                 ir_node  *cmp         = get_Proj_pred(cond);
2914                 ir_node  *cmp_left    = get_Cmp_left(cmp);
2915                 ir_node  *cmp_right   = get_Cmp_right(cmp);
2916                 pn_Cmp   pnc          = get_Proj_proj(cond);
2917
2918                 if (ia32_cg_config.use_sse2) {
2919                         if (pnc == pn_Cmp_Lt || pnc == pn_Cmp_Le) {
2920                                 if (cmp_left == mux_true && cmp_right == mux_false) {
2921                                         /* Mux(a <= b, a, b) => MIN */
2922                                         return gen_binop(node, cmp_left, cmp_right, new_bd_ia32_xMin,
2923                                          match_commutative | match_am | match_two_users);
2924                                 } else if (cmp_left == mux_false && cmp_right == mux_true) {
2925                                         /* Mux(a <= b, b, a) => MAX */
2926                                         return gen_binop(node, cmp_left, cmp_right, new_bd_ia32_xMax,
2927                                          match_commutative | match_am | match_two_users);
2928                                 }
2929                         } else if (pnc == pn_Cmp_Gt || pnc == pn_Cmp_Ge) {
2930                                 if (cmp_left == mux_true && cmp_right == mux_false) {
2931                                         /* Mux(a >= b, a, b) => MAX */
2932                                         return gen_binop(node, cmp_left, cmp_right, new_bd_ia32_xMax,
2933                                          match_commutative | match_am | match_two_users);
2934                                 } else if (cmp_left == mux_false && cmp_right == mux_true) {
2935                                         /* Mux(a >= b, b, a) => MIN */
2936                                         return gen_binop(node, cmp_left, cmp_right, new_bd_ia32_xMin,
2937                                          match_commutative | match_am | match_two_users);
2938                                 }
2939                         }
2940                 }
2941                 panic("cannot transform floating point Mux");
2942
2943         } else {
2944                 ir_node *flags;
2945                 ir_node *new_node;
2946
2947                 assert(ia32_mode_needs_gp_reg(mode));
2948
2949                 if (is_Proj(cond)) {
2950                         ir_node *cmp = get_Proj_pred(cond);
2951                         if (is_Cmp(cmp)) {
2952                                 ir_node  *cmp_left    = get_Cmp_left(cmp);
2953                                 ir_node  *cmp_right   = get_Cmp_right(cmp);
2954                                 pn_Cmp   pnc          = get_Proj_proj(cond);
2955
2956                                 /* check for unsigned Doz first */
2957                                 if ((pnc & pn_Cmp_Gt) && !mode_is_signed(mode) &&
2958                                         is_Const_0(mux_false) && is_Sub(mux_true) &&
2959                                         get_Sub_left(mux_true) == cmp_left && get_Sub_right(mux_true) == cmp_right) {
2960                                         /* Mux(a >=u b, a - b, 0) unsigned Doz */
2961                                         return create_Doz(node, cmp_left, cmp_right);
2962                                 } else if ((pnc & pn_Cmp_Lt) && !mode_is_signed(mode) &&
2963                                         is_Const_0(mux_true) && is_Sub(mux_false) &&
2964                                         get_Sub_left(mux_false) == cmp_left && get_Sub_right(mux_false) == cmp_right) {
2965                                         /* Mux(a <=u b, 0, a - b) unsigned Doz */
2966                                         return create_Doz(node, cmp_left, cmp_right);
2967                                 }
2968                         }
2969                 }
2970
2971                 flags = get_flags_node(cond, &pnc);
2972
2973                 if (is_Const(mux_true) && is_Const(mux_false)) {
2974                         /* both are const, good */
2975                         if (is_Const_1(mux_true) && is_Const_0(mux_false)) {
2976                                 new_node = create_set_32bit(dbgi, new_block, flags, pnc, node, /*is_premuted=*/0);
2977                         } else if (is_Const_0(mux_true) && is_Const_1(mux_false)) {
2978                                 new_node = create_set_32bit(dbgi, new_block, flags, pnc, node, /*is_premuted=*/1);
2979                         } else {
2980                                 /* Not that simple. */
2981                                 goto need_cmov;
2982                         }
2983                 } else {
2984 need_cmov:
2985                         new_node = create_CMov(node, cond, flags, pnc);
2986                 }
2987                 return new_node;
2988         }
2989 }
2990
2991
2992 /**
2993  * Create a conversion from x87 state register to general purpose.
2994  */
2995 static ir_node *gen_x87_fp_to_gp(ir_node *node)
2996 {
2997         ir_node         *block      = be_transform_node(get_nodes_block(node));
2998         ir_node         *op         = get_Conv_op(node);
2999         ir_node         *new_op     = be_transform_node(op);
3000         ia32_code_gen_t *cg         = env_cg;
3001         ir_graph        *irg        = current_ir_graph;
3002         dbg_info        *dbgi       = get_irn_dbg_info(node);
3003         ir_node         *noreg      = ia32_new_NoReg_gp(cg);
3004         ir_mode         *mode       = get_irn_mode(node);
3005         ir_node         *fist, *load, *mem;
3006
3007         mem = gen_vfist(dbgi, irg, block, get_irg_frame(irg), noreg, new_NoMem(), new_op, &fist);
3008         set_irn_pinned(fist, op_pin_state_floats);
3009         set_ia32_use_frame(fist);
3010         set_ia32_op_type(fist, ia32_AddrModeD);
3011
3012         assert(get_mode_size_bits(mode) <= 32);
3013         /* exception we can only store signed 32 bit integers, so for unsigned
3014            we store a 64bit (signed) integer and load the lower bits */
3015         if (get_mode_size_bits(mode) == 32 && !mode_is_signed(mode)) {
3016                 set_ia32_ls_mode(fist, mode_Ls);
3017         } else {
3018                 set_ia32_ls_mode(fist, mode_Is);
3019         }
3020         SET_IA32_ORIG_NODE(fist, node);
3021
3022         /* do a Load */
3023         load = new_bd_ia32_Load(dbgi, block, get_irg_frame(irg), noreg, mem);
3024
3025         set_irn_pinned(load, op_pin_state_floats);
3026         set_ia32_use_frame(load);
3027         set_ia32_op_type(load, ia32_AddrModeS);
3028         set_ia32_ls_mode(load, mode_Is);
3029         if (get_ia32_ls_mode(fist) == mode_Ls) {
3030                 ia32_attr_t *attr = get_ia32_attr(load);
3031                 attr->data.need_64bit_stackent = 1;
3032         } else {
3033                 ia32_attr_t *attr = get_ia32_attr(load);
3034                 attr->data.need_32bit_stackent = 1;
3035         }
3036         SET_IA32_ORIG_NODE(load, node);
3037
3038         return new_r_Proj(irg, block, load, mode_Iu, pn_ia32_Load_res);
3039 }
3040
3041 /**
3042  * Creates a x87 strict Conv by placing a Store and a Load
3043  */
3044 static ir_node *gen_x87_strict_conv(ir_mode *tgt_mode, ir_node *node)
3045 {
3046         ir_node  *block    = get_nodes_block(node);
3047         ir_graph *irg      = current_ir_graph;
3048         dbg_info *dbgi     = get_irn_dbg_info(node);
3049         ir_node  *noreg    = ia32_new_NoReg_gp(env_cg);
3050         ir_node  *nomem    = new_NoMem();
3051         ir_node  *frame    = get_irg_frame(irg);
3052         ir_node  *store, *load;
3053         ir_node  *new_node;
3054
3055         store = new_bd_ia32_vfst(dbgi, block, frame, noreg, nomem, node, tgt_mode);
3056         set_ia32_use_frame(store);
3057         set_ia32_op_type(store, ia32_AddrModeD);
3058         SET_IA32_ORIG_NODE(store, node);
3059
3060         load = new_bd_ia32_vfld(dbgi, block, frame, noreg, store, tgt_mode);
3061         set_ia32_use_frame(load);
3062         set_ia32_op_type(load, ia32_AddrModeS);
3063         SET_IA32_ORIG_NODE(load, node);
3064
3065         new_node = new_r_Proj(irg, block, load, mode_E, pn_ia32_vfld_res);
3066         return new_node;
3067 }
3068
3069 /**
3070  * Create a conversion from general purpose to x87 register
3071  */
3072 static ir_node *gen_x87_gp_to_fp(ir_node *node, ir_mode *src_mode)
3073 {
3074         ir_node  *src_block = get_nodes_block(node);
3075         ir_node  *block     = be_transform_node(src_block);
3076         ir_graph *irg       = current_ir_graph;
3077         dbg_info *dbgi      = get_irn_dbg_info(node);
3078         ir_node  *op        = get_Conv_op(node);
3079         ir_node  *new_op    = NULL;
3080         ir_node  *noreg;
3081         ir_node  *nomem;
3082         ir_mode  *mode;
3083         ir_mode  *store_mode;
3084         ir_node  *fild;
3085         ir_node  *store;
3086         ir_node  *new_node;
3087         int       src_bits;
3088
3089         /* fild can use source AM if the operand is a signed 16bit or 32bit integer */
3090         if (src_mode == mode_Is || src_mode == mode_Hs) {
3091                 ia32_address_mode_t am;
3092
3093                 match_arguments(&am, src_block, NULL, op, NULL,
3094                                 match_am | match_try_am | match_16bit | match_16bit_am);
3095                 if (am.op_type == ia32_AddrModeS) {
3096                         ia32_address_t *addr = &am.addr;
3097
3098                         fild     = new_bd_ia32_vfild(dbgi, block, addr->base, addr->index,
3099                                         addr->mem);
3100                         new_node = new_r_Proj(irg, block, fild, mode_vfp,
3101                                               pn_ia32_vfild_res);
3102
3103                         set_am_attributes(fild, &am);
3104                         SET_IA32_ORIG_NODE(fild, node);
3105
3106                         fix_mem_proj(fild, &am);
3107
3108                         return new_node;
3109                 }
3110         }
3111         if (new_op == NULL) {
3112                 new_op = be_transform_node(op);
3113         }
3114
3115         noreg  = ia32_new_NoReg_gp(env_cg);
3116         nomem  = new_NoMem();
3117         mode   = get_irn_mode(op);
3118
3119         /* first convert to 32 bit signed if necessary */
3120         src_bits = get_mode_size_bits(src_mode);
3121         if (src_bits == 8) {
3122                 new_op = new_bd_ia32_Conv_I2I8Bit(dbgi, block, noreg, noreg, nomem,
3123                                                   new_op, src_mode);
3124                 SET_IA32_ORIG_NODE(new_op, node);
3125                 mode = mode_Is;
3126         } else if (src_bits < 32) {
3127                 new_op = new_bd_ia32_Conv_I2I(dbgi, block, noreg, noreg, nomem,
3128                                               new_op, src_mode);
3129                 SET_IA32_ORIG_NODE(new_op, node);
3130                 mode = mode_Is;
3131         }
3132
3133         assert(get_mode_size_bits(mode) == 32);
3134
3135         /* do a store */
3136         store = new_bd_ia32_Store(dbgi, block, get_irg_frame(irg), noreg, nomem,
3137                                   new_op);
3138
3139         set_ia32_use_frame(store);
3140         set_ia32_op_type(store, ia32_AddrModeD);
3141         set_ia32_ls_mode(store, mode_Iu);
3142
3143         /* exception for 32bit unsigned, do a 64bit spill+load */
3144         if (!mode_is_signed(mode)) {
3145                 ir_node *in[2];
3146                 /* store a zero */
3147                 ir_node *zero_const = create_Immediate(NULL, 0, 0);
3148
3149                 ir_node *zero_store = new_bd_ia32_Store(dbgi, block, get_irg_frame(irg),
3150                                 noreg, nomem, zero_const);
3151
3152                 set_ia32_use_frame(zero_store);
3153                 set_ia32_op_type(zero_store, ia32_AddrModeD);
3154                 add_ia32_am_offs_int(zero_store, 4);
3155                 set_ia32_ls_mode(zero_store, mode_Iu);
3156
3157                 in[0] = zero_store;
3158                 in[1] = store;
3159
3160                 store      = new_rd_Sync(dbgi, irg, block, 2, in);
3161                 store_mode = mode_Ls;
3162         } else {
3163                 store_mode = mode_Is;
3164         }
3165
3166         /* do a fild */
3167         fild = new_bd_ia32_vfild(dbgi, block, get_irg_frame(irg), noreg, store);
3168
3169         set_ia32_use_frame(fild);
3170         set_ia32_op_type(fild, ia32_AddrModeS);
3171         set_ia32_ls_mode(fild, store_mode);
3172
3173         new_node = new_r_Proj(irg, block, fild, mode_vfp, pn_ia32_vfild_res);
3174
3175         return new_node;
3176 }
3177
3178 /**
3179  * Create a conversion from one integer mode into another one
3180  */
3181 static ir_node *create_I2I_Conv(ir_mode *src_mode, ir_mode *tgt_mode,
3182                                 dbg_info *dbgi, ir_node *block, ir_node *op,
3183                                 ir_node *node)
3184 {
3185         int       src_bits  = get_mode_size_bits(src_mode);
3186         int       tgt_bits  = get_mode_size_bits(tgt_mode);
3187         ir_node  *new_block = be_transform_node(block);
3188         ir_node  *new_node;
3189         ir_mode  *smaller_mode;
3190         int       smaller_bits;
3191         ia32_address_mode_t  am;
3192         ia32_address_t      *addr = &am.addr;
3193
3194         (void) node;
3195         if (src_bits < tgt_bits) {
3196                 smaller_mode = src_mode;
3197                 smaller_bits = src_bits;
3198         } else {
3199                 smaller_mode = tgt_mode;
3200                 smaller_bits = tgt_bits;
3201         }
3202
3203 #ifdef DEBUG_libfirm
3204         if (is_Const(op)) {
3205                 ir_fprintf(stderr, "Optimisation warning: conv after constant %+F\n",
3206                            op);
3207         }
3208 #endif
3209
3210         match_arguments(&am, block, NULL, op, NULL,
3211                         match_8bit | match_16bit |
3212                         match_am | match_8bit_am | match_16bit_am);
3213
3214         if (upper_bits_clean(am.new_op2, smaller_mode)) {
3215                 /* unnecessary conv. in theory it shouldn't have been AM */
3216                 assert(is_ia32_NoReg_GP(addr->base));
3217                 assert(is_ia32_NoReg_GP(addr->index));
3218                 assert(is_NoMem(addr->mem));
3219                 assert(am.addr.offset == 0);
3220                 assert(am.addr.symconst_ent == NULL);
3221                 return am.new_op2;
3222         }
3223
3224         if (smaller_bits == 8) {
3225                 new_node = new_bd_ia32_Conv_I2I8Bit(dbgi, new_block, addr->base,
3226                                                     addr->index, addr->mem, am.new_op2,
3227                                                     smaller_mode);
3228         } else {
3229                 new_node = new_bd_ia32_Conv_I2I(dbgi, new_block, addr->base,
3230                                                 addr->index, addr->mem, am.new_op2,
3231                                                 smaller_mode);
3232         }
3233         set_am_attributes(new_node, &am);
3234         /* match_arguments assume that out-mode = in-mode, this isn't true here
3235          * so fix it */
3236         set_ia32_ls_mode(new_node, smaller_mode);
3237         SET_IA32_ORIG_NODE(new_node, node);
3238         new_node = fix_mem_proj(new_node, &am);
3239         return new_node;
3240 }
3241
3242 /**
3243  * Transforms a Conv node.
3244  *
3245  * @return The created ia32 Conv node
3246  */
3247 static ir_node *gen_Conv(ir_node *node)
3248 {
3249         ir_node  *block     = get_nodes_block(node);
3250         ir_node  *new_block = be_transform_node(block);
3251         ir_node  *op        = get_Conv_op(node);
3252         ir_node  *new_op    = NULL;
3253         dbg_info *dbgi      = get_irn_dbg_info(node);
3254         ir_mode  *src_mode  = get_irn_mode(op);
3255         ir_mode  *tgt_mode  = get_irn_mode(node);
3256         int       src_bits  = get_mode_size_bits(src_mode);
3257         int       tgt_bits  = get_mode_size_bits(tgt_mode);
3258         ir_node  *noreg     = ia32_new_NoReg_gp(env_cg);
3259         ir_node  *nomem     = new_NoMem();
3260         ir_node  *res       = NULL;
3261
3262         if (src_mode == mode_b) {
3263                 assert(mode_is_int(tgt_mode) || mode_is_reference(tgt_mode));
3264                 /* nothing to do, we already model bools as 0/1 ints */
3265                 return be_transform_node(op);
3266         }
3267
3268         if (src_mode == tgt_mode) {
3269                 if (get_Conv_strict(node)) {
3270                         if (ia32_cg_config.use_sse2) {
3271                                 /* when we are in SSE mode, we can kill all strict no-op conversion */
3272                                 return be_transform_node(op);
3273                         }
3274                 } else {
3275                         /* this should be optimized already, but who knows... */
3276                         DEBUG_ONLY(ir_fprintf(stderr, "Debug warning: conv %+F is pointless\n", node));
3277                         DB((dbg, LEVEL_1, "killed Conv(mode, mode) ..."));
3278                         return be_transform_node(op);
3279                 }
3280         }
3281
3282         if (mode_is_float(src_mode)) {
3283                 new_op = be_transform_node(op);
3284                 /* we convert from float ... */
3285                 if (mode_is_float(tgt_mode)) {
3286                         if (src_mode == mode_E && tgt_mode == mode_D
3287                                         && !get_Conv_strict(node)) {
3288                                 DB((dbg, LEVEL_1, "killed Conv(mode, mode) ..."));
3289                                 return new_op;
3290                         }
3291
3292                         /* ... to float */
3293                         if (ia32_cg_config.use_sse2) {
3294                                 DB((dbg, LEVEL_1, "create Conv(float, float) ..."));
3295                                 res = new_bd_ia32_Conv_FP2FP(dbgi, new_block, noreg, noreg,
3296                                                              nomem, new_op);
3297                                 set_ia32_ls_mode(res, tgt_mode);
3298                         } else {
3299                                 if (get_Conv_strict(node)) {
3300                                         res = gen_x87_strict_conv(tgt_mode, new_op);
3301                                         SET_IA32_ORIG_NODE(get_Proj_pred(res), node);
3302                                         return res;
3303                                 }
3304                                 DB((dbg, LEVEL_1, "killed Conv(float, float) ..."));
3305                                 return new_op;
3306                         }
3307                 } else {
3308                         /* ... to int */
3309                         DB((dbg, LEVEL_1, "create Conv(float, int) ..."));
3310                         if (ia32_cg_config.use_sse2) {
3311                                 res = new_bd_ia32_Conv_FP2I(dbgi, new_block, noreg, noreg,
3312                                                             nomem, new_op);
3313                                 set_ia32_ls_mode(res, src_mode);
3314                         } else {
3315                                 return gen_x87_fp_to_gp(node);
3316                         }
3317                 }
3318         } else {
3319                 /* we convert from int ... */
3320                 if (mode_is_float(tgt_mode)) {
3321                         /* ... to float */
3322                         DB((dbg, LEVEL_1, "create Conv(int, float) ..."));
3323                         if (ia32_cg_config.use_sse2) {
3324                                 new_op = be_transform_node(op);
3325                                 res = new_bd_ia32_Conv_I2FP(dbgi, new_block, noreg, noreg,
3326                                                             nomem, new_op);
3327                                 set_ia32_ls_mode(res, tgt_mode);
3328                         } else {
3329                                 res = gen_x87_gp_to_fp(node, src_mode);
3330                                 if (get_Conv_strict(node)) {
3331                                         /* The strict-Conv is only necessary, if the int mode has more bits
3332                                          * than the float mantissa */
3333                                         size_t int_mantissa = get_mode_size_bits(src_mode) - (mode_is_signed(src_mode) ? 1 : 0);
3334                                         size_t float_mantissa;
3335                                         /* FIXME There is no way to get the mantissa size of a mode */
3336                                         switch (get_mode_size_bits(tgt_mode)) {
3337                                                 case 32: float_mantissa = 23 + 1; break; // + 1 for implicit 1
3338                                                 case 64: float_mantissa = 52 + 1; break;
3339                                                 case 80:
3340                                                 case 96: float_mantissa = 64;     break;
3341                                                 default: float_mantissa = 0;      break;
3342                                         }
3343                                         if (float_mantissa < int_mantissa) {
3344                                                 res = gen_x87_strict_conv(tgt_mode, res);
3345                                                 SET_IA32_ORIG_NODE(get_Proj_pred(res), node);
3346                                         }
3347                                 }
3348                                 return res;
3349                         }
3350                 } else if (tgt_mode == mode_b) {
3351                         /* mode_b lowering already took care that we only have 0/1 values */
3352                         DB((dbg, LEVEL_1, "omitting unnecessary Conv(%+F, %+F) ...",
3353                             src_mode, tgt_mode));
3354                         return be_transform_node(op);
3355                 } else {
3356                         /* to int */
3357                         if (src_bits == tgt_bits) {
3358                                 DB((dbg, LEVEL_1, "omitting unnecessary Conv(%+F, %+F) ...",
3359                                     src_mode, tgt_mode));
3360                                 return be_transform_node(op);
3361                         }
3362
3363                         res = create_I2I_Conv(src_mode, tgt_mode, dbgi, block, op, node);
3364                         return res;
3365                 }
3366         }
3367
3368         return res;
3369 }
3370
3371 static ir_node *create_immediate_or_transform(ir_node *node,
3372                                               char immediate_constraint_type)
3373 {
3374         ir_node *new_node = try_create_Immediate(node, immediate_constraint_type);
3375         if (new_node == NULL) {
3376                 new_node = be_transform_node(node);
3377         }
3378         return new_node;
3379 }
3380
3381 /**
3382  * Transforms a FrameAddr into an ia32 Add.
3383  */
3384 static ir_node *gen_be_FrameAddr(ir_node *node)
3385 {
3386         ir_node  *block  = be_transform_node(get_nodes_block(node));
3387         ir_node  *op     = be_get_FrameAddr_frame(node);
3388         ir_node  *new_op = be_transform_node(op);
3389         dbg_info *dbgi   = get_irn_dbg_info(node);
3390         ir_node  *noreg  = ia32_new_NoReg_gp(env_cg);
3391         ir_node  *new_node;
3392
3393         new_node = new_bd_ia32_Lea(dbgi, block, new_op, noreg);
3394         set_ia32_frame_ent(new_node, arch_get_frame_entity(node));
3395         set_ia32_use_frame(new_node);
3396
3397         SET_IA32_ORIG_NODE(new_node, node);
3398
3399         return new_node;
3400 }
3401
3402 /**
3403  * In case SSE is used we need to copy the result from XMM0 to FPU TOS before return.
3404  */
3405 static ir_node *gen_be_Return(ir_node *node)
3406 {
3407         ir_graph  *irg     = current_ir_graph;
3408         ir_node   *ret_val = get_irn_n(node, be_pos_Return_val);
3409         ir_node   *ret_mem = get_irn_n(node, be_pos_Return_mem);
3410         ir_entity *ent     = get_irg_entity(irg);
3411         ir_type   *tp      = get_entity_type(ent);
3412         dbg_info  *dbgi;
3413         ir_node   *block;
3414         ir_type   *res_type;
3415         ir_mode   *mode;
3416         ir_node   *frame, *sse_store, *fld, *mproj, *barrier;
3417         ir_node   *new_barrier, *new_ret_val, *new_ret_mem;
3418         ir_node   *noreg;
3419         ir_node   **in;
3420         int       pn_ret_val, pn_ret_mem, arity, i;
3421
3422         assert(ret_val != NULL);
3423         if (be_Return_get_n_rets(node) < 1 || ! ia32_cg_config.use_sse2) {
3424                 return be_duplicate_node(node);
3425         }
3426
3427         res_type = get_method_res_type(tp, 0);
3428
3429         if (! is_Primitive_type(res_type)) {
3430                 return be_duplicate_node(node);
3431         }
3432
3433         mode = get_type_mode(res_type);
3434         if (! mode_is_float(mode)) {
3435                 return be_duplicate_node(node);
3436         }
3437
3438         assert(get_method_n_ress(tp) == 1);
3439
3440         pn_ret_val = get_Proj_proj(ret_val);
3441         pn_ret_mem = get_Proj_proj(ret_mem);
3442
3443         /* get the Barrier */
3444         barrier = get_Proj_pred(ret_val);
3445
3446         /* get result input of the Barrier */
3447         ret_val     = get_irn_n(barrier, pn_ret_val);
3448         new_ret_val = be_transform_node(ret_val);
3449
3450         /* get memory input of the Barrier */
3451         ret_mem     = get_irn_n(barrier, pn_ret_mem);
3452         new_ret_mem = be_transform_node(ret_mem);
3453
3454         frame = get_irg_frame(irg);
3455
3456         dbgi  = get_irn_dbg_info(barrier);
3457         block = be_transform_node(get_nodes_block(barrier));
3458
3459         noreg = ia32_new_NoReg_gp(env_cg);
3460
3461         /* store xmm0 onto stack */
3462         sse_store = new_bd_ia32_xStoreSimple(dbgi, block, frame, noreg,
3463                                              new_ret_mem, new_ret_val);
3464         set_ia32_ls_mode(sse_store, mode);
3465         set_ia32_op_type(sse_store, ia32_AddrModeD);
3466         set_ia32_use_frame(sse_store);
3467
3468         /* load into x87 register */
3469         fld = new_bd_ia32_vfld(dbgi, block, frame, noreg, sse_store, mode);
3470         set_ia32_op_type(fld, ia32_AddrModeS);
3471         set_ia32_use_frame(fld);
3472
3473         mproj = new_r_Proj(irg, block, fld, mode_M, pn_ia32_vfld_M);
3474         fld   = new_r_Proj(irg, block, fld, mode_vfp, pn_ia32_vfld_res);
3475
3476         /* create a new barrier */
3477         arity = get_irn_arity(barrier);
3478         in    = ALLOCAN(ir_node*, arity);
3479         for (i = 0; i < arity; ++i) {
3480                 ir_node *new_in;
3481
3482                 if (i == pn_ret_val) {
3483                         new_in = fld;
3484                 } else if (i == pn_ret_mem) {
3485                         new_in = mproj;
3486                 } else {
3487                         ir_node *in = get_irn_n(barrier, i);
3488                         new_in = be_transform_node(in);
3489                 }
3490                 in[i] = new_in;
3491         }
3492
3493         new_barrier = new_ir_node(dbgi, irg, block,
3494                                   get_irn_op(barrier), get_irn_mode(barrier),
3495                                   arity, in);
3496         copy_node_attr(barrier, new_barrier);
3497         be_duplicate_deps(barrier, new_barrier);
3498         be_set_transformed_node(barrier, new_barrier);
3499
3500         /* transform normally */
3501         return be_duplicate_node(node);
3502 }
3503
3504 /**
3505  * Transform a be_AddSP into an ia32_SubSP.
3506  */
3507 static ir_node *gen_be_AddSP(ir_node *node)
3508 {
3509         ir_node  *sz = get_irn_n(node, be_pos_AddSP_size);
3510         ir_node  *sp = get_irn_n(node, be_pos_AddSP_old_sp);
3511
3512         return gen_binop(node, sp, sz, new_bd_ia32_SubSP,
3513                          match_am | match_immediate);
3514 }
3515
3516 /**
3517  * Transform a be_SubSP into an ia32_AddSP
3518  */
3519 static ir_node *gen_be_SubSP(ir_node *node)
3520 {
3521         ir_node  *sz = get_irn_n(node, be_pos_SubSP_size);
3522         ir_node  *sp = get_irn_n(node, be_pos_SubSP_old_sp);
3523
3524         return gen_binop(node, sp, sz, new_bd_ia32_AddSP,
3525                          match_am | match_immediate);
3526 }
3527
3528 /**
3529  * Change some phi modes
3530  */
3531 static ir_node *gen_Phi(ir_node *node)
3532 {
3533         ir_node  *block = be_transform_node(get_nodes_block(node));
3534         ir_graph *irg   = current_ir_graph;
3535         dbg_info *dbgi  = get_irn_dbg_info(node);
3536         ir_mode  *mode  = get_irn_mode(node);
3537         ir_node  *phi;
3538
3539         if (ia32_mode_needs_gp_reg(mode)) {
3540                 /* we shouldn't have any 64bit stuff around anymore */
3541                 assert(get_mode_size_bits(mode) <= 32);
3542                 /* all integer operations are on 32bit registers now */
3543                 mode = mode_Iu;
3544         } else if (mode_is_float(mode)) {
3545                 if (ia32_cg_config.use_sse2) {
3546                         mode = mode_xmm;
3547                 } else {
3548                         mode = mode_vfp;
3549                 }
3550         }
3551
3552         /* phi nodes allow loops, so we use the old arguments for now
3553          * and fix this later */
3554         phi = new_ir_node(dbgi, irg, block, op_Phi, mode, get_irn_arity(node),
3555                           get_irn_in(node) + 1);
3556         copy_node_attr(node, phi);
3557         be_duplicate_deps(node, phi);
3558
3559         be_enqueue_preds(node);
3560
3561         return phi;
3562 }
3563
3564 /**
3565  * Transform IJmp
3566  */
3567 static ir_node *gen_IJmp(ir_node *node)
3568 {
3569         ir_node  *block     = get_nodes_block(node);
3570         ir_node  *new_block = be_transform_node(block);
3571         dbg_info *dbgi      = get_irn_dbg_info(node);
3572         ir_node  *op        = get_IJmp_target(node);
3573         ir_node  *new_node;
3574         ia32_address_mode_t  am;
3575         ia32_address_t      *addr = &am.addr;
3576
3577         assert(get_irn_mode(op) == mode_P);
3578
3579         match_arguments(&am, block, NULL, op, NULL,
3580                         match_am | match_8bit_am | match_16bit_am |
3581                         match_immediate | match_8bit | match_16bit);
3582
3583         new_node = new_bd_ia32_IJmp(dbgi, new_block, addr->base, addr->index,
3584                         addr->mem, am.new_op2);
3585         set_am_attributes(new_node, &am);
3586         SET_IA32_ORIG_NODE(new_node, node);
3587
3588         new_node = fix_mem_proj(new_node, &am);
3589
3590         return new_node;
3591 }
3592
3593 /**
3594  * Transform a Bound node.
3595  */
3596 static ir_node *gen_Bound(ir_node *node)
3597 {
3598         ir_node  *new_node;
3599         ir_node  *lower = get_Bound_lower(node);
3600         dbg_info *dbgi  = get_irn_dbg_info(node);
3601
3602         if (is_Const_0(lower)) {
3603                 /* typical case for Java */
3604                 ir_node  *sub, *res, *flags, *block;
3605                 ir_graph *irg  = current_ir_graph;
3606
3607                 res = gen_binop(node, get_Bound_index(node), get_Bound_upper(node),
3608                         new_bd_ia32_Sub, match_mode_neutral     | match_am | match_immediate);
3609
3610                 block = get_nodes_block(res);
3611                 if (! is_Proj(res)) {
3612                         sub = res;
3613                         set_irn_mode(sub, mode_T);
3614                         res = new_rd_Proj(NULL, irg, block, sub, mode_Iu, pn_ia32_res);
3615                 } else {
3616                         sub = get_Proj_pred(res);
3617                 }
3618                 flags = new_rd_Proj(NULL, irg, block, sub, mode_Iu, pn_ia32_Sub_flags);
3619                 new_node = new_bd_ia32_Jcc(dbgi, block, flags, pn_Cmp_Lt | ia32_pn_Cmp_unsigned);
3620                 SET_IA32_ORIG_NODE(new_node, node);
3621         } else {
3622                 panic("generic Bound not supported in ia32 Backend");
3623         }
3624         return new_node;
3625 }
3626
3627
3628 static ir_node *gen_ia32_l_ShlDep(ir_node *node)
3629 {
3630         ir_node *left  = get_irn_n(node, n_ia32_l_ShlDep_val);
3631         ir_node *right = get_irn_n(node, n_ia32_l_ShlDep_count);
3632
3633         return gen_shift_binop(node, left, right, new_bd_ia32_Shl,
3634                                match_immediate | match_mode_neutral);
3635 }
3636
3637 static ir_node *gen_ia32_l_ShrDep(ir_node *node)
3638 {
3639         ir_node *left  = get_irn_n(node, n_ia32_l_ShrDep_val);
3640         ir_node *right = get_irn_n(node, n_ia32_l_ShrDep_count);
3641         return gen_shift_binop(node, left, right, new_bd_ia32_Shr,
3642                                match_immediate);
3643 }
3644
3645 static ir_node *gen_ia32_l_SarDep(ir_node *node)
3646 {
3647         ir_node *left  = get_irn_n(node, n_ia32_l_SarDep_val);
3648         ir_node *right = get_irn_n(node, n_ia32_l_SarDep_count);
3649         return gen_shift_binop(node, left, right, new_bd_ia32_Sar,
3650                                match_immediate);
3651 }
3652
3653 static ir_node *gen_ia32_l_Add(ir_node *node)
3654 {
3655         ir_node *left    = get_irn_n(node, n_ia32_l_Add_left);
3656         ir_node *right   = get_irn_n(node, n_ia32_l_Add_right);
3657         ir_node *lowered = gen_binop(node, left, right, new_bd_ia32_Add,
3658                         match_commutative | match_am | match_immediate |
3659                         match_mode_neutral);
3660
3661         if (is_Proj(lowered)) {
3662                 lowered = get_Proj_pred(lowered);
3663         } else {
3664                 assert(is_ia32_Add(lowered));
3665                 set_irn_mode(lowered, mode_T);
3666         }
3667
3668         return lowered;
3669 }
3670
3671 static ir_node *gen_ia32_l_Adc(ir_node *node)
3672 {
3673         return gen_binop_flags(node, new_bd_ia32_Adc,
3674                         match_commutative | match_am | match_immediate |
3675                         match_mode_neutral);
3676 }
3677
3678 /**
3679  * Transforms a l_MulS into a "real" MulS node.
3680  *
3681  * @return the created ia32 Mul node
3682  */
3683 static ir_node *gen_ia32_l_Mul(ir_node *node)
3684 {
3685         ir_node *left  = get_binop_left(node);
3686         ir_node *right = get_binop_right(node);
3687
3688         return gen_binop(node, left, right, new_bd_ia32_Mul,
3689                          match_commutative | match_am | match_mode_neutral);
3690 }
3691
3692 /**
3693  * Transforms a l_IMulS into a "real" IMul1OPS node.
3694  *
3695  * @return the created ia32 IMul1OP node
3696  */
3697 static ir_node *gen_ia32_l_IMul(ir_node *node)
3698 {
3699         ir_node  *left  = get_binop_left(node);
3700         ir_node  *right = get_binop_right(node);
3701
3702         return gen_binop(node, left, right, new_bd_ia32_IMul1OP,
3703                          match_commutative | match_am | match_mode_neutral);
3704 }
3705
3706 static ir_node *gen_ia32_l_Sub(ir_node *node)
3707 {
3708         ir_node *left    = get_irn_n(node, n_ia32_l_Sub_minuend);
3709         ir_node *right   = get_irn_n(node, n_ia32_l_Sub_subtrahend);
3710         ir_node *lowered = gen_binop(node, left, right, new_bd_ia32_Sub,
3711                         match_am | match_immediate | match_mode_neutral);
3712
3713         if (is_Proj(lowered)) {
3714                 lowered = get_Proj_pred(lowered);
3715         } else {
3716                 assert(is_ia32_Sub(lowered));
3717                 set_irn_mode(lowered, mode_T);
3718         }
3719
3720         return lowered;
3721 }
3722
3723 static ir_node *gen_ia32_l_Sbb(ir_node *node)
3724 {
3725         return gen_binop_flags(node, new_bd_ia32_Sbb,
3726                         match_am | match_immediate | match_mode_neutral);
3727 }
3728
3729 /**
3730  * Transforms a l_ShlD/l_ShrD into a ShlD/ShrD. Those nodes have 3 data inputs:
3731  * op1 - target to be shifted
3732  * op2 - contains bits to be shifted into target
3733  * op3 - shift count
3734  * Only op3 can be an immediate.
3735  */
3736 static ir_node *gen_lowered_64bit_shifts(ir_node *node, ir_node *high,
3737                                          ir_node *low, ir_node *count)
3738 {
3739         ir_node  *block     = get_nodes_block(node);
3740         ir_node  *new_block = be_transform_node(block);
3741         dbg_info *dbgi      = get_irn_dbg_info(node);
3742         ir_node  *new_high  = be_transform_node(high);
3743         ir_node  *new_low   = be_transform_node(low);
3744         ir_node  *new_count;
3745         ir_node  *new_node;
3746
3747         /* the shift amount can be any mode that is bigger than 5 bits, since all
3748          * other bits are ignored anyway */
3749         while (is_Conv(count)              &&
3750                get_irn_n_edges(count) == 1 &&
3751                mode_is_int(get_irn_mode(count))) {
3752                 assert(get_mode_size_bits(get_irn_mode(count)) >= 5);
3753                 count = get_Conv_op(count);
3754         }
3755         new_count = create_immediate_or_transform(count, 0);
3756
3757         if (is_ia32_l_ShlD(node)) {
3758                 new_node = new_bd_ia32_ShlD(dbgi, new_block, new_high, new_low,
3759                                             new_count);
3760         } else {
3761                 new_node = new_bd_ia32_ShrD(dbgi, new_block, new_high, new_low,
3762                                             new_count);
3763         }
3764         SET_IA32_ORIG_NODE(new_node, node);
3765
3766         return new_node;
3767 }
3768
3769 static ir_node *gen_ia32_l_ShlD(ir_node *node)
3770 {
3771         ir_node *high  = get_irn_n(node, n_ia32_l_ShlD_val_high);
3772         ir_node *low   = get_irn_n(node, n_ia32_l_ShlD_val_low);
3773         ir_node *count = get_irn_n(node, n_ia32_l_ShlD_count);
3774         return gen_lowered_64bit_shifts(node, high, low, count);
3775 }
3776
3777 static ir_node *gen_ia32_l_ShrD(ir_node *node)
3778 {
3779         ir_node *high  = get_irn_n(node, n_ia32_l_ShrD_val_high);
3780         ir_node *low   = get_irn_n(node, n_ia32_l_ShrD_val_low);
3781         ir_node *count = get_irn_n(node, n_ia32_l_ShrD_count);
3782         return gen_lowered_64bit_shifts(node, high, low, count);
3783 }
3784
3785 static ir_node *gen_ia32_l_LLtoFloat(ir_node *node)
3786 {
3787         ir_node  *src_block    = get_nodes_block(node);
3788         ir_node  *block        = be_transform_node(src_block);
3789         ir_graph *irg          = current_ir_graph;
3790         dbg_info *dbgi         = get_irn_dbg_info(node);
3791         ir_node  *frame        = get_irg_frame(irg);
3792         ir_node  *noreg        = ia32_new_NoReg_gp(env_cg);
3793         ir_node  *nomem        = new_NoMem();
3794         ir_node  *val_low      = get_irn_n(node, n_ia32_l_LLtoFloat_val_low);
3795         ir_node  *val_high     = get_irn_n(node, n_ia32_l_LLtoFloat_val_high);
3796         ir_node  *new_val_low  = be_transform_node(val_low);
3797         ir_node  *new_val_high = be_transform_node(val_high);
3798         ir_node  *in[2];
3799         ir_node  *sync;
3800         ir_node  *fild;
3801         ir_node  *store_low;
3802         ir_node  *store_high;
3803
3804         if (!mode_is_signed(get_irn_mode(val_high))) {
3805                 panic("unsigned long long -> float not supported yet (%+F)", node);
3806         }
3807
3808         /* do a store */
3809         store_low = new_bd_ia32_Store(dbgi, block, frame, noreg, nomem,
3810                                       new_val_low);
3811         store_high = new_bd_ia32_Store(dbgi, block, frame, noreg, nomem,
3812                                        new_val_high);
3813         SET_IA32_ORIG_NODE(store_low,  node);
3814         SET_IA32_ORIG_NODE(store_high, node);
3815
3816         set_ia32_use_frame(store_low);
3817         set_ia32_use_frame(store_high);
3818         set_ia32_op_type(store_low, ia32_AddrModeD);
3819         set_ia32_op_type(store_high, ia32_AddrModeD);
3820         set_ia32_ls_mode(store_low, mode_Iu);
3821         set_ia32_ls_mode(store_high, mode_Is);
3822         add_ia32_am_offs_int(store_high, 4);
3823
3824         in[0] = store_low;
3825         in[1] = store_high;
3826         sync  = new_rd_Sync(dbgi, irg, block, 2, in);
3827
3828         /* do a fild */
3829         fild = new_bd_ia32_vfild(dbgi, block, frame, noreg, sync);
3830
3831         set_ia32_use_frame(fild);
3832         set_ia32_op_type(fild, ia32_AddrModeS);
3833         set_ia32_ls_mode(fild, mode_Ls);
3834
3835         SET_IA32_ORIG_NODE(fild, node);
3836
3837         return new_r_Proj(irg, block, fild, mode_vfp, pn_ia32_vfild_res);
3838 }
3839
3840 static ir_node *gen_ia32_l_FloattoLL(ir_node *node)
3841 {
3842         ir_node  *src_block  = get_nodes_block(node);
3843         ir_node  *block      = be_transform_node(src_block);
3844         ir_graph *irg        = current_ir_graph;
3845         dbg_info *dbgi       = get_irn_dbg_info(node);
3846         ir_node  *frame      = get_irg_frame(irg);
3847         ir_node  *noreg      = ia32_new_NoReg_gp(env_cg);
3848         ir_node  *nomem      = new_NoMem();
3849         ir_node  *val        = get_irn_n(node, n_ia32_l_FloattoLL_val);
3850         ir_node  *new_val    = be_transform_node(val);
3851         ir_node  *fist, *mem;
3852
3853         mem = gen_vfist(dbgi, irg, block, frame, noreg, nomem, new_val, &fist);
3854         SET_IA32_ORIG_NODE(fist, node);
3855         set_ia32_use_frame(fist);
3856         set_ia32_op_type(fist, ia32_AddrModeD);
3857         set_ia32_ls_mode(fist, mode_Ls);
3858
3859         return mem;
3860 }
3861
3862 /**
3863  * the BAD transformer.
3864  */
3865 static ir_node *bad_transform(ir_node *node)
3866 {
3867         panic("No transform function for %+F available.", node);
3868         return NULL;
3869 }
3870
3871 static ir_node *gen_Proj_l_FloattoLL(ir_node *node)
3872 {
3873         ir_graph *irg      = current_ir_graph;
3874         ir_node  *block    = be_transform_node(get_nodes_block(node));
3875         ir_node  *pred     = get_Proj_pred(node);
3876         ir_node  *new_pred = be_transform_node(pred);
3877         ir_node  *frame    = get_irg_frame(irg);
3878         ir_node  *noreg    = ia32_new_NoReg_gp(env_cg);
3879         dbg_info *dbgi     = get_irn_dbg_info(node);
3880         long      pn       = get_Proj_proj(node);
3881         ir_node  *load;
3882         ir_node  *proj;
3883         ia32_attr_t *attr;
3884
3885         load = new_bd_ia32_Load(dbgi, block, frame, noreg, new_pred);
3886         SET_IA32_ORIG_NODE(load, node);
3887         set_ia32_use_frame(load);
3888         set_ia32_op_type(load, ia32_AddrModeS);
3889         set_ia32_ls_mode(load, mode_Iu);
3890         /* we need a 64bit stackslot (fist stores 64bit) even though we only load
3891          * 32 bit from it with this particular load */
3892         attr = get_ia32_attr(load);
3893         attr->data.need_64bit_stackent = 1;
3894
3895         if (pn == pn_ia32_l_FloattoLL_res_high) {
3896                 add_ia32_am_offs_int(load, 4);
3897         } else {
3898                 assert(pn == pn_ia32_l_FloattoLL_res_low);
3899         }
3900
3901         proj = new_r_Proj(irg, block, load, mode_Iu, pn_ia32_Load_res);
3902
3903         return proj;
3904 }
3905
3906 /**
3907  * Transform the Projs of an AddSP.
3908  */
3909 static ir_node *gen_Proj_be_AddSP(ir_node *node)
3910 {
3911         ir_node  *block    = be_transform_node(get_nodes_block(node));
3912         ir_node  *pred     = get_Proj_pred(node);
3913         ir_node  *new_pred = be_transform_node(pred);
3914         ir_graph *irg      = current_ir_graph;
3915         dbg_info *dbgi     = get_irn_dbg_info(node);
3916         long     proj      = get_Proj_proj(node);
3917
3918         if (proj == pn_be_AddSP_sp) {
3919                 ir_node *res = new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu,
3920                                            pn_ia32_SubSP_stack);
3921                 arch_set_irn_register(res, &ia32_gp_regs[REG_ESP]);
3922                 return res;
3923         } else if (proj == pn_be_AddSP_res) {
3924                 return new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu,
3925                                    pn_ia32_SubSP_addr);
3926         } else if (proj == pn_be_AddSP_M) {
3927                 return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_SubSP_M);
3928         }
3929
3930         panic("No idea how to transform proj->AddSP");
3931 }
3932
3933 /**
3934  * Transform the Projs of a SubSP.
3935  */
3936 static ir_node *gen_Proj_be_SubSP(ir_node *node)
3937 {
3938         ir_node  *block    = be_transform_node(get_nodes_block(node));
3939         ir_node  *pred     = get_Proj_pred(node);
3940         ir_node  *new_pred = be_transform_node(pred);
3941         ir_graph *irg      = current_ir_graph;
3942         dbg_info *dbgi     = get_irn_dbg_info(node);
3943         long     proj      = get_Proj_proj(node);
3944
3945         if (proj == pn_be_SubSP_sp) {
3946                 ir_node *res = new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu,
3947                                            pn_ia32_AddSP_stack);
3948                 arch_set_irn_register(res, &ia32_gp_regs[REG_ESP]);
3949                 return res;
3950         } else if (proj == pn_be_SubSP_M) {
3951                 return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_AddSP_M);
3952         }
3953
3954         panic("No idea how to transform proj->SubSP");
3955 }
3956
3957 /**
3958  * Transform and renumber the Projs from a Load.
3959  */
3960 static ir_node *gen_Proj_Load(ir_node *node)
3961 {
3962         ir_node  *new_pred;
3963         ir_node  *block    = be_transform_node(get_nodes_block(node));
3964         ir_node  *pred     = get_Proj_pred(node);
3965         ir_graph *irg      = current_ir_graph;
3966         dbg_info *dbgi     = get_irn_dbg_info(node);
3967         long     proj      = get_Proj_proj(node);
3968
3969         /* loads might be part of source address mode matches, so we don't
3970          * transform the ProjMs yet (with the exception of loads whose result is
3971          * not used)
3972          */
3973         if (is_Load(pred) && proj == pn_Load_M && get_irn_n_edges(pred) > 1) {
3974                 ir_node *res;
3975
3976                 /* this is needed, because sometimes we have loops that are only
3977                    reachable through the ProjM */
3978                 be_enqueue_preds(node);
3979                 /* do it in 2 steps, to silence firm verifier */
3980                 res = new_rd_Proj(dbgi, irg, block, pred, mode_M, pn_Load_M);
3981                 set_Proj_proj(res, pn_ia32_mem);
3982                 return res;
3983         }
3984
3985         /* renumber the proj */
3986         new_pred = be_transform_node(pred);
3987         if (is_ia32_Load(new_pred)) {
3988                 switch (proj) {
3989                 case pn_Load_res:
3990                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu, pn_ia32_Load_res);
3991                 case pn_Load_M:
3992                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_Load_M);
3993                 case pn_Load_X_regular:
3994                         return new_rd_Jmp(dbgi, irg, block);
3995                 case pn_Load_X_except:
3996                         /* This Load might raise an exception. Mark it. */
3997                         set_ia32_exc_label(new_pred, 1);
3998                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_X, pn_ia32_Load_X_exc);
3999                 default:
4000                         break;
4001                 }
4002         } else if (is_ia32_Conv_I2I(new_pred) ||
4003                    is_ia32_Conv_I2I8Bit(new_pred)) {
4004                 set_irn_mode(new_pred, mode_T);
4005                 if (proj == pn_Load_res) {
4006                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu, pn_ia32_res);
4007                 } else if (proj == pn_Load_M) {
4008                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_mem);
4009                 }
4010         } else if (is_ia32_xLoad(new_pred)) {
4011                 switch (proj) {
4012                 case pn_Load_res:
4013                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_xmm, pn_ia32_xLoad_res);
4014                 case pn_Load_M:
4015                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_xLoad_M);
4016                 case pn_Load_X_regular:
4017                         return new_rd_Jmp(dbgi, irg, block);
4018                 case pn_Load_X_except:
4019                         /* This Load might raise an exception. Mark it. */
4020                         set_ia32_exc_label(new_pred, 1);
4021                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_X, pn_ia32_xLoad_X_exc);
4022                 default:
4023                         break;
4024                 }
4025         } else if (is_ia32_vfld(new_pred)) {
4026                 switch (proj) {
4027                 case pn_Load_res:
4028                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_vfp, pn_ia32_vfld_res);
4029                 case pn_Load_M:
4030                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_vfld_M);
4031                 case pn_Load_X_regular:
4032                         return new_rd_Jmp(dbgi, irg, block);
4033                 case pn_Load_X_except:
4034                         /* This Load might raise an exception. Mark it. */
4035                         set_ia32_exc_label(new_pred, 1);
4036                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_X, pn_ia32_xLoad_X_exc);
4037                 default:
4038                         break;
4039                 }
4040         } else {
4041                 /* can happen for ProJMs when source address mode happened for the
4042                    node */
4043
4044                 /* however it should not be the result proj, as that would mean the
4045                    load had multiple users and should not have been used for
4046                    SourceAM */
4047                 if (proj != pn_Load_M) {
4048                         panic("internal error: transformed node not a Load");
4049                 }
4050                 return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, 1);
4051         }
4052
4053         panic("No idea how to transform proj");
4054 }
4055
4056 /**
4057  * Transform and renumber the Projs from a DivMod like instruction.
4058  */
4059 static ir_node *gen_Proj_DivMod(ir_node *node)
4060 {
4061         ir_node  *block    = be_transform_node(get_nodes_block(node));
4062         ir_node  *pred     = get_Proj_pred(node);
4063         ir_node  *new_pred = be_transform_node(pred);
4064         ir_graph *irg      = current_ir_graph;
4065         dbg_info *dbgi     = get_irn_dbg_info(node);
4066         long     proj      = get_Proj_proj(node);
4067
4068         assert(is_ia32_Div(new_pred) || is_ia32_IDiv(new_pred));
4069
4070         switch (get_irn_opcode(pred)) {
4071         case iro_Div:
4072                 switch (proj) {
4073                 case pn_Div_M:
4074                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_Div_M);
4075                 case pn_Div_res:
4076                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu, pn_ia32_Div_div_res);
4077                 case pn_Div_X_regular:
4078                         return new_rd_Jmp(dbgi, irg, block);
4079                 case pn_Div_X_except:
4080                         set_ia32_exc_label(new_pred, 1);
4081                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_X, pn_ia32_Div_X_exc);
4082                 default:
4083                         break;
4084                 }
4085                 break;
4086         case iro_Mod:
4087                 switch (proj) {
4088                 case pn_Mod_M:
4089                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_Div_M);
4090                 case pn_Mod_res:
4091                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu, pn_ia32_Div_mod_res);
4092                 case pn_Mod_X_except:
4093                         set_ia32_exc_label(new_pred, 1);
4094                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_X, pn_ia32_Div_X_exc);
4095                 default:
4096                         break;
4097                 }
4098                 break;
4099         case iro_DivMod:
4100                 switch (proj) {
4101                 case pn_DivMod_M:
4102                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_Div_M);
4103                 case pn_DivMod_res_div:
4104                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu, pn_ia32_Div_div_res);
4105                 case pn_DivMod_res_mod:
4106                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_Iu, pn_ia32_Div_mod_res);
4107                 case pn_DivMod_X_regular:
4108                         return new_rd_Jmp(dbgi, irg, block);
4109                 case pn_DivMod_X_except:
4110                         set_ia32_exc_label(new_pred, 1);
4111                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_X, pn_ia32_Div_X_exc);
4112                 default:
4113                         break;
4114                 }
4115                 break;
4116         default:
4117                 break;
4118         }
4119
4120         panic("No idea how to transform proj->DivMod");
4121 }
4122
4123 /**
4124  * Transform and renumber the Projs from a CopyB.
4125  */
4126 static ir_node *gen_Proj_CopyB(ir_node *node)
4127 {
4128         ir_node  *block    = be_transform_node(get_nodes_block(node));
4129         ir_node  *pred     = get_Proj_pred(node);
4130         ir_node  *new_pred = be_transform_node(pred);
4131         ir_graph *irg      = current_ir_graph;
4132         dbg_info *dbgi     = get_irn_dbg_info(node);
4133         long     proj      = get_Proj_proj(node);
4134
4135         switch (proj) {
4136         case pn_CopyB_M_regular:
4137                 if (is_ia32_CopyB_i(new_pred)) {
4138                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_CopyB_i_M);
4139                 } else if (is_ia32_CopyB(new_pred)) {
4140                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_CopyB_M);
4141                 }
4142                 break;
4143         default:
4144                 break;
4145         }
4146
4147         panic("No idea how to transform proj->CopyB");
4148 }
4149
4150 /**
4151  * Transform and renumber the Projs from a Quot.
4152  */
4153 static ir_node *gen_Proj_Quot(ir_node *node)
4154 {
4155         ir_node  *block    = be_transform_node(get_nodes_block(node));
4156         ir_node  *pred     = get_Proj_pred(node);
4157         ir_node  *new_pred = be_transform_node(pred);
4158         ir_graph *irg      = current_ir_graph;
4159         dbg_info *dbgi     = get_irn_dbg_info(node);
4160         long     proj      = get_Proj_proj(node);
4161
4162         switch (proj) {
4163         case pn_Quot_M:
4164                 if (is_ia32_xDiv(new_pred)) {
4165                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_xDiv_M);
4166                 } else if (is_ia32_vfdiv(new_pred)) {
4167                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_M, pn_ia32_vfdiv_M);
4168                 }
4169                 break;
4170         case pn_Quot_res:
4171                 if (is_ia32_xDiv(new_pred)) {
4172                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_xmm, pn_ia32_xDiv_res);
4173                 } else if (is_ia32_vfdiv(new_pred)) {
4174                         return new_rd_Proj(dbgi, irg, block, new_pred, mode_vfp, pn_ia32_vfdiv_res);
4175                 }
4176                 break;
4177         case pn_Quot_X_regular:
4178         case pn_Quot_X_except:
4179         default:
4180                 break;
4181         }
4182
4183         panic("No idea how to transform proj->Quot");
4184 }
4185
4186 static ir_node *gen_be_Call(ir_node *node)
4187 {
4188         dbg_info       *const dbgi      = get_irn_dbg_info(node);
4189         ir_graph       *const irg       = current_ir_graph;
4190         ir_node        *const src_block = get_nodes_block(node);
4191         ir_node        *const block     = be_transform_node(src_block);
4192         ir_node        *const src_mem   = get_irn_n(node, be_pos_Call_mem);
4193         ir_node        *const src_sp    = get_irn_n(node, be_pos_Call_sp);
4194         ir_node        *const sp        = be_transform_node(src_sp);
4195         ir_node        *const src_ptr   = get_irn_n(node, be_pos_Call_ptr);
4196         ir_node        *const noreg     = ia32_new_NoReg_gp(env_cg);
4197         ia32_address_mode_t   am;
4198         ia32_address_t *const addr      = &am.addr;
4199         ir_node        *      mem;
4200         ir_node        *      call;
4201         int                   i;
4202         ir_node        *      fpcw;
4203         ir_node        *      eax       = noreg;
4204         ir_node        *      ecx       = noreg;
4205         ir_node        *      edx       = noreg;
4206         unsigned        const pop       = be_Call_get_pop(node);
4207         ir_type        *const call_tp   = be_Call_get_type(node);
4208
4209         /* Run the x87 simulator if the call returns a float value */
4210         if (get_method_n_ress(call_tp) > 0) {
4211                 ir_type *const res_type = get_method_res_type(call_tp, 0);
4212                 ir_mode *const res_mode = get_type_mode(res_type);
4213
4214                 if (res_mode != NULL && mode_is_float(res_mode)) {
4215                         env_cg->do_x87_sim = 1;
4216                 }
4217         }
4218
4219         /* We do not want be_Call direct calls */
4220         assert(be_Call_get_entity(node) == NULL);
4221
4222         match_arguments(&am, src_block, NULL, src_ptr, src_mem,
4223                         match_am | match_immediate);
4224
4225         i    = get_irn_arity(node) - 1;
4226         fpcw = be_transform_node(get_irn_n(node, i--));
4227         for (; i >= be_pos_Call_first_arg; --i) {
4228                 arch_register_req_t const *const req = arch_get_register_req(node, i);
4229                 ir_node *const reg_parm = be_transform_node(get_irn_n(node, i));
4230
4231                 assert(req->type == arch_register_req_type_limited);
4232                 assert(req->cls == &ia32_reg_classes[CLASS_ia32_gp]);
4233
4234                 switch (*req->limited) {
4235                         case 1 << REG_EAX: assert(eax == noreg); eax = reg_parm; break;
4236                         case 1 << REG_ECX: assert(ecx == noreg); ecx = reg_parm; break;
4237                         case 1 << REG_EDX: assert(edx == noreg); edx = reg_parm; break;
4238                         default: panic("Invalid GP register for register parameter");
4239                 }
4240         }
4241
4242         mem  = transform_AM_mem(irg, block, src_ptr, src_mem, addr->mem);
4243         call = new_bd_ia32_Call(dbgi, block, addr->base, addr->index, mem,
4244                                 am.new_op2, sp, fpcw, eax, ecx, edx, pop, call_tp);
4245         set_am_attributes(call, &am);
4246         call = fix_mem_proj(call, &am);
4247
4248         if (get_irn_pinned(node) == op_pin_state_pinned)
4249                 set_irn_pinned(call, op_pin_state_pinned);
4250
4251         SET_IA32_ORIG_NODE(call, node);
4252         return call;
4253 }
4254
4255 static ir_node *gen_be_IncSP(ir_node *node)
4256 {
4257         ir_node *res = be_duplicate_node(node);
4258         arch_irn_add_flags(res, arch_irn_flags_modify_flags);
4259
4260         return res;
4261 }
4262
4263 /**
4264  * Transform the Projs from a be_Call.
4265  */
4266 static ir_node *gen_Proj_be_Call(ir_node *node)
4267 {
4268         ir_node  *block       = be_transform_node(get_nodes_block(node));
4269         ir_node  *call        = get_Proj_pred(node);
4270         ir_node  *new_call    = be_transform_node(call);
4271         ir_graph *irg         = current_ir_graph;
4272         dbg_info *dbgi        = get_irn_dbg_info(node);
4273         ir_type  *method_type = be_Call_get_type(call);
4274         int       n_res       = get_method_n_ress(method_type);
4275         long      proj        = get_Proj_proj(node);
4276         ir_mode  *mode        = get_irn_mode(node);
4277         ir_node  *sse_load;
4278         ir_node  *res;
4279
4280         /* The following is kinda tricky: If we're using SSE, then we have to
4281          * move the result value of the call in floating point registers to an
4282          * xmm register, we therefore construct a GetST0 -> xLoad sequence
4283          * after the call, we have to make sure to correctly make the
4284          * MemProj and the result Proj use these 2 nodes
4285          */
4286         if (proj == pn_be_Call_M_regular) {
4287                 // get new node for result, are we doing the sse load/store hack?
4288                 ir_node *call_res = be_get_Proj_for_pn(call, pn_be_Call_first_res);
4289                 ir_node *call_res_new;
4290                 ir_node *call_res_pred = NULL;
4291
4292                 if (call_res != NULL) {
4293                         call_res_new  = be_transform_node(call_res);
4294                         call_res_pred = get_Proj_pred(call_res_new);
4295                 }
4296
4297                 if (call_res_pred == NULL || is_ia32_Call(call_res_pred)) {
4298                         return new_rd_Proj(dbgi, irg, block, new_call, mode_M,
4299                                            n_ia32_Call_mem);
4300                 } else {
4301                         assert(is_ia32_xLoad(call_res_pred));
4302                         return new_rd_Proj(dbgi, irg, block, call_res_pred, mode_M,
4303                                            pn_ia32_xLoad_M);
4304                 }
4305         }
4306         if (ia32_cg_config.use_sse2 && proj >= pn_be_Call_first_res
4307                         && proj < (pn_be_Call_first_res + n_res) && mode_is_float(mode)) {
4308                 ir_node *fstp;
4309                 ir_node *frame = get_irg_frame(irg);
4310                 ir_node *noreg = ia32_new_NoReg_gp(env_cg);
4311                 //ir_node *p;
4312                 ir_node *call_mem = be_get_Proj_for_pn(call, pn_be_Call_M_regular);
4313                 ir_node *call_res;
4314
4315                 /* in case there is no memory output: create one to serialize the copy
4316                    FPU -> SSE */
4317                 call_mem = new_rd_Proj(dbgi, irg, block, new_call, mode_M,
4318                                        pn_be_Call_M_regular);
4319                 call_res = new_rd_Proj(dbgi, irg, block, new_call, mode,
4320                                        pn_be_Call_first_res);
4321
4322                 /* store st(0) onto stack */
4323                 fstp = new_bd_ia32_vfst(dbgi, block, frame, noreg, call_mem,
4324                                         call_res, mode);
4325                 set_ia32_op_type(fstp, ia32_AddrModeD);
4326                 set_ia32_use_frame(fstp);
4327
4328                 /* load into SSE register */
4329                 sse_load = new_bd_ia32_xLoad(dbgi, block, frame, noreg, fstp, mode);
4330                 set_ia32_op_type(sse_load, ia32_AddrModeS);
4331                 set_ia32_use_frame(sse_load);
4332
4333                 sse_load = new_rd_Proj(dbgi, irg, block, sse_load, mode_xmm,
4334                                        pn_ia32_xLoad_res);
4335
4336                 return sse_load;
4337         }
4338
4339         /* transform call modes */
4340         if (mode_is_data(mode)) {
4341                 const arch_register_class_t *cls = arch_get_irn_reg_class_out(node);
4342                 mode = cls->mode;
4343         }
4344
4345         /* Map from be_Call to ia32_Call proj number */
4346         if (proj == pn_be_Call_sp) {
4347                 proj = pn_ia32_Call_stack;
4348         } else if (proj == pn_be_Call_M_regular) {
4349                 proj = pn_ia32_Call_M;
4350         } else {
4351                 arch_register_req_t const *const req    = arch_get_register_req_out(node);
4352                 int                        const n_outs = arch_irn_get_n_outs(new_call);
4353                 int                              i;
4354
4355                 assert(proj      >= pn_be_Call_first_res);
4356                 assert(req->type & arch_register_req_type_limited);
4357
4358                 for (i = 0; i < n_outs; ++i) {
4359                         arch_register_req_t const *const new_req = get_ia32_out_req(new_call, i);
4360
4361                         if (!(new_req->type & arch_register_req_type_limited) ||
4362                             new_req->cls      != req->cls                     ||
4363                             *new_req->limited != *req->limited)
4364                                 continue;
4365
4366                         proj = i;
4367                         break;
4368                 }
4369                 assert(i < n_outs);
4370         }
4371
4372         res = new_rd_Proj(dbgi, irg, block, new_call, mode, proj);
4373
4374         /* TODO arch_set_irn_register() only operates on Projs, need variant with index */
4375         switch (proj) {
4376                 case pn_ia32_Call_stack:
4377                         arch_set_irn_register(res, &ia32_gp_regs[REG_ESP]);
4378                         break;
4379
4380                 case pn_ia32_Call_fpcw:
4381                         arch_set_irn_register(res, &ia32_fp_cw_regs[REG_FPCW]);
4382                         break;
4383         }
4384
4385         return res;
4386 }
4387
4388 /**
4389  * Transform the Projs from a Cmp.
4390  */
4391 static ir_node *gen_Proj_Cmp(ir_node *node)
4392 {
4393         /* this probably means not all mode_b nodes were lowered... */
4394         panic("trying to directly transform Proj_Cmp %+F (mode_b not lowered?)",
4395               node);
4396 }
4397
4398 /**
4399  * Transform the Projs from a Bound.
4400  */
4401 static ir_node *gen_Proj_Bound(ir_node *node)
4402 {
4403         ir_node *new_node, *block;
4404         ir_node *pred = get_Proj_pred(node);
4405
4406         switch (get_Proj_proj(node)) {
4407         case pn_Bound_M:
4408                 return be_transform_node(get_Bound_mem(pred));
4409         case pn_Bound_X_regular:
4410                 new_node = be_transform_node(pred);
4411                 block    = get_nodes_block(new_node);
4412                 return new_r_Proj(current_ir_graph, block, new_node, mode_X, pn_ia32_Jcc_true);
4413         case pn_Bound_X_except:
4414                 new_node = be_transform_node(pred);
4415                 block    = get_nodes_block(new_node);
4416                 return new_r_Proj(current_ir_graph, block, new_node, mode_X, pn_ia32_Jcc_false);
4417         case pn_Bound_res:
4418                 return be_transform_node(get_Bound_index(pred));
4419         default:
4420                 panic("unsupported Proj from Bound");
4421         }
4422 }
4423
4424 static ir_node *gen_Proj_ASM(ir_node *node)
4425 {
4426         ir_node *pred;
4427         ir_node *new_pred;
4428         ir_node *block;
4429
4430         if (get_irn_mode(node) != mode_M)
4431                 return be_duplicate_node(node);
4432
4433         pred     = get_Proj_pred(node);
4434         new_pred = be_transform_node(pred);
4435         block    = get_nodes_block(new_pred);
4436         return new_r_Proj(current_ir_graph, block, new_pred, mode_M,
4437                         arch_irn_get_n_outs(new_pred) + 1);
4438 }
4439
4440 /**
4441  * Transform and potentially renumber Proj nodes.
4442  */
4443 static ir_node *gen_Proj(ir_node *node)
4444 {
4445         ir_node *pred = get_Proj_pred(node);
4446         long    proj;
4447
4448         switch (get_irn_opcode(pred)) {
4449         case iro_Store:
4450                 proj = get_Proj_proj(node);
4451                 if (proj == pn_Store_M) {
4452                         return be_transform_node(pred);
4453                 } else {
4454                         panic("No idea how to transform proj->Store");
4455                 }
4456         case iro_Load:
4457                 return gen_Proj_Load(node);
4458         case iro_ASM:
4459                 return gen_Proj_ASM(node);
4460         case iro_Div:
4461         case iro_Mod:
4462         case iro_DivMod:
4463                 return gen_Proj_DivMod(node);
4464         case iro_CopyB:
4465                 return gen_Proj_CopyB(node);
4466         case iro_Quot:
4467                 return gen_Proj_Quot(node);
4468         case beo_SubSP:
4469                 return gen_Proj_be_SubSP(node);
4470         case beo_AddSP:
4471                 return gen_Proj_be_AddSP(node);
4472         case beo_Call:
4473                 return gen_Proj_be_Call(node);
4474         case iro_Cmp:
4475                 return gen_Proj_Cmp(node);
4476         case iro_Bound:
4477                 return gen_Proj_Bound(node);
4478         case iro_Start:
4479                 proj = get_Proj_proj(node);
4480                 switch (proj) {
4481                         case pn_Start_X_initial_exec: {
4482                                 ir_node  *block     = get_nodes_block(pred);
4483                                 ir_node  *new_block = be_transform_node(block);
4484                                 dbg_info *dbgi      = get_irn_dbg_info(node);
4485                                 /* we exchange the ProjX with a jump */
4486                                 ir_node  *jump      = new_rd_Jmp(dbgi, current_ir_graph, new_block);
4487
4488                                 return jump;
4489                         }
4490
4491                         case pn_Start_P_tls:
4492                                 return gen_Proj_tls(node);
4493                 }
4494                 break;
4495
4496         default:
4497                 if (is_ia32_l_FloattoLL(pred)) {
4498                         return gen_Proj_l_FloattoLL(node);
4499 #ifdef FIRM_EXT_GRS
4500                 } else if (!is_ia32_irn(pred)) { // Quick hack for SIMD optimization
4501 #else
4502                 } else {
4503 #endif
4504                         ir_mode *mode = get_irn_mode(node);
4505                         if (ia32_mode_needs_gp_reg(mode)) {
4506                                 ir_node *new_pred = be_transform_node(pred);
4507                                 ir_node *block    = be_transform_node(get_nodes_block(node));
4508                                 ir_node *new_proj = new_r_Proj(current_ir_graph, block, new_pred,
4509                                                                                            mode_Iu, get_Proj_proj(node));
4510 #ifdef DEBUG_libfirm
4511                                 new_proj->node_nr = node->node_nr;
4512 #endif
4513                                 return new_proj;
4514                         }
4515                 }
4516         }
4517         return be_duplicate_node(node);
4518 }
4519
4520 /**
4521  * Enters all transform functions into the generic pointer
4522  */
4523 static void register_transformers(void)
4524 {
4525         ir_op *op_Mulh;
4526
4527         /* first clear the generic function pointer for all ops */
4528         clear_irp_opcodes_generic_func();
4529
4530 #define GEN(a)   { be_transform_func *func = gen_##a; op_##a->ops.generic = (op_func) func; }
4531 #define BAD(a)   op_##a->ops.generic = (op_func)bad_transform
4532
4533         GEN(Add);
4534         GEN(Sub);
4535         GEN(Mul);
4536         GEN(And);
4537         GEN(Or);
4538         GEN(Eor);
4539
4540         GEN(Shl);
4541         GEN(Shr);
4542         GEN(Shrs);
4543         GEN(Rotl);
4544
4545         GEN(Quot);
4546
4547         GEN(Div);
4548         GEN(Mod);
4549         GEN(DivMod);
4550
4551         GEN(Minus);
4552         GEN(Conv);
4553         GEN(Abs);
4554         GEN(Not);
4555
4556         GEN(Load);
4557         GEN(Store);
4558         GEN(Cond);
4559
4560         GEN(Cmp);
4561         GEN(ASM);
4562         GEN(CopyB);
4563         GEN(Mux);
4564         GEN(Proj);
4565         GEN(Phi);
4566         GEN(IJmp);
4567         GEN(Bound);
4568
4569         /* transform ops from intrinsic lowering */
4570         GEN(ia32_l_Add);
4571         GEN(ia32_l_Adc);
4572         GEN(ia32_l_Mul);
4573         GEN(ia32_l_IMul);
4574         GEN(ia32_l_ShlDep);
4575         GEN(ia32_l_ShrDep);
4576         GEN(ia32_l_SarDep);
4577         GEN(ia32_l_ShlD);
4578         GEN(ia32_l_ShrD);
4579         GEN(ia32_l_Sub);
4580         GEN(ia32_l_Sbb);
4581         GEN(ia32_l_LLtoFloat);
4582         GEN(ia32_l_FloattoLL);
4583
4584         GEN(Const);
4585         GEN(SymConst);
4586         GEN(Unknown);
4587
4588         /* we should never see these nodes */
4589         BAD(Raise);
4590         BAD(Sel);
4591         BAD(InstOf);
4592         BAD(Cast);
4593         BAD(Free);
4594         BAD(Tuple);
4595         BAD(Id);
4596         //BAD(Bad);
4597         BAD(Confirm);
4598         BAD(Filter);
4599         BAD(CallBegin);
4600         BAD(EndReg);
4601         BAD(EndExcept);
4602
4603         /* handle generic backend nodes */
4604         GEN(be_FrameAddr);
4605         GEN(be_Call);
4606         GEN(be_IncSP);
4607         GEN(be_Return);
4608         GEN(be_AddSP);
4609         GEN(be_SubSP);
4610         GEN(be_Copy);
4611
4612         op_Mulh = get_op_Mulh();
4613         if (op_Mulh)
4614                 GEN(Mulh);
4615
4616 #undef GEN
4617 #undef BAD
4618 }
4619
4620 /**
4621  * Pre-transform all unknown and noreg nodes.
4622  */
4623 static void ia32_pretransform_node(void)
4624 {
4625         ia32_code_gen_t *cg = env_cg;
4626
4627         cg->unknown_gp  = be_pre_transform_node(cg->unknown_gp);
4628         cg->unknown_vfp = be_pre_transform_node(cg->unknown_vfp);
4629         cg->unknown_xmm = be_pre_transform_node(cg->unknown_xmm);
4630         cg->noreg_gp    = be_pre_transform_node(cg->noreg_gp);
4631         cg->noreg_vfp   = be_pre_transform_node(cg->noreg_vfp);
4632         cg->noreg_xmm   = be_pre_transform_node(cg->noreg_xmm);
4633         get_fpcw();
4634 }
4635
4636 /**
4637  * Walker, checks if all ia32 nodes producing more than one result have their
4638  * Projs, otherwise creates new Projs and keeps them using a be_Keep node.
4639  */
4640 static void add_missing_keep_walker(ir_node *node, void *data)
4641 {
4642         int              n_outs, i;
4643         unsigned         found_projs = 0;
4644         const ir_edge_t *edge;
4645         ir_mode         *mode = get_irn_mode(node);
4646         ir_node         *last_keep;
4647         (void) data;
4648         if (mode != mode_T)
4649                 return;
4650         if (!is_ia32_irn(node))
4651                 return;
4652
4653         n_outs = arch_irn_get_n_outs(node);
4654         if (n_outs <= 0)
4655                 return;
4656         if (is_ia32_SwitchJmp(node))
4657                 return;
4658
4659         assert(n_outs < (int) sizeof(unsigned) * 8);
4660         foreach_out_edge(node, edge) {
4661                 ir_node *proj = get_edge_src_irn(edge);
4662                 int      pn;
4663
4664                 /* The node could be kept */
4665                 if (is_End(proj))
4666                         continue;
4667
4668                 if (get_irn_mode(proj) == mode_M)
4669                         continue;
4670
4671                 pn = get_Proj_proj(proj);
4672                 assert(pn < n_outs);
4673                 found_projs |= 1 << pn;
4674         }
4675
4676
4677         /* are keeps missing? */
4678         last_keep = NULL;
4679         for (i = 0; i < n_outs; ++i) {
4680                 ir_node                     *block;
4681                 ir_node                     *in[1];
4682                 const arch_register_req_t   *req;
4683                 const arch_register_class_t *cls;
4684
4685                 if (found_projs & (1 << i)) {
4686                         continue;
4687                 }
4688
4689                 req = get_ia32_out_req(node, i);
4690                 cls = req->cls;
4691                 if (cls == NULL) {
4692                         continue;
4693                 }
4694                 if (cls == &ia32_reg_classes[CLASS_ia32_flags]) {
4695                         continue;
4696                 }
4697
4698                 block = get_nodes_block(node);
4699                 in[0] = new_r_Proj(current_ir_graph, block, node,
4700                                    arch_register_class_mode(cls), i);
4701                 if (last_keep != NULL) {
4702                         be_Keep_add_node(last_keep, cls, in[0]);
4703                 } else {
4704                         last_keep = be_new_Keep(cls, current_ir_graph, block, 1, in);
4705                         if (sched_is_scheduled(node)) {
4706                                 sched_add_after(node, last_keep);
4707                         }
4708                 }
4709         }
4710 }
4711
4712 /**
4713  * Adds missing keeps to nodes. Adds missing Proj nodes for unused outputs
4714  * and keeps them.
4715  */
4716 void ia32_add_missing_keeps(ia32_code_gen_t *cg)
4717 {
4718         ir_graph *irg = be_get_birg_irg(cg->birg);
4719         irg_walk_graph(irg, add_missing_keep_walker, NULL, NULL);
4720 }
4721
4722 /* do the transformation */
4723 void ia32_transform_graph(ia32_code_gen_t *cg)
4724 {
4725         int cse_last;
4726
4727         register_transformers();
4728         env_cg       = cg;
4729         initial_fpcw = NULL;
4730
4731         BE_TIMER_PUSH(t_heights);
4732         heights      = heights_new(cg->irg);
4733         BE_TIMER_POP(t_heights);
4734         ia32_calculate_non_address_mode_nodes(cg->birg);
4735
4736         /* the transform phase is not safe for CSE (yet) because several nodes get
4737          * attributes set after their creation */
4738         cse_last = get_opt_cse();
4739         set_opt_cse(0);
4740
4741         be_transform_graph(cg->birg, ia32_pretransform_node);
4742
4743         set_opt_cse(cse_last);
4744
4745         ia32_free_non_address_mode_nodes();
4746         heights_free(heights);
4747         heights = NULL;
4748 }
4749
4750 void ia32_init_transform(void)
4751 {
4752         FIRM_DBG_REGISTER(dbg, "firm.be.ia32.transform");
4753 }