CbC/CbC_llvm: lib/CodeGen/SplitKit.h comparison

comparison lib/CodeGen/SplitKit.h @ 120:1172e4bd9c6f

update 4.0.0

author	mir3636
date	Fri, 25 Nov 2016 19:14:25 +0900
parents	afa8332a0e37
children	803732b1fca8

comparison

equal deleted inserted replaced

-:34baf5011add
+:1172e4bd9c6f
 #define LLVM_LIB_CODEGEN_SPLITKIT_H
 #include "LiveRangeCalc.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/IntervalMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
 namespace llvm {
 class TargetRegisterInfo;
 class VirtRegMap;
 class VNInfo;
 class raw_ostream;
+/// Determines the latest safe point in a block in which we can insert a split,
+/// spill or other instruction related with CurLI.
+class LLVM_LIBRARY_VISIBILITY InsertPointAnalysis {
+private:
+const LiveIntervals &LIS;
+/// Last legal insert point in each basic block in the current function.
+/// The first entry is the first terminator, the second entry is the
+/// last valid point to insert a split or spill for a variable that is
+/// live into a landing pad successor.
+SmallVector<std::pair<SlotIndex, SlotIndex>, 8> LastInsertPoint;
+SlotIndex computeLastInsertPoint(const LiveInterval &CurLI,
+const MachineBasicBlock &MBB);
+public:
+InsertPointAnalysis(const LiveIntervals &lis, unsigned BBNum);
+/// Return the base index of the last valid insert point for \pCurLI in \pMBB.
+SlotIndex getLastInsertPoint(const LiveInterval &CurLI,
+const MachineBasicBlock &MBB) {
+unsigned Num = MBB.getNumber();
+// Inline the common simple case.
+if (LastInsertPoint[Num].first.isValid() &&
+!LastInsertPoint[Num].second.isValid())
+return LastInsertPoint[Num].first;
+return computeLastInsertPoint(CurLI, MBB);
+}
+/// Returns the last insert point as an iterator for \pCurLI in \pMBB.
+MachineBasicBlock::iterator getLastInsertPointIter(const LiveInterval &CurLI,
+MachineBasicBlock &MBB);
+};
 /// SplitAnalysis - Analyze a LiveInterval, looking for live range splitting
 /// opportunities.
 class LLVM_LIBRARY_VISIBILITY SplitAnalysis {
 public:
 const MachineFunction &MF;
 private:
 // Current live interval.
 const LiveInterval *CurLI;
+/// Insert Point Analysis.
+InsertPointAnalysis IPA;
 // Sorted slot indexes of using instructions.
 SmallVector<SlotIndex, 8> UseSlots;
-/// LastSplitPoint - Last legal split point in each basic block in the current
-/// function. The first entry is the first terminator, the second entry is the
-/// last valid split point for a variable that is live in to a landing pad
-/// successor.
-SmallVector<std::pair<SlotIndex, SlotIndex>, 8> LastSplitPoint;
 /// UseBlocks - Blocks where CurLI has uses.
 SmallVector<BlockInfo, 8> UseBlocks;
 /// NumGapBlocks - Number of duplicate entries in UseBlocks for blocks where
 /// NumThroughBlocks - Number of live-through blocks.
 unsigned NumThroughBlocks;
 /// DidRepairRange - analyze was forced to shrinkToUses().
 bool DidRepairRange;
-SlotIndex computeLastSplitPoint(unsigned Num);
 // Sumarize statistics by counting instructions using CurLI.
 void analyzeUses();
 /// calcLiveBlockInfo - Compute per-block information about CurLI.
 /// new interval.
 void clear();
 /// getParent - Return the last analyzed interval.
 const LiveInterval &getParent() const { return *CurLI; }
-/// getLastSplitPoint - Return the base index of the last valid split point
-/// in the basic block numbered Num.
-SlotIndex getLastSplitPoint(unsigned Num) {
-// Inline the common simple case.
-if (LastSplitPoint[Num].first.isValid() &&
-!LastSplitPoint[Num].second.isValid())
-return LastSplitPoint[Num].first;
-return computeLastSplitPoint(Num);
-}
-/// getLastSplitPointIter - Returns the last split point as an iterator.
-MachineBasicBlock::iterator getLastSplitPointIter(MachineBasicBlock*);
 /// isOriginalEndpoint - Return true if the original live range was killed or
 /// (re-)defined at Idx. Idx should be the 'def' slot for a normal kill/def,
 /// and 'use' for an early-clobber def.
 /// This can be used to recognize code inserted by earlier live range
 /// class.
 ///
 /// @param BI           The block to be isolated.
 /// @param SingleInstrs True when single instructions should be isolated.
 bool shouldSplitSingleBlock(const BlockInfo &BI, bool SingleInstrs) const;
+SlotIndex getLastSplitPoint(unsigned Num) {
+return IPA.getLastInsertPoint(*CurLI, *MF.getBlockNumbered(Num));
+}
+MachineBasicBlock::iterator getLastSplitPointIter(MachineBasicBlock *BB) {
+return IPA.getLastInsertPointIter(*CurLI, *BB);
+}
 };
 /// SplitEditor - Edit machine code and LiveIntervals for live range
 /// splitting.
 /// - Finish the current interval with closeIntv and repeat from 2.
 /// - Rewrite instructions with finish().
 ///
 class LLVM_LIBRARY_VISIBILITY SplitEditor {
 SplitAnalysis &SA;
+AliasAnalysis &AA;
 LiveIntervals &LIS;
 VirtRegMap &VRM;
 MachineRegisterInfo &MRI;
 MachineDominatorTree &MDT;
 const TargetInstrInfo &TII;
 /// LRCalc instance.  When not in spill mode, all intervals can share one.
 LiveRangeCalc &getLRCalc(unsigned RegIdx) {
 return LRCalc[SpillMode != SM_Partition && RegIdx != 0];
 }
+/// Find a subrange corresponding to the lane mask @p LM in the live
+/// interval @p LI. The interval @p LI is assumed to contain such a subrange.
+/// This function is used to find corresponding subranges between the
+/// original interval and the new intervals.
+LiveInterval::SubRange &getSubRangeForMask(LaneBitmask LM, LiveInterval &LI);
+/// Add a segment to the interval LI for the value number VNI. If LI has
+/// subranges, corresponding segments will be added to them as well, but
+/// with newly created value numbers. If Original is true, dead def will
+/// only be added a subrange of LI if the corresponding subrange of the
+/// original interval has a def at this index. Otherwise, all subranges
+/// of LI will be updated.
+void addDeadDef(LiveInterval &LI, VNInfo *VNI, bool Original);
 /// defValue - define a value in RegIdx from ParentVNI at Idx.
 /// Idx does not have to be ParentVNI->def, but it must be contained within
 /// ParentVNI's live range in ParentLI. The new value is added to the value
-/// map.
+/// map. The value being defined may either come from rematerialization
+/// (or an inserted copy), or it may be coming from the original interval.
+/// The parameter Original should be true in the latter case, otherwise
+/// it should be false.
 /// Return the new LI value.
-VNInfo *defValue(unsigned RegIdx, const VNInfo *ParentVNI, SlotIndex Idx);
+VNInfo *defValue(unsigned RegIdx, const VNInfo *ParentVNI, SlotIndex Idx,
+bool Original);
 /// forceRecompute - Force the live range of ParentVNI in RegIdx to be
 /// recomputed by LiveRangeCalc::extend regardless of the number of defs.
 /// This is used for values whose live range doesn't match RegAssign exactly.
 /// They could have rematerialized, or back-copies may have been moved.
 /// getShallowDominator - Returns the least busy dominator of MBB that is
 /// also dominated by DefMBB.  Busy is measured by loop depth.
 MachineBasicBlock *findShallowDominator(MachineBasicBlock *MBB,
 MachineBasicBlock *DefMBB);
-/// hoistCopiesForSize - Hoist back-copies to the complement interval in a
+/// Find out all the backCopies dominated by others.
-/// way that minimizes code size. This implements the SM_Size spill mode.
+void computeRedundantBackCopies(DenseSet<unsigned> &NotToHoistSet,
-void hoistCopiesForSize();
+SmallVectorImpl<VNInfo *> &BackCopies);
+/// Hoist back-copies to the complement interval. It tries to hoist all
+/// the back-copies to one BB if it is beneficial, or else simply remove
+/// redundant backcopies dominated by others.
+void hoistCopies();
 /// transferValues - Transfer values to the new ranges.
 /// Return true if any ranges were skipped.
 bool transferValues();
+/// Live range @p LR corresponding to the lane Mask @p LM has a live
+/// PHI def at the beginning of block @p B. Extend the range @p LR of
+/// all predecessor values that reach this def. If @p LR is a subrange,
+/// the array @p Undefs is the set of all locations where it is undefined
+/// via <def,read-undef> in other subranges for the same register.
+void extendPHIRange(MachineBasicBlock &B, LiveRangeCalc &LRC,
+LiveRange &LR, LaneBitmask LM,
+ArrayRef<SlotIndex> Undefs);
 /// extendPHIKillRanges - Extend the ranges of all values killed by original
 /// parent PHIDefs.
 void extendPHIKillRanges();
 /// rewriteAssigned - Rewrite all uses of Edit.getReg() to assigned registers.
 void deleteRematVictims();
 public:
 /// Create a new SplitEditor for editing the LiveInterval analyzed by SA.
 /// Newly created intervals will be appended to newIntervals.
-SplitEditor(SplitAnalysis &SA, LiveIntervals&, VirtRegMap&,
+SplitEditor(SplitAnalysis &SA, AliasAnalysis &AA, LiveIntervals&,
-MachineDominatorTree&, MachineBlockFrequencyInfo &);
+VirtRegMap&, MachineDominatorTree&,
+MachineBlockFrequencyInfo &);
 /// reset - Prepare for a new split.
 void reset(LiveRangeEdit&, ComplementSpillMode = SM_Partition);
 /// Create a new virtual register and live interval.

Mercurial > hg > CbC > CbC_llvm

comparison lib/CodeGen/SplitKit.h @ 120:1172e4bd9c6f