LLVM  6.0.0svn
Classes | Public Member Functions | Static Public Member Functions | Static Public Attributes | List of all members
llvm::LiveIntervals Class Reference

#include "llvm/CodeGen/LiveIntervalAnalysis.h"

Inheritance diagram for llvm::LiveIntervals:
Inheritance graph
[legend]
Collaboration diagram for llvm::LiveIntervals:
Collaboration graph
[legend]

Classes

class  HMEditor
 Toolkit used by handleMove to trim or extend live intervals. More...
 

Public Member Functions

 LiveIntervals ()
 
 ~LiveIntervals () override
 
LiveIntervalgetInterval (unsigned Reg)
 
const LiveIntervalgetInterval (unsigned Reg) const
 
bool hasInterval (unsigned Reg) const
 
LiveIntervalcreateEmptyInterval (unsigned Reg)
 Interval creation. More...
 
LiveIntervalcreateAndComputeVirtRegInterval (unsigned Reg)
 
void removeInterval (unsigned Reg)
 Interval removal. More...
 
LiveInterval::Segment addSegmentToEndOfBlock (unsigned reg, MachineInstr &startInst)
 Given a register and an instruction, adds a live segment from that instruction to the end of its MBB. More...
 
bool shrinkToUses (LiveInterval *li, SmallVectorImpl< MachineInstr *> *dead=nullptr)
 After removing some uses of a register, shrink its live range to just the remaining uses. More...
 
void shrinkToUses (LiveInterval::SubRange &SR, unsigned Reg)
 Specialized version of shrinkToUses(LiveInterval li, SmallVectorImpl<MachineInstr> *dead) that works on a subregister live range and only looks at uses matching the lane mask of the subregister range. More...
 
void extendToIndices (LiveRange &LR, ArrayRef< SlotIndex > Indices, ArrayRef< SlotIndex > Undefs)
 Extend the live range LR to reach all points in Indices. More...
 
void extendToIndices (LiveRange &LR, ArrayRef< SlotIndex > Indices)
 
void pruneValue (LiveRange &LR, SlotIndex Kill, SmallVectorImpl< SlotIndex > *EndPoints)
 If LR has a live value at Kill, prune its live range by removing any liveness reachable from Kill. More...
 
LLVM_ATTRIBUTE_UNUSED void pruneValue (LiveInterval &, SlotIndex, SmallVectorImpl< SlotIndex > *)
 This function should not be used. More...
 
SlotIndexesgetSlotIndexes () const
 
AliasAnalysisgetAliasAnalysis () const
 
bool isNotInMIMap (const MachineInstr &Instr) const
 Returns true if the specified machine instr has been removed or was never entered in the map. More...
 
SlotIndex getInstructionIndex (const MachineInstr &Instr) const
 Returns the base index of the given instruction. More...
 
