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