| /external/llvm/include/llvm/CodeGen/ |
| CalcSpillWeights.h | 51 LiveIntervals &LIS;
58 VirtRegAuxInfo(MachineFunction &mf, LiveIntervals &lis,
62 : MF(mf), LIS(lis), Loops(loops), MBFI(mbfi), normalize(norm) {}
70 void calculateSpillWeightsAndHints(LiveIntervals &LIS, MachineFunction &MF,
|
| LiveRegMatrix.h | 42 LiveIntervals *LIS;
|
| ScheduleDAGInstrs.h | 83 LiveIntervals *LIS;
161 LiveIntervals *LIS = nullptr);
168 LiveIntervals *getLIS() const { return LIS; }
|
| LiveRangeEdit.h | 63 LiveIntervals &LIS;
110 /// @param lis The collection of all live intervals in this function.
117 LiveIntervals &lis,
121 MRI(MF.getRegInfo()), LIS(lis), VRM(vrm),
210 /// to erase it from LIS.
|
| RegisterPressure.h | 255 const LiveIntervals *LIS;
264 /// or RegisterPressure. If requireIntervals is false, LIS are ignored.
288 MF(nullptr), TRI(nullptr), RCI(nullptr), LIS(nullptr), MBB(nullptr), P(rp),
292 MF(nullptr), TRI(nullptr), RCI(nullptr), LIS(nullptr), MBB(nullptr), P(rp),
298 const LiveIntervals *lis, const MachineBasicBlock *mbb,
|
| /external/llvm/lib/CodeGen/ |
| CalcSpillWeights.cpp | 25 void llvm::calculateSpillWeightsAndHints(LiveIntervals &LIS,
34 VirtRegAuxInfo VRAI(MF, LIS, MLI, MBFI, norm);
39 VRAI.calculateSpillWeightAndHint(LIS.getInterval(Reg));
76 const LiveIntervals &LIS,
86 MachineInstr *MI = LIS.getInstructionFromIndex(VNI->def);
89 if (!TII.isTriviallyReMaterializable(MI, LIS.getAliasAnalysis()))
140 if (writes && isExiting && LIS.isLiveOutOfMBB(li, mbb))
180 if (li.isZeroLength(LIS.getSlotIndexes())) {
189 if (isRematerializable(li, LIS, *MF.getTarget().getInstrInfo()))
|
| RegAllocBase.h | 64 LiveIntervals *LIS;
69 : TRI(nullptr), MRI(nullptr), VRM(nullptr), LIS(nullptr), Matrix(nullptr) {}
74 void init(VirtRegMap &vrm, LiveIntervals &lis, LiveRegMatrix &mat);
|
| LiveDebugVariables.h | 54 LiveIntervals &LIS);
|
| PHIElimination.cpp | 53 LiveIntervals *LIS;
130 LIS = getAnalysisIfAvailable<LiveIntervals>();
139 if (!DisableEdgeSplitting && (LV || LIS)) {
158 if (LIS)
159 LIS->RemoveMachineInstrFromMaps(DefMI);
167 if (LIS)
168 LIS->RemoveMachineInstrFromMaps(I->first);
308 if (LIS) {
310 SlotIndex DestCopyIndex = LIS->InsertMachineInstrInMaps(NewInstr);
312 SlotIndex MBBStartIndex = LIS->getMBBStartIdx(&MBB)
[all...] |
| LiveDebugVariables.cpp | 133 LiveIntervals &LIS, const TargetInstrInfo &TII);
138 LiveIntervals &LIS);
229 /// @param LIS Live intervals analysis.
234 LiveIntervals &LIS, MachineDominatorTree &MDT,
248 LiveIntervals &LIS);
253 LiveIntervals &LIS, MachineDominatorTree &MDT,
259 LiveIntervals &LIS);
267 LiveIntervals &LIS, const TargetInstrInfo &TRI);
287 LiveIntervals *LIS;
486 LIS->getMBBStartIdx(MBB)
[all...] |
| LiveRangeEdit.cpp | 39 LiveInterval &LI = LIS.createEmptyInterval(VReg);
68 MachineInstr *DefMI = LIS.getInstructionFromIndex(VNI->def);
101 LiveInterval &li = LIS.getInterval(MO.getReg());
130 DefIdx = LIS.getInstructionIndex(RM.OrigMI);
133 RM.OrigMI = LIS.getInstructionFromIndex(DefIdx);
157 return LIS.getSlotIndexes()->insertMachineInstrInMaps(--MI, Late)
163 LIS.removeInterval(Reg);
194 LIS.getInstructionIndex(DefMI),
195 LIS.getInstructionIndex(UseMI)))
215 LIS.ReplaceMachineInstrInMaps(UseMI, FoldMI)
[all...] |
| RegAllocBase.cpp | 58 LiveIntervals &lis,
63 LIS = &lis;
78 enqueue(&LIS->getInterval(Reg));
94 LIS->removeInterval(VirtReg->reg);
139 LiveInterval *SplitVirtReg = &LIS->getInterval(*I);
143 LIS->removeInterval(SplitVirtReg->reg);
|
| RegisterCoalescer.cpp | 84 LiveIntervals *LIS;
400 LiveRangeEdit(nullptr, NewRegs, *MF, *LIS,
431 LIS->getInterval(CP.isFlipped() ? CP.getDstReg() : CP.getSrcReg());
433 LIS->getInterval(CP.isFlipped() ? CP.getSrcReg() : CP.getDstReg());
434 SlotIndex CopyIdx = LIS->getInstructionIndex(CopyMI).getRegSlot();
456 MachineInstr *ACopyMI = LIS->getInstructionFromIndex(AValNo->def);
470 LIS->getInstructionFromIndex(ValS->end.getPrevSlot());
509 LIS->shrinkToUses(&IntA);
523 if (LIS->hasPHIKill(IntA, AValNo))
572 SlotIndex CopyIdx = LIS->getInstructionIndex(CopyMI).getRegSlot()
[all...] |
| InlineSpiller.cpp | 61 LiveIntervals &LIS;
146 LIS(pass.getAnalysis<LiveIntervals>()),
237 if (SnipLI.getNumValNums() > 2 || !LIS.intervalIsInOneMBB(SnipLI))
289 LiveInterval &SnipLI = LIS.getInterval(SnipReg);
375 SV.SpillMBB = LIS.getMBBFromIndex(SV.SpillVNI->def);
393 DepSV.SpillMBB = LIS.getMBBFromIndex(DepSV.SpillVNI->def);
545 LiveInterval &LI = LIS.getInterval(Reg);
546 LiveInterval &OrigLI = LIS.getInterval(Original);
591 MachineInstr *MI = LIS.getInstructionFromIndex(VNI->def);
597 LiveInterval &SrcLI = LIS.getInterval(SrcReg)
[all...] |
| TwoAddressInstructionPass.cpp | 77 LiveIntervals *LIS;
173 static bool isPlainlyKilled(MachineInstr *MI, unsigned Reg, LiveIntervals *LIS);
216 if (LIS) {
217 LiveInterval &LI = LIS->getInterval(SavedReg);
221 SlotIndex MBBEndIdx = LIS->getMBBEndIdx(MBB).getPrevSlot();
227 KillMI = LIS->getInstructionFromIndex(I->end);
277 if (MO.isKill() || (LIS && isPlainlyKilled(OtherMI, MOReg, LIS))) {
290 if (!LIS) {
304 if (LIS)
[all...] |
| SplitKit.cpp | 44 const LiveIntervals &lis,
48 LIS(lis),
66 SlotIndex MBBEnd = LIS.getMBBEndIdx(MBB);
75 LSP.first = LIS.getInstructionIndex(FirstTerm);
86 LSP.second = LIS.getInstructionIndex(I);
94 if (!LPad || !LSP.second || !LIS.isLiveInToMBB(*CurLI, LPad))
117 if (LSP == LIS.getMBBEndIdx(MBB))
119 return LIS.getInstructionFromIndex(LSP);
137 UseSlots.push_back(LIS.getInstructionIndex(MO.getParent()).getRegSlot())
[all...] |
| LiveRegMatrix.cpp | 53 LIS = &getAnalysis<LiveIntervals>();
111 LIS->checkRegMaskInterference(VirtReg, RegMaskUsable);
126 const LiveRange &UnitRange = LIS->getRegUnit(*Units);
127 if (VirtReg.overlaps(UnitRange, CP, *LIS->getSlotIndexes()))
|
| InterferenceCache.h | 57 /// LIS - Used for accessing register mask interference maps.
58 LiveIntervals *LIS;
97 Entry() : PhysReg(0), Tag(0), RefCount(0), Indexes(nullptr), LIS(nullptr) {}
99 void clear(MachineFunction *mf, SlotIndexes *indexes, LiveIntervals *lis) {
104 LIS = lis;
|
| SplitKit.h | 46 const LiveIntervals &LIS;
120 SplitAnalysis(const VirtRegMap &vrm, const LiveIntervals &lis,
213 LiveIntervals &LIS;
|
| RegAllocBasic.cpp | 203 LiveRangeEdit LRE(&Spill, SplitVRegs, *MF, *LIS, VRM);
262 LiveRangeEdit LRE(&VirtReg, SplitVRegs, *MF, *LIS, VRM);
280 calculateSpillWeightsAndHints(*LIS, *MF,
|
| RegisterPressure.cpp | 153 return &LIS->getInterval(Reg);
154 return LIS->getCachedRegUnit(Reg);
159 LIS = nullptr;
180 const LiveIntervals *lis,
195 assert(lis && "IntervalPressure requires LiveIntervals");
196 LIS = lis;
232 return LIS->getMBBEndIdx(MBB);
233 return LIS->getInstructionIndex(IdxPos).getRegSlot();
482 SlotIdx = LIS->getInstructionIndex(CurrPos).getRegSlot()
[all...] |
| LiveIntervalAnalysis.cpp | 725 LiveIntervals& LIS;
734 HMEditor(LiveIntervals& LIS, const MachineRegisterInfo& MRI,
737 : LIS(LIS), MRI(MRI), TRI(TRI), OldIdx(OldIdx), NewIdx(NewIdx),
746 return &LIS.getRegUnit(Unit);
747 return LIS.getCachedRegUnit(Unit);
769 LiveInterval &LI = LIS.getInterval(Reg);
843 if (MachineInstr *KillMI = LIS.getInstructionFromIndex(I->end))
[all...] |
| VirtRegMap.cpp | 163 LiveIntervals *LIS;
212 LIS = &getAnalysis<LiveIntervals>();
220 LIS->addKillFlags(VRM);
246 LiveInterval &LI = LIS->getInterval(VirtReg);
247 if (LI.empty() || LIS->intervalIsInOneMBB(LI))
|
| RegAllocGreedy.cpp | 456 Matrix->unassign(LIS->getInterval(VirtReg));
469 LiveInterval &LI = LIS->getInterval(VirtReg);
521 LIS->intervalIsInOneMBB(*LI)) {
557 LiveInterval *LI = &LIS->getInterval(~CurQueue.top().second);
681 bool IsLocal = LIS->intervalIsInOneMBB(VirtReg);
744 if (!MaxCost.isMax() && IsLocal && LIS->intervalIsInOneMBB(*Intf) &&
[all...] |
| /external/llvm/lib/Target/R600/ |
| SIFixSGPRLiveRanges.cpp | 78 LiveIntervals *LIS = &getAnalysis<LiveIntervals>();
99 LiveInterval &LI = LIS->getInterval(Def.getReg());
|
