#include <LiveIntervalAnalysis.h>

Inheritance diagram for llvm::LiveIntervals:

Collaboration diagram for llvm::LiveIntervals:

Classes
class	HMEditor

Public Member Functions
	LiveIntervals ()

virtual	~LiveIntervals ()

LiveInterval &	getInterval (unsigned Reg)

const LiveInterval &	getInterval (unsigned Reg) const

bool	hasInterval (unsigned Reg) const

LiveInterval &	createEmptyInterval (unsigned Reg)

LiveInterval &	createAndComputeVirtRegInterval (unsigned Reg)

void	removeInterval (unsigned Reg)

LiveInterval::Segment	addSegmentToEndOfBlock (unsigned reg, MachineInstr *startInst)

bool	shrinkToUses (LiveInterval li, SmallVectorImpl< MachineInstr > *dead=0)

void	extendToIndices (LiveRange &LR, ArrayRef< SlotIndex > Indices)

void	pruneValue (LiveInterval LI, SlotIndex Kill, SmallVectorImpl< SlotIndex > EndPoints)

SlotIndexes *	getSlotIndexes () const

AliasAnalysis *	getAliasAnalysis () const

bool	isNotInMIMap (const MachineInstr *Instr) const

SlotIndex	getInstructionIndex (const MachineInstr *instr) const
	Returns the base index of the given instruction. More...

MachineInstr *	getInstructionFromIndex (SlotIndex index) const
	Returns the instruction associated with the given index. More...

SlotIndex	getMBBStartIdx (const MachineBasicBlock *mbb) const
	Return the first index in the given basic block. More...

SlotIndex	getMBBEndIdx (const MachineBasicBlock *mbb) const
	Return the last index in the given basic block. More...

bool	isLiveInToMBB (const LiveRange &LR, const MachineBasicBlock *mbb) const

bool	isLiveOutOfMBB (const LiveRange &LR, const MachineBasicBlock *mbb) const

MachineBasicBlock *	getMBBFromIndex (SlotIndex index) const

void	insertMBBInMaps (MachineBasicBlock *MBB)

SlotIndex	InsertMachineInstrInMaps (MachineInstr *MI)

void	InsertMachineInstrRangeInMaps (MachineBasicBlock::iterator B, MachineBasicBlock::iterator E)

void	RemoveMachineInstrFromMaps (MachineInstr *MI)

void	ReplaceMachineInstrInMaps (MachineInstr MI, MachineInstr NewMI)

bool	findLiveInMBBs (SlotIndex Start, SlotIndex End, SmallVectorImpl< MachineBasicBlock * > &MBBs) const

VNInfo::Allocator &	getVNInfoAllocator ()

virtual void	getAnalysisUsage (AnalysisUsage &AU) const

virtual void	releaseMemory ()

virtual bool	runOnMachineFunction (MachineFunction &)
	runOnMachineFunction - pass entry point More...

virtual void	print (raw_ostream &O, const Module *=0) const
	print - Implement the dump method. More...

MachineBasicBlock *	intervalIsInOneMBB (const LiveInterval &LI) const

bool	hasPHIKill (const LiveInterval &LI, const VNInfo *VNI) const

void	addKillFlags (const VirtRegMap *)

void	handleMove (MachineInstr *MI, bool UpdateFlags=false)

void	handleMoveIntoBundle (MachineInstr MI, MachineInstr BundleStart, bool UpdateFlags=false)

void	repairIntervalsInRange (MachineBasicBlock *MBB, MachineBasicBlock::iterator Begin, MachineBasicBlock::iterator End, ArrayRef< unsigned > OrigRegs)

ArrayRef< SlotIndex >	getRegMaskSlots () const

ArrayRef< SlotIndex >	getRegMaskSlotsInBlock (unsigned MBBNum) const

ArrayRef< const uint32_t * >	getRegMaskBits () const

ArrayRef< const uint32_t * >	getRegMaskBitsInBlock (unsigned MBBNum) const

bool	checkRegMaskInterference (LiveInterval &LI, BitVector &UsableRegs)

LiveRange &	getRegUnit (unsigned Unit)

