From 078628465b73348b5608ec6aa2d7181679543903 Mon Sep 17 00:00:00 2001 From: Jakob Stoklund Olesen Date: Wed, 26 Jan 2011 00:50:53 +0000 Subject: [PATCH] Rename member variables to follow the rest of LLVM. No functional change. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@124257 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/CodeGen/SplitKit.cpp | 438 +++++++++++++++++++-------------------- lib/CodeGen/SplitKit.h | 152 +++++++------- 2 files changed, 295 insertions(+), 295 deletions(-) diff --git a/lib/CodeGen/SplitKit.cpp b/lib/CodeGen/SplitKit.cpp index 01deab15739..daa3140c153 100644 --- a/lib/CodeGen/SplitKit.cpp +++ b/lib/CodeGen/SplitKit.cpp @@ -41,51 +41,51 @@ AllowSplit("spiller-splits-edges", SplitAnalysis::SplitAnalysis(const MachineFunction &mf, const LiveIntervals &lis, const MachineLoopInfo &mli) - : mf_(mf), - lis_(lis), - loops_(mli), - tii_(*mf.getTarget().getInstrInfo()), - curli_(0) {} + : MF(mf), + LIS(lis), + Loops(mli), + TII(*mf.getTarget().getInstrInfo()), + CurLI(0) {} void SplitAnalysis::clear() { UseSlots.clear(); - usingInstrs_.clear(); - usingBlocks_.clear(); - usingLoops_.clear(); - curli_ = 0; + UsingInstrs.clear(); + UsingBlocks.clear(); + UsingLoops.clear(); + CurLI = 0; } bool SplitAnalysis::canAnalyzeBranch(const MachineBasicBlock *MBB) { MachineBasicBlock *T, *F; SmallVector Cond; - return !tii_.AnalyzeBranch(const_cast(*MBB), T, F, Cond); + return !TII.AnalyzeBranch(const_cast(*MBB), T, F, Cond); } -/// analyzeUses - Count instructions, basic blocks, and loops using curli. +/// analyzeUses - Count instructions, basic blocks, and loops using CurLI. void SplitAnalysis::analyzeUses() { - const MachineRegisterInfo &MRI = mf_.getRegInfo(); - for (MachineRegisterInfo::reg_iterator I = MRI.reg_begin(curli_->reg); + const MachineRegisterInfo &MRI = MF.getRegInfo(); + for (MachineRegisterInfo::reg_iterator I = MRI.reg_begin(CurLI->reg); MachineInstr *MI = I.skipInstruction();) { - if (MI->isDebugValue() || !usingInstrs_.insert(MI)) + if (MI->isDebugValue() || !UsingInstrs.insert(MI)) continue; - UseSlots.push_back(lis_.getInstructionIndex(MI).getDefIndex()); + UseSlots.push_back(LIS.getInstructionIndex(MI).getDefIndex()); MachineBasicBlock *MBB = MI->getParent(); - if (usingBlocks_[MBB]++) + if (UsingBlocks[MBB]++) continue; - for (MachineLoop *Loop = loops_.getLoopFor(MBB); Loop; + for (MachineLoop *Loop = Loops.getLoopFor(MBB); Loop; Loop = Loop->getParentLoop()) - usingLoops_[Loop]++; + UsingLoops[Loop]++; } array_pod_sort(UseSlots.begin(), UseSlots.end()); DEBUG(dbgs() << " counted " - << usingInstrs_.size() << " instrs, " - << usingBlocks_.size() << " blocks, " - << usingLoops_.size() << " loops.\n"); + << UsingInstrs.size() << " instrs, " + << UsingBlocks.size() << " blocks, " + << UsingLoops.size() << " loops.\n"); } void SplitAnalysis::print(const BlockPtrSet &B, raw_ostream &OS) const { for (BlockPtrSet::const_iterator I = B.begin(), E = B.end(); I != E; ++I) { - unsigned count = usingBlocks_.lookup(*I); + unsigned count = UsingBlocks.lookup(*I); OS << " BB#" << (*I)->getNumber(); if (count) OS << '(' << count << ')'; @@ -127,12 +127,12 @@ void SplitAnalysis::print(const LoopBlocks &B, raw_ostream &OS) const { print(B.Exits, OS); } -/// analyzeLoopPeripheralUse - Return an enum describing how curli_ is used in +/// analyzeLoopPeripheralUse - Return an enum describing how CurLI is used in /// and around the Loop. SplitAnalysis::LoopPeripheralUse SplitAnalysis:: analyzeLoopPeripheralUse(const SplitAnalysis::LoopBlocks &Blocks) { LoopPeripheralUse use = ContainedInLoop; - for (BlockCountMap::iterator I = usingBlocks_.begin(), E = usingBlocks_.end(); + for (BlockCountMap::iterator I = UsingBlocks.begin(), E = UsingBlocks.end(); I != E; ++I) { const MachineBasicBlock *MBB = I->first; // Is this a peripheral block? @@ -159,7 +159,7 @@ void SplitAnalysis::getCriticalExits(const SplitAnalysis::LoopBlocks &Blocks, BlockPtrSet &CriticalExits) { CriticalExits.clear(); - // A critical exit block has curli live-in, and has a predecessor that is not + // A critical exit block has CurLI live-in, and has a predecessor that is not // in the loop nor a loop predecessor. For such an exit block, the edges // carrying the new variable must be moved to a new pre-exit block. for (BlockPtrSet::iterator I = Blocks.Exits.begin(), E = Blocks.Exits.end(); @@ -168,8 +168,8 @@ void SplitAnalysis::getCriticalExits(const SplitAnalysis::LoopBlocks &Blocks, // A single-predecessor exit block is definitely not a critical edge. if (Exit->pred_size() == 1) continue; - // This exit may not have curli live in at all. No need to split. - if (!lis_.isLiveInToMBB(*curli_, Exit)) + // This exit may not have CurLI live in at all. No need to split. + if (!LIS.isLiveInToMBB(*CurLI, Exit)) continue; // Does this exit block have a predecessor that is not a loop block or loop // predecessor? @@ -189,8 +189,8 @@ void SplitAnalysis::getCriticalPreds(const SplitAnalysis::LoopBlocks &Blocks, BlockPtrSet &CriticalPreds) { CriticalPreds.clear(); - // A critical predecessor block has curli live-out, and has a successor that - // has curli live-in and is not in the loop nor a loop exit block. For such a + // A critical predecessor block has CurLI live-out, and has a successor that + // has CurLI live-in and is not in the loop nor a loop exit block. For such a // predecessor block, we must carry the value in both the 'inside' and // 'outside' registers. for (BlockPtrSet::iterator I = Blocks.Preds.begin(), E = Blocks.Preds.end(); @@ -199,8 +199,8 @@ void SplitAnalysis::getCriticalPreds(const SplitAnalysis::LoopBlocks &Blocks, // Definitely not a critical edge. if (Pred->succ_size() == 1) continue; - // This block may not have curli live out at all if there is a PHI. - if (!lis_.isLiveOutOfMBB(*curli_, Pred)) + // This block may not have CurLI live out at all if there is a PHI. + if (!LIS.isLiveOutOfMBB(*CurLI, Pred)) continue; // Does this block have a successor outside the loop? for (MachineBasicBlock::const_pred_iterator SI = Pred->succ_begin(), @@ -208,7 +208,7 @@ void SplitAnalysis::getCriticalPreds(const SplitAnalysis::LoopBlocks &Blocks, const MachineBasicBlock *Succ = *SI; if (Blocks.Loop.count(Succ) || Blocks.Exits.count(Succ)) continue; - if (!lis_.isLiveInToMBB(*curli_, Succ)) + if (!LIS.isLiveInToMBB(*CurLI, Succ)) continue; // This is a critical predecessor block. CriticalPreds.insert(Pred); @@ -245,7 +245,7 @@ SplitAnalysis::canSplitCriticalExits(const SplitAnalysis::LoopBlocks &Blocks, // If Succ's layout predecessor falls through, that too must be analyzable. // We need to insert the pre-exit block in the gap. MachineFunction::const_iterator MFI = Succ; - if (MFI == mf_.begin()) + if (MFI == MF.begin()) continue; if (!canAnalyzeBranch(--MFI)) return false; @@ -256,21 +256,21 @@ SplitAnalysis::canSplitCriticalExits(const SplitAnalysis::LoopBlocks &Blocks, void SplitAnalysis::analyze(const LiveInterval *li) { clear(); - curli_ = li; + CurLI = li; analyzeUses(); } void SplitAnalysis::getSplitLoops(LoopPtrSet &Loops) { - assert(curli_ && "Call analyze() before getSplitLoops"); - if (usingLoops_.empty()) + assert(CurLI && "Call analyze() before getSplitLoops"); + if (UsingLoops.empty()) return; LoopBlocks Blocks; BlockPtrSet CriticalExits; - // We split around loops where curli is used outside the periphery. - for (LoopCountMap::const_iterator I = usingLoops_.begin(), - E = usingLoops_.end(); I != E; ++I) { + // We split around loops where CurLI is used outside the periphery. + for (LoopCountMap::const_iterator I = UsingLoops.begin(), + E = UsingLoops.end(); I != E; ++I) { const MachineLoop *Loop = I->first; getLoopBlocks(Loop, Blocks); DEBUG({ dbgs() << " "; print(Blocks, dbgs()); }); @@ -320,7 +320,7 @@ const MachineLoop *SplitAnalysis::getBestSplitLoop() { SlotIndex BestIdx; for (LoopPtrSet::const_iterator I = Loops.begin(), E = Loops.end(); I != E; ++I) { - SlotIndex Idx = lis_.getMBBStartIdx((*I)->getHeader()); + SlotIndex Idx = LIS.getMBBStartIdx((*I)->getHeader()); if (!Best || Idx < BestIdx) Best = *I, BestIdx = Idx; } @@ -328,25 +328,25 @@ const MachineLoop *SplitAnalysis::getBestSplitLoop() { return Best; } -/// isBypassLoop - Return true if curli is live through Loop and has no uses +/// isBypassLoop - Return true if CurLI is live through Loop and has no uses /// inside the loop. Bypass loops are candidates for splitting because it can /// prevent interference inside the loop. bool SplitAnalysis::isBypassLoop(const MachineLoop *Loop) { - // If curli is live into the loop header and there are no uses in the loop, it + // If CurLI is live into the loop header and there are no uses in the loop, it // must be live in the entire loop and live on at least one exiting edge. - return !usingLoops_.count(Loop) && - lis_.isLiveInToMBB(*curli_, Loop->getHeader()); + return !UsingLoops.count(Loop) && + LIS.isLiveInToMBB(*CurLI, Loop->getHeader()); } /// getBypassLoops - Get all the maximal bypass loops. These are the bypass /// loops whose parent is not a bypass loop. void SplitAnalysis::getBypassLoops(LoopPtrSet &BypassLoops) { - SmallVector Todo(loops_.begin(), loops_.end()); + SmallVector Todo(Loops.begin(), Loops.end()); while (!Todo.empty()) { MachineLoop *Loop = Todo.pop_back_val(); - if (!usingLoops_.count(Loop)) { + if (!UsingLoops.count(Loop)) { // This is either a bypass loop or completely irrelevant. - if (lis_.isLiveInToMBB(*curli_, Loop->getHeader())) + if (LIS.isLiveInToMBB(*CurLI, Loop->getHeader())) BypassLoops.insert(Loop); // Either way, skip the child loops. continue; @@ -370,26 +370,26 @@ makeVV(const VNInfo *a, VNInfo *b) { } void LiveIntervalMap::reset(LiveInterval *li) { - li_ = li; - valueMap_.clear(); - liveOutCache_.clear(); + LI = li; + Values.clear(); + LiveOutCache.clear(); } bool LiveIntervalMap::isComplexMapped(const VNInfo *ParentVNI) const { - ValueMap::const_iterator i = valueMap_.find(ParentVNI); - return i != valueMap_.end() && i->second == 0; + ValueMap::const_iterator i = Values.find(ParentVNI); + return i != Values.end() && i->second == 0; } -// defValue - Introduce a li_ def for ParentVNI that could be later than +// defValue - Introduce a LI def for ParentVNI that could be later than // ParentVNI->def. VNInfo *LiveIntervalMap::defValue(const VNInfo *ParentVNI, SlotIndex Idx) { - assert(li_ && "call reset first"); + assert(LI && "call reset first"); assert(ParentVNI && "Mapping NULL value"); assert(Idx.isValid() && "Invalid SlotIndex"); - assert(parentli_.getVNInfoAt(Idx) == ParentVNI && "Bad ParentVNI"); + assert(ParentLI.getVNInfoAt(Idx) == ParentVNI && "Bad ParentVNI"); // Create a new value. - VNInfo *VNI = li_->getNextValue(Idx, 0, lis_.getVNInfoAllocator()); + VNInfo *VNI = LI->getNextValue(Idx, 0, LIS.getVNInfoAllocator()); // Preserve the PHIDef bit. if (ParentVNI->isPHIDef() && Idx == ParentVNI->def) @@ -397,7 +397,7 @@ VNInfo *LiveIntervalMap::defValue(const VNInfo *ParentVNI, SlotIndex Idx) { // Use insert for lookup, so we can add missing values with a second lookup. std::pair InsP = - valueMap_.insert(makeVV(ParentVNI, Idx == ParentVNI->def ? VNI : 0)); + Values.insert(makeVV(ParentVNI, Idx == ParentVNI->def ? VNI : 0)); // This is now a complex def. Mark with a NULL in valueMap. if (!InsP.second) @@ -411,20 +411,20 @@ VNInfo *LiveIntervalMap::defValue(const VNInfo *ParentVNI, SlotIndex Idx) { // Potentially create phi-def values. VNInfo *LiveIntervalMap::mapValue(const VNInfo *ParentVNI, SlotIndex Idx, bool *simple) { - assert(li_ && "call reset first"); + assert(LI && "call reset first"); assert(ParentVNI && "Mapping NULL value"); assert(Idx.isValid() && "Invalid SlotIndex"); - assert(parentli_.getVNInfoAt(Idx) == ParentVNI && "Bad ParentVNI"); + assert(ParentLI.getVNInfoAt(Idx) == ParentVNI && "Bad ParentVNI"); // Use insert for lookup, so we can add missing values with a second lookup. std::pair InsP = - valueMap_.insert(makeVV(ParentVNI, 0)); + Values.insert(makeVV(ParentVNI, 0)); // This was an unknown value. Create a simple mapping. if (InsP.second) { if (simple) *simple = true; - return InsP.first->second = li_->createValueCopy(ParentVNI, - lis_.getVNInfoAllocator()); + return InsP.first->second = LI->createValueCopy(ParentVNI, + LIS.getVNInfoAllocator()); } // This was a simple mapped value. @@ -436,7 +436,7 @@ VNInfo *LiveIntervalMap::mapValue(const VNInfo *ParentVNI, SlotIndex Idx, // This is a complex mapped value. There may be multiple defs, and we may need // to create phi-defs. if (simple) *simple = false; - MachineBasicBlock *IdxMBB = lis_.getMBBFromIndex(Idx); + MachineBasicBlock *IdxMBB = LIS.getMBBFromIndex(Idx); assert(IdxMBB && "No MBB at Idx"); // Is there a def in the same MBB we can extend? @@ -448,14 +448,14 @@ VNInfo *LiveIntervalMap::mapValue(const VNInfo *ParentVNI, SlotIndex Idx, // Perform a search for all predecessor blocks where we know the dominating // VNInfo. Insert phi-def VNInfos along the path back to IdxMBB. DEBUG(dbgs() << "\n Reaching defs for BB#" << IdxMBB->getNumber() - << " at " << Idx << " in " << *li_ << '\n'); + << " at " << Idx << " in " << *LI << '\n'); DEBUG(dumpCache()); - // Blocks where li_ should be live-in. + // Blocks where LI should be live-in. SmallVector LiveIn; - LiveIn.push_back(mdt_[IdxMBB]); + LiveIn.push_back(MDT[IdxMBB]); - // Using liveOutCache_ as a visited set, perform a BFS for all reaching defs. + // Using LiveOutCache as a visited set, perform a BFS for all reaching defs. for (unsigned i = 0; i != LiveIn.size(); ++i) { MachineBasicBlock *MBB = LiveIn[i]->getBlock(); for (MachineBasicBlock::pred_iterator PI = MBB->pred_begin(), @@ -463,7 +463,7 @@ VNInfo *LiveIntervalMap::mapValue(const VNInfo *ParentVNI, SlotIndex Idx, MachineBasicBlock *Pred = *PI; // Is this a known live-out block? std::pair LOIP = - liveOutCache_.insert(std::make_pair(Pred, LiveOutPair())); + LiveOutCache.insert(std::make_pair(Pred, LiveOutPair())); // Yes, we have been here before. if (!LOIP.second) { DEBUG(if (VNInfo *VNI = LOIP.first->second.first) @@ -473,20 +473,20 @@ VNInfo *LiveIntervalMap::mapValue(const VNInfo *ParentVNI, SlotIndex Idx, } // Does Pred provide a live-out value? - SlotIndex Last = lis_.getMBBEndIdx(Pred).getPrevSlot(); + SlotIndex Last = LIS.getMBBEndIdx(Pred).getPrevSlot(); if (VNInfo *VNI = extendTo(Pred, Last)) { - MachineBasicBlock *DefMBB = lis_.getMBBFromIndex(VNI->def); + MachineBasicBlock *DefMBB = LIS.getMBBFromIndex(VNI->def); DEBUG(dbgs() << " found valno #" << VNI->id << " from BB#" << DefMBB->getNumber() << " at BB#" << Pred->getNumber() << '\n'); LiveOutPair &LOP = LOIP.first->second; LOP.first = VNI; - LOP.second = mdt_[DefMBB]; + LOP.second = MDT[DefMBB]; continue; } // No, we need a live-in value for Pred as well if (Pred != IdxMBB) - LiveIn.push_back(mdt_[Pred]); + LiveIn.push_back(MDT[Pred]); } } @@ -512,8 +512,8 @@ VNInfo *LiveIntervalMap::mapValue(const VNInfo *ParentVNI, SlotIndex Idx, // Get the IDom live-out value. if (!needPHI) { - LiveOutMap::iterator I = liveOutCache_.find(IDom->getBlock()); - if (I != liveOutCache_.end()) + LiveOutMap::iterator I = LiveOutCache.find(IDom->getBlock()); + if (I != LiveOutCache.end()) IDomValue = I->second; else // If IDom is outside our set of live-out blocks, there must be new @@ -527,13 +527,13 @@ VNInfo *LiveIntervalMap::mapValue(const VNInfo *ParentVNI, SlotIndex Idx, if (!needPHI) { for (MachineBasicBlock::pred_iterator PI = MBB->pred_begin(), PE = MBB->pred_end(); PI != PE; ++PI) { - LiveOutPair Value = liveOutCache_[*PI]; + LiveOutPair Value = LiveOutCache[*PI]; if (!Value.first || Value.first == IDomValue.first) continue; // This predecessor is carrying something other than IDomValue. // It could be because IDomValue hasn't propagated yet, or it could be // because MBB is in the dominance frontier of that value. - if (mdt_.dominates(IDom, Value.second)) { + if (MDT.dominates(IDom, Value.second)) { needPHI = true; break; } @@ -543,25 +543,25 @@ VNInfo *LiveIntervalMap::mapValue(const VNInfo *ParentVNI, SlotIndex Idx, // Create a phi-def if required. if (needPHI) { ++Changes; - SlotIndex Start = lis_.getMBBStartIdx(MBB); - VNInfo *VNI = li_->getNextValue(Start, 0, lis_.getVNInfoAllocator()); + SlotIndex Start = LIS.getMBBStartIdx(MBB); + VNInfo *VNI = LI->getNextValue(Start, 0, LIS.getVNInfoAllocator()); VNI->setIsPHIDef(true); DEBUG(dbgs() << " - BB#" << MBB->getNumber() << " phi-def #" << VNI->id << " at " << Start << '\n'); - // We no longer need li_ to be live-in. + // We no longer need LI to be live-in. LiveIn.erase(LiveIn.begin()+(i-1)); // Blocks in LiveIn are either IdxMBB, or have a value live-through. if (MBB == IdxMBB) IdxVNI = VNI; // Check if we need to update live-out info. - LiveOutMap::iterator I = liveOutCache_.find(MBB); - if (I == liveOutCache_.end() || I->second.second == Node) { + LiveOutMap::iterator I = LiveOutCache.find(MBB); + if (I == LiveOutCache.end() || I->second.second == Node) { // We already have a live-out defined in MBB, so this must be IdxMBB. assert(MBB == IdxMBB && "Adding phi-def to known live-out"); - li_->addRange(LiveRange(Start, Idx.getNextSlot(), VNI)); + LI->addRange(LiveRange(Start, Idx.getNextSlot(), VNI)); } else { // This phi-def is also live-out, so color the whole block. - li_->addRange(LiveRange(Start, lis_.getMBBEndIdx(MBB), VNI)); + LI->addRange(LiveRange(Start, LIS.getMBBEndIdx(MBB), VNI)); I->second = LiveOutPair(VNI, Node); } } else if (IDomValue.first) { @@ -570,8 +570,8 @@ VNInfo *LiveIntervalMap::mapValue(const VNInfo *ParentVNI, SlotIndex Idx, IdxVNI = IDomValue.first; // Propagate IDomValue if needed: // MBB is live-out and doesn't define its own value. - LiveOutMap::iterator I = liveOutCache_.find(MBB); - if (I != liveOutCache_.end() && I->second.second != Node && + LiveOutMap::iterator I = LiveOutCache.find(MBB); + if (I != LiveOutCache.end() && I->second.second != Node && I->second.first != IDomValue.first) { ++Changes; I->second = IDomValue; @@ -588,8 +588,8 @@ VNInfo *LiveIntervalMap::mapValue(const VNInfo *ParentVNI, SlotIndex Idx, #ifndef NDEBUG DEBUG(dumpCache()); - // Check the liveOutCache_ invariants. - for (LiveOutMap::iterator I = liveOutCache_.begin(), E = liveOutCache_.end(); + // Check the LiveOutCache invariants. + for (LiveOutMap::iterator I = LiveOutCache.begin(), E = LiveOutCache.end(); I != E; ++I) { assert(I->first && "Null MBB entry in cache"); assert(I->second.first && "Null VNInfo in cache"); @@ -598,7 +598,7 @@ VNInfo *LiveIntervalMap::mapValue(const VNInfo *ParentVNI, SlotIndex Idx, continue; for (MachineBasicBlock::pred_iterator PI = I->first->pred_begin(), PE = I->first->pred_end(); PI != PE; ++PI) - assert(liveOutCache_.lookup(*PI) == I->second && "Bad invariant"); + assert(LiveOutCache.lookup(*PI) == I->second && "Bad invariant"); } #endif @@ -608,15 +608,15 @@ VNInfo *LiveIntervalMap::mapValue(const VNInfo *ParentVNI, SlotIndex Idx, // This makes the next mapValue call much faster. for (unsigned i = 0, e = LiveIn.size(); i != e; ++i) { MachineBasicBlock *MBB = LiveIn[i]->getBlock(); - SlotIndex Start = lis_.getMBBStartIdx(MBB); + SlotIndex Start = LIS.getMBBStartIdx(MBB); if (MBB == IdxMBB) { - li_->addRange(LiveRange(Start, Idx.getNextSlot(), IdxVNI)); + LI->addRange(LiveRange(Start, Idx.getNextSlot(), IdxVNI)); continue; } // Anything in LiveIn other than IdxMBB is live-through. - VNInfo *VNI = liveOutCache_.lookup(MBB).first; + VNInfo *VNI = LiveOutCache.lookup(MBB).first; assert(VNI && "Missing block value"); - li_->addRange(LiveRange(Start, lis_.getMBBEndIdx(MBB), VNI)); + LI->addRange(LiveRange(Start, LIS.getMBBEndIdx(MBB), VNI)); } return IdxVNI; @@ -624,7 +624,7 @@ VNInfo *LiveIntervalMap::mapValue(const VNInfo *ParentVNI, SlotIndex Idx, #ifndef NDEBUG void LiveIntervalMap::dumpCache() { - for (LiveOutMap::iterator I = liveOutCache_.begin(), E = liveOutCache_.end(); + for (LiveOutMap::iterator I = LiveOutCache.begin(), E = LiveOutCache.end(); I != E; ++I) { assert(I->first && "Null MBB entry in cache"); assert(I->second.first && "Null VNInfo in cache"); @@ -637,70 +637,70 @@ void LiveIntervalMap::dumpCache() { dbgs() << " BB#" << (*PI)->getNumber(); dbgs() << '\n'; } - dbgs() << " cache: " << liveOutCache_.size() << " entries.\n"; + dbgs() << " cache: " << LiveOutCache.size() << " entries.\n"; } #endif -// extendTo - Find the last li_ value defined in MBB at or before Idx. The -// parentli_ is assumed to be live at Idx. Extend the live range to Idx. +// extendTo - Find the last LI value defined in MBB at or before Idx. The +// ParentLI is assumed to be live at Idx. Extend the live range to Idx. // Return the found VNInfo, or NULL. VNInfo *LiveIntervalMap::extendTo(const MachineBasicBlock *MBB, SlotIndex Idx) { - assert(li_ && "call reset first"); - LiveInterval::iterator I = std::upper_bound(li_->begin(), li_->end(), Idx); - if (I == li_->begin()) + assert(LI && "call reset first"); + LiveInterval::iterator I = std::upper_bound(LI->begin(), LI->end(), Idx); + if (I == LI->begin()) return 0; --I; - if (I->end <= lis_.getMBBStartIdx(MBB)) + if (I->end <= LIS.getMBBStartIdx(MBB)) return 0; if (I->end <= Idx) I->end = Idx.getNextSlot(); return I->valno; } -// addSimpleRange - Add a simple range from parentli_ to li_. +// addSimpleRange - Add a simple range from ParentLI to LI. // ParentVNI must be live in the [Start;End) interval. void LiveIntervalMap::addSimpleRange(SlotIndex Start, SlotIndex End, const VNInfo *ParentVNI) { - assert(li_ && "call reset first"); + assert(LI && "call reset first"); bool simple; VNInfo *VNI = mapValue(ParentVNI, Start, &simple); // A simple mapping is easy. if (simple) { - li_->addRange(LiveRange(Start, End, VNI)); + LI->addRange(LiveRange(Start, End, VNI)); return; } // ParentVNI is a complex value. We must map per MBB. - MachineFunction::iterator MBB = lis_.getMBBFromIndex(Start); - MachineFunction::iterator MBBE = lis_.getMBBFromIndex(End.getPrevSlot()); + MachineFunction::iterator MBB = LIS.getMBBFromIndex(Start); + MachineFunction::iterator MBBE = LIS.getMBBFromIndex(End.getPrevSlot()); if (MBB == MBBE) { - li_->addRange(LiveRange(Start, End, VNI)); + LI->addRange(LiveRange(Start, End, VNI)); return; } // First block. - li_->addRange(LiveRange(Start, lis_.getMBBEndIdx(MBB), VNI)); + LI->addRange(LiveRange(Start, LIS.getMBBEndIdx(MBB), VNI)); // Run sequence of full blocks. for (++MBB; MBB != MBBE; ++MBB) { - Start = lis_.getMBBStartIdx(MBB); - li_->addRange(LiveRange(Start, lis_.getMBBEndIdx(MBB), + Start = LIS.getMBBStartIdx(MBB); + LI->addRange(LiveRange(Start, LIS.getMBBEndIdx(MBB), mapValue(ParentVNI, Start))); } // Final block. - Start = lis_.getMBBStartIdx(MBB); + Start = LIS.getMBBStartIdx(MBB); if (Start != End) - li_->addRange(LiveRange(Start, End, mapValue(ParentVNI, Start))); + LI->addRange(LiveRange(Start, End, mapValue(ParentVNI, Start))); } -/// addRange - Add live ranges to li_ where [Start;End) intersects parentli_. +/// addRange - Add live ranges to LI where [Start;End) intersects ParentLI. /// All needed values whose def is not inside [Start;End) must be defined /// beforehand so mapValue will work. void LiveIntervalMap::addRange(SlotIndex Start, SlotIndex End) { - assert(li_ && "call reset first"); - LiveInterval::const_iterator B = parentli_.begin(), E = parentli_.end(); + assert(LI && "call reset first"); + LiveInterval::const_iterator B = ParentLI.begin(), E = ParentLI.end(); LiveInterval::const_iterator I = std::lower_bound(B, E, Start); // Check if --I begins before Start and overlaps. @@ -727,22 +727,22 @@ SplitEditor::SplitEditor(SplitAnalysis &sa, VirtRegMap &vrm, MachineDominatorTree &mdt, LiveRangeEdit &edit) - : sa_(sa), lis_(lis), vrm_(vrm), - mri_(vrm.getMachineFunction().getRegInfo()), - tii_(*vrm.getMachineFunction().getTarget().getInstrInfo()), - tri_(*vrm.getMachineFunction().getTarget().getRegisterInfo()), - edit_(edit), - dupli_(lis_, mdt, edit.getParent()), - openli_(lis_, mdt, edit.getParent()) + : sa_(sa), LIS(lis), VRM(vrm), + MRI(vrm.getMachineFunction().getRegInfo()), + TII(*vrm.getMachineFunction().getTarget().getInstrInfo()), + TRI(*vrm.getMachineFunction().getTarget().getRegisterInfo()), + Edit(edit), + DupLI(LIS, mdt, edit.getParent()), + OpenLI(LIS, mdt, edit.getParent()) { // We don't need an AliasAnalysis since we will only be performing // cheap-as-a-copy remats anyway. - edit_.anyRematerializable(lis_, tii_, 0); + Edit.anyRematerializable(LIS, TII, 0); } bool SplitEditor::intervalsLiveAt(SlotIndex Idx) const { - for (LiveRangeEdit::iterator I = edit_.begin(), E = edit_.end(); I != E; ++I) - if (*I != dupli_.getLI() && (*I)->liveAt(Idx)) + for (LiveRangeEdit::iterator I = Edit.begin(), E = Edit.end(); I != E; ++I) + if (*I != DupLI.getLI() && (*I)->liveAt(Idx)) return true; return false; } @@ -758,14 +758,14 @@ VNInfo *SplitEditor::defFromParent(LiveIntervalMap &Reg, // Attempt cheap-as-a-copy rematerialization. LiveRangeEdit::Remat RM(ParentVNI); - if (edit_.canRematerializeAt(RM, UseIdx, true, lis_)) { - Def = edit_.rematerializeAt(MBB, I, Reg.getLI()->reg, RM, - lis_, tii_, tri_); + if (Edit.canRematerializeAt(RM, UseIdx, true, LIS)) { + Def = Edit.rematerializeAt(MBB, I, Reg.getLI()->reg, RM, + LIS, TII, TRI); } else { // Can't remat, just insert a copy from parent. - CopyMI = BuildMI(MBB, I, DebugLoc(), tii_.get(TargetOpcode::COPY), - Reg.getLI()->reg).addReg(edit_.getReg()); - Def = lis_.InsertMachineInstrInMaps(CopyMI).getDefIndex(); + CopyMI = BuildMI(MBB, I, DebugLoc(), TII.get(TargetOpcode::COPY), + Reg.getLI()->reg).addReg(Edit.getReg()); + Def = LIS.InsertMachineInstrInMaps(CopyMI).getDefIndex(); } // Define the value in Reg. @@ -781,121 +781,121 @@ VNInfo *SplitEditor::defFromParent(LiveIntervalMap &Reg, /// Create a new virtual register and live interval. void SplitEditor::openIntv() { - assert(!openli_.getLI() && "Previous LI not closed before openIntv"); - if (!dupli_.getLI()) - dupli_.reset(&edit_.create(mri_, lis_, vrm_)); + assert(!OpenLI.getLI() && "Previous LI not closed before openIntv"); + if (!DupLI.getLI()) + DupLI.reset(&Edit.create(MRI, LIS, VRM)); - openli_.reset(&edit_.create(mri_, lis_, vrm_)); + OpenLI.reset(&Edit.create(MRI, LIS, VRM)); } -/// enterIntvBefore - Enter openli before the instruction at Idx. If curli is +/// enterIntvBefore - Enter OpenLI before the instruction at Idx. If CurLI is /// not live before Idx, a COPY is not inserted. void SplitEditor::enterIntvBefore(SlotIndex Idx) { - assert(openli_.getLI() && "openIntv not called before enterIntvBefore"); + assert(OpenLI.getLI() && "openIntv not called before enterIntvBefore"); Idx = Idx.getUseIndex(); DEBUG(dbgs() << " enterIntvBefore " << Idx); - VNInfo *ParentVNI = edit_.getParent().getVNInfoAt(Idx); + VNInfo *ParentVNI = Edit.getParent().getVNInfoAt(Idx); if (!ParentVNI) { DEBUG(dbgs() << ": not live\n"); return; } DEBUG(dbgs() << ": valno " << ParentVNI->id); truncatedValues.insert(ParentVNI); - MachineInstr *MI = lis_.getInstructionFromIndex(Idx); + MachineInstr *MI = LIS.getInstructionFromIndex(Idx); assert(MI && "enterIntvBefore called with invalid index"); - defFromParent(openli_, ParentVNI, Idx, *MI->getParent(), MI); + defFromParent(OpenLI, ParentVNI, Idx, *MI->getParent(), MI); - DEBUG(dbgs() << ": " << *openli_.getLI() << '\n'); + DEBUG(dbgs() << ": " << *OpenLI.getLI() << '\n'); } -/// enterIntvAtEnd - Enter openli at the end of MBB. +/// enterIntvAtEnd - Enter OpenLI at the end of MBB. void SplitEditor::enterIntvAtEnd(MachineBasicBlock &MBB) { - assert(openli_.getLI() && "openIntv not called before enterIntvAtEnd"); - SlotIndex End = lis_.getMBBEndIdx(&MBB).getPrevSlot(); + assert(OpenLI.getLI() && "openIntv not called before enterIntvAtEnd"); + SlotIndex End = LIS.getMBBEndIdx(&MBB).getPrevSlot(); DEBUG(dbgs() << " enterIntvAtEnd BB#" << MBB.getNumber() << ", " << End); - VNInfo *ParentVNI = edit_.getParent().getVNInfoAt(End); + VNInfo *ParentVNI = Edit.getParent().getVNInfoAt(End); if (!ParentVNI) { DEBUG(dbgs() << ": not live\n"); return; } DEBUG(dbgs() << ": valno " << ParentVNI->id); truncatedValues.insert(ParentVNI); - defFromParent(openli_, ParentVNI, End, MBB, MBB.getFirstTerminator()); - DEBUG(dbgs() << ": " << *openli_.getLI() << '\n'); + defFromParent(OpenLI, ParentVNI, End, MBB, MBB.getFirstTerminator()); + DEBUG(dbgs() << ": " << *OpenLI.getLI() << '\n'); } -/// useIntv - indicate that all instructions in MBB should use openli. +/// useIntv - indicate that all instructions in MBB should use OpenLI. void SplitEditor::useIntv(const MachineBasicBlock &MBB) { - useIntv(lis_.getMBBStartIdx(&MBB), lis_.getMBBEndIdx(&MBB)); + useIntv(LIS.getMBBStartIdx(&MBB), LIS.getMBBEndIdx(&MBB)); } void SplitEditor::useIntv(SlotIndex Start, SlotIndex End) { - assert(openli_.getLI() && "openIntv not called before useIntv"); - openli_.addRange(Start, End); + assert(OpenLI.getLI() && "openIntv not called before useIntv"); + OpenLI.addRange(Start, End); DEBUG(dbgs() << " use [" << Start << ';' << End << "): " - << *openli_.getLI() << '\n'); + << *OpenLI.getLI() << '\n'); } -/// leaveIntvAfter - Leave openli after the instruction at Idx. +/// leaveIntvAfter - Leave OpenLI after the instruction at Idx. void SplitEditor::leaveIntvAfter(SlotIndex Idx) { - assert(openli_.getLI() && "openIntv not called before leaveIntvAfter"); + assert(OpenLI.getLI() && "openIntv not called before leaveIntvAfter"); DEBUG(dbgs() << " leaveIntvAfter " << Idx); // The interval must be live beyond the instruction at Idx. Idx = Idx.getBoundaryIndex(); - VNInfo *ParentVNI = edit_.getParent().getVNInfoAt(Idx); + VNInfo *ParentVNI = Edit.getParent().getVNInfoAt(Idx); if (!ParentVNI) { DEBUG(dbgs() << ": not live\n"); return; } DEBUG(dbgs() << ": valno " << ParentVNI->id); - MachineBasicBlock::iterator MII = lis_.getInstructionFromIndex(Idx); - VNInfo *VNI = defFromParent(dupli_, ParentVNI, Idx, + MachineBasicBlock::iterator MII = LIS.getInstructionFromIndex(Idx); + VNInfo *VNI = defFromParent(DupLI, ParentVNI, Idx, *MII->getParent(), llvm::next(MII)); - // Make sure that openli is properly extended from Idx to the new copy. + // Make sure that OpenLI is properly extended from Idx to the new copy. // FIXME: This shouldn't be necessary for remats. - openli_.addSimpleRange(Idx, VNI->def, ParentVNI); + OpenLI.addSimpleRange(Idx, VNI->def, ParentVNI); - DEBUG(dbgs() << ": " << *openli_.getLI() << '\n'); + DEBUG(dbgs() << ": " << *OpenLI.getLI() << '\n'); } /// leaveIntvAtTop - Leave the interval at the top of MBB. /// Currently, only one value can leave the interval. void SplitEditor::leaveIntvAtTop(MachineBasicBlock &MBB) { - assert(openli_.getLI() && "openIntv not called before leaveIntvAtTop"); - SlotIndex Start = lis_.getMBBStartIdx(&MBB); + assert(OpenLI.getLI() && "openIntv not called before leaveIntvAtTop"); + SlotIndex Start = LIS.getMBBStartIdx(&MBB); DEBUG(dbgs() << " leaveIntvAtTop BB#" << MBB.getNumber() << ", " << Start); - VNInfo *ParentVNI = edit_.getParent().getVNInfoAt(Start); + VNInfo *ParentVNI = Edit.getParent().getVNInfoAt(Start); if (!ParentVNI) { DEBUG(dbgs() << ": not live\n"); return; } - VNInfo *VNI = defFromParent(dupli_, ParentVNI, Start, MBB, + VNInfo *VNI = defFromParent(DupLI, ParentVNI, Start, MBB, MBB.SkipPHIsAndLabels(MBB.begin())); - // Finally we must make sure that openli is properly extended from Start to + // Finally we must make sure that OpenLI is properly extended from Start to // the new copy. - openli_.addSimpleRange(Start, VNI->def, ParentVNI); - DEBUG(dbgs() << ": " << *openli_.getLI() << '\n'); + OpenLI.addSimpleRange(Start, VNI->def, ParentVNI); + DEBUG(dbgs() << ": " << *OpenLI.getLI() << '\n'); } /// closeIntv - Indicate that we are done editing the currently open /// LiveInterval, and ranges can be trimmed. void SplitEditor::closeIntv() { - assert(openli_.getLI() && "openIntv not called before closeIntv"); - DEBUG(dbgs() << " closeIntv " << *openli_.getLI() << '\n'); - openli_.reset(0); + assert(OpenLI.getLI() && "openIntv not called before closeIntv"); + DEBUG(dbgs() << " closeIntv " << *OpenLI.getLI() << '\n'); + OpenLI.reset(0); } /// rewrite - Rewrite all uses of reg to use the new registers. void SplitEditor::rewrite(unsigned reg) { - for (MachineRegisterInfo::reg_iterator RI = mri_.reg_begin(reg), - RE = mri_.reg_end(); RI != RE;) { + for (MachineRegisterInfo::reg_iterator RI = MRI.reg_begin(reg), + RE = MRI.reg_end(); RI != RE;) { MachineOperand &MO = RI.getOperand(); unsigned OpNum = RI.getOperandNo(); MachineInstr *MI = MO.getParent(); @@ -906,10 +906,10 @@ void SplitEditor::rewrite(unsigned reg) { MO.setReg(0); continue; } - SlotIndex Idx = lis_.getInstructionIndex(MI); + SlotIndex Idx = LIS.getInstructionIndex(MI); Idx = MO.isUse() ? Idx.getUseIndex() : Idx.getDefIndex(); LiveInterval *LI = 0; - for (LiveRangeEdit::iterator I = edit_.begin(), E = edit_.end(); I != E; + for (LiveRangeEdit::iterator I = Edit.begin(), E = Edit.end(); I != E; ++I) { LiveInterval *testli = *I; if (testli->liveAt(Idx)) { @@ -932,9 +932,9 @@ SplitEditor::addTruncSimpleRange(SlotIndex Start, SlotIndex End, VNInfo *VNI) { typedef std::pair IIPair; SmallVector Iters; - for (LiveRangeEdit::iterator LI = edit_.begin(), LE = edit_.end(); LI != LE; + for (LiveRangeEdit::iterator LI = Edit.begin(), LE = Edit.end(); LI != LE; ++LI) { - if (*LI == dupli_.getLI()) + if (*LI == DupLI.getLI()) continue; LiveInterval::const_iterator I = (*LI)->find(Start); LiveInterval::const_iterator E = (*LI)->end(); @@ -968,7 +968,7 @@ SplitEditor::addTruncSimpleRange(SlotIndex Start, SlotIndex End, VNInfo *VNI) { } // Now, [sidx;eidx) doesn't overlap anything in intervals_. if (sidx < eidx) - dupli_.addSimpleRange(sidx, eidx, VNI); + DupLI.addSimpleRange(sidx, eidx, VNI); // If the interval end was truncated, we can try again from next. if (next <= sidx) break; @@ -983,13 +983,13 @@ void SplitEditor::computeRemainder() { // If values were partially rematted, we should shrink to uses. // If values were fully rematted, they should be omitted. // FIXME: If a single value is redefined, just move the def and truncate. - LiveInterval &parent = edit_.getParent(); + LiveInterval &parent = Edit.getParent(); DEBUG(dbgs() << "computeRemainder from " << parent << '\n'); // Values that are fully contained in the split intervals. SmallPtrSet deadValues; - // Map all curli values that should have live defs in dupli. + // Map all CurLI values that should have live defs in dupli. for (LiveInterval::const_vni_iterator I = parent.vni_begin(), E = parent.vni_end(); I != E; ++I) { const VNInfo *VNI = *I; @@ -999,15 +999,15 @@ void SplitEditor::computeRemainder() { // Original def is contained in the split intervals. if (intervalsLiveAt(VNI->def)) { // Did this value escape? - if (dupli_.isMapped(VNI)) + if (DupLI.isMapped(VNI)) truncatedValues.insert(VNI); else deadValues.insert(VNI); continue; } // Add minimal live range at the definition. - VNInfo *DVNI = dupli_.defValue(VNI, VNI->def); - dupli_.getLI()->addRange(LiveRange(VNI->def, VNI->def.getNextSlot(), DVNI)); + VNInfo *DVNI = DupLI.defValue(VNI, VNI->def); + DupLI.getLI()->addRange(LiveRange(VNI->def, VNI->def.getNextSlot(), DVNI)); } // Add all ranges to dupli. @@ -1019,40 +1019,40 @@ void SplitEditor::computeRemainder() { addTruncSimpleRange(LR.start, LR.end, LR.valno); } else if (!deadValues.count(LR.valno)) { // recolor without truncation. - dupli_.addSimpleRange(LR.start, LR.end, LR.valno); + DupLI.addSimpleRange(LR.start, LR.end, LR.valno); } } - // Extend dupli_ to be live out of any critical loop predecessors. + // Extend DupLI to be live out of any critical loop predecessors. // This means we have multiple registers live out of those blocks. // The alternative would be to split the critical edges. if (criticalPreds_.empty()) return; for (SplitAnalysis::BlockPtrSet::iterator I = criticalPreds_.begin(), E = criticalPreds_.end(); I != E; ++I) - dupli_.extendTo(*I, lis_.getMBBEndIdx(*I).getPrevSlot()); + DupLI.extendTo(*I, LIS.getMBBEndIdx(*I).getPrevSlot()); criticalPreds_.clear(); } void SplitEditor::finish() { - assert(!openli_.getLI() && "Previous LI not closed before rewrite"); - assert(dupli_.getLI() && "No dupli for rewrite. Noop spilt?"); + assert(!OpenLI.getLI() && "Previous LI not closed before rewrite"); + assert(DupLI.getLI() && "No dupli for rewrite. Noop spilt?"); // Complete dupli liveness. computeRemainder(); // Get rid of unused values and set phi-kill flags. - for (LiveRangeEdit::iterator I = edit_.begin(), E = edit_.end(); I != E; ++I) - (*I)->RenumberValues(lis_); + for (LiveRangeEdit::iterator I = Edit.begin(), E = Edit.end(); I != E; ++I) + (*I)->RenumberValues(LIS); // Rewrite instructions. - rewrite(edit_.getReg()); + rewrite(Edit.getReg()); // Now check if any registers were separated into multiple components. - ConnectedVNInfoEqClasses ConEQ(lis_); - for (unsigned i = 0, e = edit_.size(); i != e; ++i) { + ConnectedVNInfoEqClasses ConEQ(LIS); + for (unsigned i = 0, e = Edit.size(); i != e; ++i) { // Don't use iterators, they are invalidated by create() below. - LiveInterval *li = edit_.get(i); + LiveInterval *li = Edit.get(i); unsigned NumComp = ConEQ.Classify(li); if (NumComp <= 1) continue; @@ -1060,19 +1060,19 @@ void SplitEditor::finish() { SmallVector dups; dups.push_back(li); for (unsigned i = 1; i != NumComp; ++i) - dups.push_back(&edit_.create(mri_, lis_, vrm_)); + dups.push_back(&Edit.create(MRI, LIS, VRM)); ConEQ.Distribute(&dups[0]); // Rewrite uses to the new regs. rewrite(li->reg); } // Calculate spill weight and allocation hints for new intervals. - VirtRegAuxInfo vrai(vrm_.getMachineFunction(), lis_, sa_.loops_); - for (LiveRangeEdit::iterator I = edit_.begin(), E = edit_.end(); I != E; ++I){ + VirtRegAuxInfo vrai(VRM.getMachineFunction(), LIS, sa_.Loops); + for (LiveRangeEdit::iterator I = Edit.begin(), E = Edit.end(); I != E; ++I){ LiveInterval &li = **I; vrai.CalculateRegClass(li.reg); vrai.CalculateWeightAndHint(li); - DEBUG(dbgs() << " new interval " << mri_.getRegClass(li.reg)->getName() + DEBUG(dbgs() << " new interval " << MRI.getRegClass(li.reg)->getName() << ":" << li << '\n'); } } @@ -1102,7 +1102,7 @@ void SplitEditor::splitAroundLoop(const MachineLoop *Loop) { openIntv(); // Insert copies in the predecessors if live-in to the header. - if (lis_.isLiveInToMBB(edit_.getParent(), Loop->getHeader())) { + if (LIS.isLiveInToMBB(Edit.getParent(), Loop->getHeader())) { for (SplitAnalysis::BlockPtrSet::iterator I = Blocks.Preds.begin(), E = Blocks.Preds.end(); I != E; ++I) { MachineBasicBlock &MBB = const_cast(**I); @@ -1132,27 +1132,27 @@ void SplitEditor::splitAroundLoop(const MachineLoop *Loop) { // Single Block Splitting //===----------------------------------------------------------------------===// -/// getMultiUseBlocks - if curli has more than one use in a basic block, it -/// may be an advantage to split curli for the duration of the block. +/// getMultiUseBlocks - if CurLI has more than one use in a basic block, it +/// may be an advantage to split CurLI for the duration of the block. bool SplitAnalysis::getMultiUseBlocks(BlockPtrSet &Blocks) { - // If curli is local to one block, there is no point to splitting it. - if (usingBlocks_.size() <= 1) + // If CurLI is local to one block, there is no point to splitting it. + if (UsingBlocks.size() <= 1) return false; // Add blocks with multiple uses. - for (BlockCountMap::iterator I = usingBlocks_.begin(), E = usingBlocks_.end(); + for (BlockCountMap::iterator I = UsingBlocks.begin(), E = UsingBlocks.end(); I != E; ++I) switch (I->second) { case 0: case 1: continue; case 2: { - // When there are only two uses and curli is both live in and live out, + // When there are only two uses and CurLI is both live in and live out, // we don't really win anything by isolating the block since we would be // inserting two copies. // The remaing register would still have two uses in the block. (Unless it // separates into disconnected components). - if (lis_.isLiveInToMBB(*curli_, I->first) && - lis_.isLiveOutOfMBB(*curli_, I->first)) + if (LIS.isLiveInToMBB(*CurLI, I->first) && + LIS.isLiveOutOfMBB(*CurLI, I->first)) continue; } // Fall through. default: @@ -1161,20 +1161,20 @@ bool SplitAnalysis::getMultiUseBlocks(BlockPtrSet &Blocks) { return !Blocks.empty(); } -/// splitSingleBlocks - Split curli into a separate live interval inside each +/// splitSingleBlocks - Split CurLI into a separate live interval inside each /// basic block in Blocks. void SplitEditor::splitSingleBlocks(const SplitAnalysis::BlockPtrSet &Blocks) { DEBUG(dbgs() << " splitSingleBlocks for " << Blocks.size() << " blocks.\n"); - // Determine the first and last instruction using curli in each block. + // Determine the first and last instruction using CurLI in each block. typedef std::pair IndexPair; typedef DenseMap IndexPairMap; IndexPairMap MBBRange; - for (SplitAnalysis::InstrPtrSet::const_iterator I = sa_.usingInstrs_.begin(), - E = sa_.usingInstrs_.end(); I != E; ++I) { + for (SplitAnalysis::InstrPtrSet::const_iterator I = sa_.UsingInstrs.begin(), + E = sa_.UsingInstrs.end(); I != E; ++I) { const MachineBasicBlock *MBB = (*I)->getParent(); if (!Blocks.count(MBB)) continue; - SlotIndex Idx = lis_.getInstructionIndex(*I); + SlotIndex Idx = LIS.getInstructionIndex(*I); DEBUG(dbgs() << " BB#" << MBB->getNumber() << '\t' << Idx << '\t' << **I); IndexPair &IP = MBBRange[MBB]; if (!IP.first.isValid() || Idx < IP.first) @@ -1205,29 +1205,29 @@ void SplitEditor::splitSingleBlocks(const SplitAnalysis::BlockPtrSet &Blocks) { // Sub Block Splitting //===----------------------------------------------------------------------===// -/// getBlockForInsideSplit - If curli is contained inside a single basic block, +/// getBlockForInsideSplit - If CurLI is contained inside a single basic block, /// and it wou pay to subdivide the interval inside that block, return it. /// Otherwise return NULL. The returned block can be passed to /// SplitEditor::splitInsideBlock. const MachineBasicBlock *SplitAnalysis::getBlockForInsideSplit() { // The interval must be exclusive to one block. - if (usingBlocks_.size() != 1) + if (UsingBlocks.size() != 1) return 0; // Don't to this for less than 4 instructions. We want to be sure that // splitting actually reduces the instruction count per interval. - if (usingInstrs_.size() < 4) + if (UsingInstrs.size() < 4) return 0; - return usingBlocks_.begin()->first; + return UsingBlocks.begin()->first; } -/// splitInsideBlock - Split curli into multiple intervals inside MBB. +/// splitInsideBlock - Split CurLI into multiple intervals inside MBB. void SplitEditor::splitInsideBlock(const MachineBasicBlock *MBB) { SmallVector Uses; - Uses.reserve(sa_.usingInstrs_.size()); - for (SplitAnalysis::InstrPtrSet::const_iterator I = sa_.usingInstrs_.begin(), - E = sa_.usingInstrs_.end(); I != E; ++I) + Uses.reserve(sa_.UsingInstrs.size()); + for (SplitAnalysis::InstrPtrSet::const_iterator I = sa_.UsingInstrs.begin(), + E = sa_.UsingInstrs.end(); I != E; ++I) if ((*I)->getParent() == MBB) - Uses.push_back(lis_.getInstructionIndex(*I)); + Uses.push_back(LIS.getInstructionIndex(*I)); DEBUG(dbgs() << " splitInsideBlock BB#" << MBB->getNumber() << " for " << Uses.size() << " instructions.\n"); assert(Uses.size() >= 3 && "Need at least 3 instructions"); diff --git a/lib/CodeGen/SplitKit.h b/lib/CodeGen/SplitKit.h index 3616baa6ced..bb4fca9084b 100644 --- a/lib/CodeGen/SplitKit.h +++ b/lib/CodeGen/SplitKit.h @@ -41,31 +41,31 @@ typedef DomTreeNodeBase MachineDomTreeNode; /// opportunities. class SplitAnalysis { public: - const MachineFunction &mf_; - const LiveIntervals &lis_; - const MachineLoopInfo &loops_; - const TargetInstrInfo &tii_; + const MachineFunction &MF; + const LiveIntervals &LIS; + const MachineLoopInfo &Loops; + const TargetInstrInfo &TII; // Instructions using the the current register. typedef SmallPtrSet InstrPtrSet; - InstrPtrSet usingInstrs_; + InstrPtrSet UsingInstrs; // Sorted slot indexes of using instructions. SmallVector UseSlots; - // The number of instructions using curli in each basic block. + // The number of instructions using CurLI in each basic block. typedef DenseMap BlockCountMap; - BlockCountMap usingBlocks_; + BlockCountMap UsingBlocks; - // The number of basic block using curli in each loop. + // The number of basic block using CurLI in each loop. typedef DenseMap LoopCountMap; - LoopCountMap usingLoops_; + LoopCountMap UsingLoops; private: // Current live interval. - const LiveInterval *curli_; + const LiveInterval *CurLI; - // Sumarize statistics by counting instructions using curli_. + // Sumarize statistics by counting instructions using CurLI. void analyzeUses(); /// canAnalyzeBranch - Return true if MBB ends in a branch that can be @@ -76,7 +76,7 @@ public: SplitAnalysis(const MachineFunction &mf, const LiveIntervals &lis, const MachineLoopInfo &mli); - /// analyze - set curli to the specified interval, and analyze how it may be + /// analyze - set CurLI to the specified interval, and analyze how it may be /// split. void analyze(const LiveInterval *li); @@ -84,9 +84,9 @@ public: /// new interval. void clear(); - /// hasUses - Return true if MBB has any uses of curli. + /// hasUses - Return true if MBB has any uses of CurLI. bool hasUses(const MachineBasicBlock *MBB) const { - return usingBlocks_.lookup(MBB); + return UsingBlocks.lookup(MBB); } typedef SmallPtrSet BlockPtrSet; @@ -123,12 +123,12 @@ public: OutsideLoop // Uses outside loop periphery. }; - /// analyzeLoopPeripheralUse - Return an enum describing how curli_ is used in + /// analyzeLoopPeripheralUse - Return an enum describing how CurLI is used in /// and around the Loop. LoopPeripheralUse analyzeLoopPeripheralUse(const LoopBlocks&); /// getCriticalExits - It may be necessary to partially break critical edges - /// leaving the loop if an exit block has phi uses of curli. Collect the exit + /// leaving the loop if an exit block has phi uses of CurLI. Collect the exit /// blocks that need special treatment into CriticalExits. void getCriticalExits(const LoopBlocks &Blocks, BlockPtrSet &CriticalExits); @@ -138,19 +138,19 @@ public: BlockPtrSet &CriticalExits); /// getCriticalPreds - Get the set of loop predecessors with critical edges to - /// blocks outside the loop that have curli live in. We don't have to break + /// blocks outside the loop that have CurLI live in. We don't have to break /// these edges, but they do require special treatment. void getCriticalPreds(const LoopBlocks &Blocks, BlockPtrSet &CriticalPreds); - /// getSplitLoops - Get the set of loops that have curli uses and would be + /// getSplitLoops - Get the set of loops that have CurLI uses and would be /// profitable to split. void getSplitLoops(LoopPtrSet&); - /// getBestSplitLoop - Return the loop where curli may best be split to a + /// getBestSplitLoop - Return the loop where CurLI may best be split to a /// separate register, or NULL. const MachineLoop *getBestSplitLoop(); - /// isBypassLoop - Return true if curli is live through Loop and has no uses + /// isBypassLoop - Return true if CurLI is live through Loop and has no uses /// inside the loop. Bypass loops are candidates for splitting because it can /// prevent interference inside the loop. bool isBypassLoop(const MachineLoop *Loop); @@ -160,13 +160,13 @@ public: void getBypassLoops(LoopPtrSet&); /// getMultiUseBlocks - Add basic blocks to Blocks that may benefit from - /// having curli split to a new live interval. Return true if Blocks can be + /// having CurLI split to a new live interval. Return true if Blocks can be /// passed to SplitEditor::splitSingleBlocks. bool getMultiUseBlocks(BlockPtrSet &Blocks); - /// getBlockForInsideSplit - If curli is contained inside a single basic block, - /// and it wou pay to subdivide the interval inside that block, return it. - /// Otherwise return NULL. The returned block can be passed to + /// getBlockForInsideSplit - If CurLI is contained inside a single basic + /// block, and it would pay to subdivide the interval inside that block, + /// return it. Otherwise return NULL. The returned block can be passed to /// SplitEditor::splitInsideBlock. const MachineBasicBlock *getBlockForInsideSplit(); }; @@ -176,45 +176,45 @@ public: /// interval that is a subset. Insert phi-def values as needed. This class is /// used by SplitEditor to create new smaller LiveIntervals. /// -/// parentli_ is the larger interval, li_ is the subset interval. Every value -/// in li_ corresponds to exactly one value in parentli_, and the live range -/// of the value is contained within the live range of the parentli_ value. -/// Values in parentli_ may map to any number of openli_ values, including 0. +/// ParentLI is the larger interval, LI is the subset interval. Every value +/// in LI corresponds to exactly one value in ParentLI, and the live range +/// of the value is contained within the live range of the ParentLI value. +/// Values in ParentLI may map to any number of OpenLI values, including 0. class LiveIntervalMap { - LiveIntervals &lis_; - MachineDominatorTree &mdt_; + LiveIntervals &LIS; + MachineDominatorTree &MDT; // The parent interval is never changed. - const LiveInterval &parentli_; + const LiveInterval &ParentLI; - // The child interval's values are fully contained inside parentli_ values. - LiveInterval *li_; + // The child interval's values are fully contained inside ParentLI values. + LiveInterval *LI; typedef DenseMap ValueMap; - // Map parentli_ values to simple values in li_ that are defined at the same - // SlotIndex, or NULL for parentli_ values that have complex li_ defs. + // Map ParentLI values to simple values in LI that are defined at the same + // SlotIndex, or NULL for ParentLI values that have complex LI defs. // Note there is a difference between values mapping to NULL (complex), and // values not present (unknown/unmapped). - ValueMap valueMap_; + ValueMap Values; typedef std::pair LiveOutPair; typedef DenseMap LiveOutMap; - // liveOutCache_ - Map each basic block where li_ is live out to the live-out + // LiveOutCache - Map each basic block where LI is live out to the live-out // value and its defining block. One of these conditions shall be true: // - // 1. !liveOutCache_.count(MBB) - // 2. liveOutCache_[MBB].second.getNode() == MBB - // 3. forall P in preds(MBB): liveOutCache_[P] == liveOutCache_[MBB] + // 1. !LiveOutCache.count(MBB) + // 2. LiveOutCache[MBB].second.getNode() == MBB + // 3. forall P in preds(MBB): LiveOutCache[P] == LiveOutCache[MBB] // // This is only a cache, the values can be computed as: // - // VNI = li_->getVNInfoAt(lis_.getMBBEndIdx(MBB)) - // Node = mbt_[lis_.getMBBFromIndex(VNI->def)] + // VNI = LI->getVNInfoAt(LIS.getMBBEndIdx(MBB)) + // Node = mbt_[LIS.getMBBFromIndex(VNI->def)] // // The cache is also used as a visiteed set by mapValue(). - LiveOutMap liveOutCache_; + LiveOutMap LiveOutCache; // Dump the live-out cache to dbgs(). void dumpCache(); @@ -223,32 +223,32 @@ public: LiveIntervalMap(LiveIntervals &lis, MachineDominatorTree &mdt, const LiveInterval &parentli) - : lis_(lis), mdt_(mdt), parentli_(parentli), li_(0) {} + : LIS(lis), MDT(mdt), ParentLI(parentli), LI(0) {} /// reset - clear all data structures and start a new live interval. void reset(LiveInterval *); /// getLI - return the current live interval. - LiveInterval *getLI() const { return li_; } + LiveInterval *getLI() const { return LI; } - /// defValue - define a value in li_ from the parentli_ value VNI and Idx. + /// defValue - define a value in LI from the ParentLI value VNI and Idx. /// Idx does not have to be ParentVNI->def, but it must be contained within - /// ParentVNI's live range in parentli_. - /// Return the new li_ value. + /// ParentVNI's live range in ParentLI. + /// Return the new LI value. VNInfo *defValue(const VNInfo *ParentVNI, SlotIndex Idx); - /// mapValue - map ParentVNI to the corresponding li_ value at Idx. It is + /// mapValue - map ParentVNI to the corresponding LI value at Idx. It is /// assumed that ParentVNI is live at Idx. /// If ParentVNI has not been defined by defValue, it is assumed that /// ParentVNI->def dominates Idx. /// If ParentVNI has been defined by defValue one or more times, a value that /// dominates Idx will be returned. This may require creating extra phi-def - /// values and adding live ranges to li_. + /// values and adding live ranges to LI. /// If simple is not NULL, *simple will indicate if ParentVNI is a simply /// mapped value. VNInfo *mapValue(const VNInfo *ParentVNI, SlotIndex Idx, bool *simple = 0); - // extendTo - Find the last li_ value defined in MBB at or before Idx. The + // extendTo - Find the last LI value defined in MBB at or before Idx. The // parentli is assumed to be live at Idx. Extend the live range to include // Idx. Return the found VNInfo, or NULL. VNInfo *extendTo(const MachineBasicBlock *MBB, SlotIndex Idx); @@ -256,18 +256,18 @@ public: /// isMapped - Return true is ParentVNI is a known mapped value. It may be a /// simple 1-1 mapping or a complex mapping to later defs. bool isMapped(const VNInfo *ParentVNI) const { - return valueMap_.count(ParentVNI); + return Values.count(ParentVNI); } /// isComplexMapped - Return true if ParentVNI has received new definitions /// with defValue. bool isComplexMapped(const VNInfo *ParentVNI) const; - // addSimpleRange - Add a simple range from parentli_ to li_. + // addSimpleRange - Add a simple range from ParentLI to LI. // ParentVNI must be live in the [Start;End) interval. void addSimpleRange(SlotIndex Start, SlotIndex End, const VNInfo *ParentVNI); - /// addRange - Add live ranges to li_ where [Start;End) intersects parentli_. + /// addRange - Add live ranges to LI where [Start;End) intersects ParentLI. /// All needed values whose def is not inside [Start;End) must be defined /// beforehand so mapValue will work. void addRange(SlotIndex Start, SlotIndex End); @@ -287,22 +287,22 @@ public: /// class SplitEditor { SplitAnalysis &sa_; - LiveIntervals &lis_; - VirtRegMap &vrm_; - MachineRegisterInfo &mri_; - const TargetInstrInfo &tii_; - const TargetRegisterInfo &tri_; + LiveIntervals &LIS; + VirtRegMap &VRM; + MachineRegisterInfo &MRI; + const TargetInstrInfo &TII; + const TargetRegisterInfo &TRI; - /// edit_ - The current parent register and new intervals created. - LiveRangeEdit &edit_; + /// Edit - The current parent register and new intervals created. + LiveRangeEdit &Edit; - /// dupli_ - Created as a copy of curli_, ranges are carved out as new + /// DupLI - Created as a copy of CurLI, ranges are carved out as new /// intervals get added through openIntv / closeIntv. This is used to avoid - /// editing curli_. - LiveIntervalMap dupli_; + /// editing CurLI. + LiveIntervalMap DupLI; /// Currently open LiveInterval. - LiveIntervalMap openli_; + LiveIntervalMap OpenLI; /// defFromParent - Define Reg from ParentVNI at UseIdx using either /// rematerialization or a COPY from parent. Return the new value. @@ -315,15 +315,15 @@ class SplitEditor { /// intervalsLiveAt - Return true if any member of intervals_ is live at Idx. bool intervalsLiveAt(SlotIndex Idx) const; - /// Values in curli whose live range has been truncated when entering an open + /// Values in CurLI whose live range has been truncated when entering an open /// li. SmallPtrSet truncatedValues; - /// addTruncSimpleRange - Add the given simple range to dupli_ after + /// addTruncSimpleRange - Add the given simple range to DupLI after /// truncating any overlap with intervals_. void addTruncSimpleRange(SlotIndex Start, SlotIndex End, VNInfo *VNI); - /// criticalPreds_ - Set of basic blocks where both dupli and openli should be + /// criticalPreds_ - Set of basic blocks where both dupli and OpenLI should be /// live out because of a critical edge. SplitAnalysis::BlockPtrSet criticalPreds_; @@ -346,20 +346,20 @@ public: /// Create a new virtual register and live interval. void openIntv(); - /// enterIntvBefore - Enter openli before the instruction at Idx. If curli is + /// enterIntvBefore - Enter OpenLI before the instruction at Idx. If CurLI is /// not live before Idx, a COPY is not inserted. void enterIntvBefore(SlotIndex Idx); - /// enterIntvAtEnd - Enter openli at the end of MBB. + /// enterIntvAtEnd - Enter OpenLI at the end of MBB. void enterIntvAtEnd(MachineBasicBlock &MBB); - /// useIntv - indicate that all instructions in MBB should use openli. + /// useIntv - indicate that all instructions in MBB should use OpenLI. void useIntv(const MachineBasicBlock &MBB); - /// useIntv - indicate that all instructions in range should use openli. + /// useIntv - indicate that all instructions in range should use OpenLI. void useIntv(SlotIndex Start, SlotIndex End); - /// leaveIntvAfter - Leave openli after the instruction at Idx. + /// leaveIntvAfter - Leave OpenLI after the instruction at Idx. void leaveIntvAfter(SlotIndex Idx); /// leaveIntvAtTop - Leave the interval at the top of MBB. @@ -376,15 +376,15 @@ public: // ===--- High level methods ---=== - /// splitAroundLoop - Split curli into a separate live interval inside + /// splitAroundLoop - Split CurLI into a separate live interval inside /// the loop. void splitAroundLoop(const MachineLoop*); - /// splitSingleBlocks - Split curli into a separate live interval inside each + /// splitSingleBlocks - Split CurLI into a separate live interval inside each /// basic block in Blocks. void splitSingleBlocks(const SplitAnalysis::BlockPtrSet &Blocks); - /// splitInsideBlock - Split curli into multiple intervals inside MBB. + /// splitInsideBlock - Split CurLI into multiple intervals inside MBB. void splitInsideBlock(const MachineBasicBlock *); };