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

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