MachineInstrgetInstructionFromIndex (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
 
MachineBasicBlockgetMBBFromIndex (SlotIndex index) const
 
void insertMBBInMaps (MachineBasicBlock *MBB)
 
SlotIndex InsertMachineInstrInMaps (MachineInstr &MI)
 
void InsertMachineInstrRangeInMaps (MachineBasicBlock::iterator B, MachineBasicBlock::iterator E)
 
void RemoveMachineInstrFromMaps (MachineInstr &MI)
 
SlotIndex ReplaceMachineInstrInMaps (MachineInstr &MI, MachineInstr &NewMI)
 
VNInfo::AllocatorgetVNInfoAllocator ()
 
void getAnalysisUsage (AnalysisUsage &AU) const override
 getAnalysisUsage - This function should be overriden by passes that need analysis information to do their job. More...
 
void releaseMemory () override
 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. More...
 
bool runOnMachineFunction (MachineFunction &) override
 Pass entry point; Calculates LiveIntervals. More...
 
void print (raw_ostream &O, const Module *=nullptr) const override
 Implement the dump method. More...
 
MachineBasicBlockintervalIsInOneMBB (const LiveInterval &LI) const
 If LI is confined to a single basic block, return a pointer to that block. More...
 
bool hasPHIKill (const LiveInterval &LI, const VNInfo *VNI) const
 Returns true if VNI is killed by any PHI-def values in LI. More...
 
void addKillFlags (const VirtRegMap *)
 Add kill flags to any instruction that kills a virtual register. More...
 
void handleMove (MachineInstr &MI, bool UpdateFlags=false)
 Call this method to notify LiveIntervals that instruction MI has been moved within a basic block. More...
 
void handleMoveIntoBundle (MachineInstr &MI, MachineInstr &BundleStart, bool UpdateFlags=false)
 Update intervals for operands of MI so that they begin/end on the SlotIndex for BundleStart. More...
 
void repairIntervalsInRange (MachineBasicBlock *MBB, MachineBasicBlock::iterator Begin, MachineBasicBlock::iterator End, ArrayRef< unsigned > OrigRegs)
 Update live intervals for instructions in a range of iterators. More...
 
ArrayRef< SlotIndexgetRegMaskSlots () const
 Returns a sorted array of slot indices of all instructions with register mask operands. More...
 
ArrayRef< SlotIndexgetRegMaskSlotsInBlock (unsigned MBBNum) const
 Returns a sorted array of slot indices of all instructions with register mask operands in the basic block numbered MBBNum. More...
 
ArrayRef< const uint32_t * > getRegMaskBits () const
 Returns an array of register mask pointers corresponding to getRegMaskSlots(). More...
 
ArrayRef< const uint32_t * > getRegMaskBitsInBlock (unsigned MBBNum) const
 Returns an array of mask pointers corresponding to getRegMaskSlotsInBlock(MBBNum). More...
 
bool checkRegMaskInterference (LiveInterval &LI, BitVector &UsableRegs)
 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. More...
 
LiveRangegetRegUnit (unsigned Unit)
 Return the live range for register unit Unit. More...
 
LiveRangegetCachedRegUnit (unsigned Unit)
 Return the live range for register unit Unit if it has already been computed, or nullptr if it hasn't been computed yet. More...
 
const LiveRangegetCachedRegUnit (unsigned Unit) const
 
void removeRegUnit (unsigned Unit)
 Remove computed live range for register unit Unit. More...
 
void removePhysRegDefAt (unsigned Reg, SlotIndex Pos)
 Remove value numbers and related live segments starting at position Pos that are part of any liverange of physical register Reg or one of its subregisters. More...
 
void removeVRegDefAt (LiveInterval &LI, SlotIndex Pos)
 Remove value number and related live segments of LI and its subranges that start at position Pos. More...
 
void splitSeparateComponents (LiveInterval &LI, SmallVectorImpl< LiveInterval *> &SplitLIs)
 Split separate components in LiveInterval LI into separate intervals. More...
 
void constructMainRangeFromSubranges (LiveInterval &LI)
 For live interval LI with correct SubRanges construct matching information for the main live range. More...
 
- Public Member Functions inherited from llvm::MachineFunctionPass
bool doInitialization (Module &) override
 doInitialization - Virtual method overridden by subclasses to do any necessary initialization before any pass is run. More...
 
- Public Member Functions inherited from llvm::FunctionPass
 FunctionPass (char &pid)
 
PasscreatePrinterPass (raw_ostream &OS, const std::string &Banner) const override
 createPrinterPass - Get a function printer pass. More...
 
void assignPassManager (PMStack &PMS, PassManagerType T) override
 Find appropriate Function Pass Manager or Call Graph Pass Manager in the PM Stack and add self into that manager. More...
 
PassManagerType getPotentialPassManagerType () const override
 Return what kind of Pass Manager can manage this pass. More...
 
- Public Member Functions inherited from llvm::Pass
 Pass (PassKind K, char &pid)
 
 Pass (const Pass &)=delete
 
Passoperator= (const Pass &)=delete
 
virtual ~Pass ()
 
PassKind getPassKind () const
 
virtual StringRef getPassName () const
 getPassName - Return a nice clean name for a pass. More...
 
AnalysisID getPassID () const
 getPassID - Return the PassID number that corresponds to this pass. More...
 
virtual bool doFinalization (Module &)
 doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes have run. More...
 
void dump () const
 
virtual void preparePassManager (PMStack &)
 Check if available pass managers are suitable for this pass or not. More...
 
void setResolver (AnalysisResolver *AR)
 
AnalysisResolvergetResolver () const
 
virtual void * getAdjustedAnalysisPointer (AnalysisID ID)
 getAdjustedAnalysisPointer - This method is used when a pass implements an analysis interface through multiple inheritance. More...
 
virtual ImmutablePassgetAsImmutablePass ()
 
virtual PMDataManagergetAsPMDataManager ()
 
virtual void verifyAnalysis () const
 verifyAnalysis() - This member can be implemented by a analysis pass to check state of analysis information. More...
 
virtual void dumpPassStructure (unsigned Offset=0)
 
template<typename AnalysisType >
AnalysisType * getAnalysisIfAvailable () const
 getAnalysisIfAvailable<AnalysisType>() - Subclasses use this function to get analysis information that might be around, for example to update it. More...
 
bool mustPreserveAnalysisID (char &AID) const
 mustPreserveAnalysisID - This method serves the same function as getAnalysisIfAvailable, but works if you just have an AnalysisID. More...
 
template<typename AnalysisType >
AnalysisType & getAnalysis () const
 getAnalysis<AnalysisType>() - This function is used by subclasses to get to the analysis information that they claim to use by overriding the getAnalysisUsage function. More...
 
template<typename AnalysisType >
AnalysisType & getAnalysis (Function &F)
 getAnalysis<AnalysisType>() - This function is used by subclasses to get to the analysis information that they claim to use by overriding the getAnalysisUsage function. More...
 
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, const MachineBlockFrequencyInfo *MBFI, const MachineInstr &Instr)
 Calculate the spill weight to assign to a single instruction. More...
 
