nsz Git - libfirm/blob - ir/be/ia32/ia32_optimize.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       Implements several optimizations for IA32.
  23  * @author      Matthias Braun, Christian Wuerdig
  24  * @version     $Id$
  25  */
  26 #ifdef HAVE_CONFIG_H
  27 #include "config.h"
  28 #endif
  29
  30 #include "irnode.h"
  31 #include "irprog_t.h"
  32 #include "ircons.h"
  33 #include "irtools.h"
  34 #include "firm_types.h"
  35 #include "iredges.h"
  36 #include "tv.h"
  37 #include "irgmod.h"
  38 #include "irgwalk.h"
  39 #include "height.h"
  40 #include "irbitset.h"
  41 #include "irprintf.h"
  42 #include "error.h"
  43
  44 #include "../be_t.h"
  45 #include "../beabi.h"
  46 #include "../benode_t.h"
  47 #include "../besched_t.h"
  48 #include "../bepeephole.h"
  49
  50 #include "ia32_new_nodes.h"
  51 #include "ia32_optimize.h"
  52 #include "bearch_ia32_t.h"
  53 #include "gen_ia32_regalloc_if.h"
  54 #include "ia32_common_transform.h"
  55 #include "ia32_transform.h"
  56 #include "ia32_dbg_stat.h"
  57 #include "ia32_util.h"
  58 #include "ia32_architecture.h"
  59
  60 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
  61
  62 static const arch_env_t *arch_env;
  63 static ia32_code_gen_t  *cg;
  64
  65 static void copy_mark(const ir_node *old, ir_node *new)
  66 {
  67         if (is_ia32_is_reload(old))
  68                 set_ia32_is_reload(new);
  69         if (is_ia32_is_spill(old))
  70                 set_ia32_is_spill(new);
  71         if (is_ia32_is_remat(old))
  72                 set_ia32_is_remat(new);
  73 }
  74
  75 /**
  76  * Returns non-zero if the given node produces
  77  * a zero flag.
  78  *
  79  * @param node  the node to check
  80  * @param pn    if >= 0, the projection number of the used result
  81  */
  82 static int produces_zero_flag(ir_node *node, int pn)
  83 {
  84         ir_node                     *count;
  85         const ia32_immediate_attr_t *imm_attr;
  86
  87         if (!is_ia32_irn(node))
  88                 return 0;
  89
  90         if (pn >= 0) {
  91                 if (pn != pn_ia32_res)
  92                         return 0;
  93         }
  94
  95         switch (get_ia32_irn_opcode(node)) {
  96         case iro_ia32_Add:
  97         case iro_ia32_Adc:
  98         case iro_ia32_And:
  99         case iro_ia32_Or:
 100         case iro_ia32_Xor:
 101         case iro_ia32_Sub:
 102         case iro_ia32_Sbb:
 103         case iro_ia32_Neg:
 104         case iro_ia32_Inc:
 105         case iro_ia32_Dec:
 106                 return 1;
 107
 108         case iro_ia32_ShlD:
 109         case iro_ia32_ShrD:
 110                 assert(n_ia32_ShlD_count == n_ia32_ShrD_count);
 111                 count = get_irn_n(node, n_ia32_ShlD_count);
 112                 goto check_shift_amount;
 113
 114         case iro_ia32_Shl:
 115         case iro_ia32_Shr:
 116         case iro_ia32_Sar:
 117                 assert(n_ia32_Shl_count == n_ia32_Shr_count
 118                                 && n_ia32_Shl_count == n_ia32_Sar_count);
 119                 count = get_irn_n(node, n_ia32_Shl_count);
 120 check_shift_amount:
 121                 /* when shift count is zero the flags are not affected, so we can only
 122                  * do this for constants != 0 */
 123                 if (!is_ia32_Immediate(count))
 124                         return 0;
 125
 126                 imm_attr = get_ia32_immediate_attr_const(count);
 127                 if (imm_attr->symconst != NULL)
 128                         return 0;
 129                 if ((imm_attr->offset & 0x1f) == 0)
 130                         return 0;
 131                 return 1;
 132
 133         default:
 134                 break;
 135         }
 136         return 0;
 137 }
 138
 139 /**
 140  * If the given node has not mode_T, creates a mode_T version (with a result Proj).
 141  *
 142  * @param node  the node to change
 143  *
 144  * @return the new mode_T node (if the mode was changed) or node itself
 145  */
 146 static ir_node *turn_into_mode_t(ir_node *node)
 147 {
 148         ir_node               *block;
 149         ir_node               *res_proj;
 150         ir_node               *new_node;
 151         const arch_register_t *reg;
 152
 153         if(get_irn_mode(node) == mode_T)
 154                 return node;
 155
 156         assert(get_irn_mode(node) == mode_Iu);
 157
 158         new_node = exact_copy(node);
 159         set_irn_mode(new_node, mode_T);
 160
 161         block    = get_nodes_block(new_node);
 162         res_proj = new_r_Proj(current_ir_graph, block, new_node, mode_Iu,
 163                               pn_ia32_res);
 164
 165         reg = arch_get_irn_register(arch_env, node);
 166         arch_set_irn_register(arch_env, res_proj, reg);
 167
 168         sched_add_before(node, new_node);
 169         be_peephole_exchange(node, res_proj);
 170         return new_node;
 171 }
 172
 173 /**
 174  * Replace Cmp(x, 0) by a Test(x, x)
 175  */
 176 static void peephole_ia32_Cmp(ir_node *const node)
 177 {
 178         ir_node                     *right;
 179         ia32_immediate_attr_t const *imm;
 180         dbg_info                    *dbgi;
 181         ir_graph                    *irg;
 182         ir_node                     *block;
 183         ir_node                     *noreg;
 184         ir_node                     *nomem;
 185         ir_node                     *op;
 186         ia32_attr_t           const *attr;
 187         int                          ins_permuted;
 188         int                          cmp_unsigned;
 189         ir_node                     *test;
 190         arch_register_t       const *reg;
 191         ir_edge_t             const *edge;
 192         ir_edge_t             const *tmp;
 193
 194         if (get_ia32_op_type(node) != ia32_Normal)
 195                 return;
 196
 197         right = get_irn_n(node, n_ia32_Cmp_right);
 198         if (!is_ia32_Immediate(right))
 199                 return;
 200
 201         imm = get_ia32_immediate_attr_const(right);
 202         if (imm->symconst != NULL || imm->offset != 0)
 203                 return;
 204
 205         dbgi         = get_irn_dbg_info(node);
 206         irg          = current_ir_graph;
 207         block        = get_nodes_block(node);
 208         noreg        = ia32_new_NoReg_gp(cg);
 209         nomem        = get_irg_no_mem(irg);
 210         op           = get_irn_n(node, n_ia32_Cmp_left);
 211         attr         = get_irn_generic_attr(node);
 212         ins_permuted = attr->data.ins_permuted;
 213         cmp_unsigned = attr->data.cmp_unsigned;
 214
 215         if (is_ia32_Cmp(node)) {
 216                 test = new_rd_ia32_Test(dbgi, irg, block, noreg, noreg, nomem,
 217                                         op, op, ins_permuted, cmp_unsigned);
 218         } else {
 219                 test = new_rd_ia32_Test8Bit(dbgi, irg, block, noreg, noreg, nomem,
 220                                             op, op, ins_permuted, cmp_unsigned);
 221         }
 222         set_ia32_ls_mode(test, get_ia32_ls_mode(node));
 223
 224         reg = arch_get_irn_register(arch_env, node);
 225         arch_set_irn_register(arch_env, test, reg);
 226
 227         foreach_out_edge_safe(node, edge, tmp) {
 228                 ir_node *const user = get_edge_src_irn(edge);
 229
 230                 if (is_Proj(user))
 231                         exchange(user, test);
 232         }
 233
 234         sched_add_before(node, test);
 235         copy_mark(node, test);
 236         be_peephole_exchange(node, test);
 237 }
 238
 239 /**
 240  * Peephole optimization for Test instructions.
 241  * We can remove the Test, if a zero flags was produced which is still
 242  * live.
 243  */
 244 static void peephole_ia32_Test(ir_node *node)
 245 {
 246         ir_node         *left  = get_irn_n(node, n_ia32_Test_left);
 247         ir_node         *right = get_irn_n(node, n_ia32_Test_right);
 248         ir_node         *flags_proj;
 249         ir_node         *block;
 250         ir_mode         *flags_mode;
 251         int              pn    = -1;
 252         ir_node         *schedpoint;
 253         const ir_edge_t *edge;
 254
 255         assert(n_ia32_Test_left == n_ia32_Test8Bit_left
 256                         && n_ia32_Test_right == n_ia32_Test8Bit_right);
 257
 258         /* we need a test for 0 */
 259         if(left != right)
 260                 return;
 261
 262         block = get_nodes_block(node);
 263         if(get_nodes_block(left) != block)
 264                 return;
 265
 266         if(is_Proj(left)) {
 267                 pn   = get_Proj_proj(left);
 268                 left = get_Proj_pred(left);
 269         }
 270
 271         /* happens rarely, but if it does code will panic' */
 272         if (is_ia32_Unknown_GP(left))
 273                 return;
 274
 275         /* walk schedule up and abort when we find left or some other node destroys
 276            the flags */
 277         schedpoint = sched_prev(node);
 278         while(schedpoint != left) {
 279                 schedpoint = sched_prev(schedpoint);
 280                 if(arch_irn_is(arch_env, schedpoint, modify_flags))
 281                         return;
 282                 if(schedpoint == block)
 283                         panic("couldn't find left");
 284         }
 285
 286         /* make sure only Lg/Eq tests are used */
 287         foreach_out_edge(node, edge) {
 288                 ir_node *user = get_edge_src_irn(edge);
 289                 int      pnc  = get_ia32_condcode(user);
 290
 291                 if(pnc != pn_Cmp_Eq && pnc != pn_Cmp_Lg) {
 292                         return;
 293                 }
 294         }
 295
 296         if(!produces_zero_flag(left, pn))
 297                 return;
 298
 299         left = turn_into_mode_t(left);
 300
 301         flags_mode = ia32_reg_classes[CLASS_ia32_flags].mode;
 302         flags_proj = new_r_Proj(current_ir_graph, block, left, flags_mode,
 303                                 pn_ia32_flags);
 304         arch_set_irn_register(arch_env, flags_proj, &ia32_flags_regs[REG_EFLAGS]);
 305
 306         assert(get_irn_mode(node) != mode_T);
 307
 308         be_peephole_exchange(node, flags_proj);
 309 }
 310
 311 /**
 312  * AMD Athlon works faster when RET is not destination of
 313  * conditional jump or directly preceded by other jump instruction.
 314  * Can be avoided by placing a Rep prefix before the return.
 315  */
 316 static void peephole_ia32_Return(ir_node *node) {
 317         ir_node *block, *irn;
 318
 319         if (!ia32_cg_config.use_pad_return)
 320                 return;
 321
 322         block = get_nodes_block(node);
 323
 324         /* check if this return is the first on the block */
 325         sched_foreach_reverse_from(node, irn) {
 326                 switch (get_irn_opcode(irn)) {
 327                 case beo_Return:
 328                         /* the return node itself, ignore */
 329                         continue;
 330                 case iro_Start:
 331                 case beo_RegParams:
 332                 case beo_Barrier:
 333                         /* ignore no code generated */
 334                         continue;
 335                 case beo_IncSP:
 336                         /* arg, IncSP 0 nodes might occur, ignore these */
 337                         if (be_get_IncSP_offset(irn) == 0)
 338                                 continue;
 339                         return;
 340                 case iro_Phi:
 341                         continue;
 342                 default:
 343                         return;
 344                 }
 345         }
 346
 347         /* ensure, that the 3 byte return is generated */
 348         be_Return_set_emit_pop(node, 1);
 349 }
 350
 351 /* only optimize up to 48 stores behind IncSPs */
 352 #define MAXPUSH_OPTIMIZE        48
 353
 354 /**
 355  * Tries to create Push's from IncSP, Store combinations.
 356  * The Stores are replaced by Push's, the IncSP is modified
 357  * (possibly into IncSP 0, but not removed).
 358  */
 359 static void peephole_IncSP_Store_to_push(ir_node *irn)
 360 {
 361         int              i;
 362         int              maxslot;
 363         int              inc_ofs;
 364         ir_node         *node;
 365         ir_node         *stores[MAXPUSH_OPTIMIZE];
 366         ir_node         *block;
 367         ir_graph        *irg;
 368         ir_node         *curr_sp;
 369         ir_mode         *spmode;
 370         ir_node         *first_push = NULL;
 371         ir_edge_t const *edge;
 372         ir_edge_t const *next;
 373
 374         memset(stores, 0, sizeof(stores));
 375
 376         assert(be_is_IncSP(irn));
 377
 378         inc_ofs = be_get_IncSP_offset(irn);
 379         if (inc_ofs < 4)
 380                 return;
 381
 382         /*
 383          * We first walk the schedule after the IncSP node as long as we find
 384          * suitable Stores that could be transformed to a Push.
 385          * We save them into the stores array which is sorted by the frame offset/4
 386          * attached to the node
 387          */
 388         maxslot = -1;
 389         for (node = sched_next(irn); !sched_is_end(node); node = sched_next(node)) {
 390                 ir_node *mem;
 391                 int offset;
 392                 int storeslot;
 393
 394                 /* it has to be a Store */
 395                 if (!is_ia32_Store(node))
 396                         break;
 397
 398                 /* it has to use our sp value */
 399                 if (get_irn_n(node, n_ia32_base) != irn)
 400                         continue;
 401                 /* Store has to be attached to NoMem */
 402                 mem = get_irn_n(node, n_ia32_mem);
 403                 if (!is_NoMem(mem))
 404                         continue;
 405
 406                 /* unfortunately we can't support the full AMs possible for push at the
 407                  * moment. TODO: fix this */
 408                 if (!is_ia32_NoReg_GP(get_irn_n(node, n_ia32_index)))
 409                         break;
 410
 411                 offset = get_ia32_am_offs_int(node);
 412                 /* we should NEVER access uninitialized stack BELOW the current SP */
 413                 assert(offset >= 0);
 414
 415                 /* storing at half-slots is bad */
 416                 if ((offset & 3) != 0)
 417                         break;
 418
 419                 if (inc_ofs - 4 < offset || offset >= MAXPUSH_OPTIMIZE * 4)
 420                         continue;
 421                 storeslot = offset >> 2;
 422
 423                 /* storing into the same slot twice is bad (and shouldn't happen...) */
 424                 if (stores[storeslot] != NULL)
 425                         break;
 426
 427                 stores[storeslot] = node;
 428                 if (storeslot > maxslot)
 429                         maxslot = storeslot;
 430         }
 431
 432         curr_sp = irn;
 433
 434         for (i = -1; i < maxslot; ++i) {
 435                 if (stores[i + 1] == NULL)
 436                         break;
 437         }
 438
 439         /* walk through the Stores and create Pushs for them */
 440         block  = get_nodes_block(irn);
 441         spmode = get_irn_mode(irn);
 442         irg    = cg->irg;
 443         for (; i >= 0; --i) {
 444                 const arch_register_t *spreg;
 445                 ir_node *push;
 446                 ir_node *val, *mem, *mem_proj;
 447                 ir_node *store = stores[i];
 448                 ir_node *noreg = ia32_new_NoReg_gp(cg);
 449
 450                 val = get_irn_n(store, n_ia32_unary_op);
 451                 mem = get_irn_n(store, n_ia32_mem);
 452                 spreg = arch_get_irn_register(cg->arch_env, curr_sp);
 453
 454                 push = new_rd_ia32_Push(get_irn_dbg_info(store), irg, block, noreg, noreg, mem, val, curr_sp);
 455                 copy_mark(store, push);
 456
 457                 if (first_push == NULL)
 458                         first_push = push;
 459
 460                 sched_add_after(curr_sp, push);
 461
 462                 /* create stackpointer Proj */
 463                 curr_sp = new_r_Proj(irg, block, push, spmode, pn_ia32_Push_stack);
 464                 arch_set_irn_register(cg->arch_env, curr_sp, spreg);
 465
 466                 /* create memory Proj */
 467                 mem_proj = new_r_Proj(irg, block, push, mode_M, pn_ia32_Push_M);
 468
 469                 /* use the memproj now */
 470                 be_peephole_exchange(store, mem_proj);
 471
 472                 inc_ofs -= 4;
 473         }
 474
 475         foreach_out_edge_safe(irn, edge, next) {
 476                 ir_node *const src = get_edge_src_irn(edge);
 477                 int      const pos = get_edge_src_pos(edge);
 478
 479                 if (src == first_push)
 480                         continue;
 481
 482                 set_irn_n(src, pos, curr_sp);
 483         }
 484
 485         be_set_IncSP_offset(irn, inc_ofs);
 486 }
 487
 488 #if 0
 489 static void peephole_store_incsp(ir_node *store)
 490 {
 491         dbg_info *dbgi;
 492         ir_node  *node;
 493         ir_node  *block;
 494         ir_node  *noref;
 495         ir_node  *mem;
 496         ir_node  *push;
 497         ir_node  *val;
 498         ir_node  *am_base = get_irn_n(store, n_ia32_Store_base);
 499         if (!be_is_IncSP(am_base)
 500                         || get_nodes_block(am_base) != get_nodes_block(store))
 501                 return;
 502         mem = get_irn_n(store, n_ia32_Store_mem);
 503         if (!is_ia32_NoReg_GP(get_irn_n(store, n_ia32_Store_index))
 504                         || !is_NoMem(mem))
 505                 return;
 506
 507         int incsp_offset = be_get_IncSP_offset(am_base);
 508         if (incsp_offset <= 0)
 509                 return;
 510
 511         /* we have to be at offset 0 */
 512         int my_offset = get_ia32_am_offs_int(store);
 513         if (my_offset != 0) {
 514                 /* TODO here: find out wether there is a store with offset 0 before
 515                  * us and wether we can move it down to our place */
 516                 return;
 517         }
 518         ir_mode *ls_mode = get_ia32_ls_mode(store);
 519         int my_store_size = get_mode_size_bytes(ls_mode);
 520
 521         if (my_offset + my_store_size > incsp_offset)
 522                 return;
 523
 524         /* correctness checking:
 525                 - noone else must write to that stackslot
 526                     (because after translation incsp won't allocate it anymore)
 527         */
 528         sched_foreach_reverse_from(store, node) {
 529                 int i, arity;
 530
 531                 if (node == am_base)
 532                         break;
 533
 534                 /* make sure noone else can use the space on the stack */
 535                 arity = get_irn_arity(node);
 536                 for (i = 0; i < arity; ++i) {
 537                         ir_node *pred = get_irn_n(node, i);
 538                         if (pred != am_base)
 539                                 continue;
 540
 541                         if (i == n_ia32_base &&
 542                                         (get_ia32_op_type(node) == ia32_AddrModeS
 543                                          || get_ia32_op_type(node) == ia32_AddrModeD)) {
 544                                 int      node_offset  = get_ia32_am_offs_int(node);
 545                                 ir_mode *node_ls_mode = get_ia32_ls_mode(node);
 546                                 int      node_size    = get_mode_size_bytes(node);
 547                                 /* overlapping with our position? abort */
 548                                 if (node_offset < my_offset + my_store_size
 549                                                 && node_offset + node_size >= my_offset)
 550                                         return;
 551                                 /* otherwise it's fine */
 552                                 continue;
 553                         }
 554
 555                         /* strange use of esp: abort */
 556                         return;
 557                 }
 558         }
 559
 560         /* all ok, change to push */
 561         dbgi  = get_irn_dbg_info(store);
 562         block = get_nodes_block(store);
 563         noreg = ia32_new_NoReg_gp(cg);
 564         val   = get_ia32_
 565
 566         push  = new_rd_ia32_Push(dbgi, irg, block, noreg, noreg, mem,
 567
 568         create_push(dbgi, current_ir_graph, block, am_base, store);
 569 }
 570 #endif
 571
 572 /**
 573  * Return true if a mode can be stored in the GP register set
 574  */
 575 static INLINE int mode_needs_gp_reg(ir_mode *mode) {
 576         if (mode == mode_fpcw)
 577                 return 0;
 578         if (get_mode_size_bits(mode) > 32)
 579                 return 0;
 580         return mode_is_int(mode) || mode_is_reference(mode) || mode == mode_b;
 581 }
 582
 583 /**
 584  * Tries to create Pops from Load, IncSP combinations.
 585  * The Loads are replaced by Pops, the IncSP is modified
 586  * (possibly into IncSP 0, but not removed).
 587  */
 588 static void peephole_Load_IncSP_to_pop(ir_node *irn)
 589 {
 590         const arch_register_t *esp = &ia32_gp_regs[REG_ESP];
 591         int      i, maxslot, inc_ofs, ofs;
 592         ir_node  *node, *pred_sp, *block;
 593         ir_node  *loads[MAXPUSH_OPTIMIZE];
 594         ir_graph *irg;
 595         unsigned regmask = 0;
 596         unsigned copymask = ~0;
 597
 598         memset(loads, 0, sizeof(loads));
 599         assert(be_is_IncSP(irn));
 600
 601         inc_ofs = -be_get_IncSP_offset(irn);
 602         if (inc_ofs < 4)
 603                 return;
 604
 605         /*
 606          * We first walk the schedule before the IncSP node as long as we find
 607          * suitable Loads that could be transformed to a Pop.
 608          * We save them into the stores array which is sorted by the frame offset/4
 609          * attached to the node
 610          */
 611         maxslot = -1;
 612         pred_sp = be_get_IncSP_pred(irn);
 613         for (node = sched_prev(irn); !sched_is_end(node); node = sched_prev(node)) {
 614                 int offset;
 615                 int loadslot;
 616                 const arch_register_t *sreg, *dreg;
 617
 618                 /* it has to be a Load */
 619                 if (!is_ia32_Load(node)) {
 620                         if (be_is_Copy(node)) {
 621                                 if (!mode_needs_gp_reg(get_irn_mode(node))) {
 622                                         /* not a GP copy, ignore */
 623                                         continue;
 624                                 }
 625                                 dreg = arch_get_irn_register(arch_env, node);
 626                                 sreg = arch_get_irn_register(arch_env, be_get_Copy_op(node));
 627                                 if (regmask & copymask & (1 << sreg->index)) {
 628                                         break;
 629                                 }
 630                                 if (regmask & copymask & (1 << dreg->index)) {
 631                                         break;
 632                                 }
 633                                 /* we CAN skip Copies if neither the destination nor the source
 634                                  * is not in our regmask, ie none of our future Pop will overwrite it */
 635                                 regmask |= (1 << dreg->index) | (1 << sreg->index);
 636                                 copymask &= ~((1 << dreg->index) | (1 << sreg->index));
 637                                 continue;
 638                         }
 639                         break;
 640                 }
 641
 642                 /* we can handle only GP loads */
 643                 if (!mode_needs_gp_reg(get_ia32_ls_mode(node)))
 644                         continue;
 645
 646                 /* it has to use our predecessor sp value */
 647                 if (get_irn_n(node, n_ia32_base) != pred_sp) {
 648                         /* it would be ok if this load does not use a Pop result,
 649                          * but we do not check this */
 650                         break;
 651                 }
 652
 653                 /* should have NO index */
 654                 if (!is_ia32_NoReg_GP(get_irn_n(node, n_ia32_index)))
 655                         break;
 656
 657                 offset = get_ia32_am_offs_int(node);
 658                 /* we should NEVER access uninitialized stack BELOW the current SP */
 659                 assert(offset >= 0);
 660
 661                 /* storing at half-slots is bad */
 662                 if ((offset & 3) != 0)
 663                         break;
 664
 665                 if (offset < 0 || offset >= MAXPUSH_OPTIMIZE * 4)
 666                         continue;
 667                 /* ignore those outside the possible windows */
 668                 if (offset > inc_ofs - 4)
 669                         continue;
 670                 loadslot = offset >> 2;
 671
 672                 /* loading from the same slot twice is bad (and shouldn't happen...) */
 673                 if (loads[loadslot] != NULL)
 674                         break;
 675
 676                 dreg = arch_get_irn_register(arch_env, node);
 677                 if (regmask & (1 << dreg->index)) {
 678                         /* this register is already used */
 679                         break;
 680                 }
 681                 regmask |= 1 << dreg->index;
 682
 683                 loads[loadslot] = node;
 684                 if (loadslot > maxslot)
 685                         maxslot = loadslot;
 686         }
 687
 688         if (maxslot < 0)
 689                 return;
 690
 691         /* find the first slot */
 692         for (i = maxslot; i >= 0; --i) {
 693                 ir_node *load = loads[i];
 694
 695                 if (load == NULL)
 696                         break;
 697         }
 698
 699         ofs = inc_ofs - (maxslot + 1) * 4;
 700         inc_ofs = (i+1) * 4;
 701
 702         /* create a new IncSP if needed */
 703         block = get_nodes_block(irn);
 704         irg   = cg->irg;
 705         if (inc_ofs > 0) {
 706                 pred_sp = be_new_IncSP(esp, irg, block, pred_sp, -inc_ofs, be_get_IncSP_align(irn));
 707                 sched_add_before(irn, pred_sp);
 708         }
 709
 710         /* walk through the Loads and create Pops for them */
 711         for (++i; i <= maxslot; ++i) {
 712                 ir_node *load = loads[i];
 713                 ir_node *mem, *pop;
 714                 const ir_edge_t *edge, *tmp;
 715                 const arch_register_t *reg;
 716
 717                 mem = get_irn_n(load, n_ia32_mem);
 718                 reg = arch_get_irn_register(arch_env, load);
 719
 720                 pop = new_rd_ia32_Pop(get_irn_dbg_info(load), irg, block, mem, pred_sp);
 721                 arch_set_irn_register(arch_env, pop, reg);
 722
 723                 copy_mark(load, pop);
 724
 725                 /* create stackpointer Proj */
 726                 pred_sp = new_r_Proj(irg, block, pop, mode_Iu, pn_ia32_Pop_stack);
 727                 arch_set_irn_register(arch_env, pred_sp, esp);
 728
 729                 sched_add_before(irn, pop);
 730
 731                 /* rewire now */
 732                 foreach_out_edge_safe(load, edge, tmp) {
 733                         ir_node *proj = get_edge_src_irn(edge);
 734
 735                         set_Proj_pred(proj, pop);
 736                 }
 737
 738                 /* we can remove the Load now */
 739                 sched_remove(load);
 740                 kill_node(load);
 741         }
 742
 743         be_set_IncSP_offset(irn, -ofs);
 744         be_set_IncSP_pred(irn, pred_sp);
 745 }
 746
 747
 748 /**
 749  * Find a free GP register if possible, else return NULL.
 750  */
 751 static const arch_register_t *get_free_gp_reg(void)
 752 {
 753         int i;
 754
 755         for(i = 0; i < N_ia32_gp_REGS; ++i) {
 756                 const arch_register_t *reg = &ia32_gp_regs[i];
 757                 if(arch_register_type_is(reg, ignore))
 758                         continue;
 759
 760                 if(be_peephole_get_value(CLASS_ia32_gp, i) == NULL)
 761                         return &ia32_gp_regs[i];
 762         }
 763
 764         return NULL;
 765 }
 766
 767 /**
 768  * Creates a Pop instruction before the given schedule point.
 769  *
 770  * @param dbgi        debug info
 771  * @param irg         the graph
 772  * @param block       the block
 773  * @param stack       the previous stack value
 774  * @param schedpoint  the new node is added before this node
 775  * @param reg         the register to pop
 776  *
 777  * @return the new stack value
 778  */
 779 static ir_node *create_pop(dbg_info *dbgi, ir_graph *irg, ir_node *block,
 780                            ir_node *stack, ir_node *schedpoint,
 781                            const arch_register_t *reg)
 782 {
 783         const arch_register_t *esp = &ia32_gp_regs[REG_ESP];
 784         ir_node *pop;
 785         ir_node *keep;
 786         ir_node *val;
 787         ir_node *in[1];
 788
 789         pop   = new_rd_ia32_Pop(dbgi, irg, block, new_NoMem(), stack);
 790
 791         stack = new_r_Proj(irg, block, pop, mode_Iu, pn_ia32_Pop_stack);
 792         arch_set_irn_register(arch_env, stack, esp);
 793         val   = new_r_Proj(irg, block, pop, mode_Iu, pn_ia32_Pop_res);
 794         arch_set_irn_register(arch_env, val, reg);
 795
 796         sched_add_before(schedpoint, pop);
 797
 798         in[0] = val;
 799         keep = be_new_Keep(&ia32_reg_classes[CLASS_ia32_gp], irg, block, 1, in);
 800         sched_add_before(schedpoint, keep);
 801
 802         return stack;
 803 }
 804
 805 /**
 806  * Creates a Push instruction before the given schedule point.
 807  *
 808  * @param dbgi        debug info
 809  * @param irg         the graph
 810  * @param block       the block
 811  * @param stack       the previous stack value
 812  * @param schedpoint  the new node is added before this node
 813  * @param reg         the register to pop
 814  *
 815  * @return the new stack value
 816  */
 817 static ir_node *create_push(dbg_info *dbgi, ir_graph *irg, ir_node *block,
 818                             ir_node *stack, ir_node *schedpoint)
 819 {
 820         const arch_register_t *esp = &ia32_gp_regs[REG_ESP];
 821
 822         ir_node *val   = ia32_new_Unknown_gp(cg);
 823         ir_node *noreg = ia32_new_NoReg_gp(cg);
 824         ir_node *nomem = get_irg_no_mem(irg);
 825         ir_node *push  = new_rd_ia32_Push(dbgi, irg, block, noreg, noreg, nomem, val, stack);
 826         sched_add_before(schedpoint, push);
 827
 828         stack = new_r_Proj(irg, block, push, mode_Iu, pn_ia32_Push_stack);
 829         arch_set_irn_register(arch_env, stack, esp);
 830
 831         return stack;
 832 }
 833
 834 /**
 835  * Optimize an IncSp by replacing it with Push/Pop.
 836  */
 837 static void peephole_be_IncSP(ir_node *node)
 838 {
 839         const arch_register_t *esp = &ia32_gp_regs[REG_ESP];
 840         const arch_register_t *reg;
 841         ir_graph              *irg = current_ir_graph;
 842         dbg_info              *dbgi;
 843         ir_node               *block;
 844         ir_node               *stack;
 845         int                    offset;
 846
 847         /* first optimize incsp->incsp combinations */
 848         node = be_peephole_IncSP_IncSP(node);
 849
 850         /* transform IncSP->Store combinations to Push where possible */
 851         peephole_IncSP_Store_to_push(node);
 852
 853         /* transform Load->IncSP combinations to Pop where possible */
 854         peephole_Load_IncSP_to_pop(node);
 855
 856         if (arch_get_irn_register(arch_env, node) != esp)
 857                 return;
 858
 859         /* replace IncSP -4 by Pop freereg when possible */
 860         offset = be_get_IncSP_offset(node);
 861         if ((offset != -8 || ia32_cg_config.use_add_esp_8) &&
 862             (offset != -4 || ia32_cg_config.use_add_esp_4) &&
 863             (offset != +4 || ia32_cg_config.use_sub_esp_4) &&
 864             (offset != +8 || ia32_cg_config.use_sub_esp_8))
 865                 return;
 866
 867         if (offset < 0) {
 868                 /* we need a free register for pop */
 869                 reg = get_free_gp_reg();
 870                 if (reg == NULL)
 871                         return;
 872
 873                 dbgi  = get_irn_dbg_info(node);
 874                 block = get_nodes_block(node);
 875                 stack = be_get_IncSP_pred(node);
 876
 877                 stack = create_pop(dbgi, irg, block, stack, node, reg);
 878
 879                 if (offset == -8) {
 880                         stack = create_pop(dbgi, irg, block, stack, node, reg);
 881                 }
 882         } else {
 883                 dbgi  = get_irn_dbg_info(node);
 884                 block = get_nodes_block(node);
 885                 stack = be_get_IncSP_pred(node);
 886                 stack = create_push(dbgi, irg, block, stack, node);
 887
 888                 if (offset == +8) {
 889                         stack = create_push(dbgi, irg, block, stack, node);
 890                 }
 891         }
 892
 893         be_peephole_exchange(node, stack);
 894 }
 895
 896 /**
 897  * Peephole optimisation for ia32_Const's
 898  */
 899 static void peephole_ia32_Const(ir_node *node)
 900 {
 901         const ia32_immediate_attr_t *attr = get_ia32_immediate_attr_const(node);
 902         const arch_register_t       *reg;
 903         ir_graph                    *irg = current_ir_graph;
 904         ir_node                     *block;
 905         dbg_info                    *dbgi;
 906         ir_node                     *produceval;
 907         ir_node                     *xor;
 908         ir_node                     *noreg;
 909
 910         /* try to transform a mov 0, reg to xor reg reg */
 911         if (attr->offset != 0 || attr->symconst != NULL)
 912                 return;
 913         if (ia32_cg_config.use_mov_0)
 914                 return;
 915         /* xor destroys the flags, so no-one must be using them */
 916         if (be_peephole_get_value(CLASS_ia32_flags, REG_EFLAGS) != NULL)
 917                 return;
 918
 919         reg = arch_get_irn_register(arch_env, node);
 920         assert(be_peephole_get_reg_value(reg) == NULL);
 921
 922         /* create xor(produceval, produceval) */
 923         block      = get_nodes_block(node);
 924         dbgi       = get_irn_dbg_info(node);
 925         produceval = new_rd_ia32_ProduceVal(dbgi, irg, block);
 926         arch_set_irn_register(arch_env, produceval, reg);
 927
 928         noreg = ia32_new_NoReg_gp(cg);
 929         xor   = new_rd_ia32_Xor(dbgi, irg, block, noreg, noreg, new_NoMem(),
 930                                 produceval, produceval);
 931         arch_set_irn_register(arch_env, xor, reg);
 932
 933         sched_add_before(node, produceval);
 934         sched_add_before(node, xor);
 935
 936         copy_mark(node, xor);
 937         be_peephole_exchange(node, xor);
 938 }
 939
 940 static INLINE int is_noreg(ia32_code_gen_t *cg, const ir_node *node)
 941 {
 942         return node == cg->noreg_gp;
 943 }
 944
 945 static ir_node *create_immediate_from_int(ia32_code_gen_t *cg, int val)
 946 {
 947         ir_graph *irg         = current_ir_graph;
 948         ir_node  *start_block = get_irg_start_block(irg);
 949         ir_node  *immediate   = new_rd_ia32_Immediate(NULL, irg, start_block, NULL,
 950                                                       0, val);
 951         arch_set_irn_register(cg->arch_env, immediate, &ia32_gp_regs[REG_GP_NOREG]);
 952
 953         return immediate;
 954 }
 955
 956 static ir_node *create_immediate_from_am(ia32_code_gen_t *cg,
 957                                          const ir_node *node)
 958 {
 959         ir_graph  *irg     = get_irn_irg(node);
 960         ir_node   *block   = get_nodes_block(node);
 961         int        offset  = get_ia32_am_offs_int(node);
 962         int        sc_sign = is_ia32_am_sc_sign(node);
 963         ir_entity *entity  = get_ia32_am_sc(node);
 964         ir_node   *res;
 965
 966         res = new_rd_ia32_Immediate(NULL, irg, block, entity, sc_sign, offset);
 967         arch_set_irn_register(cg->arch_env, res, &ia32_gp_regs[REG_GP_NOREG]);
 968         return res;
 969 }
 970
 971 static int is_am_one(const ir_node *node)
 972 {
 973         int        offset  = get_ia32_am_offs_int(node);
 974         ir_entity *entity  = get_ia32_am_sc(node);
 975
 976         return offset == 1 && entity == NULL;
 977 }
 978
 979 static int is_am_minus_one(const ir_node *node)
 980 {
 981         int        offset  = get_ia32_am_offs_int(node);
 982         ir_entity *entity  = get_ia32_am_sc(node);
 983
 984         return offset == -1 && entity == NULL;
 985 }
 986
 987 /**
 988  * Transforms a LEA into an Add or SHL if possible.
 989  */
 990 static void peephole_ia32_Lea(ir_node *node)
 991 {
 992         const arch_env_t      *arch_env = cg->arch_env;
 993         ir_graph              *irg      = current_ir_graph;
 994         ir_node               *base;
 995         ir_node               *index;
 996         const arch_register_t *base_reg;
 997         const arch_register_t *index_reg;
 998         const arch_register_t *out_reg;
 999         int                    scale;
1000         int                    has_immediates;
1001         ir_node               *op1;
1002         ir_node               *op2;
1003         dbg_info              *dbgi;
1004         ir_node               *block;
1005         ir_node               *res;
1006         ir_node               *noreg;
1007         ir_node               *nomem;
1008
1009         assert(is_ia32_Lea(node));
1010
1011         /* we can only do this if are allowed to globber the flags */
1012         if(be_peephole_get_value(CLASS_ia32_flags, REG_EFLAGS) != NULL)
1013                 return;
1014
1015         base  = get_irn_n(node, n_ia32_Lea_base);
1016         index = get_irn_n(node, n_ia32_Lea_index);
1017
1018         if(is_noreg(cg, base)) {
1019                 base     = NULL;
1020                 base_reg = NULL;
1021         } else {
1022                 base_reg = arch_get_irn_register(arch_env, base);
1023         }
1024         if(is_noreg(cg, index)) {
1025                 index     = NULL;
1026                 index_reg = NULL;
1027         } else {
1028                 index_reg = arch_get_irn_register(arch_env, index);
1029         }
1030
1031         if(base == NULL && index == NULL) {
1032                 /* we shouldn't construct these in the first place... */
1033 #ifdef DEBUG_libfirm
1034                 ir_fprintf(stderr, "Optimisation warning: found immediate only lea\n");
1035 #endif
1036                 return;
1037         }
1038
1039         out_reg = arch_get_irn_register(arch_env, node);
1040         scale   = get_ia32_am_scale(node);
1041         assert(!is_ia32_need_stackent(node) || get_ia32_frame_ent(node) != NULL);
1042         /* check if we have immediates values (frame entities should already be
1043          * expressed in the offsets) */
1044         if(get_ia32_am_offs_int(node) != 0 || get_ia32_am_sc(node) != NULL) {
1045                 has_immediates = 1;
1046         } else {
1047                 has_immediates = 0;
1048         }
1049
1050         /* we can transform leas where the out register is the same as either the
1051          * base or index register back to an Add or Shl */
1052         if(out_reg == base_reg) {
1053                 if(index == NULL) {
1054 #ifdef DEBUG_libfirm
1055                         if(!has_immediates) {
1056                                 ir_fprintf(stderr, "Optimisation warning: found lea which is "
1057                                            "just a copy\n");
1058                         }
1059 #endif
1060                         op1 = base;
1061                         goto make_add_immediate;
1062                 }
1063                 if(scale == 0 && !has_immediates) {
1064                         op1 = base;
1065                         op2 = index;
1066                         goto make_add;
1067                 }
1068                 /* can't create an add */
1069                 return;
1070         } else if(out_reg == index_reg) {
1071                 if(base == NULL) {
1072                         if(has_immediates && scale == 0) {
1073                                 op1 = index;
1074                                 goto make_add_immediate;
1075                         } else if(!has_immediates && scale > 0) {
1076                                 op1 = index;
1077                                 op2 = create_immediate_from_int(cg, scale);
1078                                 goto make_shl;
1079                         } else if(!has_immediates) {
1080 #ifdef DEBUG_libfirm
1081                                 ir_fprintf(stderr, "Optimisation warning: found lea which is "
1082                                            "just a copy\n");
1083 #endif
1084                         }
1085                 } else if(scale == 0 && !has_immediates) {
1086                         op1 = index;
1087                         op2 = base;
1088                         goto make_add;
1089                 }
1090                 /* can't create an add */
1091                 return;
1092         } else {
1093                 /* can't create an add */
1094                 return;
1095         }
1096
1097 make_add_immediate:
1098         if(ia32_cg_config.use_incdec) {
1099                 if(is_am_one(node)) {
1100                         dbgi  = get_irn_dbg_info(node);
1101                         block = get_nodes_block(node);
1102                         res   = new_rd_ia32_Inc(dbgi, irg, block, op1);
1103                         arch_set_irn_register(arch_env, res, out_reg);
1104                         goto exchange;
1105                 }
1106                 if(is_am_minus_one(node)) {
1107                         dbgi  = get_irn_dbg_info(node);
1108                         block = get_nodes_block(node);
1109                         res   = new_rd_ia32_Dec(dbgi, irg, block, op1);
1110                         arch_set_irn_register(arch_env, res, out_reg);
1111                         goto exchange;
1112                 }
1113         }
1114         op2 = create_immediate_from_am(cg, node);
1115
1116 make_add:
1117         dbgi  = get_irn_dbg_info(node);
1118         block = get_nodes_block(node);
1119         noreg = ia32_new_NoReg_gp(cg);
1120         nomem = new_NoMem();
1121         res   = new_rd_ia32_Add(dbgi, irg, block, noreg, noreg, nomem, op1, op2);
1122         arch_set_irn_register(arch_env, res, out_reg);
1123         set_ia32_commutative(res);
1124         goto exchange;
1125
1126 make_shl:
1127         dbgi  = get_irn_dbg_info(node);
1128         block = get_nodes_block(node);
1129         noreg = ia32_new_NoReg_gp(cg);
1130         nomem = new_NoMem();
1131         res   = new_rd_ia32_Shl(dbgi, irg, block, op1, op2);
1132         arch_set_irn_register(arch_env, res, out_reg);
1133         goto exchange;
1134
1135 exchange:
1136         SET_IA32_ORIG_NODE(res, ia32_get_old_node_name(cg, node));
1137
1138         /* add new ADD/SHL to schedule */
1139         DBG_OPT_LEA2ADD(node, res);
1140
1141         /* exchange the Add and the LEA */
1142         sched_add_before(node, res);
1143         copy_mark(node, res);
1144         be_peephole_exchange(node, res);
1145 }
1146
1147 /**
1148  * Split a Imul mem, imm into a Load mem and Imul reg, imm if possible.
1149  */
1150 static void peephole_ia32_Imul_split(ir_node *imul)
1151 {
1152         const ir_node         *right = get_irn_n(imul, n_ia32_IMul_right);
1153         const arch_register_t *reg;
1154         ir_node               *res;
1155
1156         if (!is_ia32_Immediate(right) || get_ia32_op_type(imul) != ia32_AddrModeS) {
1157                 /* no memory, imm form ignore */
1158                 return;
1159         }
1160         /* we need a free register */
1161         reg = get_free_gp_reg();
1162         if (reg == NULL)
1163                 return;
1164
1165         /* fine, we can rebuild it */
1166         res = turn_back_am(imul);
1167         arch_set_irn_register(arch_env, res, reg);
1168 }
1169
1170 /**
1171  * Replace xorps r,r and xorpd r,r by pxor r,r
1172  */
1173 static void peephole_ia32_xZero(ir_node *xor) {
1174         set_irn_op(xor, op_ia32_xPzero);
1175 }
1176
1177 /**
1178  * Register a peephole optimisation function.
1179  */
1180 static void register_peephole_optimisation(ir_op *op, peephole_opt_func func) {
1181         assert(op->ops.generic == NULL);
1182         op->ops.generic = (op_func)func;
1183 }
1184
1185 /* Perform peephole-optimizations. */
1186 void ia32_peephole_optimization(ia32_code_gen_t *new_cg)
1187 {
1188         cg       = new_cg;
1189         arch_env = cg->arch_env;
1190
1191         /* register peephole optimisations */
1192         clear_irp_opcodes_generic_func();
1193         register_peephole_optimisation(op_ia32_Const,    peephole_ia32_Const);
1194         register_peephole_optimisation(op_be_IncSP,      peephole_be_IncSP);
1195         register_peephole_optimisation(op_ia32_Lea,      peephole_ia32_Lea);
1196         register_peephole_optimisation(op_ia32_Cmp,      peephole_ia32_Cmp);
1197         register_peephole_optimisation(op_ia32_Cmp8Bit,  peephole_ia32_Cmp);
1198         register_peephole_optimisation(op_ia32_Test,     peephole_ia32_Test);
1199         register_peephole_optimisation(op_ia32_Test8Bit, peephole_ia32_Test);
1200         register_peephole_optimisation(op_be_Return,     peephole_ia32_Return);
1201         if (! ia32_cg_config.use_imul_mem_imm32)
1202                 register_peephole_optimisation(op_ia32_IMul, peephole_ia32_Imul_split);
1203         if (ia32_cg_config.use_pxor)
1204                 register_peephole_optimisation(op_ia32_xZero, peephole_ia32_xZero);
1205
1206         be_peephole_opt(cg->birg);
1207 }
1208
1209 /**
1210  * Removes node from schedule if it is not used anymore. If irn is a mode_T node
1211  * all it's Projs are removed as well.
1212  * @param irn  The irn to be removed from schedule
1213  */
1214 static INLINE void try_kill(ir_node *node)
1215 {
1216         if(get_irn_mode(node) == mode_T) {
1217                 const ir_edge_t *edge, *next;
1218                 foreach_out_edge_safe(node, edge, next) {
1219                         ir_node *proj = get_edge_src_irn(edge);
1220                         try_kill(proj);
1221                 }
1222         }
1223
1224         if(get_irn_n_edges(node) != 0)
1225                 return;
1226
1227         if (sched_is_scheduled(node)) {
1228                 sched_remove(node);
1229         }
1230
1231         kill_node(node);
1232 }
1233
1234 static void optimize_conv_store(ir_node *node)
1235 {
1236         ir_node *pred;
1237         ir_node *pred_proj;
1238         ir_mode *conv_mode;
1239         ir_mode *store_mode;
1240
1241         if(!is_ia32_Store(node) && !is_ia32_Store8Bit(node))
1242                 return;
1243
1244         assert(n_ia32_Store_val == n_ia32_Store8Bit_val);
1245         pred_proj = get_irn_n(node, n_ia32_Store_val);
1246         if(is_Proj(pred_proj)) {
1247                 pred = get_Proj_pred(pred_proj);
1248         } else {
1249                 pred = pred_proj;
1250         }
1251         if(!is_ia32_Conv_I2I(pred) && !is_ia32_Conv_I2I8Bit(pred))
1252                 return;
1253         if(get_ia32_op_type(pred) != ia32_Normal)
1254                 return;
1255
1256         /* the store only stores the lower bits, so we only need the conv
1257          * it it shrinks the mode */
1258         conv_mode  = get_ia32_ls_mode(pred);
1259         store_mode = get_ia32_ls_mode(node);
1260         if(get_mode_size_bits(conv_mode) < get_mode_size_bits(store_mode))
1261                 return;
1262
1263         set_irn_n(node, n_ia32_Store_val, get_irn_n(pred, n_ia32_Conv_I2I_val));
1264         if(get_irn_n_edges(pred_proj) == 0) {
1265                 kill_node(pred_proj);
1266                 if(pred != pred_proj)
1267                         kill_node(pred);
1268         }
1269 }
1270
1271 static void optimize_load_conv(ir_node *node)
1272 {
1273         ir_node *pred, *predpred;
1274         ir_mode *load_mode;
1275         ir_mode *conv_mode;
1276
1277         if (!is_ia32_Conv_I2I(node) && !is_ia32_Conv_I2I8Bit(node))
1278                 return;
1279
1280         assert(n_ia32_Conv_I2I_val == n_ia32_Conv_I2I8Bit_val);
1281         pred = get_irn_n(node, n_ia32_Conv_I2I_val);
1282         if(!is_Proj(pred))
1283                 return;
1284
1285         predpred = get_Proj_pred(pred);
1286         if(!is_ia32_Load(predpred))
1287                 return;
1288
1289         /* the load is sign extending the upper bits, so we only need the conv
1290          * if it shrinks the mode */
1291         load_mode = get_ia32_ls_mode(predpred);
1292         conv_mode = get_ia32_ls_mode(node);
1293         if(get_mode_size_bits(conv_mode) < get_mode_size_bits(load_mode))
1294                 return;
1295
1296         if(get_mode_sign(conv_mode) != get_mode_sign(load_mode)) {
1297                 /* change the load if it has only 1 user */
1298                 if(get_irn_n_edges(pred) == 1) {
1299                         ir_mode *newmode;
1300                         if(get_mode_sign(conv_mode)) {
1301                                 newmode = find_signed_mode(load_mode);
1302                         } else {
1303                                 newmode = find_unsigned_mode(load_mode);
1304                         }
1305                         assert(newmode != NULL);
1306                         set_ia32_ls_mode(predpred, newmode);
1307                 } else {
1308                         /* otherwise we have to keep the conv */
1309                         return;
1310                 }
1311         }
1312
1313         /* kill the conv */
1314         exchange(node, pred);
1315 }
1316
1317 static void optimize_conv_conv(ir_node *node)
1318 {
1319         ir_node *pred_proj, *pred, *result_conv;
1320         ir_mode *pred_mode, *conv_mode;
1321         int      conv_mode_bits;
1322         int      pred_mode_bits;
1323
1324         if (!is_ia32_Conv_I2I(node) && !is_ia32_Conv_I2I8Bit(node))
1325                 return;
1326
1327         assert(n_ia32_Conv_I2I_val == n_ia32_Conv_I2I8Bit_val);
1328         pred_proj = get_irn_n(node, n_ia32_Conv_I2I_val);
1329         if(is_Proj(pred_proj))
1330                 pred = get_Proj_pred(pred_proj);
1331         else
1332                 pred = pred_proj;
1333
1334         if(!is_ia32_Conv_I2I(pred) && !is_ia32_Conv_I2I8Bit(pred))
1335                 return;
1336
1337         /* we know that after a conv, the upper bits are sign extended
1338          * so we only need the 2nd conv if it shrinks the mode */
1339         conv_mode      = get_ia32_ls_mode(node);
1340         conv_mode_bits = get_mode_size_bits(conv_mode);
1341         pred_mode      = get_ia32_ls_mode(pred);
1342         pred_mode_bits = get_mode_size_bits(pred_mode);
1343
1344         if(conv_mode_bits == pred_mode_bits
1345                         && get_mode_sign(conv_mode) == get_mode_sign(pred_mode)) {
1346                 result_conv = pred_proj;
1347         } else if(conv_mode_bits <= pred_mode_bits) {
1348                 /* if 2nd conv is smaller then first conv, then we can always take the
1349                  * 2nd conv */
1350                 if(get_irn_n_edges(pred_proj) == 1) {
1351                         result_conv = pred_proj;
1352                         set_ia32_ls_mode(pred, conv_mode);
1353
1354                         /* Argh:We must change the opcode to 8bit AND copy the register constraints */
1355                         if (get_mode_size_bits(conv_mode) == 8) {
1356                                 set_irn_op(pred, op_ia32_Conv_I2I8Bit);
1357                                 set_ia32_in_req_all(pred, get_ia32_in_req_all(node));
1358                         }
1359                 } else {
1360                         /* we don't want to end up with 2 loads, so we better do nothing */
1361                         if(get_irn_mode(pred) == mode_T) {
1362                                 return;
1363                         }
1364
1365                         result_conv = exact_copy(pred);
1366                         set_ia32_ls_mode(result_conv, conv_mode);
1367
1368                         /* Argh:We must change the opcode to 8bit AND copy the register constraints */
1369                         if (get_mode_size_bits(conv_mode) == 8) {
1370                                 set_irn_op(result_conv, op_ia32_Conv_I2I8Bit);
1371                                 set_ia32_in_req_all(result_conv, get_ia32_in_req_all(node));
1372                         }
1373                 }
1374         } else {
1375                 /* if both convs have the same sign, then we can take the smaller one */
1376                 if(get_mode_sign(conv_mode) == get_mode_sign(pred_mode)) {
1377                         result_conv = pred_proj;
1378                 } else {
1379                         /* no optimisation possible if smaller conv is sign-extend */
1380                         if(mode_is_signed(pred_mode)) {
1381                                 return;
1382                         }
1383                         /* we can take the smaller conv if it is unsigned */
1384                         result_conv = pred_proj;
1385                 }
1386         }
1387
1388         /* kill the conv */
1389         exchange(node, result_conv);
1390
1391         if(get_irn_n_edges(pred_proj) == 0) {
1392                 kill_node(pred_proj);
1393                 if(pred != pred_proj)
1394                         kill_node(pred);
1395         }
1396         optimize_conv_conv(result_conv);
1397 }
1398
1399 static void optimize_node(ir_node *node, void *env)
1400 {
1401         (void) env;
1402
1403         optimize_load_conv(node);
1404         optimize_conv_store(node);
1405         optimize_conv_conv(node);
1406 }
1407
1408 /**
1409  * Performs conv and address mode optimization.
1410  */
1411 void ia32_optimize_graph(ia32_code_gen_t *cg)
1412 {
1413         irg_walk_blkwise_graph(cg->irg, NULL, optimize_node, cg);
1414
1415         if (cg->dump)
1416                 be_dump(cg->irg, "-opt", dump_ir_block_graph_sched);
1417 }
1418
1419 void ia32_init_optimize(void)
1420 {
1421         FIRM_DBG_REGISTER(dbg, "firm.be.ia32.optimize");
1422 }