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