static float getSpillWeight (bool isDef, bool isUse, const MachineBlockFrequencyInfo *MBFI, const MachineBasicBlock *MBB)
 Calculate the spill weight to assign to a single instruction. More...
 
- Static Public Member Functions inherited from llvm::Pass
static const PassInfolookupPassInfo (const void *TI)
 
static const PassInfolookupPassInfo (StringRef Arg)
 
static PasscreatePass (AnalysisID ID)
 

Static Public Attributes

static char ID = 0
 

Additional Inherited Members

- Protected Member Functions inherited from llvm::MachineFunctionPass
 MachineFunctionPass (char &ID)
 
void getAnalysisUsage (AnalysisUsage &AU) const override
 getAnalysisUsage - Subclasses that override getAnalysisUsage must call this. More...
 
virtual MachineFunctionProperties getRequiredProperties () const
 
virtual MachineFunctionProperties getSetProperties () const
 
virtual MachineFunctionProperties getClearedProperties () const
 
- Protected Member Functions inherited from llvm::FunctionPass
bool skipFunction (const Function &F) const
 Optional passes call this function to check whether the pass should be skipped. More...
 

Detailed Description

Definition at line 55 of file LiveIntervalAnalysis.h.

Constructor & Destructor Documentation

◆ LiveIntervals()

LiveIntervals::LiveIntervals ( )

◆ ~LiveIntervals()

LiveIntervals::~LiveIntervals ( )
override

Definition at line 104 of file LiveIntervalAnalysis.cpp.

Member Function Documentation

◆ addKillFlags()

void LiveIntervals::addKillFlags ( const VirtRegMap VRM)

◆ addSegmentToEndOfBlock()

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 839 of file LiveIntervalAnalysis.cpp.

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

Referenced by removeInterval().

◆ checkRegMaskInterference()

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

