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

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