LiveRange *	getCachedRegUnit (unsigned Unit)

const LiveRange *	getCachedRegUnit (unsigned Unit) const

Public Member Functions inherited from llvm::FunctionPass
	FunctionPass (char &pid)

Pass *	createPrinterPass (raw_ostream &O, const std::string &Banner) const
	createPrinterPass - Get a function printer pass. More...

virtual void	assignPassManager (PMStack &PMS, PassManagerType T)

virtual PassManagerType	getPotentialPassManagerType () const
	Return what kind of Pass Manager can manage this pass. More...

Public Member Functions inherited from llvm::Pass
	Pass (PassKind K, char &pid)

virtual	~Pass ()

PassKind	getPassKind () const

virtual const char *	getPassName () const

AnalysisID	getPassID () const
	getPassID - Return the PassID number that corresponds to this pass. More...

virtual bool	doInitialization (Module &)

virtual bool	doFinalization (Module &)

void	dump () const

virtual void	preparePassManager (PMStack &)
	Check if available pass managers are suitable for this pass or not. More...

void	setResolver (AnalysisResolver *AR)

AnalysisResolver *	getResolver () const

virtual void *	getAdjustedAnalysisPointer (AnalysisID ID)

virtual ImmutablePass *	getAsImmutablePass ()

virtual PMDataManager *	getAsPMDataManager ()

virtual void	verifyAnalysis () const

virtual void	dumpPassStructure (unsigned Offset=0)

template<typename AnalysisType >
AnalysisType *	getAnalysisIfAvailable () const

bool	mustPreserveAnalysisID (char &AID) const

template<typename AnalysisType >
AnalysisType &	getAnalysis () const

template<typename AnalysisType >
AnalysisType &	getAnalysis (Function &F)

template<typename AnalysisType >
AnalysisType &	getAnalysisID (AnalysisID PI) const

template<typename AnalysisType >
AnalysisType &	getAnalysisID (AnalysisID PI, Function &F)

Static Public Member Functions
static float	getSpillWeight (bool isDef, bool isUse, BlockFrequency freq)

Static Public Member Functions inherited from llvm::Pass
static const PassInfo *	lookupPassInfo (const void *TI)

static const PassInfo *	lookupPassInfo (StringRef Arg)

static Pass *	createPass (AnalysisID ID)

Static Public Attributes
static char	ID = 0

Additional Inherited Members
Protected Member Functions inherited from llvm::MachineFunctionPass
	MachineFunctionPass (char &ID)

Detailed Description

Definition at line 49 of file LiveIntervalAnalysis.h.

Constructor & Destructor Documentation

LiveIntervals::LiveIntervals ( )

Definition at line 80 of file LiveIntervalAnalysis.cpp.

References llvm::PassRegistry::getPassRegistry(), and llvm::initializeLiveIntervalsPass().

LiveIntervals::~LiveIntervals ( )

virtual

Definition at line 85 of file LiveIntervalAnalysis.cpp.

Member Function Documentation

void LiveIntervals::addKillFlags ( const VirtRegMap * VRM )

addKillFlags - Add kill flags to any instruction that kills a virtual register.

Definition at line 516 of file LiveIntervalAnalysis.cpp.

References llvm::MachineInstr::addRegisterKilled(), llvm::LiveRange::advanceTo(), llvm::LiveRange::begin(), llvm::SmallVectorImpl< T >::clear(), llvm::MachineInstr::clearRegisterKills(), llvm::LiveRange::empty(), llvm::LiveRange::end(), llvm::LiveRange::find(), getInstructionFromIndex(), getInterval(), llvm::MachineRegisterInfo::getNumVirtRegs(), llvm::VirtRegMap::getPhys(), getRegUnit(), I, llvm::TargetRegisterInfo::index2VirtReg(), llvm::MCRegisterInfo::DiffListIterator::isValid(), llvm::A64CC::MI, llvm::SmallVectorTemplateBase< T, isPodLike< T >::value >::push_back(), llvm::MachineRegisterInfo::reg_nodbg_empty(), and llvm::SmallVectorTemplateCommon< T >::size().