◆ constructMainRangeFromSubranges()

void LiveIntervals::constructMainRangeFromSubranges ( LiveInterval LI)

For live interval LI with correct SubRanges construct matching information for the main live range.

Expects the main live range to not have any segments or value numbers.

Definition at line 1594 of file LiveIntervalAnalysis.cpp.

References assert(), getSlotIndexes(), and getVNInfoAllocator().

Referenced by removeRegUnit().

◆ createAndComputeVirtRegInterval()

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

◆ createEmptyInterval()

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

◆ extendToIndices() [1/2]

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

Extend the live range LR to reach all points in Indices.

The points in the Indices array must be jointly dominated by the union of the existing defs in LR and points in Undefs.

PHI-defs are added as needed to maintain SSA form.

If a SlotIndex in Indices is the end index of a basic block, LR will be extended to be live out of the basic block. If a SlotIndex in Indices is jointy dominated only by points in Undefs, the live range will not be extended to that point.

See also LiveRangeCalc::extend().

Definition at line 583 of file LiveIntervalAnalysis.cpp.

References assert(), llvm::LiveRangeCalc::extend(), getSlotIndexes(), getVNInfoAllocator(), and llvm::LiveRangeCalc::reset().

Referenced by addSegmentsWithValNo(), extendToIndices(), removeInterval(), and ReplaceDominatedUses().

◆ extendToIndices() [2/2]

void llvm::LiveIntervals::extendToIndices ( LiveRange LR,
ArrayRef< SlotIndex Indices 
)
inline

Definition at line 187 of file LiveIntervalAnalysis.h.

References extendToIndices(), llvm::RegState::Kill, and pruneValue().

◆ getAliasAnalysis()

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

Definition at line 215 of file LiveIntervalAnalysis.h.

Referenced by isRematerializable().

◆ getAnalysisUsage()

void LiveIntervals::getAnalysisUsage ( AnalysisUsage ) const
overridevirtual

getAnalysisUsage - This function should be overriden by passes that need analysis information to do their job.

If a pass specifies that it uses a particular analysis result to this function, it can then use the getAnalysis<AnalysisType>() function, below.

Reimplemented from llvm::Pass.

Definition at line 87 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().

Referenced by getVNInfoAllocator().

◆ getCachedRegUnit() [1/2]

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

Return the live range for register unit Unit if it has already been computed, or nullptr if it hasn't been computed yet.

Definition at line 406 of file LiveIntervalAnalysis.h.

Referenced by getLanesWithProperty(), getLiveRange(), llvm::LiveIntervals::HMEditor::getRegUnitLI(), matchPair(), and removePhysRegDefAt().

◆ getCachedRegUnit() [2/2]

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

Definition at line 410 of file LiveIntervalAnalysis.h.

◆ getInstructionFromIndex()

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

◆ getInstructionIndex()

SlotIndex llvm::LiveIntervals::getInstructionIndex ( const MachineInstr Instr) const
inline

◆ getInterval() [1/2]

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

◆ getInterval() [2/2]

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

Definition at line 122 of file LiveIntervalAnalysis.h.

References getInterval().

◆ getMBBEndIdx()

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

◆ getMBBFromIndex()

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

◆ getMBBStartIdx()

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

◆ getRegMaskBits()

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

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

Definition at line 362 of file LiveIntervalAnalysis.h.

Referenced by checkRegMaskInterference(), and getRegMaskBitsInBlock().

◆ getRegMaskBitsInBlock()

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

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

Definition at line 366 of file LiveIntervalAnalysis.h.

References checkRegMaskInterference(), getRegMaskBits(), and P.

Referenced by checkRegMaskInterference().

◆ getRegMaskSlots()

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

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

Definition at line 351 of file LiveIntervalAnalysis.h.

Referenced by checkRegMaskInterference(), getRegMaskSlotsInBlock(), and llvm::VirtRegAuxInfo::weightCalcHelper().

