| /external/llvm/include/llvm/CodeGen/ |
| LiveRegMatrix.h | 33 class LiveInterval;
105 InterferenceKind checkInterference(LiveInterval &VirtReg, unsigned PhysReg);
110 void assign(LiveInterval &VirtReg, unsigned PhysReg);
115 void unassign(LiveInterval &VirtReg);
127 bool checkRegMaskInterference(LiveInterval &VirtReg, unsigned PhysReg = 0);
132 bool checkRegUnitInterference(LiveInterval &VirtReg, unsigned PhysReg);
138 LiveIntervalUnion::Query &query(LiveInterval &VirtReg, unsigned RegUnit);
|
| LiveIntervalUnion.h | 21 #include "llvm/CodeGen/LiveInterval.h"
35 overlap(const LiveInterval::Segment &VRSeg,
36 const IntervalMap<SlotIndex, LiveInterval*>::const_iterator &LUSeg) {
48 typedef IntervalMap<SlotIndex, LiveInterval*> LiveSegments;
87 void unify(LiveInterval &VirtReg);
90 void extract(LiveInterval &VirtReg);
107 LiveInterval *VirtReg;
108 LiveInterval::iterator VirtRegI; // current position in VirtReg
110 SmallVector<LiveInterval*,4> InterferingVRegs;
119 Query(LiveInterval *VReg, LiveIntervalUnion *LIU)
[all...] |
| LiveIntervalAnalysis.h | 10 // This file implements the LiveInterval analysis pass. Given some numbering of
25 #include "llvm/CodeGen/LiveInterval.h"
61 /// Special pool allocator for VNInfo's (LiveInterval val#).
66 IndexedMap<LiveInterval*, VirtReg2IndexFunctor> VirtRegIntervals;
84 /// Also see the comment in LiveInterval::find().
108 LiveInterval &getInterval(unsigned Reg) {
115 const LiveInterval &getInterval(unsigned Reg) const {
124 LiveInterval &createEmptyInterval(unsigned Reg) {
131 LiveInterval &createAndComputeVirtRegInterval(unsigned Reg) {
132 LiveInterval &LI = createEmptyInterval(Reg)
[all...] |
| LiveRangeEdit.h | 24 #include "llvm/CodeGen/LiveInterval.h"
60 LiveInterval *Parent;
92 bool foldAsLoad(LiveInterval *LI, SmallVectorImpl<MachineInstr*> &Dead);
94 typedef SetVector<LiveInterval*,
95 SmallVector<LiveInterval*, 8>,
96 SmallPtrSet<LiveInterval*, 8> > ToShrinkSet;
114 LiveRangeEdit(LiveInterval *parent,
129 LiveInterval &getParent() const {
130 assert(Parent && "No parent LiveInterval");
148 LiveInterval &createEmptyIntervalFrom(unsigned OldReg)
[all...] |
| CalcSpillWeights.h | 19 class LiveInterval;
65 void calculateSpillWeightAndHint(LiveInterval &li);
|
| LiveStackAnalysis.h | 19 #include "llvm/CodeGen/LiveInterval.h"
30 /// Special pool allocator for VNInfo's (LiveInterval val#).
36 typedef std::map<int, LiveInterval> SS2IntervalMap;
57 LiveInterval &getOrCreateInterval(int Slot, const TargetRegisterClass *RC);
59 LiveInterval &getInterval(int Slot) {
66 const LiveInterval &getInterval(int Slot) const {
|
| /art/compiler/optimizing/ |
| register_allocator.h | 31 class LiveInterval;
60 static bool ValidateIntervals(const GrowableArray<LiveInterval*>& intervals,
82 bool TryAllocateFreeReg(LiveInterval* interval);
83 bool AllocateBlockedReg(LiveInterval* interval);
87 void AddToUnhandled(LiveInterval* interval);
90 LiveInterval* Split(LiveInterval* interval, size_t at);
99 void AllocateSpillSlotFor(LiveInterval* interval);
100 void AllocateOneSpillSlot(LiveInterval* interval, size_t end);
101 void AllocateTwoSpillSlots(LiveInterval* interval, size_t end)
[all...] |
| live_interval_test.cc | 25 TEST(LiveInterval, GetStart) {
31 LiveInterval* interval = BuildInterval(ranges, arraysize(ranges), &allocator);
37 LiveInterval* interval = BuildInterval(ranges, arraysize(ranges), &allocator);
42 TEST(LiveInterval, IsDeadAt) {
48 LiveInterval* interval = BuildInterval(ranges, arraysize(ranges), &allocator);
58 LiveInterval* interval = BuildInterval(ranges, arraysize(ranges), &allocator);
70 TEST(LiveInterval, Covers) {
76 LiveInterval* interval = BuildInterval(ranges, arraysize(ranges), &allocator);
86 LiveInterval* interval = BuildInterval(ranges, arraysize(ranges), &allocator);
98 TEST(LiveInterval, FirstIntersectionWith)
[all...] |
| optimizing_unit_test.h | 39 LiveInterval* BuildInterval(const size_t ranges[][2],
43 LiveInterval* interval = new (allocator) LiveInterval(allocator, Primitive::kPrimInt);
|
| register_allocator.cc | 66 static bool ShouldProcess(bool processing_core_registers, LiveInterval* interval) {
93 LiveInterval* interval = physical_register_intervals_.Get(reg);
95 interval = LiveInterval::MakeFixedInterval(allocator_, reg, type);
117 LiveInterval* current = instruction->GetLiveInterval();
160 LiveInterval* split = Split(current, first_register_use - 1);
179 explicit AllRangesIterator(LiveInterval* interval)
185 LiveInterval* CurrentInterval() const { return current_interval_; }
198 LiveInterval* current_interval_;
207 GrowableArray<LiveInterval*> intervals(allocator_, 0);
216 LiveInterval* fixed = physical_register_intervals_.Get(i)
[all...] |
| ssa_liveness_analysis.h | 82 friend class LiveInterval;
134 class LiveInterval : public ArenaObject {
136 LiveInterval(ArenaAllocator* allocator, Primitive::Type type, HInstruction* defined_by = nullptr)
149 static LiveInterval* MakeFixedInterval(ArenaAllocator* allocator, int reg, Primitive::Type type) {
150 LiveInterval* interval = new (allocator) LiveInterval(allocator, type);
232 LiveInterval* GetParent() const { return parent_; }
259 size_t FirstIntersectionWith(LiveInterval* other) const {
344 LiveInterval* SplitAt(size_t position) {
353 LiveInterval* new_interval = new (allocator_) LiveInterval(allocator_, type_)
[all...] |
| /external/llvm/lib/CodeGen/ |
| RegAllocBase.h | 40 #include "llvm/CodeGen/LiveInterval.h"
84 virtual void enqueue(LiveInterval *LI) = 0;
87 virtual LiveInterval *dequeue() = 0;
93 virtual unsigned selectOrSplit(LiveInterval &VirtReg,
|
| LiveIntervalUnion.cpp | 28 // Merge a LiveInterval's segments. Guarantee no overlaps.
29 void LiveIntervalUnion::unify(LiveInterval &VirtReg) {
35 LiveInterval::iterator RegPos = VirtReg.begin();
36 LiveInterval::iterator RegEnd = VirtReg.end();
56 void LiveIntervalUnion::extract(LiveInterval &VirtReg) {
62 LiveInterval::iterator RegPos = VirtReg.begin();
63 LiveInterval::iterator RegEnd = VirtReg.end();
67 assert(SegPos.value() == &VirtReg && "Inconsistent LiveInterval");
104 bool LiveIntervalUnion::Query::isSeenInterference(LiveInterval *VirtReg) const {
105 SmallVectorImpl<LiveInterval*>::const_iterator I
[all...] |
| RegAllocBasic.cpp | 50 bool operator()(LiveInterval *A, LiveInterval *B) const {
69 std::priority_queue<LiveInterval*, std::vector<LiveInterval*>,
91 void enqueue(LiveInterval *LI) override {
95 LiveInterval *dequeue() override {
98 LiveInterval *LI = Queue.top();
103 unsigned selectOrSplit(LiveInterval &VirtReg,
112 bool spillInterferences(LiveInterval &VirtReg, unsigned PhysReg,
167 bool RABasic::spillInterferences(LiveInterval &VirtReg, unsigned PhysReg
[all...] |
| LiveDebugVariables.h | 30 class LiveInterval;
|
| LiveRegMatrix.cpp | 75 void LiveRegMatrix::assign(LiveInterval &VirtReg, unsigned PhysReg) {
89 void LiveRegMatrix::unassign(LiveInterval &VirtReg) {
102 bool LiveRegMatrix::checkRegMaskInterference(LiveInterval &VirtReg,
120 bool LiveRegMatrix::checkRegUnitInterference(LiveInterval &VirtReg,
133 LiveIntervalUnion::Query &LiveRegMatrix::query(LiveInterval &VirtReg,
141 LiveRegMatrix::checkInterference(LiveInterval &VirtReg, unsigned PhysReg) {
|
| LiveStackAnalysis.cpp | 58 LiveInterval &
64 LiveInterval(TargetRegisterInfo::index2StackSlot(Slot), 0.0F)));
|
| StackSlotColoring.cpp | 55 std::vector<LiveInterval*> SSIntervals;
82 SmallVector<SmallVector<LiveInterval*,4>, 16> Assignments;
107 bool OverlapWithAssignments(LiveInterval *li, int Color) const;
108 int ColorSlot(LiveInterval *li);
131 bool operator()(LiveInterval* LHS, LiveInterval* RHS) const {
158 LiveInterval &li = LS->getInterval(FI);
190 LiveInterval &li = i->second;
209 /// OverlapWithAssignments - Return true if LiveInterval overlaps with any
212 StackSlotColoring::OverlapWithAssignments(LiveInterval *li, int Color) const
[all...] |
| SplitKit.h | 27 class LiveInterval;
40 /// SplitAnalysis - Analyze a LiveInterval, looking for live range splitting
84 const LiveInterval *CurLI;
125 void analyze(const LiveInterval *li);
137 const LiveInterval &getParent() const { return *CurLI; }
184 unsigned countLiveBlocks(const LiveInterval *li) const;
351 /// Create a new SplitEditor for editing the LiveInterval analyzed by SA.
|
| InlineSpiller.cpp | 75 LiveInterval *StackInt;
161 bool isSnippet(const LiveInterval &SnipLI);
174 bool hoistSpill(LiveInterval &SpillLI, MachineInstr *CopyMI);
175 void eliminateRedundantSpills(LiveInterval &LI, VNInfo *VNI);
177 void markValueUsed(LiveInterval*, VNInfo*);
178 bool reMaterializeFor(LiveInterval&, MachineBasicBlock::iterator MI);
227 bool InlineSpiller::isSnippet(const LiveInterval &SnipLI) {
289 LiveInterval &SnipLI = LIS.getInterval(SnipReg);
545 LiveInterval &LI = LIS.getInterval(Reg);
546 LiveInterval &OrigLI = LIS.getInterval(Original)
[all...] |
| LiveRangeCalc.h | 27 #include "llvm/CodeGen/LiveInterval.h"
171 void createDeadDefs(LiveInterval &LI) {
182 void extendToUses(LiveInterval &LI) {
|
| RegAllocGreedy.cpp | 104 typedef SmallPtrSet<LiveInterval *, 4> SmallLISet;
197 LiveRangeStage getStage(const LiveInterval &VirtReg) const {
201 void setStage(const LiveInterval &VirtReg, LiveRangeStage Stage) {
311 void enqueue(LiveInterval *LI) override;
312 LiveInterval *dequeue() override;
313 unsigned selectOrSplit(LiveInterval&, SmallVectorImpl<unsigned>&) override;
321 unsigned selectOrSplitImpl(LiveInterval &, SmallVectorImpl<unsigned> &,
327 void enqueue(PQueue &CurQueue, LiveInterval *LI);
328 LiveInterval *dequeue(PQueue &CurQueue);
338 unsigned canReassign(LiveInterval &VirtReg, unsigned PhysReg)
[all...] |
| LiveRangeEdit.cpp | 34 LiveInterval &LiveRangeEdit::createEmptyIntervalFrom(unsigned OldReg) {
39 LiveInterval &LI = LIS.createEmptyInterval(VReg);
63 for (LiveInterval::vni_iterator I = getParent().vni_begin(),
101 LiveInterval &li = LIS.getInterval(MO.getReg());
166 bool LiveRangeEdit::foldAsLoad(LiveInterval *LI,
272 LiveInterval &LI = LIS.getInterval(Reg);
344 LiveInterval *LI = ToShrink.back();
376 SmallVector<LiveInterval*, 8> Dups(1, LI);
412 LiveInterval &LI = LIS.getInterval(get(I));
|
| CalcSpillWeights.cpp | 75 static bool isRematerializable(const LiveInterval &LI,
78 for (LiveInterval::const_vni_iterator I = LI.vni_begin(), E = LI.vni_end();
96 VirtRegAuxInfo::calculateSpillWeightAndHint(LiveInterval &li) {
|
| SplitKit.cpp | 128 for (LiveInterval::const_vni_iterator I = CurLI->vni_begin(),
155 .shrinkToUses(const_cast<LiveInterval*>(CurLI));
177 LiveInterval::const_iterator LVI = CurLI->begin();
178 LiveInterval::const_iterator LVE = CurLI->end();
275 unsigned SplitAnalysis::countLiveBlocks(const LiveInterval *cli) const {
278 LiveInterval *li = const_cast<LiveInterval*>(cli);
279 LiveInterval::iterator LVI = li->begin();
280 LiveInterval::iterator LVE = li->end();
300 const LiveInterval &Orig = LIS.getInterval(OrigReg)
[all...] |