LiveRange::Segment LiveIntervals::addSegmentToEndOfBlock	(	unsigned	reg,
		MachineInstr *	startInst
	)

Given a register and an instruction, adds a live segment from that instruction to the end of its MBB.

Definition at line 629 of file LiveIntervalAnalysis.cpp.

References llvm::LiveRange::addSegment(), createEmptyInterval(), getInstructionIndex(), getMBBEndIdx(), llvm::LiveRange::getNextValue(), llvm::MachineInstr::getParent(), and getVNInfoAllocator().

bool LiveIntervals::checkRegMaskInterference	(	LiveInterval &	LI,
		BitVector &	UsableRegs
	)

checkRegMaskInterference - Test if LI is live across any register mask instructions, and compute a bit mask of physical registers that are not clobbered by any of them.

Returns false if LI doesn't cross any register mask instructions. In that case, the bit vector is not filled in.

Definition at line 647 of file LiveIntervalAnalysis.cpp.

References llvm::LiveRange::advanceTo(), llvm::ArrayRef< T >::begin(), llvm::LiveRange::begin(), llvm::tgtok::Bits, llvm::BitVector::clear(), llvm::BitVector::clearBitsNotInMask(), llvm::LiveRange::empty(), llvm::sys::path::end(), llvm::ArrayRef< T >::end(), llvm::LiveRange::end(), llvm::MachineBasicBlock::getNumber(), llvm::MCRegisterInfo::getNumRegs(), getRegMaskBits(), getRegMaskBitsInBlock(), getRegMaskSlots(), getRegMaskSlotsInBlock(), intervalIsInOneMBB(), and llvm::BitVector::resize().

Referenced by llvm::PBQPBuilder::build(), and llvm::LiveRegMatrix::checkRegMaskInterference().

LiveInterval& llvm::LiveIntervals::createAndComputeVirtRegInterval ( unsigned Reg )

inline

Definition at line 128 of file LiveIntervalAnalysis.h.

References createEmptyInterval(), and LI.

Referenced by getInterval(), and repairIntervalsInRange().

LiveInterval& llvm::LiveIntervals::createEmptyInterval ( unsigned Reg )

inline

Definition at line 121 of file LiveIntervalAnalysis.h.

References hasInterval().

Referenced by addSegmentToEndOfBlock(), createAndComputeVirtRegInterval(), and llvm::LiveRangeEdit::createEmptyIntervalFrom().

void LiveIntervals::extendToIndices	(	LiveRange &	LR,
		ArrayRef< SlotIndex >	Indices
	)

extendToIndices - Extend the live range of LI to reach all points in Indices. The points in the Indices array must be jointly dominated by existing defs in LI. PHI-defs are added as needed to maintain SSA form.

If a SlotIndex in Indices is the end index of a basic block, LI will be extended to be live out of the basic block.

See also LiveRangeCalc::extend().

Definition at line 444 of file LiveIntervalAnalysis.cpp.

References llvm::LiveRangeCalc::extend(), getSlotIndexes(), getVNInfoAllocator(), llvm::LiveRangeCalc::reset(), and llvm::ArrayRef< T >::size().

bool llvm::LiveIntervals::findLiveInMBBs	(	SlotIndex	Start,
		SlotIndex	End,
		SmallVectorImpl< MachineBasicBlock * > &	MBBs
	)		const

inline

Definition at line 248 of file LiveIntervalAnalysis.h.

References llvm::SlotIndexes::findLiveInMBBs().

AliasAnalysis* llvm::LiveIntervals::getAliasAnalysis ( ) const

inline

Definition at line 179 of file LiveIntervalAnalysis.h.

Referenced by isRematerializable().

void LiveIntervals::getAnalysisUsage ( AnalysisUsage & AU ) const

virtual

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.

For MachineFunctionPasses, calling AU.preservesCFG() indicates that the pass does not modify the MachineBasicBlock CFG.

Reimplemented from llvm::MachineFunctionPass.

Definition at line 63 of file LiveIntervalAnalysis.cpp.