◆ getRegMaskSlotsInBlock()

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

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

Definition at line 355 of file LiveIntervalAnalysis.h.

References getRegMaskSlots(), and P.

Referenced by checkRegMaskInterference().

◆ getRegUnit()

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

◆ getSlotIndexes()

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

◆ getSpillWeight() [1/2]

float LiveIntervals::getSpillWeight ( bool  isDef,
bool  isUse,
const MachineBlockFrequencyInfo MBFI,
const MachineInstr Instr 
)
static

Calculate the spill weight to assign to a single instruction.

Definition at line 824 of file LiveIntervalAnalysis.cpp.

References llvm::MachineInstr::getParent().

Referenced by computeWeight(), false::IntervalSorter::operator()(), and llvm::VirtRegAuxInfo::weightCalcHelper().

◆ getSpillWeight() [2/2]

float LiveIntervals::getSpillWeight ( bool  isDef,
bool  isUse,
const MachineBlockFrequencyInfo MBFI,
const MachineBasicBlock MBB 
)
static

Calculate the spill weight to assign to a single instruction.

Definition at line 830 of file LiveIntervalAnalysis.cpp.

References llvm::MachineBlockFrequencyInfo::getBlockFreq(), llvm::MachineBlockFrequencyInfo::getEntryFreq(), and llvm::BlockFrequency::getFrequency().

◆ getVNInfoAllocator()

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

◆ handleMove()

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

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
UpdateFlagsUpdate live intervals for nonallocatable physregs.

Definition at line 1383 of file LiveIntervalAnalysis.cpp.

References assert(), getMBBEndIdx(), getMBBStartIdx(), llvm::MachineInstr::getParent(), llvm::MachineInstr::isBundled(), MRI, and llvm::LiveIntervals::HMEditor::updateAllRanges().

Referenced by getVNInfoAllocator(), MoveAndTeeForMultiUse(), MoveForSingleUse(), nextIfDebug(), regOverlapsSet(), llvm::GCNScheduleDAGMILive::schedule(), and llvm::GCNIterativeScheduler::scheduleRegion().

◆ handleMoveIntoBundle()

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

◆ hasInterval()

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

◆ hasPHIKill()

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

◆ InsertMachineInstrInMaps()

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

◆ InsertMachineInstrRangeInMaps()

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

Definition at line 270 of file LiveIntervalAnalysis.h.

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

◆ insertMBBInMaps()

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

◆ intervalIsInOneMBB()

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

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 785 of file LiveIntervalAnalysis.cpp.

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

Referenced by checkRegMaskInterference(), getVNInfoAllocator(), and isLocalCopy().

◆ isLiveInToMBB()

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

◆ isLiveOutOfMBB()

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

◆ isNotInMIMap()

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

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

Definition at line 221 of file LiveIntervalAnalysis.h.

References llvm::SlotIndexes::hasIndex().

Referenced by findNextInsertLocation(), isPlainlyKilled(), and matchPair().

◆ print()

void LiveIntervals::print ( raw_ostream O,
const Module = nullptr 
) const
overridevirtual

Implement the dump method.

Reimplemented from llvm::Pass.

Definition at line 154 of file LiveIntervalAnalysis.cpp.

