Replace TargetInstrInfo::isInvariantLoad and its target-specific
implementations with a new MachineInstr::isInvariantLoad, which uses MachineMemOperands and is target-independent. This brings MachineLICM and other functionality to targets which previously lacked an isInvariantLoad implementation. llvm-svn: 83475
This commit is contained in:
parent
db9493ce68
commit
be8137b0b4
|
@ -26,6 +26,7 @@
|
||||||
|
|
||||||
namespace llvm {
|
namespace llvm {
|
||||||
|
|
||||||
|
class AliasAnalysis;
|
||||||
class TargetInstrDesc;
|
class TargetInstrDesc;
|
||||||
class TargetInstrInfo;
|
class TargetInstrInfo;
|
||||||
class TargetRegisterInfo;
|
class TargetRegisterInfo;
|
||||||
|
@ -286,6 +287,13 @@ public:
|
||||||
/// have no volatile memory references.
|
/// have no volatile memory references.
|
||||||
bool hasVolatileMemoryRef() const;
|
bool hasVolatileMemoryRef() const;
|
||||||
|
|
||||||
|
/// isInvariantLoad - Return true if this instruction is loading from a
|
||||||
|
/// location whose value is invariant across the function. For example,
|
||||||
|
/// loading a value from the constant pool or from from the argument area of
|
||||||
|
/// a function if it does not change. This should only return true of *all*
|
||||||
|
/// loads the instruction does are invariant (if it does multiple loads).
|
||||||
|
bool isInvariantLoad(AliasAnalysis *AA = 0) const;
|
||||||
|
|
||||||
//
|
//
|
||||||
// Debugging support
|
// Debugging support
|
||||||
//
|
//
|
||||||
|
|
|
@ -157,16 +157,6 @@ public:
|
||||||
unsigned DestReg, unsigned SubIdx,
|
unsigned DestReg, unsigned SubIdx,
|
||||||
const MachineInstr *Orig) const = 0;
|
const MachineInstr *Orig) const = 0;
|
||||||
|
|
||||||
/// isInvariantLoad - Return true if the specified instruction (which is
|
|
||||||
/// marked mayLoad) is loading from a location whose value is invariant across
|
|
||||||
/// the function. For example, loading a value from the constant pool or from
|
|
||||||
/// from the argument area of a function if it does not change. This should
|
|
||||||
/// only return true of *all* loads the instruction does are invariant (if it
|
|
||||||
/// does multiple loads).
|
|
||||||
virtual bool isInvariantLoad(const MachineInstr *MI) const {
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// convertToThreeAddress - This method must be implemented by targets that
|
/// convertToThreeAddress - This method must be implemented by targets that
|
||||||
/// set the M_CONVERTIBLE_TO_3_ADDR flag. When this flag is set, the target
|
/// set the M_CONVERTIBLE_TO_3_ADDR flag. When this flag is set, the target
|
||||||
/// may be able to convert a two-address instruction into one or more true
|
/// may be able to convert a two-address instruction into one or more true
|
||||||
|
|
|
@ -24,6 +24,7 @@
|
||||||
#include "llvm/Target/TargetInstrInfo.h"
|
#include "llvm/Target/TargetInstrInfo.h"
|
||||||
#include "llvm/Target/TargetInstrDesc.h"
|
#include "llvm/Target/TargetInstrDesc.h"
|
||||||
#include "llvm/Target/TargetRegisterInfo.h"
|
#include "llvm/Target/TargetRegisterInfo.h"
|
||||||
|
#include "llvm/Analysis/AliasAnalysis.h"
|
||||||
#include "llvm/Analysis/DebugInfo.h"
|
#include "llvm/Analysis/DebugInfo.h"
|
||||||
#include "llvm/Support/ErrorHandling.h"
|
#include "llvm/Support/ErrorHandling.h"
|
||||||
#include "llvm/Support/LeakDetector.h"
|
#include "llvm/Support/LeakDetector.h"
|
||||||
|
@ -946,7 +947,7 @@ bool MachineInstr::isSafeToMove(const TargetInstrInfo *TII,
|
||||||
// destination. The check for isInvariantLoad gives the targe the chance to
|
// destination. The check for isInvariantLoad gives the targe the chance to
|
||||||
// classify the load as always returning a constant, e.g. a constant pool
|
// classify the load as always returning a constant, e.g. a constant pool
|
||||||
// load.
|
// load.
|
||||||
if (TID->mayLoad() && !TII->isInvariantLoad(this))
|
if (TID->mayLoad() && !isInvariantLoad())
|
||||||
// Otherwise, this is a real load. If there is a store between the load and
|
// Otherwise, this is a real load. If there is a store between the load and
|
||||||
// end of block, or if the load is volatile, we can't move it.
|
// end of block, or if the load is volatile, we can't move it.
|
||||||
return !SawStore && !hasVolatileMemoryRef();
|
return !SawStore && !hasVolatileMemoryRef();
|
||||||
|
@ -1005,6 +1006,46 @@ bool MachineInstr::hasVolatileMemoryRef() const {
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// isInvariantLoad - Return true if this instruction is loading from a
|
||||||
|
/// location whose value is invariant across the function. For example,
|
||||||
|
/// loading a value from the constant pool or from from the argument area
|
||||||
|
/// of a function if it does not change. This should only return true of
|
||||||
|
/// *all* loads the instruction does are invariant (if it does multiple loads).
|
||||||
|
bool MachineInstr::isInvariantLoad(AliasAnalysis *AA) const {
|
||||||
|
// If the instruction doesn't load at all, it isn't an invariant load.
|
||||||
|
if (!TID->mayLoad())
|
||||||
|
return false;
|
||||||
|
|
||||||
|
// If the instruction has lost its memoperands, conservatively assume that
|
||||||
|
// it may not be an invariant load.
|
||||||
|
if (memoperands_empty())
|
||||||
|
return false;
|
||||||
|
|
||||||
|
const MachineFrameInfo *MFI = getParent()->getParent()->getFrameInfo();
|
||||||
|
|
||||||
|
for (mmo_iterator I = memoperands_begin(),
|
||||||
|
E = memoperands_end(); I != E; ++I) {
|
||||||
|
if ((*I)->isVolatile()) return false;
|
||||||
|
if ((*I)->isStore()) return false;
|
||||||
|
|
||||||
|
if (const Value *V = (*I)->getValue()) {
|
||||||
|
// A load from a constant PseudoSourceValue is invariant.
|
||||||
|
if (const PseudoSourceValue *PSV = dyn_cast<PseudoSourceValue>(V))
|
||||||
|
if (PSV->isConstant(MFI))
|
||||||
|
continue;
|
||||||
|
// If we have an AliasAnalysis, ask it whether the memory is constant.
|
||||||
|
if (AA && AA->pointsToConstantMemory(V))
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Otherwise assume conservatively.
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Everything checks out.
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
void MachineInstr::dump() const {
|
void MachineInstr::dump() const {
|
||||||
errs() << " " << *this;
|
errs() << " " << *this;
|
||||||
}
|
}
|
||||||
|
|
|
@ -28,6 +28,7 @@
|
||||||
#include "llvm/Target/TargetRegisterInfo.h"
|
#include "llvm/Target/TargetRegisterInfo.h"
|
||||||
#include "llvm/Target/TargetInstrInfo.h"
|
#include "llvm/Target/TargetInstrInfo.h"
|
||||||
#include "llvm/Target/TargetMachine.h"
|
#include "llvm/Target/TargetMachine.h"
|
||||||
|
#include "llvm/Analysis/AliasAnalysis.h"
|
||||||
#include "llvm/ADT/DenseMap.h"
|
#include "llvm/ADT/DenseMap.h"
|
||||||
#include "llvm/ADT/Statistic.h"
|
#include "llvm/ADT/Statistic.h"
|
||||||
#include "llvm/Support/Compiler.h"
|
#include "llvm/Support/Compiler.h"
|
||||||
|
@ -47,6 +48,7 @@ namespace {
|
||||||
BitVector AllocatableSet;
|
BitVector AllocatableSet;
|
||||||
|
|
||||||
// Various analyses that we use...
|
// Various analyses that we use...
|
||||||
|
AliasAnalysis *AA; // Alias analysis info.
|
||||||
MachineLoopInfo *LI; // Current MachineLoopInfo
|
MachineLoopInfo *LI; // Current MachineLoopInfo
|
||||||
MachineDominatorTree *DT; // Machine dominator tree for the cur loop
|
MachineDominatorTree *DT; // Machine dominator tree for the cur loop
|
||||||
MachineRegisterInfo *RegInfo; // Machine register information
|
MachineRegisterInfo *RegInfo; // Machine register information
|
||||||
|
@ -72,6 +74,7 @@ namespace {
|
||||||
AU.setPreservesCFG();
|
AU.setPreservesCFG();
|
||||||
AU.addRequired<MachineLoopInfo>();
|
AU.addRequired<MachineLoopInfo>();
|
||||||
AU.addRequired<MachineDominatorTree>();
|
AU.addRequired<MachineDominatorTree>();
|
||||||
|
AU.addRequired<AliasAnalysis>();
|
||||||
AU.addPreserved<MachineLoopInfo>();
|
AU.addPreserved<MachineLoopInfo>();
|
||||||
AU.addPreserved<MachineDominatorTree>();
|
AU.addPreserved<MachineDominatorTree>();
|
||||||
MachineFunctionPass::getAnalysisUsage(AU);
|
MachineFunctionPass::getAnalysisUsage(AU);
|
||||||
|
@ -144,6 +147,7 @@ bool MachineLICM::runOnMachineFunction(MachineFunction &MF) {
|
||||||
// Get our Loop information...
|
// Get our Loop information...
|
||||||
LI = &getAnalysis<MachineLoopInfo>();
|
LI = &getAnalysis<MachineLoopInfo>();
|
||||||
DT = &getAnalysis<MachineDominatorTree>();
|
DT = &getAnalysis<MachineDominatorTree>();
|
||||||
|
AA = &getAnalysis<AliasAnalysis>();
|
||||||
|
|
||||||
for (MachineLoopInfo::iterator
|
for (MachineLoopInfo::iterator
|
||||||
I = LI->begin(), E = LI->end(); I != E; ++I) {
|
I = LI->begin(), E = LI->end(); I != E; ++I) {
|
||||||
|
@ -214,7 +218,7 @@ bool MachineLICM::IsLoopInvariantInst(MachineInstr &I) {
|
||||||
// Okay, this instruction does a load. As a refinement, we allow the target
|
// Okay, this instruction does a load. As a refinement, we allow the target
|
||||||
// to decide whether the loaded value is actually a constant. If so, we can
|
// to decide whether the loaded value is actually a constant. If so, we can
|
||||||
// actually use it as a load.
|
// actually use it as a load.
|
||||||
if (!TII->isInvariantLoad(&I))
|
if (!I.isInvariantLoad(AA))
|
||||||
// FIXME: we should be able to sink loads with no other side effects if
|
// FIXME: we should be able to sink loads with no other side effects if
|
||||||
// there is nothing that can change memory from here until the end of
|
// there is nothing that can change memory from here until the end of
|
||||||
// block. This is a trivial form of alias analysis.
|
// block. This is a trivial form of alias analysis.
|
||||||
|
@ -259,8 +263,6 @@ bool MachineLICM::IsLoopInvariantInst(MachineInstr &I) {
|
||||||
|
|
||||||
// Don't hoist an instruction that uses or defines a physical register.
|
// Don't hoist an instruction that uses or defines a physical register.
|
||||||
if (TargetRegisterInfo::isPhysicalRegister(Reg)) {
|
if (TargetRegisterInfo::isPhysicalRegister(Reg)) {
|
||||||
// If this is a physical register use, we can't move it. If it is a def,
|
|
||||||
// we can move it, but only if the def is dead.
|
|
||||||
if (MO.isUse()) {
|
if (MO.isUse()) {
|
||||||
// If the physreg has no defs anywhere, it's just an ambient register
|
// If the physreg has no defs anywhere, it's just an ambient register
|
||||||
// and we can freely move its uses. Alternatively, if it's allocatable,
|
// and we can freely move its uses. Alternatively, if it's allocatable,
|
||||||
|
|
|
@ -178,8 +178,6 @@ bool MachineSinking::SinkInstruction(MachineInstr *MI, bool &SawStore) {
|
||||||
if (Reg == 0) continue;
|
if (Reg == 0) continue;
|
||||||
|
|
||||||
if (TargetRegisterInfo::isPhysicalRegister(Reg)) {
|
if (TargetRegisterInfo::isPhysicalRegister(Reg)) {
|
||||||
// If this is a physical register use, we can't move it. If it is a def,
|
|
||||||
// we can move it, but only if the def is dead.
|
|
||||||
if (MO.isUse()) {
|
if (MO.isUse()) {
|
||||||
// If the physreg has no defs anywhere, it's just an ambient register
|
// If the physreg has no defs anywhere, it's just an ambient register
|
||||||
// and we can freely move its uses. Alternatively, if it's allocatable,
|
// and we can freely move its uses. Alternatively, if it's allocatable,
|
||||||
|
|
|
@ -375,7 +375,7 @@ void ScheduleDAGInstrs::BuildSchedGraph() {
|
||||||
// Treat all other stores conservatively.
|
// Treat all other stores conservatively.
|
||||||
goto new_chain;
|
goto new_chain;
|
||||||
} else if (TID.mayLoad()) {
|
} else if (TID.mayLoad()) {
|
||||||
if (TII->isInvariantLoad(MI)) {
|
if (MI->isInvariantLoad()) {
|
||||||
// Invariant load, no chain dependencies needed!
|
// Invariant load, no chain dependencies needed!
|
||||||
} else if (const Value *V = getUnderlyingObjectForInstr(MI)) {
|
} else if (const Value *V = getUnderlyingObjectForInstr(MI)) {
|
||||||
// A load from a specific PseudoSourceValue. Add precise dependencies.
|
// A load from a specific PseudoSourceValue. Add precise dependencies.
|
||||||
|
|
|
@ -266,30 +266,6 @@ unsigned SystemZInstrInfo::isStoreToStackSlot(const MachineInstr *MI,
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
bool SystemZInstrInfo::isInvariantLoad(const MachineInstr *MI) const {
|
|
||||||
for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
|
|
||||||
const MachineOperand &MO = MI->getOperand(i);
|
|
||||||
// Loads from constant pools are trivially invariant.
|
|
||||||
if (MO.isCPI())
|
|
||||||
return true;
|
|
||||||
|
|
||||||
if (MO.isGlobal())
|
|
||||||
return isGVStub(MO.getGlobal(), TM);
|
|
||||||
|
|
||||||
// If this is a load from an invariant stack slot, the load is a constant.
|
|
||||||
if (MO.isFI()) {
|
|
||||||
const MachineFrameInfo &MFI =
|
|
||||||
*MI->getParent()->getParent()->getFrameInfo();
|
|
||||||
int Idx = MO.getIndex();
|
|
||||||
return MFI.isFixedObjectIndex(Idx) && MFI.isImmutableObjectIndex(Idx);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// All other instances of these instructions are presumed to have other
|
|
||||||
// issues.
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool
|
bool
|
||||||
SystemZInstrInfo::spillCalleeSavedRegisters(MachineBasicBlock &MBB,
|
SystemZInstrInfo::spillCalleeSavedRegisters(MachineBasicBlock &MBB,
|
||||||
MachineBasicBlock::iterator MI,
|
MachineBasicBlock::iterator MI,
|
||||||
|
|
|
@ -70,7 +70,6 @@ public:
|
||||||
unsigned &SrcSubIdx, unsigned &DstSubIdx) const;
|
unsigned &SrcSubIdx, unsigned &DstSubIdx) const;
|
||||||
unsigned isLoadFromStackSlot(const MachineInstr *MI, int &FrameIndex) const;
|
unsigned isLoadFromStackSlot(const MachineInstr *MI, int &FrameIndex) const;
|
||||||
unsigned isStoreToStackSlot(const MachineInstr *MI, int &FrameIndex) const;
|
unsigned isStoreToStackSlot(const MachineInstr *MI, int &FrameIndex) const;
|
||||||
bool isInvariantLoad(const MachineInstr *MI) const;
|
|
||||||
|
|
||||||
virtual void storeRegToStackSlot(MachineBasicBlock &MBB,
|
virtual void storeRegToStackSlot(MachineBasicBlock &MBB,
|
||||||
MachineBasicBlock::iterator MI,
|
MachineBasicBlock::iterator MI,
|
||||||
|
|
|
@ -958,43 +958,6 @@ void X86InstrInfo::reMaterialize(MachineBasicBlock &MBB,
|
||||||
NewMI->getOperand(0).setSubReg(SubIdx);
|
NewMI->getOperand(0).setSubReg(SubIdx);
|
||||||
}
|
}
|
||||||
|
|
||||||
/// isInvariantLoad - Return true if the specified instruction (which is marked
|
|
||||||
/// mayLoad) is loading from a location whose value is invariant across the
|
|
||||||
/// function. For example, loading a value from the constant pool or from
|
|
||||||
/// from the argument area of a function if it does not change. This should
|
|
||||||
/// only return true of *all* loads the instruction does are invariant (if it
|
|
||||||
/// does multiple loads).
|
|
||||||
bool X86InstrInfo::isInvariantLoad(const MachineInstr *MI) const {
|
|
||||||
// This code cares about loads from three cases: constant pool entries,
|
|
||||||
// invariant argument slots, and global stubs. In order to handle these cases
|
|
||||||
// for all of the myriad of X86 instructions, we just scan for a CP/FI/GV
|
|
||||||
// operand and base our analysis on it. This is safe because the address of
|
|
||||||
// none of these three cases is ever used as anything other than a load base
|
|
||||||
// and X86 doesn't have any instructions that load from multiple places.
|
|
||||||
|
|
||||||
for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
|
|
||||||
const MachineOperand &MO = MI->getOperand(i);
|
|
||||||
// Loads from constant pools are trivially invariant.
|
|
||||||
if (MO.isCPI())
|
|
||||||
return true;
|
|
||||||
|
|
||||||
if (MO.isGlobal())
|
|
||||||
return isGlobalStubReference(MO.getTargetFlags());
|
|
||||||
|
|
||||||
// If this is a load from an invariant stack slot, the load is a constant.
|
|
||||||
if (MO.isFI()) {
|
|
||||||
const MachineFrameInfo &MFI =
|
|
||||||
*MI->getParent()->getParent()->getFrameInfo();
|
|
||||||
int Idx = MO.getIndex();
|
|
||||||
return MFI.isFixedObjectIndex(Idx) && MFI.isImmutableObjectIndex(Idx);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// All other instances of these instructions are presumed to have other
|
|
||||||
// issues.
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// hasLiveCondCodeDef - True if MI has a condition code def, e.g. EFLAGS, that
|
/// hasLiveCondCodeDef - True if MI has a condition code def, e.g. EFLAGS, that
|
||||||
/// is not marked dead.
|
/// is not marked dead.
|
||||||
static bool hasLiveCondCodeDef(MachineInstr *MI) {
|
static bool hasLiveCondCodeDef(MachineInstr *MI) {
|
||||||
|
|
|
@ -456,8 +456,6 @@ public:
|
||||||
unsigned DestReg, unsigned SubIdx,
|
unsigned DestReg, unsigned SubIdx,
|
||||||
const MachineInstr *Orig) const;
|
const MachineInstr *Orig) const;
|
||||||
|
|
||||||
bool isInvariantLoad(const MachineInstr *MI) const;
|
|
||||||
|
|
||||||
/// convertToThreeAddress - This method must be implemented by targets that
|
/// convertToThreeAddress - This method must be implemented by targets that
|
||||||
/// set the M_CONVERTIBLE_TO_3_ADDR flag. When this flag is set, the target
|
/// set the M_CONVERTIBLE_TO_3_ADDR flag. When this flag is set, the target
|
||||||
/// may be able to convert a two-address instruction into a true
|
/// may be able to convert a two-address instruction into a true
|
||||||
|
|
|
@ -116,30 +116,6 @@ XCoreInstrInfo::isStoreToStackSlot(const MachineInstr *MI,
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
/// isInvariantLoad - Return true if the specified instruction (which is marked
|
|
||||||
/// mayLoad) is loading from a location whose value is invariant across the
|
|
||||||
/// function. For example, loading a value from the constant pool or from
|
|
||||||
/// from the argument area of a function if it does not change. This should
|
|
||||||
/// only return true of *all* loads the instruction does are invariant (if it
|
|
||||||
/// does multiple loads).
|
|
||||||
bool
|
|
||||||
XCoreInstrInfo::isInvariantLoad(const MachineInstr *MI) const {
|
|
||||||
// Loads from constants pools and loads from invariant argument slots are
|
|
||||||
// invariant
|
|
||||||
int Opcode = MI->getOpcode();
|
|
||||||
if (Opcode == XCore::LDWCP_ru6 || Opcode == XCore::LDWCP_lru6) {
|
|
||||||
return MI->getOperand(1).isCPI();
|
|
||||||
}
|
|
||||||
int FrameIndex;
|
|
||||||
if (isLoadFromStackSlot(MI, FrameIndex)) {
|
|
||||||
const MachineFrameInfo &MFI =
|
|
||||||
*MI->getParent()->getParent()->getFrameInfo();
|
|
||||||
return MFI.isFixedObjectIndex(FrameIndex) &&
|
|
||||||
MFI.isImmutableObjectIndex(FrameIndex);
|
|
||||||
}
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
//===----------------------------------------------------------------------===//
|
//===----------------------------------------------------------------------===//
|
||||||
// Branch Analysis
|
// Branch Analysis
|
||||||
//===----------------------------------------------------------------------===//
|
//===----------------------------------------------------------------------===//
|
||||||
|
|
|
@ -52,8 +52,6 @@ public:
|
||||||
virtual unsigned isStoreToStackSlot(const MachineInstr *MI,
|
virtual unsigned isStoreToStackSlot(const MachineInstr *MI,
|
||||||
int &FrameIndex) const;
|
int &FrameIndex) const;
|
||||||
|
|
||||||
virtual bool isInvariantLoad(const MachineInstr *MI) const;
|
|
||||||
|
|
||||||
virtual bool AnalyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
|
virtual bool AnalyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
|
||||||
MachineBasicBlock *&FBB,
|
MachineBasicBlock *&FBB,
|
||||||
SmallVectorImpl<MachineOperand> &Cond,
|
SmallVectorImpl<MachineOperand> &Cond,
|
||||||
|
|
Loading…
Reference in New Issue