References llvm::AnalysisUsage::addPreserved(), llvm::AnalysisUsage::addPreservedID(), llvm::AnalysisUsage::addRequired(), llvm::AnalysisUsage::addRequiredTransitive(), llvm::AnalysisUsage::addRequiredTransitiveID(), llvm::MachineFunctionPass::getAnalysisUsage(), llvm::MachineDominatorsID, llvm::MachineLoopInfoID, and llvm::AnalysisUsage::setPreservesCFG().

LiveRange* llvm::LiveIntervals::getCachedRegUnit ( unsigned Unit )

inline

getCachedRegUnit - Return the live range for Unit if it has already been computed, or NULL if it hasn't been computed yet.

Definition at line 379 of file LiveIntervalAnalysis.h.

Referenced by llvm::RegPressureTracker::getLiveRange().

const LiveRange* llvm::LiveIntervals::getCachedRegUnit ( unsigned Unit ) const

inline

Definition at line 383 of file LiveIntervalAnalysis.h.

MachineInstr* llvm::LiveIntervals::getInstructionFromIndex ( SlotIndex index ) const

inline

Returns the instruction associated with the given index.

Definition at line 195 of file LiveIntervalAnalysis.h.

References llvm::SlotIndexes::getInstructionFromIndex().

Referenced by addKillFlags(), llvm::ScheduleDAGInstrs::addVRegUseDeps(), llvm::LiveRangeEdit::canRematerializeAt(), llvm::SplitEditor::enterIntvAfter(), llvm::SplitEditor::enterIntvBefore(), findInsertLocation(), llvm::SplitAnalysis::getLastSplitPointIter(), isRematerializable(), llvm::SplitEditor::leaveIntvAfter(), llvm::SplitEditor::leaveIntvBefore(), repairIntervalsInRange(), llvm::SplitAnalysis::shouldSplitSingleBlock(), and shrinkToUses().

SlotIndex llvm::LiveIntervals::getInstructionIndex ( const MachineInstr * instr ) const

inline

Returns the base index of the given instruction.

Definition at line 190 of file LiveIntervalAnalysis.h.

References llvm::SlotIndexes::getInstructionIndex().

Referenced by addSegmentToEndOfBlock(), llvm::ScheduleDAGInstrs::addVRegUseDeps(), llvm::RegPressureTracker::bumpDownwardPressure(), llvm::RegPressureTracker::bumpUpwardPressure(), llvm::LiveRangeEdit::canRematerializeAt(), dumpMachineInstrRangeWithSlotIndex(), findUseBetween(), llvm::RegPressureTracker::getCurrSlot(), isPlainlyKilled(), llvm::RegPressureTracker::recede(), repairIntervalsInRange(), and shrinkToUses().

LiveInterval& llvm::LiveIntervals::getInterval ( unsigned Reg )

inline

Definition at line 105 of file LiveIntervalAnalysis.h.

References createAndComputeVirtRegInterval(), and hasInterval().

Referenced by addKillFlags(), llvm::ScheduleDAGInstrs::addVRegUseDeps(), llvm::RegAllocBase::allocatePhysRegs(), llvm::PBQPBuilder::build(), llvm::LiveRangeEdit::calculateRegClassAndHint(), llvm::calculateSpillWeightsAndHints(), llvm::SplitEditor::finish(), getInterval(), llvm::RegPressureTracker::getLiveRange(), isLocalCopy(), llvm::SplitAnalysis::isOriginalEndpoint(), isPlainlyKilled(), print(), and repairIntervalsInRange().

const LiveInterval& llvm::LiveIntervals::getInterval ( unsigned Reg ) const

inline

Definition at line 112 of file LiveIntervalAnalysis.h.

References getInterval().

SlotIndex llvm::LiveIntervals::getMBBEndIdx ( const MachineBasicBlock * mbb ) const

inline

Return the last index in the given basic block.

Definition at line 205 of file LiveIntervalAnalysis.h.

References llvm::SlotIndexes::getMBBEndIdx().

Referenced by addSegmentToEndOfBlock(), llvm::SplitAnalysis::countLiveBlocks(), llvm::SplitEditor::enterIntvAtEnd(), llvm::RegPressureTracker::getCurrSlot(), llvm::SplitAnalysis::getLastSplitPointIter(), handleMove(), isLiveOutOfMBB(), repairIntervalsInRange(), shrinkToUses(), and llvm::SplitEditor::useIntv().

