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