2010-08-09 23:59:04 +00:00
|
|
|
//===-- PeepholeOptimizer.cpp - Peephole Optimizations --------------------===//
|
2010-01-13 00:30:23 +00:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
2010-01-13 07:59:13 +00:00
|
|
|
//
|
2010-08-09 23:59:04 +00:00
|
|
|
// Perform peephole optimizations on the machine code:
|
2010-01-13 07:59:13 +00:00
|
|
|
//
|
2010-08-09 23:59:04 +00:00
|
|
|
// - Optimize Extensions
|
2010-01-13 07:59:13 +00:00
|
|
|
//
|
2010-08-09 23:59:04 +00:00
|
|
|
// Optimization of sign / zero extension instructions. It may be extended to
|
|
|
|
// handle other instructions with similar properties.
|
|
|
|
//
|
|
|
|
// On some targets, some instructions, e.g. X86 sign / zero extension, may
|
|
|
|
// leave the source value in the lower part of the result. This optimization
|
|
|
|
// will replace some uses of the pre-extension value with uses of the
|
|
|
|
// sub-register of the results.
|
|
|
|
//
|
|
|
|
// - Optimize Comparisons
|
|
|
|
//
|
|
|
|
// Optimization of comparison instructions. For instance, in this code:
|
|
|
|
//
|
|
|
|
// sub r1, 1
|
|
|
|
// cmp r1, 0
|
|
|
|
// bz L1
|
|
|
|
//
|
|
|
|
// If the "sub" instruction all ready sets (or could be modified to set) the
|
|
|
|
// same flag that the "cmp" instruction sets and that "bz" uses, then we can
|
|
|
|
// eliminate the "cmp" instruction.
|
|
|
|
//
|
2010-01-13 07:59:13 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2010-01-13 00:30:23 +00:00
|
|
|
|
2010-08-09 23:59:04 +00:00
|
|
|
#define DEBUG_TYPE "peephole-opt"
|
2010-01-13 00:30:23 +00:00
|
|
|
#include "llvm/CodeGen/Passes.h"
|
|
|
|
#include "llvm/CodeGen/MachineDominators.h"
|
|
|
|
#include "llvm/CodeGen/MachineInstrBuilder.h"
|
|
|
|
#include "llvm/CodeGen/MachineRegisterInfo.h"
|
|
|
|
#include "llvm/Target/TargetInstrInfo.h"
|
|
|
|
#include "llvm/Target/TargetRegisterInfo.h"
|
|
|
|
#include "llvm/Support/CommandLine.h"
|
2010-11-17 20:13:28 +00:00
|
|
|
#include "llvm/ADT/DenseMap.h"
|
2010-01-13 00:30:23 +00:00
|
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
2010-11-17 20:13:28 +00:00
|
|
|
#include "llvm/ADT/SmallSet.h"
|
2010-01-13 00:30:23 +00:00
|
|
|
#include "llvm/ADT/Statistic.h"
|
|
|
|
using namespace llvm;
|
|
|
|
|
2010-08-09 23:59:04 +00:00
|
|
|
// Optimize Extensions
|
|
|
|
static cl::opt<bool>
|
|
|
|
Aggressive("aggressive-ext-opt", cl::Hidden,
|
|
|
|
cl::desc("Aggressive extension optimization"));
|
2010-01-13 00:30:23 +00:00
|
|
|
|
When we look at instructions to convert to setting the 's' flag, we need to look
at more than those which define CPSR. You can have this situation:
(1) subs ...
(2) sub r6, r5, r4
(3) movge ...
(4) cmp r6, 0
(5) movge ...
We cannot convert (2) to "subs" because (3) is using the CPSR set by
(1). There's an analogous situation here:
(1) sub r1, r2, r3
(2) sub r4, r5, r6
(3) cmp r4, ...
(5) movge ...
(6) cmp r1, ...
(7) movge ...
We cannot convert (1) to "subs" because of the intervening use of CPSR.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@117950 91177308-0d34-0410-b5e6-96231b3b80d8
2010-11-01 20:41:43 +00:00
|
|
|
static cl::opt<bool>
|
|
|
|
DisablePeephole("disable-peephole", cl::Hidden, cl::init(false),
|
|
|
|
cl::desc("Disable the peephole optimizer"));
|
|
|
|
|
2010-08-27 20:39:09 +00:00
|
|
|
STATISTIC(NumReuse, "Number of extension results reused");
|
2010-08-09 23:59:04 +00:00
|
|
|
STATISTIC(NumEliminated, "Number of compares eliminated");
|
2010-11-17 20:13:28 +00:00
|
|
|
STATISTIC(NumImmFold, "Number of move immediate foled");
|
2010-08-09 23:59:04 +00:00
|
|
|
|
2010-01-13 00:30:23 +00:00
|
|
|
namespace {
|
2010-08-09 23:59:04 +00:00
|
|
|
class PeepholeOptimizer : public MachineFunctionPass {
|
2010-01-13 00:30:23 +00:00
|
|
|
const TargetMachine *TM;
|
|
|
|
const TargetInstrInfo *TII;
|
2010-08-09 23:59:04 +00:00
|
|
|
MachineRegisterInfo *MRI;
|
|
|
|
MachineDominatorTree *DT; // Machine dominator tree
|
2010-01-13 00:30:23 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
static char ID; // Pass identification
|
2010-10-19 17:21:58 +00:00
|
|
|
PeepholeOptimizer() : MachineFunctionPass(ID) {
|
|
|
|
initializePeepholeOptimizerPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
2010-01-13 00:30:23 +00:00
|
|
|
|
|
|
|
virtual bool runOnMachineFunction(MachineFunction &MF);
|
|
|
|
|
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
|
|
|
AU.setPreservesCFG();
|
|
|
|
MachineFunctionPass::getAnalysisUsage(AU);
|
2010-01-13 07:59:13 +00:00
|
|
|
if (Aggressive) {
|
|
|
|
AU.addRequired<MachineDominatorTree>();
|
|
|
|
AU.addPreserved<MachineDominatorTree>();
|
|
|
|
}
|
2010-01-13 00:30:23 +00:00
|
|
|
}
|
2010-01-13 07:59:13 +00:00
|
|
|
|
|
|
|
private:
|
2010-11-15 21:20:45 +00:00
|
|
|
bool OptimizeCmpInstr(MachineInstr *MI, MachineBasicBlock *MBB);
|
2010-08-09 23:59:04 +00:00
|
|
|
bool OptimizeExtInstr(MachineInstr *MI, MachineBasicBlock *MBB,
|
|
|
|
SmallPtrSet<MachineInstr*, 8> &LocalMIs);
|
2010-11-17 20:13:28 +00:00
|
|
|
bool isMoveImmediate(MachineInstr *MI,
|
|
|
|
SmallSet<unsigned, 4> &ImmDefRegs,
|
|
|
|
DenseMap<unsigned, MachineInstr*> &ImmDefMIs);
|
|
|
|
bool FoldImmediate(MachineInstr *MI, MachineBasicBlock *MBB,
|
|
|
|
SmallSet<unsigned, 4> &ImmDefRegs,
|
|
|
|
DenseMap<unsigned, MachineInstr*> &ImmDefMIs);
|
2010-01-13 00:30:23 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2010-08-09 23:59:04 +00:00
|
|
|
char PeepholeOptimizer::ID = 0;
|
2010-10-12 19:48:12 +00:00
|
|
|
INITIALIZE_PASS_BEGIN(PeepholeOptimizer, "peephole-opts",
|
|
|
|
"Peephole Optimizations", false, false)
|
|
|
|
INITIALIZE_PASS_DEPENDENCY(MachineDominatorTree)
|
|
|
|
INITIALIZE_PASS_END(PeepholeOptimizer, "peephole-opts",
|
2010-10-07 22:25:06 +00:00
|
|
|
"Peephole Optimizations", false, false)
|
2010-08-09 23:59:04 +00:00
|
|
|
|
|
|
|
FunctionPass *llvm::createPeepholeOptimizerPass() {
|
|
|
|
return new PeepholeOptimizer();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// OptimizeExtInstr - If instruction is a copy-like instruction, i.e. it reads
|
|
|
|
/// a single register and writes a single register and it does not modify the
|
|
|
|
/// source, and if the source value is preserved as a sub-register of the
|
|
|
|
/// result, then replace all reachable uses of the source with the subreg of the
|
|
|
|
/// result.
|
|
|
|
///
|
|
|
|
/// Do not generate an EXTRACT that is used only in a debug use, as this changes
|
|
|
|
/// the code. Since this code does not currently share EXTRACTs, just ignore all
|
|
|
|
/// debug uses.
|
|
|
|
bool PeepholeOptimizer::
|
|
|
|
OptimizeExtInstr(MachineInstr *MI, MachineBasicBlock *MBB,
|
|
|
|
SmallPtrSet<MachineInstr*, 8> &LocalMIs) {
|
2010-01-13 07:59:13 +00:00
|
|
|
unsigned SrcReg, DstReg, SubIdx;
|
2010-08-02 22:06:08 +00:00
|
|
|
if (!TII->isCoalescableExtInstr(*MI, SrcReg, DstReg, SubIdx))
|
|
|
|
return false;
|
2010-11-15 21:20:45 +00:00
|
|
|
|
2010-08-02 22:06:08 +00:00
|
|
|
if (TargetRegisterInfo::isPhysicalRegister(DstReg) ||
|
|
|
|
TargetRegisterInfo::isPhysicalRegister(SrcReg))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
MachineRegisterInfo::use_nodbg_iterator UI = MRI->use_nodbg_begin(SrcReg);
|
|
|
|
if (++UI == MRI->use_nodbg_end())
|
|
|
|
// No other uses.
|
|
|
|
return false;
|
|
|
|
|
2010-08-09 23:59:04 +00:00
|
|
|
// The source has other uses. See if we can replace the other uses with use of
|
|
|
|
// the result of the extension.
|
2010-08-02 22:06:08 +00:00
|
|
|
SmallPtrSet<MachineBasicBlock*, 4> ReachedBBs;
|
|
|
|
UI = MRI->use_nodbg_begin(DstReg);
|
|
|
|
for (MachineRegisterInfo::use_nodbg_iterator UE = MRI->use_nodbg_end();
|
|
|
|
UI != UE; ++UI)
|
|
|
|
ReachedBBs.insert(UI->getParent());
|
|
|
|
|
|
|
|
// Uses that are in the same BB of uses of the result of the instruction.
|
|
|
|
SmallVector<MachineOperand*, 8> Uses;
|
2010-08-09 23:59:04 +00:00
|
|
|
|
2010-08-02 22:06:08 +00:00
|
|
|
// Uses that the result of the instruction can reach.
|
|
|
|
SmallVector<MachineOperand*, 8> ExtendedUses;
|
|
|
|
|
2010-08-09 23:59:04 +00:00
|
|
|
bool ExtendLife = true;
|
2010-08-02 22:06:08 +00:00
|
|
|
UI = MRI->use_nodbg_begin(SrcReg);
|
|
|
|
for (MachineRegisterInfo::use_nodbg_iterator UE = MRI->use_nodbg_end();
|
|
|
|
UI != UE; ++UI) {
|
|
|
|
MachineOperand &UseMO = UI.getOperand();
|
|
|
|
MachineInstr *UseMI = &*UI;
|
|
|
|
if (UseMI == MI)
|
|
|
|
continue;
|
2010-08-09 23:59:04 +00:00
|
|
|
|
2010-08-02 22:06:08 +00:00
|
|
|
if (UseMI->isPHI()) {
|
|
|
|
ExtendLife = false;
|
|
|
|
continue;
|
|
|
|
}
|
2010-01-13 07:59:13 +00:00
|
|
|
|
2010-08-02 22:06:08 +00:00
|
|
|
// It's an error to translate this:
|
|
|
|
//
|
|
|
|
// %reg1025 = <sext> %reg1024
|
|
|
|
// ...
|
|
|
|
// %reg1026 = SUBREG_TO_REG 0, %reg1024, 4
|
|
|
|
//
|
|
|
|
// into this:
|
|
|
|
//
|
|
|
|
// %reg1025 = <sext> %reg1024
|
|
|
|
// ...
|
|
|
|
// %reg1027 = COPY %reg1025:4
|
|
|
|
// %reg1026 = SUBREG_TO_REG 0, %reg1027, 4
|
|
|
|
//
|
|
|
|
// The problem here is that SUBREG_TO_REG is there to assert that an
|
|
|
|
// implicit zext occurs. It doesn't insert a zext instruction. If we allow
|
|
|
|
// the COPY here, it will give us the value after the <sext>, not the
|
|
|
|
// original value of %reg1024 before <sext>.
|
|
|
|
if (UseMI->getOpcode() == TargetOpcode::SUBREG_TO_REG)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
MachineBasicBlock *UseMBB = UseMI->getParent();
|
|
|
|
if (UseMBB == MBB) {
|
|
|
|
// Local uses that come after the extension.
|
|
|
|
if (!LocalMIs.count(UseMI))
|
|
|
|
Uses.push_back(&UseMO);
|
2010-08-09 23:59:04 +00:00
|
|
|
} else if (ReachedBBs.count(UseMBB)) {
|
|
|
|
// Non-local uses where the result of the extension is used. Always
|
|
|
|
// replace these unless it's a PHI.
|
2010-08-02 22:06:08 +00:00
|
|
|
Uses.push_back(&UseMO);
|
2010-08-09 23:59:04 +00:00
|
|
|
} else if (Aggressive && DT->dominates(MBB, UseMBB)) {
|
|
|
|
// We may want to extend the live range of the extension result in order
|
|
|
|
// to replace these uses.
|
2010-08-02 22:06:08 +00:00
|
|
|
ExtendedUses.push_back(&UseMO);
|
2010-08-09 23:59:04 +00:00
|
|
|
} else {
|
2010-08-02 22:06:08 +00:00
|
|
|
// Both will be live out of the def MBB anyway. Don't extend live range of
|
|
|
|
// the extension result.
|
|
|
|
ExtendLife = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-01-13 07:59:13 +00:00
|
|
|
|
2010-08-02 22:06:08 +00:00
|
|
|
if (ExtendLife && !ExtendedUses.empty())
|
2010-08-09 23:59:04 +00:00
|
|
|
// Extend the liveness of the extension result.
|
2010-08-02 22:06:08 +00:00
|
|
|
std::copy(ExtendedUses.begin(), ExtendedUses.end(),
|
|
|
|
std::back_inserter(Uses));
|
2010-01-13 19:16:39 +00:00
|
|
|
|
2010-08-02 22:06:08 +00:00
|
|
|
// Now replace all uses.
|
|
|
|
bool Changed = false;
|
|
|
|
if (!Uses.empty()) {
|
|
|
|
SmallPtrSet<MachineBasicBlock*, 4> PHIBBs;
|
2010-08-09 23:59:04 +00:00
|
|
|
|
2010-08-02 22:06:08 +00:00
|
|
|
// Look for PHI uses of the extended result, we don't want to extend the
|
|
|
|
// liveness of a PHI input. It breaks all kinds of assumptions down
|
|
|
|
// stream. A PHI use is expected to be the kill of its source values.
|
|
|
|
UI = MRI->use_nodbg_begin(DstReg);
|
2010-08-09 23:59:04 +00:00
|
|
|
for (MachineRegisterInfo::use_nodbg_iterator
|
|
|
|
UE = MRI->use_nodbg_end(); UI != UE; ++UI)
|
2010-08-02 22:06:08 +00:00
|
|
|
if (UI->isPHI())
|
|
|
|
PHIBBs.insert(UI->getParent());
|
2010-06-09 19:00:55 +00:00
|
|
|
|
2010-08-02 22:06:08 +00:00
|
|
|
const TargetRegisterClass *RC = MRI->getRegClass(SrcReg);
|
|
|
|
for (unsigned i = 0, e = Uses.size(); i != e; ++i) {
|
|
|
|
MachineOperand *UseMO = Uses[i];
|
|
|
|
MachineInstr *UseMI = UseMO->getParent();
|
2010-01-13 07:59:13 +00:00
|
|
|
MachineBasicBlock *UseMBB = UseMI->getParent();
|
2010-08-02 22:06:08 +00:00
|
|
|
if (PHIBBs.count(UseMBB))
|
|
|
|
continue;
|
2010-08-09 23:59:04 +00:00
|
|
|
|
2010-08-02 22:06:08 +00:00
|
|
|
unsigned NewVR = MRI->createVirtualRegister(RC);
|
|
|
|
BuildMI(*UseMBB, UseMI, UseMI->getDebugLoc(),
|
|
|
|
TII->get(TargetOpcode::COPY), NewVR)
|
|
|
|
.addReg(DstReg, 0, SubIdx);
|
2010-08-09 23:59:04 +00:00
|
|
|
|
2010-08-02 22:06:08 +00:00
|
|
|
UseMO->setReg(NewVR);
|
|
|
|
++NumReuse;
|
|
|
|
Changed = true;
|
2010-01-13 07:59:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return Changed;
|
|
|
|
}
|
|
|
|
|
2010-08-09 23:59:04 +00:00
|
|
|
/// OptimizeCmpInstr - If the instruction is a compare and the previous
|
|
|
|
/// instruction it's comparing against all ready sets (or could be modified to
|
|
|
|
/// set) the same flag as the compare, then we can remove the comparison and use
|
|
|
|
/// the flag from the previous instruction.
|
|
|
|
bool PeepholeOptimizer::OptimizeCmpInstr(MachineInstr *MI,
|
2010-11-15 21:20:45 +00:00
|
|
|
MachineBasicBlock *MBB){
|
2010-08-09 23:59:04 +00:00
|
|
|
// If this instruction is a comparison against zero and isn't comparing a
|
|
|
|
// physical register, we can try to optimize it.
|
|
|
|
unsigned SrcReg;
|
2010-09-21 12:01:15 +00:00
|
|
|
int CmpMask, CmpValue;
|
|
|
|
if (!TII->AnalyzeCompare(MI, SrcReg, CmpMask, CmpValue) ||
|
2010-09-10 23:34:19 +00:00
|
|
|
TargetRegisterInfo::isPhysicalRegister(SrcReg))
|
2010-08-09 23:59:04 +00:00
|
|
|
return false;
|
|
|
|
|
2010-09-11 00:13:50 +00:00
|
|
|
// Attempt to optimize the comparison instruction.
|
2010-11-15 21:20:45 +00:00
|
|
|
if (TII->OptimizeCompareInstr(MI, SrcReg, CmpMask, CmpValue, MRI)) {
|
2010-08-09 23:59:04 +00:00
|
|
|
++NumEliminated;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-11-17 20:13:28 +00:00
|
|
|
bool PeepholeOptimizer::isMoveImmediate(MachineInstr *MI,
|
|
|
|
SmallSet<unsigned, 4> &ImmDefRegs,
|
|
|
|
DenseMap<unsigned, MachineInstr*> &ImmDefMIs) {
|
|
|
|
const TargetInstrDesc &TID = MI->getDesc();
|
|
|
|
if (!TID.isMoveImmediate())
|
|
|
|
return false;
|
|
|
|
if (TID.getNumDefs() != 1)
|
|
|
|
return false;
|
|
|
|
unsigned Reg = MI->getOperand(0).getReg();
|
|
|
|
if (TargetRegisterInfo::isVirtualRegister(Reg)) {
|
|
|
|
ImmDefMIs.insert(std::make_pair(Reg, MI));
|
|
|
|
ImmDefRegs.insert(Reg);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// FoldImmediate - Try folding register operands that are defined by move
|
|
|
|
/// immediate instructions, i.e. a trivial constant folding optimization, if
|
|
|
|
/// and only if the def and use are in the same BB.
|
|
|
|
bool PeepholeOptimizer::FoldImmediate(MachineInstr *MI, MachineBasicBlock *MBB,
|
|
|
|
SmallSet<unsigned, 4> &ImmDefRegs,
|
|
|
|
DenseMap<unsigned, MachineInstr*> &ImmDefMIs) {
|
|
|
|
for (unsigned i = 0, e = MI->getDesc().getNumOperands(); i != e; ++i) {
|
|
|
|
MachineOperand &MO = MI->getOperand(i);
|
|
|
|
if (!MO.isReg() || MO.isDef())
|
|
|
|
continue;
|
|
|
|
unsigned Reg = MO.getReg();
|
2011-01-10 02:58:51 +00:00
|
|
|
if (!TargetRegisterInfo::isVirtualRegister(Reg))
|
2010-11-17 20:13:28 +00:00
|
|
|
continue;
|
|
|
|
if (ImmDefRegs.count(Reg) == 0)
|
|
|
|
continue;
|
|
|
|
DenseMap<unsigned, MachineInstr*>::iterator II = ImmDefMIs.find(Reg);
|
|
|
|
assert(II != ImmDefMIs.end());
|
|
|
|
if (TII->FoldImmediate(MI, II->second, Reg, MRI)) {
|
|
|
|
++NumImmFold;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-08-09 23:59:04 +00:00
|
|
|
bool PeepholeOptimizer::runOnMachineFunction(MachineFunction &MF) {
|
2010-11-15 21:20:45 +00:00
|
|
|
if (DisablePeephole)
|
|
|
|
return false;
|
|
|
|
|
2010-08-09 23:59:04 +00:00
|
|
|
TM = &MF.getTarget();
|
2010-01-13 00:30:23 +00:00
|
|
|
TII = TM->getInstrInfo();
|
|
|
|
MRI = &MF.getRegInfo();
|
2010-08-09 23:59:04 +00:00
|
|
|
DT = Aggressive ? &getAnalysis<MachineDominatorTree>() : 0;
|
2010-01-13 00:30:23 +00:00
|
|
|
|
|
|
|
bool Changed = false;
|
|
|
|
|
|
|
|
SmallPtrSet<MachineInstr*, 8> LocalMIs;
|
2010-11-17 20:13:28 +00:00
|
|
|
SmallSet<unsigned, 4> ImmDefRegs;
|
|
|
|
DenseMap<unsigned, MachineInstr*> ImmDefMIs;
|
2010-01-13 00:30:23 +00:00
|
|
|
for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I) {
|
|
|
|
MachineBasicBlock *MBB = &*I;
|
2010-11-17 20:13:28 +00:00
|
|
|
|
|
|
|
bool SeenMoveImm = false;
|
2010-01-13 07:59:13 +00:00
|
|
|
LocalMIs.clear();
|
2010-11-17 20:13:28 +00:00
|
|
|
ImmDefRegs.clear();
|
|
|
|
ImmDefMIs.clear();
|
2010-08-09 23:59:04 +00:00
|
|
|
|
2011-02-15 05:00:24 +00:00
|
|
|
bool First = true;
|
|
|
|
MachineBasicBlock::iterator PMII;
|
2010-08-09 23:59:04 +00:00
|
|
|
for (MachineBasicBlock::iterator
|
2010-09-10 21:55:43 +00:00
|
|
|
MII = I->begin(), MIE = I->end(); MII != MIE; ) {
|
2011-02-14 21:50:37 +00:00
|
|
|
MachineInstr *MI = &*MII;
|
2010-11-15 21:20:45 +00:00
|
|
|
LocalMIs.insert(MI);
|
|
|
|
|
2011-01-07 21:08:26 +00:00
|
|
|
if (MI->isLabel() || MI->isPHI() || MI->isImplicitDef() ||
|
|
|
|
MI->isKill() || MI->isInlineAsm() || MI->isDebugValue() ||
|
2011-02-14 21:50:37 +00:00
|
|
|
MI->hasUnmodeledSideEffects()) {
|
|
|
|
++MII;
|
2010-11-15 21:20:45 +00:00
|
|
|
continue;
|
2011-02-14 21:50:37 +00:00
|
|
|
}
|
2010-11-15 21:20:45 +00:00
|
|
|
|
|
|
|
if (MI->getDesc().isCompare()) {
|
2011-02-14 21:50:37 +00:00
|
|
|
if (OptimizeCmpInstr(MI, MBB)) {
|
|
|
|
// MI is deleted.
|
|
|
|
Changed = true;
|
2011-02-15 05:00:24 +00:00
|
|
|
MII = First ? I->begin() : llvm::next(PMII);
|
2011-02-14 21:50:37 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isMoveImmediate(MI, ImmDefRegs, ImmDefMIs)) {
|
2010-11-17 20:13:28 +00:00
|
|
|
SeenMoveImm = true;
|
2010-08-09 23:59:04 +00:00
|
|
|
} else {
|
|
|
|
Changed |= OptimizeExtInstr(MI, MBB, LocalMIs);
|
2010-11-17 20:13:28 +00:00
|
|
|
if (SeenMoveImm)
|
|
|
|
Changed |= FoldImmediate(MI, MBB, ImmDefRegs, ImmDefMIs);
|
2010-08-09 23:59:04 +00:00
|
|
|
}
|
2011-02-15 05:00:24 +00:00
|
|
|
|
|
|
|
First = false;
|
2011-02-14 21:50:37 +00:00
|
|
|
PMII = MII;
|
|
|
|
++MII;
|
2010-01-13 00:30:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return Changed;
|
|
|
|
}
|