diff options
Diffstat (limited to 'include/llvm/CodeGen/LiveIntervalAnalysis.h')
| -rw-r--r-- | include/llvm/CodeGen/LiveIntervalAnalysis.h | 140 |
1 files changed, 71 insertions, 69 deletions
diff --git a/include/llvm/CodeGen/LiveIntervalAnalysis.h b/include/llvm/CodeGen/LiveIntervalAnalysis.h index f8dc52566dc00..f5b1f87720ad3 100644 --- a/include/llvm/CodeGen/LiveIntervalAnalysis.h +++ b/include/llvm/CodeGen/LiveIntervalAnalysis.h @@ -7,13 +7,13 @@ // //===----------------------------------------------------------------------===// // -// This file implements the LiveInterval analysis pass. Given some numbering of -// each the machine instructions (in this implemention depth-first order) an -// interval [i, j) is said to be a live interval for register v if there is no -// instruction with number j' > j such that v is live at j' and there is no -// instruction with number i' < i such that v is live at i'. In this -// implementation intervals can have holes, i.e. an interval might look like -// [1,20), [50,65), [1000,1001). +/// \file This file implements the LiveInterval analysis pass. Given some +/// numbering of each the machine instructions (in this implemention depth-first +/// order) an interval [i, j) is said to be a live interval for register v if +/// there is no instruction with number j' > j such that v is live at j' and +/// there is no instruction with number i' < i such that v is live at i'. In +/// this implementation intervals can have holes, i.e. an interval might look +/// like [1,20), [50,65), [1000,1001). // //===----------------------------------------------------------------------===// @@ -60,20 +60,17 @@ extern cl::opt<bool> UseSegmentSetForPhysRegs; LiveRangeCalc *LRCalc; /// Special pool allocator for VNInfo's (LiveInterval val#). - /// VNInfo::Allocator VNInfoAllocator; /// Live interval pointers for all the virtual registers. IndexedMap<LiveInterval*, VirtReg2IndexFunctor> VirtRegIntervals; - /// RegMaskSlots - Sorted list of instructions with register mask operands. - /// Always use the 'r' slot, RegMasks are normal clobbers, not early - /// clobbers. + /// Sorted list of instructions with register mask operands. Always use the + /// 'r' slot, RegMasks are normal clobbers, not early clobbers. SmallVector<SlotIndex, 8> RegMaskSlots; - /// RegMaskBits - This vector is parallel to RegMaskSlots, it holds a - /// pointer to the corresponding register mask. This pointer can be - /// recomputed as: + /// This vector is parallel to RegMaskSlots, it holds a pointer to the + /// corresponding register mask. This pointer can be recomputed as: /// /// MI = Indexes->getInstructionFromIndex(RegMaskSlot[N]); /// unsigned OpNum = findRegMaskOperand(MI); @@ -97,11 +94,11 @@ extern cl::opt<bool> UseSegmentSetForPhysRegs; SmallVector<LiveRange*, 0> RegUnitRanges; public: - static char ID; // Pass identification, replacement for typeid + static char ID; LiveIntervals(); ~LiveIntervals() override; - // Calculate the spill weight to assign to a single instruction. + /// Calculate the spill weight to assign to a single instruction. static float getSpillWeight(bool isDef, bool isUse, const MachineBlockFrequencyInfo *MBFI, const MachineInstr &Instr); @@ -121,7 +118,7 @@ extern cl::opt<bool> UseSegmentSetForPhysRegs; return VirtRegIntervals.inBounds(Reg) && VirtRegIntervals[Reg]; } - // Interval creation. + /// Interval creation. LiveInterval &createEmptyInterval(unsigned Reg) { assert(!hasInterval(Reg) && "Interval already exists!"); VirtRegIntervals.grow(Reg); @@ -135,7 +132,7 @@ extern cl::opt<bool> UseSegmentSetForPhysRegs; return LI; } - // Interval removal. + /// Interval removal. void removeInterval(unsigned Reg) { delete VirtRegIntervals[Reg]; VirtRegIntervals[Reg] = nullptr; @@ -163,16 +160,16 @@ extern cl::opt<bool> UseSegmentSetForPhysRegs; /// LiveInterval::removeEmptySubranges() afterwards. void shrinkToUses(LiveInterval::SubRange &SR, unsigned Reg); - /// Extend the live range @p LR to reach all points in @p Indices. The - /// points in the @p Indices array must be jointly dominated by the union - /// of the existing defs in @p LR and points in @p Undefs. + /// Extend the live range \p LR to reach all points in \p Indices. The + /// points in the \p Indices array must be jointly dominated by the union + /// of the existing defs in \p LR and points in \p Undefs. /// /// PHI-defs are added as needed to maintain SSA form. /// - /// If a SlotIndex in @p Indices is the end index of a basic block, @p LR + /// If a SlotIndex in \p Indices is the end index of a basic block, \p LR /// will be extended to be live out of the basic block. - /// If a SlotIndex in @p Indices is jointy dominated only by points in - /// @p Undefs, the live range will not be extended to that point. + /// If a SlotIndex in \p Indices is jointy dominated only by points in + /// \p Undefs, the live range will not be extended to that point. /// /// See also LiveRangeCalc::extend(). void extendToIndices(LiveRange &LR, ArrayRef<SlotIndex> Indices, @@ -182,7 +179,7 @@ extern cl::opt<bool> UseSegmentSetForPhysRegs; extendToIndices(LR, Indices, /*Undefs=*/{}); } - /// If @p LR has a live value at @p Kill, prune its live range by removing + /// If \p LR has a live value at \p 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. @@ -192,6 +189,16 @@ extern cl::opt<bool> UseSegmentSetForPhysRegs; void pruneValue(LiveRange &LR, SlotIndex Kill, SmallVectorImpl<SlotIndex> *EndPoints); + /// This function should 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. + LLVM_ATTRIBUTE_UNUSED void pruneValue(LiveInterval &, SlotIndex, + SmallVectorImpl<SlotIndex> *) { + llvm_unreachable( + "Use pruneValue on the main LiveRange and on each subrange"); + } + SlotIndexes *getSlotIndexes() const { return Indexes; } @@ -200,8 +207,8 @@ extern cl::opt<bool> UseSegmentSetForPhysRegs; return AA; } - /// isNotInMIMap - returns true if the specified machine instr has been - /// removed or was never entered in the map. + /// Returns true if the specified machine instr has been removed or was + /// never entered in the map. bool isNotInMIMap(const MachineInstr &Instr) const { return !Indexes->hasIndex(Instr); } @@ -270,35 +277,32 @@ extern cl::opt<bool> UseSegmentSetForPhysRegs; void getAnalysisUsage(AnalysisUsage &AU) const override; void releaseMemory() override; - /// runOnMachineFunction - pass entry point + /// Pass entry point; Calculates LiveIntervals. bool runOnMachineFunction(MachineFunction&) override; - /// print - Implement the dump method. + /// Implement the dump method. void print(raw_ostream &O, const Module* = nullptr) const override; - /// 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. + /// 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. MachineBasicBlock *intervalIsInOneMBB(const LiveInterval &LI) const; /// Returns true if VNI is killed by any PHI-def values in LI. /// This may conservatively return true to avoid expensive computations. bool hasPHIKill(const LiveInterval &LI, const VNInfo *VNI) const; - /// addKillFlags - Add kill flags to any instruction that kills a virtual - /// register. + /// Add kill flags to any instruction that kills a virtual register. void addKillFlags(const VirtRegMap*); - /// 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. + /// Call this method to notify LiveIntervals that instruction \p MI has been + /// moved within a basic block. This will update the live intervals for all + /// operands of \p MI. Moves between basic blocks are not supported. /// /// \param UpdateFlags Update live intervals for nonallocatable physregs. void handleMove(MachineInstr &MI, bool UpdateFlags = false); - /// moveIntoBundle - Update intervals for operands of MI so that they - /// begin/end on the SlotIndex for BundleStart. + /// Update intervals for operands of \p MI so that they begin/end on the + /// SlotIndex for \p BundleStart. /// /// \param UpdateFlags Update live intervals for nonallocatable physregs. /// @@ -308,10 +312,9 @@ extern cl::opt<bool> UseSegmentSetForPhysRegs; void handleMoveIntoBundle(MachineInstr &MI, MachineInstr &BundleStart, bool UpdateFlags = false); - /// 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. + /// 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. @@ -334,34 +337,33 @@ extern cl::opt<bool> UseSegmentSetForPhysRegs; // LiveIntervalAnalysis maintains a sorted list of instructions with // register mask operands. - /// getRegMaskSlots - Returns a sorted array of slot indices of all - /// instructions with register mask operands. + /// Returns a sorted array of slot indices of all instructions with + /// register mask operands. ArrayRef<SlotIndex> getRegMaskSlots() const { return RegMaskSlots; } - /// getRegMaskSlotsInBlock - Returns a sorted array of slot indices of all - /// instructions with register mask operands in the basic block numbered - /// MBBNum. + /// Returns a sorted array of slot indices of all instructions with register + /// mask operands in the basic block numbered \p MBBNum. ArrayRef<SlotIndex> getRegMaskSlotsInBlock(unsigned MBBNum) const { std::pair<unsigned, unsigned> P = RegMaskBlocks[MBBNum]; return getRegMaskSlots().slice(P.first, P.second); } - /// getRegMaskBits() - Returns an array of register mask pointers - /// corresponding to getRegMaskSlots(). + /// Returns an array of register mask pointers corresponding to + /// getRegMaskSlots(). ArrayRef<const uint32_t*> getRegMaskBits() const { return RegMaskBits; } - /// getRegMaskBitsInBlock - Returns an array of mask pointers corresponding - /// to getRegMaskSlotsInBlock(MBBNum). + /// Returns an array of mask pointers corresponding to + /// getRegMaskSlotsInBlock(MBBNum). ArrayRef<const uint32_t*> getRegMaskBitsInBlock(unsigned MBBNum) const { std::pair<unsigned, unsigned> P = RegMaskBlocks[MBBNum]; return getRegMaskBits().slice(P.first, P.second); } - /// 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. + /// Test if \p 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 + /// Returns false if \p LI doesn't cross any register mask instructions. In /// that case, the bit vector is not filled in. bool checkRegMaskInterference(LiveInterval &LI, BitVector &UsableRegs); @@ -377,8 +379,8 @@ extern cl::opt<bool> UseSegmentSetForPhysRegs; // track liveness per register unit to handle aliasing registers more // efficiently. - /// getRegUnit - Return the live range for Unit. - /// It will be computed if it doesn't exist. + /// Return the live range for register unit \p Unit. It will be computed if + /// it doesn't exist. LiveRange &getRegUnit(unsigned Unit) { LiveRange *LR = RegUnitRanges[Unit]; if (!LR) { @@ -390,8 +392,8 @@ extern cl::opt<bool> UseSegmentSetForPhysRegs; return *LR; } - /// getCachedRegUnit - Return the live range for Unit if it has already - /// been computed, or NULL if it hasn't been computed yet. + /// Return the live range for register unit \p Unit if it has already been + /// computed, or nullptr if it hasn't been computed yet. LiveRange *getCachedRegUnit(unsigned Unit) { return RegUnitRanges[Unit]; } @@ -400,7 +402,7 @@ extern cl::opt<bool> UseSegmentSetForPhysRegs; return RegUnitRanges[Unit]; } - /// removeRegUnit - Remove computed live range for Unit. Subsequent uses + /// Remove computed live range for register unit \p Unit. Subsequent uses /// should rely on on-demand recomputation. void removeRegUnit(unsigned Unit) { delete RegUnitRanges[Unit]; @@ -408,12 +410,12 @@ extern cl::opt<bool> UseSegmentSetForPhysRegs; } /// Remove value numbers and related live segments starting at position - /// @p Pos that are part of any liverange of physical register @p Reg or one + /// \p Pos that are part of any liverange of physical register \p Reg or one /// of its subregisters. void removePhysRegDefAt(unsigned Reg, SlotIndex Pos); - /// Remove value number and related live segments of @p LI and its subranges - /// that start at position @p Pos. + /// Remove value number and related live segments of \p LI and its subranges + /// that start at position \p Pos. void removeVRegDefAt(LiveInterval &LI, SlotIndex Pos); /// Split separate components in LiveInterval \p LI into separate intervals. @@ -432,10 +434,10 @@ extern cl::opt<bool> UseSegmentSetForPhysRegs; /// Compute RegMaskSlots and RegMaskBits. void computeRegMasks(); - /// Walk the values in @p LI and check for dead values: + /// Walk the values in \p LI and check for dead values: /// - Dead PHIDef values are marked as unused. /// - Dead operands are marked as such. - /// - Completely dead machine instructions are added to the @p dead vector + /// - Completely dead machine instructions are added to the \p dead vector /// if it is not nullptr. /// Returns true if any PHI value numbers have been removed which may /// have separated the interval into multiple connected components. @@ -453,8 +455,8 @@ extern cl::opt<bool> UseSegmentSetForPhysRegs; /// Helper function for repairIntervalsInRange(), walks backwards and - /// creates/modifies live segments in @p LR to match the operands found. - /// Only full operands or operands with subregisters matching @p LaneMask + /// creates/modifies live segments in \p LR to match the operands found. + /// Only full operands or operands with subregisters matching \p LaneMask /// are considered. void repairOldRegInRange(MachineBasicBlock::iterator Begin, MachineBasicBlock::iterator End, |