References assert(), llvm::LiveRangeCalc::calculate(), createAndComputeVirtRegInterval(), llvm::LiveRange::createDeadDef(), llvm::LiveRangeCalc::createDeadDefs(), llvm::dbgs(), DEBUG, llvm::LiveRange::empty(), llvm::LiveRange::flushSegmentSet(), llvm::SlotIndexes::getInstructionIndex(), getInterval(), llvm::SlotIndexes::getMBBStartIdx(), llvm::MachineFunction::getNumBlockIDs(), llvm::MCRegisterInfo::getNumRegUnits(), llvm::MachineRegisterInfo::getNumVirtRegs(), llvm::SlotIndex::getRegSlot(), getSlotIndexes(), getVNInfoAllocator(), hasInterval(), llvm::huge_valf, llvm::VNInfo::id, llvm::TargetRegisterInfo::index2VirtReg(), llvm::TargetRegisterInfo::isPhysicalRegister(), llvm::MachineRegisterInfo::isReserved(), llvm::MachineRegisterInfo::isReservedRegUnit(), llvm::MCRegisterInfo::DiffListIterator::isValid(), llvm::MCRegUnitRootIterator::isValid(), LLVM_DUMP_METHOD, llvm::BitmaskEnumDetail::Mask(), MI, llvm::MachineFunction::print(), llvm::PrintRegUnit(), llvm::SmallVectorTemplateBase< T, isPodLike >::push_back(), llvm::LiveInterval::reg, llvm::MachineRegisterInfo::reg_empty(), llvm::MachineRegisterInfo::reg_nodbg_empty(), llvm::LiveRangeCalc::reset(), llvm::SmallVectorImpl< T >::resize(), llvm::MachineRegisterInfo::shouldTrackSubRegLiveness(), llvm::SmallVectorTemplateCommon< T, typename >::size(), and llvm::UseSegmentSetForPhysRegs.

Referenced by getVNInfoAllocator(), isTerminalReg(), and llvm::MachineFunction::verify().

◆ pruneValue() [1/2]

void LiveIntervals::pruneValue ( LiveRange LR,
SlotIndex  Kill,
SmallVectorImpl< SlotIndex > *  EndPoints 
)

If LR has a live value 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 592 of file LiveIntervalAnalysis.cpp.

References llvm::df_ext_begin(), llvm::df_ext_end(), E, llvm::LiveQueryResult::endPoint(), llvm::SlotIndexes::getMBBEndIdx(), llvm::SlotIndexes::getMBBFromIndex(), llvm::SlotIndexes::getMBBRange(), I, llvm::SmallVectorTemplateBase< T, isPodLike< T >::value >::push_back(), llvm::LiveRange::Query(), llvm::LiveRange::removeSegment(), llvm::MachineBasicBlock::successors(), llvm::LiveQueryResult::valueIn(), and llvm::LiveQueryResult::valueOutOrDead().

Referenced by addSegmentsWithValNo(), and extendToIndices().

◆ pruneValue() [2/2]

LLVM_ATTRIBUTE_UNUSED void llvm::LiveIntervals::pruneValue ( LiveInterval ,
SlotIndex  ,
SmallVectorImpl< SlotIndex > *   
)
inline

This function should not be used.

Its intend is to tell you that you are doing something wrong if you call pruveValue directly on a LiveInterval. Indeed, you are supposed to call pruneValue on the main LiveRange and all the LiveRange of the subranges if any.

Definition at line 205 of file LiveIntervalAnalysis.h.

References llvm_unreachable.

◆ releaseMemory()

void LiveIntervals::releaseMemory ( )
overridevirtual

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 108 of file LiveIntervalAnalysis.cpp.

References llvm::SmallVectorImpl< T >::clear(), llvm::TargetRegisterInfo::index2VirtReg(), and llvm::BumpPtrAllocatorImpl< AllocatorT, SlabSize, SizeThreshold >::Reset().

Referenced by getVNInfoAllocator().

◆ removeInterval()

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

◆ RemoveMachineInstrFromMaps()

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

◆ removePhysRegDefAt()

void LiveIntervals::removePhysRegDefAt ( unsigned  Reg,
SlotIndex  Pos 
)

Remove value numbers and related live segments starting at position Pos that are part of any liverange of physical register Reg or one of its subregisters.

Definition at line 1551 of file LiveIntervalAnalysis.cpp.

References getCachedRegUnit(), llvm::LiveRange::getVNInfoAt(), and llvm::LiveRange::removeValNo().

Referenced by RematerializeCheapDef(), and removeRegUnit().

◆ removeRegUnit()

void llvm::LiveIntervals::removeRegUnit ( unsigned  Unit)
inline

