#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/Statistic.h"
-#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
-static cl::opt<bool> HoistLdConst("licm-const-load",
- cl::desc("LICM load from constant memory"),
- cl::init(false), cl::Hidden);
-
STATISTIC(NumHoisted, "Number of machine instructions hoisted out of loops");
STATISTIC(NumCSEed, "Number of hoisted machine instructions CSEed");
/// IsProfitableToHoist - Return true if it is potentially profitable to
/// hoist the given loop invariant.
- bool IsProfitableToHoist(MachineInstr &MI, bool &isConstLd);
+ bool IsProfitableToHoist(MachineInstr &MI);
/// HoistRegion - Walk the specified region of the CFG (defined by all
/// blocks dominated by the specified block, and that are in the current
/// loop.
///
bool MachineLICM::runOnMachineFunction(MachineFunction &MF) {
- DEBUG(errs() << "******** Machine LICM ********\n");
+ DEBUG(dbgs() << "******** Machine LICM ********\n");
Changed = FirstInLoop = false;
MCP = MF.getConstantPool();
}
DEBUG({
- errs() << "--- Checking if we can hoist " << I;
+ dbgs() << "--- Checking if we can hoist " << I;
if (I.getDesc().getImplicitUses()) {
- errs() << " * Instruction has implicit uses:\n";
+ dbgs() << " * Instruction has implicit uses:\n";
const TargetRegisterInfo *TRI = TM->getRegisterInfo();
for (const unsigned *ImpUses = I.getDesc().getImplicitUses();
*ImpUses; ++ImpUses)
- errs() << " -> " << TRI->getName(*ImpUses) << "\n";
+ dbgs() << " -> " << TRI->getName(*ImpUses) << "\n";
}
if (I.getDesc().getImplicitDefs()) {
- errs() << " * Instruction has implicit defines:\n";
+ dbgs() << " * Instruction has implicit defines:\n";
const TargetRegisterInfo *TRI = TM->getRegisterInfo();
for (const unsigned *ImpDefs = I.getDesc().getImplicitDefs();
*ImpDefs; ++ImpDefs)
- errs() << " -> " << TRI->getName(*ImpDefs) << "\n";
+ dbgs() << " -> " << TRI->getName(*ImpDefs) << "\n";
}
});
if (I.getDesc().getImplicitDefs() || I.getDesc().getImplicitUses()) {
- DEBUG(errs() << "Cannot hoist with implicit defines or uses\n");
+ DEBUG(dbgs() << "Cannot hoist with implicit defines or uses\n");
return false;
}
// If the loop contains the definition of an operand, then the instruction
// isn't loop invariant.
- if (CurLoop->contains(RegInfo->getVRegDef(Reg)->getParent()))
+ if (CurLoop->contains(RegInfo->getVRegDef(Reg)))
return false;
}
/// IsProfitableToHoist - Return true if it is potentially profitable to hoist
/// the given loop invariant.
-bool MachineLICM::IsProfitableToHoist(MachineInstr &MI, bool &isConstLd) {
- isConstLd = false;
-
+bool MachineLICM::IsProfitableToHoist(MachineInstr &MI) {
if (MI.getOpcode() == TargetInstrInfo::IMPLICIT_DEF)
return false;
// adding a store in the loop preheader. But the reload is no more expensive.
// The side benefit is these loads are frequently CSE'ed.
if (!TII->isTriviallyReMaterializable(&MI, AA)) {
- if (!HoistLdConst || !isLoadFromConstantMemory(&MI))
+ if (!isLoadFromConstantMemory(&MI))
return false;
- isConstLd = true;
}
// If result(s) of this instruction is used by PHIs, then don't hoist it.
MBB->insert(MI, NewMIs[1]);
// If unfolding produced a load that wasn't loop-invariant or profitable to
// hoist, discard the new instructions and bail.
- bool isConstLd;
- if (!IsLoopInvariantInst(*NewMIs[0]) ||
- !IsProfitableToHoist(*NewMIs[0], isConstLd)) {
+ if (!IsLoopInvariantInst(*NewMIs[0]) || !IsProfitableToHoist(*NewMIs[0])) {
NewMIs[0]->eraseFromParent();
NewMIs[1]->eraseFromParent();
return 0;
return false;
if (const MachineInstr *Dup = LookForDuplicate(MI, CI->second)) {
- DEBUG(errs() << "CSEing " << *MI << " with " << *Dup);
+ DEBUG(dbgs() << "CSEing " << *MI << " with " << *Dup);
for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
const MachineOperand &MO = MI->getOperand(i);
if (MO.isReg() && MO.isDef())
///
void MachineLICM::Hoist(MachineInstr *MI) {
// First check whether we should hoist this instruction.
- bool isConstLd;
- if (!IsLoopInvariantInst(*MI) ||
- !IsProfitableToHoist(*MI, isConstLd)) {
+ if (!IsLoopInvariantInst(*MI) || !IsProfitableToHoist(*MI)) {
// If not, try unfolding a hoistable load.
MI = ExtractHoistableLoad(MI);
if (!MI) return;
// Now move the instructions to the predecessor, inserting it before any
// terminator instructions.
DEBUG({
- errs() << "Hoisting ";
- if (isConstLd)
- errs() << "load from constant mem ";
- errs() << *MI;
+ dbgs() << "Hoisting " << *MI;
if (CurPreheader->getBasicBlock())
- errs() << " to MachineBasicBlock "
+ dbgs() << " to MachineBasicBlock "
<< CurPreheader->getName();
if (MI->getParent()->getBasicBlock())
- errs() << " from MachineBasicBlock "
+ dbgs() << " from MachineBasicBlock "
<< MI->getParent()->getName();
- errs() << "\n";
+ dbgs() << "\n";
});
// If this is the first instruction being hoisted to the preheader,