MachineBasicBlock* llvm::LiveIntervals::getMBBFromIndex ( SlotIndex index ) const

inline

Definition at line 219 of file LiveIntervalAnalysis.h.

References llvm::SlotIndexes::getMBBFromIndex().

Referenced by llvm::SplitAnalysis::countLiveBlocks(), hasPHIKill(), llvm::SplitEditor::overlapIntv(), and shrinkToUses().

SlotIndex llvm::LiveIntervals::getMBBStartIdx ( const MachineBasicBlock * mbb ) const

inline

Return the first index in the given basic block.

Definition at line 200 of file LiveIntervalAnalysis.h.

References llvm::SlotIndexes::getMBBStartIdx().

Referenced by findInsertLocation(), handleMove(), isLiveInToMBB(), llvm::SplitEditor::leaveIntvAtTop(), shrinkToUses(), and llvm::SplitEditor::useIntv().

ArrayRef<const uint32_t*> llvm::LiveIntervals::getRegMaskBits ( ) const

inline

getRegMaskBits() - Returns an array of register mask pointers corresponding to getRegMaskSlots().

Definition at line 336 of file LiveIntervalAnalysis.h.

Referenced by checkRegMaskInterference(), and getRegMaskBitsInBlock().

ArrayRef<const uint32_t*> llvm::LiveIntervals::getRegMaskBitsInBlock ( unsigned MBBNum ) const

inline

getRegMaskBitsInBlock - Returns an array of mask pointers corresponding to getRegMaskSlotsInBlock(MBBNum).

Definition at line 340 of file LiveIntervalAnalysis.h.

References getRegMaskBits(), and P.

Referenced by checkRegMaskInterference().

ArrayRef<SlotIndex> llvm::LiveIntervals::getRegMaskSlots ( ) const

inline

getRegMaskSlots - Returns a sorted array of slot indices of all instructions with register mask operands.

Definition at line 324 of file LiveIntervalAnalysis.h.

Referenced by checkRegMaskInterference(), and getRegMaskSlotsInBlock().

ArrayRef<SlotIndex> llvm::LiveIntervals::getRegMaskSlotsInBlock ( unsigned MBBNum ) const

inline

getRegMaskSlotsInBlock - Returns a sorted array of slot indices of all instructions with register mask operands in the basic block numbered MBBNum.

Definition at line 329 of file LiveIntervalAnalysis.h.

References getRegMaskSlots(), and P.

Referenced by checkRegMaskInterference().

LiveRange& llvm::LiveIntervals::getRegUnit ( unsigned Unit )

inline

getRegUnit - Return the live range for Unit. It will be computed if it doesn't exist.

Definition at line 367 of file LiveIntervalAnalysis.h.

Referenced by addKillFlags(), llvm::PBQPBuilder::build(), llvm::LiveRegMatrix::checkRegUnitInterference(), and runOnMachineFunction().

SlotIndexes* llvm::LiveIntervals::getSlotIndexes ( ) const

inline

Definition at line 175 of file LiveIntervalAnalysis.h.

Referenced by llvm::VirtRegAuxInfo::calculateSpillWeightAndHint(), llvm::LiveRegMatrix::checkRegUnitInterference(), extendToIndices(), llvm::LiveRangeEdit::rematerializeAt(), llvm::SplitEditor::reset(), llvm::SplitEditor::splitLiveThroughBlock(), llvm::SplitEditor::splitRegInBlock(), and llvm::SplitEditor::splitRegOutBlock().

float LiveIntervals::getSpillWeight	(	bool	isDef,
		bool	isUse,
		BlockFrequency	freq
	)

static

Definition at line 623 of file LiveIntervalAnalysis.cpp.

References llvm::BlockFrequency::getEntryFrequency(), and llvm::BlockFrequency::getFrequency().

Referenced by llvm::PBQPBuilderWithCoalescing::build(), and llvm::VirtRegAuxInfo::calculateSpillWeightAndHint().