Remove computed live range for register unit Unit.

Subsequent uses should rely on on-demand recomputation.

Definition at line 416 of file LiveIntervalAnalysis.h.

References constructMainRangeFromSubranges(), llvm::LaneBitmask::getAll(), removePhysRegDefAt(), removeVRegDefAt(), and splitSeparateComponents().

Referenced by getOrExecSource().

◆ removeVRegDefAt()

void LiveIntervals::removeVRegDefAt ( LiveInterval LI,
SlotIndex  Pos 
)

◆ repairIntervalsInRange()

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

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 1500 of file LiveIntervalAnalysis.cpp.

References llvm::MachineBasicBlock::begin(), createAndComputeVirtRegInterval(), llvm::MachineBasicBlock::end(), getInstructionIndex(), getInterval(), getMBBEndIdx(), llvm::SlotIndex::getPrevSlot(), llvm::LiveRange::hasAtLeastOneValue(), hasInterval(), I, llvm::MachineInstr::isDebugValue(), llvm::TargetRegisterInfo::isVirtualRegister(), MI, llvm::MachineInstr::operands_begin(), llvm::MachineInstr::operands_end(), and llvm::LiveInterval::subranges().

Referenced by getVNInfoAllocator(), and regOverlapsSet().

◆ ReplaceMachineInstrInMaps()

SlotIndex llvm::LiveIntervals::ReplaceMachineInstrInMaps ( MachineInstr MI,
MachineInstr NewMI 
)
inline

◆ runOnMachineFunction()

bool LiveIntervals::runOnMachineFunction ( MachineFunction fn)
overridevirtual

◆ shrinkToUses() [1/2]

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

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. Returns true if the interval may have been separated into multiple connected components.

Definition at line 414 of file LiveIntervalAnalysis.cpp.

References llvm::MachineInstr::addRegisterDead(), llvm::MachineInstr::allDefsAreDead(), assert(), llvm::LiveRange::begin(), createSegmentsForValues(), llvm::dbgs(), DEBUG, llvm::tgtok::Def, llvm::VNInfo::def, llvm::LiveRange::end(), extendSegmentsToUses(), llvm::LiveRange::FindSegmentContaining(), llvm::SlotIndex::getDeadSlot(), getInstructionFromIndex(), getInstructionIndex(), llvm::SlotIndex::getRegSlot(), I, llvm::VNInfo::isPHIDef(), llvm::VNInfo::isUnused(), llvm::TargetRegisterInfo::isVirtualRegister(), llvm::make_range(), llvm::VNInfo::markUnused(), MI, llvm::SmallVectorTemplateBase< T, isPodLike >::push_back(), llvm::LiveRange::Query(), llvm::LiveInterval::reg, llvm::MachineRegisterInfo::reg_instructions(), llvm::LiveInterval::removeEmptySubRanges(), llvm::LiveRange::removeSegment(), llvm::LiveRange::segments, llvm::MachineInstr::setRegisterDefReadUndef(), llvm::MachineRegisterInfo::shouldTrackSubRegLiveness(), llvm::LiveInterval::subranges(), llvm::SmallVectorImpl< T >::swap(), UseMI, llvm::LiveRange::valnos, llvm::LiveQueryResult::valueDefined(), llvm::LiveQueryResult::valueIn(), llvm::LiveRange::vni_begin(), and llvm::LiveRange::vni_end().

Referenced by removeInterval(), ReplaceDominatedUses(), and ShrinkToUses().

◆ shrinkToUses() [2/2]

void LiveIntervals::shrinkToUses ( LiveInterval::SubRange SR,
unsigned  Reg 
)

◆ splitSeparateComponents()

void LiveIntervals::splitSeparateComponents ( LiveInterval LI,
SmallVectorImpl< LiveInterval *> &  SplitLIs 
)

Member Data Documentation

◆ ID

char LiveIntervals::ID = 0
static

Definition at line 100 of file LiveIntervalAnalysis.h.


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