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

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