VNInfo::Allocator& llvm::LiveIntervals::getVNInfoAllocator ( )

inline

Definition at line 253 of file LiveIntervalAnalysis.h.

Referenced by addSegmentToEndOfBlock(), extendToIndices(), and llvm::SplitEditor::reset().

void LiveIntervals::handleMove	(	MachineInstr *	MI,
		bool	UpdateFlags = `false`
	)

handleMove - call this method to notify LiveIntervals that instruction 'mi' has been moved within a basic block. This will update the live intervals for all operands of mi. Moves between basic blocks are not supported.

Parameters

UpdateFlags Update live intervals for nonallocatable physregs.

Definition at line 1027 of file LiveIntervalAnalysis.cpp.

References llvm::SlotIndexes::getInstructionIndex(), getMBBEndIdx(), getMBBStartIdx(), llvm::MachineInstr::getParent(), llvm::SlotIndexes::insertMachineInstrInMaps(), llvm::MachineInstr::isBundled(), llvm::SlotIndexes::removeMachineInstrFromMaps(), and llvm::LiveIntervals::HMEditor::updateAllRanges().

void LiveIntervals::handleMoveIntoBundle	(	MachineInstr *	MI,
		MachineInstr *	BundleStart,
		bool	UpdateFlags = `false`
	)

moveIntoBundle - Update intervals for operands of MI so that they begin/end on the SlotIndex for BundleStart.

Parameters

UpdateFlags Update live intervals for nonallocatable physregs.

Requires MI and BundleStart to have SlotIndexes, and assumes existing liveness is accurate. BundleStart should be the first instruction in the Bundle.

Definition at line 1040 of file LiveIntervalAnalysis.cpp.

References llvm::SlotIndexes::getInstructionIndex(), and llvm::LiveIntervals::HMEditor::updateAllRanges().

bool llvm::LiveIntervals::hasInterval ( unsigned Reg ) const

inline

Definition at line 116 of file LiveIntervalAnalysis.h.

Referenced by createEmptyInterval(), getInterval(), print(), and repairIntervalsInRange().

bool LiveIntervals::hasPHIKill	(	const LiveInterval &	LI,
		const VNInfo *	VNI
	)		const

Returns true if VNI is killed by any PHI-def values in LI. This may conservatively return true to avoid expensive computations.

Definition at line 604 of file LiveIntervalAnalysis.cpp.

References llvm::VNInfo::def, llvm::SlotIndexes::getMBBEndIdx(), getMBBFromIndex(), llvm::LiveRange::getVNInfoBefore(), I, llvm::VNInfo::isPHIDef(), llvm::VNInfo::isUnused(), llvm::TargetOpcode::PHI, llvm::MachineBasicBlock::pred_begin(), llvm::MachineBasicBlock::pred_end(), llvm::MachineBasicBlock::pred_size(), llvm::LiveRange::vni_begin(), and llvm::LiveRange::vni_end().

SlotIndex llvm::LiveIntervals::InsertMachineInstrInMaps ( MachineInstr * MI )

inline

Definition at line 230 of file LiveIntervalAnalysis.h.

References llvm::SlotIndexes::insertMachineInstrInMaps().

void llvm::LiveIntervals::InsertMachineInstrRangeInMaps	(	MachineBasicBlock::iterator	B,
		MachineBasicBlock::iterator	E
	)

inline

Definition at line 234 of file LiveIntervalAnalysis.h.

References I, and llvm::SlotIndexes::insertMachineInstrInMaps().

void llvm::LiveIntervals::insertMBBInMaps ( MachineBasicBlock * MBB )

inline

Definition at line 223 of file LiveIntervalAnalysis.h.

References llvm::MachineBasicBlock::getNumber(), llvm::SlotIndexes::insertMBBInMaps(), llvm::SmallVectorTemplateBase< T, isPodLike >::push_back(), and llvm::SmallVectorTemplateCommon< T, typename >::size().

MachineBasicBlock * LiveIntervals::intervalIsInOneMBB ( const LiveInterval & LI ) const

intervalIsInOneMBB - If LI is confined to a single basic block, return a pointer to that block. If LI is live in to or out of any block, return NULL.

Definition at line 580 of file LiveIntervalAnalysis.cpp.

References llvm::LiveRange::beginIndex(), llvm::LiveRange::endIndex(), llvm::SlotIndexes::getMBBFromIndex(), and llvm::SlotIndex::isBlock().

Referenced by checkRegMaskInterference(), and isLocalCopy().

bool llvm::LiveIntervals::isLiveInToMBB	(	const LiveRange &	LR,
		const MachineBasicBlock *	mbb
	)		const

inline

Definition at line 209 of file LiveIntervalAnalysis.h.

References getMBBStartIdx(), and llvm::LiveRange::liveAt().

bool llvm::LiveIntervals::isLiveOutOfMBB	(	const LiveRange &	LR,
		const MachineBasicBlock *	mbb
	)		const

inline

Definition at line 214 of file LiveIntervalAnalysis.h.

References getMBBEndIdx(), and llvm::LiveRange::liveAt().

Referenced by llvm::VirtRegAuxInfo::calculateSpillWeightAndHint().

bool llvm::LiveIntervals::isNotInMIMap ( const MachineInstr * Instr ) const

inline

isNotInMIMap - returns true if the specified machine instr has been removed or was never entered in the map.

Definition at line 185 of file LiveIntervalAnalysis.h.

References llvm::SlotIndexes::hasIndex().

Referenced by isPlainlyKilled().

void LiveIntervals::print	(	raw_ostream &	O,
		const Module *	= `0`
	)		const

virtual

print - Implement the dump method.

Reimplemented from llvm::Pass.

Definition at line 138 of file LiveIntervalAnalysis.cpp.

References getInterval(), llvm::MachineRegisterInfo::getNumVirtRegs(), hasInterval(), and llvm::TargetRegisterInfo::index2VirtReg().

void LiveIntervals::pruneValue	(	LiveInterval *	LI,
		SlotIndex	Kill,
		SmallVectorImpl< SlotIndex > *	EndPoints
	)

pruneValue - If an LI value is live at Kill, prune its live range by removing any liveness reachable from Kill. Add live range end points to EndPoints such that extendToIndices(LI, EndPoints) will reconstruct the value's live range.

Calling pruneValue() and extendToIndices() can be used to reconstruct SSA form after adding defs to a virtual register.

Definition at line 452 of file LiveIntervalAnalysis.cpp.

References llvm::df_ext_begin(), llvm::df_ext_end(), llvm::LiveQueryResult::endPoint(), llvm::SlotIndexes::getMBBFromIndex(), llvm::SlotIndexes::getMBBRange(), I, llvm::SmallVectorTemplateBase< T, isPodLike< T >::value >::push_back(), llvm::LiveRange::Query(), llvm::LiveRange::removeSegment(), llvm::MachineBasicBlock::succ_begin(), llvm::MachineBasicBlock::succ_end(), llvm::tie(), llvm::LiveQueryResult::valueIn(), and llvm::LiveQueryResult::valueOut().

void LiveIntervals::releaseMemory ( )

virtual

releaseMemory() - This member can be implemented by a pass if it wants to be able to release its memory when it is no longer needed. The default behavior of passes is to hold onto memory for the entire duration of their lifetime (which is the entire compile time). For pipelined passes, this is not a big deal because that memory gets recycled every time the pass is invoked on another program unit. For IP passes, it is more important to free memory when it is unused.

Optionally implement this function to release pass memory when it is no longer used.

Reimplemented from llvm::Pass.

Definition at line 89 of file LiveIntervalAnalysis.cpp.

References llvm::SmallVectorImpl< T >::clear(), llvm::TargetRegisterInfo::index2VirtReg(), and llvm::BumpPtrAllocator::Reset().

void llvm::LiveIntervals::removeInterval ( unsigned Reg )

inline

Definition at line 135 of file LiveIntervalAnalysis.h.

Referenced by llvm::RegAllocBase::allocatePhysRegs(), and llvm::LiveRangeEdit::eraseVirtReg().

void llvm::LiveIntervals::RemoveMachineInstrFromMaps ( MachineInstr * MI )

inline

Definition at line 240 of file LiveIntervalAnalysis.h.

References llvm::SlotIndexes::removeMachineInstrFromMaps().

void LiveIntervals::repairIntervalsInRange	(	MachineBasicBlock *	MBB,
		MachineBasicBlock::iterator	Begin,
		MachineBasicBlock::iterator	End,
		ArrayRef< unsigned >	OrigRegs
	)

repairIntervalsInRange - Update live intervals for instructions in a range of iterators. It is intended for use after target hooks that may insert or remove instructions, and is only efficient for a small number of instructions.

OrigRegs is a vector of registers that were originally used by the instructions in the range between the two iterators.

Currently, the only only changes that are supported are simple removal and addition of uses.

Definition at line 1050 of file LiveIntervalAnalysis.cpp.

References llvm::LiveRange::addSegment(), llvm::LiveRange::begin(), llvm::MachineBasicBlock::begin(), createAndComputeVirtRegInterval(), llvm::LiveRange::end(), llvm::MachineBasicBlock::end(), llvm::LiveRange::find(), for(), llvm::SlotIndex::getDeadSlot(), getInstructionFromIndex(), getInstructionIndex(), getInterval(), getMBBEndIdx(), llvm::LiveRange::getNextValue(), llvm::SlotIndex::getPrevSlot(), llvm::MachineOperand::getReg(), llvm::SlotIndex::getRegSlot(), llvm::MachineOperand::getSubReg(), llvm::LiveRange::hasAtLeastOneValue(), llvm::SlotIndexes::hasIndex(), hasInterval(), I, llvm::MachineInstr::isDebugValue(), llvm::MachineOperand::isDef(), llvm::MachineOperand::isReg(), llvm::MachineOperand::isUndef(), llvm::MachineOperand::isUse(), llvm::SlotIndex::isValid(), llvm::TargetRegisterInfo::isVirtualRegister(), llvm::MachineInstr::operands_begin(), llvm::MachineInstr::operands_end(), llvm::prior(), llvm::LiveRange::removeSegment(), llvm::SlotIndexes::repairIndexesInRange(), and llvm::ArrayRef< T >::size().

void llvm::LiveIntervals::ReplaceMachineInstrInMaps	(	MachineInstr *	MI,
		MachineInstr *	NewMI
	)

inline

Definition at line 244 of file LiveIntervalAnalysis.h.

References llvm::SlotIndexes::replaceMachineInstrInMaps().

bool LiveIntervals::runOnMachineFunction ( MachineFunction & fn )

virtual

runOnMachineFunction - pass entry point

runOnMachineFunction - calculates LiveIntervals

Implements llvm::MachineFunctionPass.

Definition at line 108 of file LiveIntervalAnalysis.cpp.

References DEBUG, llvm::Pass::dump(), EnablePrecomputePhysRegs(), llvm::TargetMachine::getInstrInfo(), llvm::MCRegisterInfo::getNumRegUnits(), llvm::MachineRegisterInfo::getNumVirtRegs(), llvm::MachineFunction::getRegInfo(), llvm::TargetMachine::getRegisterInfo(), getRegUnit(), and llvm::MachineFunction::getTarget().

bool LiveIntervals::shrinkToUses	(	LiveInterval *	li,
		SmallVectorImpl< MachineInstr * > *	dead = `0`
	)

shrinkToUses - After removing some uses of a register, shrink its live range to just the remaining uses. This method does not compute reaching defs for new uses, and it doesn't remove dead defs. Dead PHIDef values are marked as unused. New dead machine instructions are added to the dead vector. Return true if the interval may have been separated into multiple connected components.

shrinkToUses - After removing some uses of a register, shrink its live range to just the remaining uses. This method does not compute reaching defs for new uses, and it doesn't remove dead defs.

Definition at line 316 of file LiveIntervalAnalysis.cpp.

Referenced by llvm::LiveRangeEdit::eliminateDeadDefs().

Member Data Documentation

char LiveIntervals::ID = 0

static

Definition at line 98 of file LiveIntervalAnalysis.h.

The documentation for this class was generated from the following files:

Classes

Public Member Functions

Static Public Member Functions

Static Public Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation