2010-12-08 03:26:16 +00:00
|
|
|
//===-- RegAllocGreedy.cpp - greedy register allocator --------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file defines the RAGreedy function pass for register allocation in
|
|
|
|
// optimized builds.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#define DEBUG_TYPE "regalloc"
|
2010-12-10 22:21:05 +00:00
|
|
|
#include "AllocationOrder.h"
|
2010-12-08 03:26:16 +00:00
|
|
|
#include "LiveIntervalUnion.h"
|
2010-12-17 23:16:32 +00:00
|
|
|
#include "LiveRangeEdit.h"
|
2010-12-08 03:26:16 +00:00
|
|
|
#include "RegAllocBase.h"
|
|
|
|
#include "Spiller.h"
|
2011-01-18 21:13:27 +00:00
|
|
|
#include "SpillPlacement.h"
|
2010-12-15 23:46:13 +00:00
|
|
|
#include "SplitKit.h"
|
2010-12-08 03:26:16 +00:00
|
|
|
#include "VirtRegMap.h"
|
|
|
|
#include "VirtRegRewriter.h"
|
|
|
|
#include "llvm/Analysis/AliasAnalysis.h"
|
|
|
|
#include "llvm/Function.h"
|
|
|
|
#include "llvm/PassAnalysisSupport.h"
|
|
|
|
#include "llvm/CodeGen/CalcSpillWeights.h"
|
2011-01-18 21:13:27 +00:00
|
|
|
#include "llvm/CodeGen/EdgeBundles.h"
|
2010-12-08 03:26:16 +00:00
|
|
|
#include "llvm/CodeGen/LiveIntervalAnalysis.h"
|
|
|
|
#include "llvm/CodeGen/LiveStackAnalysis.h"
|
2010-12-17 23:16:32 +00:00
|
|
|
#include "llvm/CodeGen/MachineDominators.h"
|
2010-12-08 03:26:16 +00:00
|
|
|
#include "llvm/CodeGen/MachineFunctionPass.h"
|
|
|
|
#include "llvm/CodeGen/MachineLoopInfo.h"
|
2010-12-15 23:46:13 +00:00
|
|
|
#include "llvm/CodeGen/MachineLoopRanges.h"
|
2010-12-08 03:26:16 +00:00
|
|
|
#include "llvm/CodeGen/MachineRegisterInfo.h"
|
|
|
|
#include "llvm/CodeGen/Passes.h"
|
|
|
|
#include "llvm/CodeGen/RegAllocRegistry.h"
|
|
|
|
#include "llvm/CodeGen/RegisterCoalescer.h"
|
|
|
|
#include "llvm/Target/TargetOptions.h"
|
|
|
|
#include "llvm/Support/Debug.h"
|
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2010-12-11 00:19:56 +00:00
|
|
|
#include "llvm/Support/Timer.h"
|
2010-12-08 03:26:16 +00:00
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
|
|
|
|
static RegisterRegAlloc greedyRegAlloc("greedy", "greedy register allocator",
|
|
|
|
createGreedyRegisterAllocator);
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
class RAGreedy : public MachineFunctionPass, public RegAllocBase {
|
|
|
|
// context
|
|
|
|
MachineFunction *MF;
|
|
|
|
BitVector ReservedRegs;
|
|
|
|
|
|
|
|
// analyses
|
2011-01-18 21:13:27 +00:00
|
|
|
SlotIndexes *Indexes;
|
2010-12-08 03:26:16 +00:00
|
|
|
LiveStacks *LS;
|
2010-12-17 23:16:32 +00:00
|
|
|
MachineDominatorTree *DomTree;
|
2010-12-15 23:46:13 +00:00
|
|
|
MachineLoopInfo *Loops;
|
|
|
|
MachineLoopRanges *LoopRanges;
|
2011-01-18 21:13:27 +00:00
|
|
|
EdgeBundles *Bundles;
|
|
|
|
SpillPlacement *SpillPlacer;
|
2010-12-17 23:16:32 +00:00
|
|
|
|
2010-12-08 03:26:16 +00:00
|
|
|
// state
|
|
|
|
std::auto_ptr<Spiller> SpillerInstance;
|
2010-12-15 23:46:13 +00:00
|
|
|
std::auto_ptr<SplitAnalysis> SA;
|
2010-12-08 03:26:16 +00:00
|
|
|
|
2011-01-18 21:13:27 +00:00
|
|
|
// splitting state.
|
|
|
|
|
|
|
|
/// All basic blocks where the current register is live.
|
|
|
|
SmallVector<SpillPlacement::BlockConstraint, 8> SpillConstraints;
|
|
|
|
|
|
|
|
/// Additional information about basic blocks where the current variable is
|
|
|
|
/// live. Such a block will look like one of these templates:
|
|
|
|
///
|
|
|
|
/// 1. | o---x | Internal to block. Variable is only live in this block.
|
|
|
|
/// 2. |---x | Live-in, kill.
|
|
|
|
/// 3. | o---| Def, live-out.
|
|
|
|
/// 4. |---x o---| Live-in, kill, def, live-out.
|
|
|
|
/// 5. |---o---o---| Live-through with uses or defs.
|
|
|
|
/// 6. |-----------| Live-through without uses. Transparent.
|
|
|
|
///
|
|
|
|
struct BlockInfo {
|
|
|
|
const MachineBasicBlock *MBB;
|
|
|
|
SlotIndex FirstUse; ///< First instr using current reg.
|
|
|
|
SlotIndex LastUse; ///< Last instr using current reg.
|
|
|
|
SlotIndex Kill; ///< Interval end point inside block.
|
|
|
|
SlotIndex Def; ///< Interval start point inside block.
|
|
|
|
bool Uses; ///< Current reg has uses or defs in block.
|
|
|
|
bool LiveThrough; ///< Live in whole block (Templ 5. or 6. above).
|
|
|
|
bool LiveIn; ///< Current reg is live in.
|
|
|
|
bool LiveOut; ///< Current reg is live out.
|
|
|
|
|
|
|
|
// Per-interference pattern scratch data.
|
|
|
|
bool OverlapEntry; ///< Interference overlaps entering interval.
|
|
|
|
bool OverlapExit; ///< Interference overlaps exiting interval.
|
|
|
|
};
|
|
|
|
|
|
|
|
/// Basic blocks where var is live. This array is parallel to
|
|
|
|
/// SpillConstraints.
|
|
|
|
SmallVector<BlockInfo, 8> LiveBlocks;
|
|
|
|
|
2010-12-08 03:26:16 +00:00
|
|
|
public:
|
|
|
|
RAGreedy();
|
|
|
|
|
|
|
|
/// Return the pass name.
|
|
|
|
virtual const char* getPassName() const {
|
2010-12-11 00:19:56 +00:00
|
|
|
return "Greedy Register Allocator";
|
2010-12-08 03:26:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// RAGreedy analysis usage.
|
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const;
|
|
|
|
|
|
|
|
virtual void releaseMemory();
|
|
|
|
|
|
|
|
virtual Spiller &spiller() { return *SpillerInstance; }
|
|
|
|
|
2010-12-08 22:57:16 +00:00
|
|
|
virtual float getPriority(LiveInterval *LI);
|
2010-12-08 22:22:41 +00:00
|
|
|
|
2010-12-08 03:26:16 +00:00
|
|
|
virtual unsigned selectOrSplit(LiveInterval &VirtReg,
|
|
|
|
SmallVectorImpl<LiveInterval*> &SplitVRegs);
|
|
|
|
|
|
|
|
/// Perform register allocation.
|
|
|
|
virtual bool runOnMachineFunction(MachineFunction &mf);
|
|
|
|
|
|
|
|
static char ID;
|
2010-12-09 18:15:21 +00:00
|
|
|
|
|
|
|
private:
|
2010-12-14 00:37:49 +00:00
|
|
|
bool checkUncachedInterference(LiveInterval&, unsigned);
|
|
|
|
LiveInterval *getSingleInterference(LiveInterval&, unsigned);
|
2010-12-09 18:15:21 +00:00
|
|
|
bool reassignVReg(LiveInterval &InterferingVReg, unsigned OldPhysReg);
|
|
|
|
bool reassignInterferences(LiveInterval &VirtReg, unsigned PhysReg);
|
2010-12-17 23:16:32 +00:00
|
|
|
unsigned findInterferenceFreeReg(MachineLoopRange*,
|
|
|
|
LiveInterval&, AllocationOrder&);
|
2010-12-22 22:01:30 +00:00
|
|
|
float calcInterferenceWeight(LiveInterval&, unsigned);
|
2011-01-18 21:13:27 +00:00
|
|
|
void calcLiveBlockInfo(LiveInterval&);
|
|
|
|
float calcInterferenceInfo(LiveInterval&, unsigned);
|
|
|
|
float calcGlobalSplitCost(const BitVector&);
|
2010-12-14 00:37:44 +00:00
|
|
|
|
2010-12-14 00:37:49 +00:00
|
|
|
unsigned tryReassign(LiveInterval&, AllocationOrder&);
|
2011-01-18 21:13:27 +00:00
|
|
|
unsigned tryRegionSplit(LiveInterval&, AllocationOrder&,
|
|
|
|
SmallVectorImpl<LiveInterval*>&);
|
2010-12-14 00:37:44 +00:00
|
|
|
unsigned trySplit(LiveInterval&, AllocationOrder&,
|
|
|
|
SmallVectorImpl<LiveInterval*>&);
|
2010-12-22 22:01:30 +00:00
|
|
|
unsigned trySpillInterferences(LiveInterval&, AllocationOrder&,
|
|
|
|
SmallVectorImpl<LiveInterval*>&);
|
2010-12-08 03:26:16 +00:00
|
|
|
};
|
|
|
|
} // end anonymous namespace
|
|
|
|
|
|
|
|
char RAGreedy::ID = 0;
|
|
|
|
|
|
|
|
FunctionPass* llvm::createGreedyRegisterAllocator() {
|
|
|
|
return new RAGreedy();
|
|
|
|
}
|
|
|
|
|
|
|
|
RAGreedy::RAGreedy(): MachineFunctionPass(ID) {
|
2011-01-18 21:13:27 +00:00
|
|
|
initializeSlotIndexesPass(*PassRegistry::getPassRegistry());
|
2010-12-08 03:26:16 +00:00
|
|
|
initializeLiveIntervalsPass(*PassRegistry::getPassRegistry());
|
|
|
|
initializeSlotIndexesPass(*PassRegistry::getPassRegistry());
|
|
|
|
initializeStrongPHIEliminationPass(*PassRegistry::getPassRegistry());
|
|
|
|
initializeRegisterCoalescerAnalysisGroup(*PassRegistry::getPassRegistry());
|
|
|
|
initializeCalculateSpillWeightsPass(*PassRegistry::getPassRegistry());
|
|
|
|
initializeLiveStacksPass(*PassRegistry::getPassRegistry());
|
|
|
|
initializeMachineDominatorTreePass(*PassRegistry::getPassRegistry());
|
|
|
|
initializeMachineLoopInfoPass(*PassRegistry::getPassRegistry());
|
2010-12-15 23:46:13 +00:00
|
|
|
initializeMachineLoopRangesPass(*PassRegistry::getPassRegistry());
|
2010-12-08 03:26:16 +00:00
|
|
|
initializeVirtRegMapPass(*PassRegistry::getPassRegistry());
|
2011-01-18 21:13:27 +00:00
|
|
|
initializeEdgeBundlesPass(*PassRegistry::getPassRegistry());
|
|
|
|
initializeSpillPlacementPass(*PassRegistry::getPassRegistry());
|
2010-12-08 03:26:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void RAGreedy::getAnalysisUsage(AnalysisUsage &AU) const {
|
|
|
|
AU.setPreservesCFG();
|
|
|
|
AU.addRequired<AliasAnalysis>();
|
|
|
|
AU.addPreserved<AliasAnalysis>();
|
|
|
|
AU.addRequired<LiveIntervals>();
|
2011-01-18 21:13:27 +00:00
|
|
|
AU.addRequired<SlotIndexes>();
|
2010-12-08 03:26:16 +00:00
|
|
|
AU.addPreserved<SlotIndexes>();
|
|
|
|
if (StrongPHIElim)
|
|
|
|
AU.addRequiredID(StrongPHIEliminationID);
|
|
|
|
AU.addRequiredTransitive<RegisterCoalescer>();
|
|
|
|
AU.addRequired<CalculateSpillWeights>();
|
|
|
|
AU.addRequired<LiveStacks>();
|
|
|
|
AU.addPreserved<LiveStacks>();
|
2010-12-17 23:16:32 +00:00
|
|
|
AU.addRequired<MachineDominatorTree>();
|
|
|
|
AU.addPreserved<MachineDominatorTree>();
|
2010-12-08 03:26:16 +00:00
|
|
|
AU.addRequired<MachineLoopInfo>();
|
|
|
|
AU.addPreserved<MachineLoopInfo>();
|
2010-12-15 23:46:13 +00:00
|
|
|
AU.addRequired<MachineLoopRanges>();
|
|
|
|
AU.addPreserved<MachineLoopRanges>();
|
2010-12-08 03:26:16 +00:00
|
|
|
AU.addRequired<VirtRegMap>();
|
|
|
|
AU.addPreserved<VirtRegMap>();
|
2011-01-18 21:13:27 +00:00
|
|
|
AU.addRequired<EdgeBundles>();
|
|
|
|
AU.addRequired<SpillPlacement>();
|
2010-12-08 03:26:16 +00:00
|
|
|
MachineFunctionPass::getAnalysisUsage(AU);
|
|
|
|
}
|
|
|
|
|
|
|
|
void RAGreedy::releaseMemory() {
|
|
|
|
SpillerInstance.reset(0);
|
|
|
|
RegAllocBase::releaseMemory();
|
|
|
|
}
|
|
|
|
|
2010-12-08 22:57:16 +00:00
|
|
|
float RAGreedy::getPriority(LiveInterval *LI) {
|
|
|
|
float Priority = LI->weight;
|
|
|
|
|
|
|
|
// Prioritize hinted registers so they are allocated first.
|
|
|
|
std::pair<unsigned, unsigned> Hint;
|
|
|
|
if (Hint.first || Hint.second) {
|
|
|
|
// The hint can be target specific, a virtual register, or a physreg.
|
|
|
|
Priority *= 2;
|
|
|
|
|
|
|
|
// Prefer physreg hints above anything else.
|
|
|
|
if (Hint.first == 0 && TargetRegisterInfo::isPhysicalRegister(Hint.second))
|
|
|
|
Priority *= 2;
|
|
|
|
}
|
|
|
|
return Priority;
|
|
|
|
}
|
|
|
|
|
2010-12-22 22:01:30 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Register Reassignment
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2010-12-10 20:45:04 +00:00
|
|
|
// Check interference without using the cache.
|
|
|
|
bool RAGreedy::checkUncachedInterference(LiveInterval &VirtReg,
|
|
|
|
unsigned PhysReg) {
|
2010-12-14 23:38:19 +00:00
|
|
|
for (const unsigned *AliasI = TRI->getOverlaps(PhysReg); *AliasI; ++AliasI) {
|
|
|
|
LiveIntervalUnion::Query subQ(&VirtReg, &PhysReg2LiveUnion[*AliasI]);
|
2010-12-10 20:45:04 +00:00
|
|
|
if (subQ.checkInterference())
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-12-14 00:37:49 +00:00
|
|
|
/// getSingleInterference - Return the single interfering virtual register
|
|
|
|
/// assigned to PhysReg. Return 0 if more than one virtual register is
|
|
|
|
/// interfering.
|
|
|
|
LiveInterval *RAGreedy::getSingleInterference(LiveInterval &VirtReg,
|
|
|
|
unsigned PhysReg) {
|
2010-12-14 23:38:19 +00:00
|
|
|
// Check physreg and aliases.
|
2010-12-14 00:37:49 +00:00
|
|
|
LiveInterval *Interference = 0;
|
2010-12-14 23:38:19 +00:00
|
|
|
for (const unsigned *AliasI = TRI->getOverlaps(PhysReg); *AliasI; ++AliasI) {
|
2010-12-14 00:37:49 +00:00
|
|
|
LiveIntervalUnion::Query &Q = query(VirtReg, *AliasI);
|
|
|
|
if (Q.checkInterference()) {
|
2010-12-14 17:47:36 +00:00
|
|
|
if (Interference)
|
2010-12-14 00:37:49 +00:00
|
|
|
return 0;
|
|
|
|
Q.collectInterferingVRegs(1);
|
2010-12-14 17:47:36 +00:00
|
|
|
if (!Q.seenAllInterferences())
|
|
|
|
return 0;
|
2010-12-14 00:37:49 +00:00
|
|
|
Interference = Q.interferingVRegs().front();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return Interference;
|
|
|
|
}
|
|
|
|
|
2010-12-09 18:15:21 +00:00
|
|
|
// Attempt to reassign this virtual register to a different physical register.
|
|
|
|
//
|
|
|
|
// FIXME: we are not yet caching these "second-level" interferences discovered
|
|
|
|
// in the sub-queries. These interferences can change with each call to
|
|
|
|
// selectOrSplit. However, we could implement a "may-interfere" cache that
|
|
|
|
// could be conservatively dirtied when we reassign or split.
|
|
|
|
//
|
|
|
|
// FIXME: This may result in a lot of alias queries. We could summarize alias
|
|
|
|
// live intervals in their parent register's live union, but it's messy.
|
|
|
|
bool RAGreedy::reassignVReg(LiveInterval &InterferingVReg,
|
2010-12-14 00:37:49 +00:00
|
|
|
unsigned WantedPhysReg) {
|
|
|
|
assert(TargetRegisterInfo::isVirtualRegister(InterferingVReg.reg) &&
|
|
|
|
"Can only reassign virtual registers");
|
|
|
|
assert(TRI->regsOverlap(WantedPhysReg, VRM->getPhys(InterferingVReg.reg)) &&
|
2010-12-09 18:15:21 +00:00
|
|
|
"inconsistent phys reg assigment");
|
|
|
|
|
2010-12-10 22:21:05 +00:00
|
|
|
AllocationOrder Order(InterferingVReg.reg, *VRM, ReservedRegs);
|
|
|
|
while (unsigned PhysReg = Order.next()) {
|
2010-12-14 00:37:49 +00:00
|
|
|
// Don't reassign to a WantedPhysReg alias.
|
|
|
|
if (TRI->regsOverlap(PhysReg, WantedPhysReg))
|
2010-12-09 18:15:21 +00:00
|
|
|
continue;
|
|
|
|
|
2010-12-10 20:45:04 +00:00
|
|
|
if (checkUncachedInterference(InterferingVReg, PhysReg))
|
2010-12-09 18:15:21 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
// Reassign the interfering virtual reg to this physical reg.
|
2010-12-14 00:37:49 +00:00
|
|
|
unsigned OldAssign = VRM->getPhys(InterferingVReg.reg);
|
|
|
|
DEBUG(dbgs() << "reassigning: " << InterferingVReg << " from " <<
|
|
|
|
TRI->getName(OldAssign) << " to " << TRI->getName(PhysReg) << '\n');
|
|
|
|
PhysReg2LiveUnion[OldAssign].extract(InterferingVReg);
|
2010-12-09 18:15:21 +00:00
|
|
|
VRM->clearVirt(InterferingVReg.reg);
|
|
|
|
VRM->assignVirt2Phys(InterferingVReg.reg, PhysReg);
|
|
|
|
PhysReg2LiveUnion[PhysReg].unify(InterferingVReg);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-12-14 00:37:49 +00:00
|
|
|
/// reassignInterferences - Reassign all interferences to different physical
|
|
|
|
/// registers such that Virtreg can be assigned to PhysReg.
|
|
|
|
/// Currently this only works with a single interference.
|
|
|
|
/// @param VirtReg Currently unassigned virtual register.
|
|
|
|
/// @param PhysReg Physical register to be cleared.
|
|
|
|
/// @return True on success, false if nothing was changed.
|
2010-12-09 18:15:21 +00:00
|
|
|
bool RAGreedy::reassignInterferences(LiveInterval &VirtReg, unsigned PhysReg) {
|
2010-12-14 00:37:49 +00:00
|
|
|
LiveInterval *InterferingVReg = getSingleInterference(VirtReg, PhysReg);
|
|
|
|
if (!InterferingVReg)
|
2010-12-09 18:15:21 +00:00
|
|
|
return false;
|
2010-12-14 00:37:49 +00:00
|
|
|
if (TargetRegisterInfo::isPhysicalRegister(InterferingVReg->reg))
|
|
|
|
return false;
|
|
|
|
return reassignVReg(*InterferingVReg, PhysReg);
|
|
|
|
}
|
2010-12-09 18:15:21 +00:00
|
|
|
|
2010-12-14 00:37:49 +00:00
|
|
|
/// tryReassign - Try to reassign interferences to different physregs.
|
|
|
|
/// @param VirtReg Currently unassigned virtual register.
|
|
|
|
/// @param Order Physregs to try.
|
|
|
|
/// @return Physreg to assign VirtReg, or 0.
|
|
|
|
unsigned RAGreedy::tryReassign(LiveInterval &VirtReg, AllocationOrder &Order) {
|
|
|
|
NamedRegionTimer T("Reassign", TimerGroupName, TimePassesIsEnabled);
|
|
|
|
Order.rewind();
|
|
|
|
while (unsigned PhysReg = Order.next())
|
|
|
|
if (reassignInterferences(VirtReg, PhysReg))
|
|
|
|
return PhysReg;
|
|
|
|
return 0;
|
2010-12-09 18:15:21 +00:00
|
|
|
}
|
|
|
|
|
2010-12-22 22:01:30 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Loop Splitting
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2010-12-17 23:16:32 +00:00
|
|
|
/// findInterferenceFreeReg - Find a physical register in Order where Loop has
|
|
|
|
/// no interferences with VirtReg.
|
|
|
|
unsigned RAGreedy::findInterferenceFreeReg(MachineLoopRange *Loop,
|
|
|
|
LiveInterval &VirtReg,
|
|
|
|
AllocationOrder &Order) {
|
|
|
|
Order.rewind();
|
|
|
|
while (unsigned PhysReg = Order.next()) {
|
|
|
|
bool interference = false;
|
|
|
|
for (const unsigned *AI = TRI->getOverlaps(PhysReg); *AI; ++AI) {
|
|
|
|
if (query(VirtReg, *AI).checkLoopInterference(Loop)) {
|
|
|
|
interference = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!interference)
|
|
|
|
return PhysReg;
|
|
|
|
}
|
|
|
|
// No physreg found.
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-12-14 00:37:44 +00:00
|
|
|
/// trySplit - Try to split VirtReg or one of its interferences, making it
|
|
|
|
/// assignable.
|
|
|
|
/// @return Physreg when VirtReg may be assigned and/or new SplitVRegs.
|
|
|
|
unsigned RAGreedy::trySplit(LiveInterval &VirtReg, AllocationOrder &Order,
|
|
|
|
SmallVectorImpl<LiveInterval*>&SplitVRegs) {
|
2011-01-18 21:13:27 +00:00
|
|
|
// Don't attempt splitting on local intervals for now.
|
|
|
|
if (LIS->intervalIsInOneMBB(VirtReg))
|
|
|
|
return 0;
|
|
|
|
|
2010-12-14 00:37:44 +00:00
|
|
|
NamedRegionTimer T("Splitter", TimerGroupName, TimePassesIsEnabled);
|
2010-12-15 23:46:13 +00:00
|
|
|
SA->analyze(&VirtReg);
|
|
|
|
|
|
|
|
// Get the set of loops that have VirtReg uses and are splittable.
|
2010-12-17 23:16:32 +00:00
|
|
|
SplitAnalysis::LoopPtrSet SplitLoopSet;
|
|
|
|
SA->getSplitLoops(SplitLoopSet);
|
|
|
|
|
|
|
|
// Order loops by descending area.
|
|
|
|
SmallVector<MachineLoopRange*, 8> SplitLoops;
|
|
|
|
for (SplitAnalysis::LoopPtrSet::const_iterator I = SplitLoopSet.begin(),
|
|
|
|
E = SplitLoopSet.end(); I != E; ++I)
|
|
|
|
SplitLoops.push_back(LoopRanges->getLoopRange(*I));
|
|
|
|
array_pod_sort(SplitLoops.begin(), SplitLoops.end(),
|
|
|
|
MachineLoopRange::byAreaDesc);
|
|
|
|
|
|
|
|
// Find the first loop that is interference-free for some register in the
|
|
|
|
// allocation order.
|
|
|
|
MachineLoopRange *Loop = 0;
|
|
|
|
for (unsigned i = 0, e = SplitLoops.size(); i != e; ++i) {
|
2010-12-18 03:04:11 +00:00
|
|
|
DEBUG(dbgs() << " Checking " << *SplitLoops[i]);
|
2010-12-17 23:16:32 +00:00
|
|
|
if (unsigned PhysReg = findInterferenceFreeReg(SplitLoops[i],
|
|
|
|
VirtReg, Order)) {
|
2010-12-18 01:05:55 +00:00
|
|
|
(void)PhysReg;
|
2010-12-17 23:16:32 +00:00
|
|
|
Loop = SplitLoops[i];
|
2010-12-18 03:04:11 +00:00
|
|
|
DEBUG(dbgs() << ": Use %" << TRI->getName(PhysReg) << '\n');
|
2010-12-17 23:16:32 +00:00
|
|
|
break;
|
2010-12-18 03:04:11 +00:00
|
|
|
} else {
|
|
|
|
DEBUG(dbgs() << ": Interference.\n");
|
2010-12-14 21:14:55 +00:00
|
|
|
}
|
2010-12-15 23:46:13 +00:00
|
|
|
}
|
2010-12-17 23:16:32 +00:00
|
|
|
|
|
|
|
if (!Loop) {
|
|
|
|
DEBUG(dbgs() << " All candidate loops have interference.\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Execute the split around Loop.
|
|
|
|
SmallVector<LiveInterval*, 4> SpillRegs;
|
|
|
|
LiveRangeEdit LREdit(VirtReg, SplitVRegs, SpillRegs);
|
|
|
|
SplitEditor(*SA, *LIS, *VRM, *DomTree, LREdit)
|
|
|
|
.splitAroundLoop(Loop->getLoop());
|
|
|
|
|
2010-12-17 23:16:35 +00:00
|
|
|
if (VerifyEnabled)
|
2010-12-18 00:06:56 +00:00
|
|
|
MF->verify(this, "After splitting live range around loop");
|
2010-12-17 23:16:35 +00:00
|
|
|
|
2010-12-17 23:16:32 +00:00
|
|
|
// We have new split regs, don't assign anything.
|
2010-12-14 00:37:44 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-12-08 03:26:16 +00:00
|
|
|
|
2011-01-18 21:13:27 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Region Splitting
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
/// calcLiveBlockInfo - Fill the LiveBlocks array with information about blocks
|
|
|
|
/// where VirtReg is live.
|
|
|
|
/// The SpillConstraints array is minimally initialized with MBB->getNumber().
|
|
|
|
void RAGreedy::calcLiveBlockInfo(LiveInterval &VirtReg) {
|
|
|
|
LiveBlocks.clear();
|
|
|
|
SpillConstraints.clear();
|
|
|
|
|
|
|
|
assert(!VirtReg.empty() && "Cannot allocate an empty interval");
|
|
|
|
LiveInterval::const_iterator LVI = VirtReg.begin();
|
|
|
|
LiveInterval::const_iterator LVE = VirtReg.end();
|
|
|
|
|
|
|
|
SmallVectorImpl<SlotIndex>::const_iterator UseI, UseE;
|
|
|
|
UseI = SA->UseSlots.begin();
|
|
|
|
UseE = SA->UseSlots.end();
|
|
|
|
|
|
|
|
// Loop over basic blocks where VirtReg is live.
|
|
|
|
MachineFunction::const_iterator MFI = Indexes->getMBBFromIndex(LVI->start);
|
|
|
|
for (;;) {
|
|
|
|
// Block constraints depend on the interference pattern.
|
|
|
|
// Just allocate them here, don't compute anything.
|
|
|
|
SpillPlacement::BlockConstraint BC;
|
|
|
|
BC.Number = MFI->getNumber();
|
|
|
|
SpillConstraints.push_back(BC);
|
|
|
|
|
|
|
|
BlockInfo BI;
|
|
|
|
BI.MBB = MFI;
|
|
|
|
SlotIndex Start, Stop;
|
|
|
|
tie(Start, Stop) = Indexes->getMBBRange(BI.MBB);
|
|
|
|
|
|
|
|
// LVI is the first live segment overlapping MBB.
|
|
|
|
BI.LiveIn = LVI->start <= Start;
|
|
|
|
if (!BI.LiveIn)
|
|
|
|
BI.Def = LVI->start;
|
|
|
|
|
|
|
|
// Find the first and last uses in the block.
|
|
|
|
BI.Uses = SA->hasUses(MFI);
|
|
|
|
if (BI.Uses && UseI != UseE) {
|
|
|
|
BI.FirstUse = *UseI;
|
|
|
|
assert(BI.FirstUse >= Start);
|
|
|
|
do ++UseI;
|
|
|
|
while (UseI != UseE && *UseI < Stop);
|
|
|
|
BI.LastUse = UseI[-1];
|
|
|
|
assert(BI.LastUse < Stop);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Look for gaps in the live range.
|
|
|
|
bool hasGap = false;
|
|
|
|
BI.LiveOut = true;
|
|
|
|
while (LVI->end < Stop) {
|
|
|
|
SlotIndex LastStop = LVI->end;
|
|
|
|
if (++LVI == LVE || LVI->start >= Stop) {
|
|
|
|
BI.Kill = LastStop;
|
|
|
|
BI.LiveOut = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (LastStop < LVI->start) {
|
|
|
|
hasGap = true;
|
|
|
|
BI.Kill = LastStop;
|
|
|
|
BI.Def = LVI->start;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Don't set LiveThrough when the block has a gap.
|
|
|
|
BI.LiveThrough = !hasGap && BI.LiveIn && BI.LiveOut;
|
|
|
|
LiveBlocks.push_back(BI);
|
|
|
|
|
|
|
|
// LVI is now at LVE or LVI->end >= Stop.
|
|
|
|
if (LVI == LVE)
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Live segment ends exactly at Stop. Move to the next segment.
|
|
|
|
if (LVI->end == Stop && ++LVI == LVE)
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Pick the next basic block.
|
|
|
|
if (LVI->start < Stop)
|
|
|
|
++MFI;
|
|
|
|
else
|
|
|
|
MFI = Indexes->getMBBFromIndex(LVI->start);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// calcInterferenceInfo - Compute per-block outgoing and ingoing constraints
|
|
|
|
/// when considering interference from PhysReg. Also compute an optimistic local
|
|
|
|
/// cost of this interference pattern.
|
|
|
|
///
|
|
|
|
/// The final cost of a split is the local cost + global cost of preferences
|
|
|
|
/// broken by SpillPlacement.
|
|
|
|
///
|
|
|
|
float RAGreedy::calcInterferenceInfo(LiveInterval &VirtReg, unsigned PhysReg) {
|
|
|
|
// Reset interference dependent info.
|
|
|
|
for (unsigned i = 0, e = LiveBlocks.size(); i != e; ++i) {
|
|
|
|
BlockInfo &BI = LiveBlocks[i];
|
|
|
|
SpillPlacement::BlockConstraint &BC = SpillConstraints[i];
|
|
|
|
BC.Entry = (BI.Uses && BI.LiveIn) ?
|
|
|
|
SpillPlacement::PrefReg : SpillPlacement::DontCare;
|
|
|
|
BC.Exit = (BI.Uses && BI.LiveOut) ?
|
|
|
|
SpillPlacement::PrefReg : SpillPlacement::DontCare;
|
|
|
|
BI.OverlapEntry = BI.OverlapExit = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add interference info from each PhysReg alias.
|
|
|
|
for (const unsigned *AI = TRI->getOverlaps(PhysReg); *AI; ++AI) {
|
|
|
|
if (!query(VirtReg, *AI).checkInterference())
|
|
|
|
continue;
|
|
|
|
DEBUG(PhysReg2LiveUnion[*AI].print(dbgs(), TRI));
|
|
|
|
LiveIntervalUnion::SegmentIter IntI =
|
|
|
|
PhysReg2LiveUnion[*AI].find(VirtReg.beginIndex());
|
|
|
|
if (!IntI.valid())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = LiveBlocks.size(); i != e; ++i) {
|
|
|
|
BlockInfo &BI = LiveBlocks[i];
|
|
|
|
SpillPlacement::BlockConstraint &BC = SpillConstraints[i];
|
|
|
|
SlotIndex Start, Stop;
|
|
|
|
tie(Start, Stop) = Indexes->getMBBRange(BI.MBB);
|
|
|
|
|
|
|
|
// Skip interference-free blocks.
|
|
|
|
if (IntI.start() >= Stop)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Handle transparent blocks with interference separately.
|
|
|
|
// Transparent blocks never incur any fixed cost.
|
|
|
|
if (BI.LiveThrough && !BI.Uses) {
|
|
|
|
// Check if interference is live-in - force spill.
|
|
|
|
if (BC.Entry != SpillPlacement::MustSpill) {
|
|
|
|
BC.Entry = SpillPlacement::PrefSpill;
|
|
|
|
IntI.advanceTo(Start);
|
|
|
|
if (IntI.valid() && IntI.start() <= Start)
|
|
|
|
BC.Entry = SpillPlacement::MustSpill;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if interference is live-out - force spill.
|
|
|
|
if (BC.Exit != SpillPlacement::MustSpill) {
|
|
|
|
BC.Exit = SpillPlacement::PrefSpill;
|
|
|
|
IntI.advanceTo(Stop);
|
|
|
|
if (IntI.valid() && IntI.start() < Stop)
|
|
|
|
BC.Exit = SpillPlacement::MustSpill;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Nothing more to do for this transparent block.
|
|
|
|
if (!IntI.valid())
|
|
|
|
break;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now we only have blocks with uses left.
|
|
|
|
// Check if the interference overlaps the uses.
|
|
|
|
assert(BI.Uses && "Non-transparent block without any uses");
|
|
|
|
|
|
|
|
// Check interference on entry.
|
|
|
|
if (BI.LiveIn && BC.Entry != SpillPlacement::MustSpill) {
|
|
|
|
IntI.advanceTo(Start);
|
|
|
|
if (!IntI.valid())
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Interference is live-in - force spill.
|
|
|
|
if (IntI.start() <= Start)
|
|
|
|
BC.Entry = SpillPlacement::MustSpill;
|
|
|
|
// Not live in, but before the first use.
|
|
|
|
else if (IntI.start() < BI.FirstUse)
|
|
|
|
BC.Entry = SpillPlacement::PrefSpill;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Does interference overlap the uses in the entry segment
|
|
|
|
// [FirstUse;Kill)?
|
|
|
|
if (BI.LiveIn && !BI.OverlapEntry) {
|
|
|
|
IntI.advanceTo(BI.FirstUse);
|
|
|
|
if (!IntI.valid())
|
|
|
|
break;
|
|
|
|
// A live-through interval has no kill.
|
|
|
|
// Check [FirstUse;LastUse) instead.
|
|
|
|
if (IntI.start() < (BI.LiveThrough ? BI.LastUse : BI.Kill))
|
|
|
|
BI.OverlapEntry = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Does interference overlap the uses in the exit segment [Def;LastUse)?
|
|
|
|
if (BI.LiveOut && !BI.LiveThrough && !BI.OverlapExit) {
|
|
|
|
IntI.advanceTo(BI.Def);
|
|
|
|
if (!IntI.valid())
|
|
|
|
break;
|
|
|
|
if (IntI.start() < BI.LastUse)
|
|
|
|
BI.OverlapExit = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check interference on exit.
|
|
|
|
if (BI.LiveOut && BC.Exit != SpillPlacement::MustSpill) {
|
|
|
|
// Check interference between LastUse and Stop.
|
|
|
|
if (BC.Exit != SpillPlacement::PrefSpill) {
|
|
|
|
IntI.advanceTo(BI.LastUse);
|
|
|
|
if (!IntI.valid())
|
|
|
|
break;
|
|
|
|
if (IntI.start() < Stop)
|
|
|
|
BC.Exit = SpillPlacement::PrefSpill;
|
|
|
|
}
|
|
|
|
// Is the interference live-out?
|
|
|
|
IntI.advanceTo(Stop);
|
|
|
|
if (!IntI.valid())
|
|
|
|
break;
|
|
|
|
if (IntI.start() < Stop)
|
|
|
|
BC.Exit = SpillPlacement::MustSpill;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Accumulate a local cost of this interference pattern.
|
|
|
|
float LocalCost = 0;
|
|
|
|
for (unsigned i = 0, e = LiveBlocks.size(); i != e; ++i) {
|
|
|
|
BlockInfo &BI = LiveBlocks[i];
|
|
|
|
if (!BI.Uses)
|
|
|
|
continue;
|
|
|
|
SpillPlacement::BlockConstraint &BC = SpillConstraints[i];
|
|
|
|
unsigned Inserts = 0;
|
|
|
|
|
|
|
|
// Do we need spill code for the entry segment?
|
|
|
|
if (BI.LiveIn)
|
|
|
|
Inserts += BI.OverlapEntry || BC.Entry != SpillPlacement::PrefReg;
|
|
|
|
|
|
|
|
// For the exit segment?
|
|
|
|
if (BI.LiveOut)
|
|
|
|
Inserts += BI.OverlapExit || BC.Exit != SpillPlacement::PrefReg;
|
|
|
|
|
|
|
|
// The local cost of spill code in this block is the block frequency times
|
|
|
|
// the number of spill instructions inserted.
|
|
|
|
if (Inserts)
|
|
|
|
LocalCost += Inserts * SpillPlacer->getBlockFrequency(BI.MBB);
|
|
|
|
}
|
|
|
|
DEBUG(dbgs() << "Local cost of " << PrintReg(PhysReg, TRI) << " = "
|
|
|
|
<< LocalCost << '\n');
|
|
|
|
return LocalCost;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// calcGlobalSplitCost - Return the global split cost of following the split
|
|
|
|
/// pattern in LiveBundles. This cost should be added to the local cost of the
|
|
|
|
/// interference pattern in SpillConstraints.
|
|
|
|
///
|
|
|
|
float RAGreedy::calcGlobalSplitCost(const BitVector &LiveBundles) {
|
|
|
|
float GlobalCost = 0;
|
|
|
|
for (unsigned i = 0, e = LiveBlocks.size(); i != e; ++i) {
|
|
|
|
SpillPlacement::BlockConstraint &BC = SpillConstraints[i];
|
|
|
|
unsigned Inserts = 0;
|
|
|
|
// Broken entry preference?
|
|
|
|
Inserts += LiveBundles[Bundles->getBundle(BC.Number, 0)] !=
|
|
|
|
(BC.Entry == SpillPlacement::PrefReg);
|
|
|
|
// Broken exit preference?
|
|
|
|
Inserts += LiveBundles[Bundles->getBundle(BC.Number, 1)] !=
|
|
|
|
(BC.Exit == SpillPlacement::PrefReg);
|
|
|
|
if (Inserts)
|
|
|
|
GlobalCost += Inserts * SpillPlacer->getBlockFrequency(LiveBlocks[i].MBB);
|
|
|
|
}
|
|
|
|
DEBUG(dbgs() << "Global cost = " << GlobalCost << '\n');
|
|
|
|
return GlobalCost;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned RAGreedy::tryRegionSplit(LiveInterval &VirtReg, AllocationOrder &Order,
|
|
|
|
SmallVectorImpl<LiveInterval*> &NewVRegs) {
|
|
|
|
calcLiveBlockInfo(VirtReg);
|
|
|
|
BitVector LiveBundles, BestBundles;
|
|
|
|
float BestCost = 0;
|
|
|
|
unsigned BestReg = 0;
|
|
|
|
Order.rewind();
|
|
|
|
while (unsigned PhysReg = Order.next()) {
|
|
|
|
float Cost = calcInterferenceInfo(VirtReg, PhysReg);
|
|
|
|
if (BestReg && Cost >= BestCost)
|
|
|
|
continue;
|
|
|
|
if (!SpillPlacer->placeSpills(SpillConstraints, LiveBundles))
|
|
|
|
Cost += calcGlobalSplitCost(LiveBundles);
|
|
|
|
if (!BestReg || Cost < BestCost) {
|
|
|
|
BestReg = PhysReg;
|
|
|
|
BestCost = Cost;
|
|
|
|
BestBundles.swap(LiveBundles);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// FIXME: Actually execute the split.
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-12-22 22:01:30 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Spilling
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
/// calcInterferenceWeight - Calculate the combined spill weight of
|
|
|
|
/// interferences when assigning VirtReg to PhysReg.
|
|
|
|
float RAGreedy::calcInterferenceWeight(LiveInterval &VirtReg, unsigned PhysReg){
|
|
|
|
float Sum = 0;
|
|
|
|
for (const unsigned *AI = TRI->getOverlaps(PhysReg); *AI; ++AI) {
|
|
|
|
LiveIntervalUnion::Query &Q = query(VirtReg, *AI);
|
|
|
|
Q.collectInterferingVRegs();
|
|
|
|
if (Q.seenUnspillableVReg())
|
|
|
|
return HUGE_VALF;
|
|
|
|
for (unsigned i = 0, e = Q.interferingVRegs().size(); i != e; ++i)
|
|
|
|
Sum += Q.interferingVRegs()[i]->weight;
|
|
|
|
}
|
|
|
|
return Sum;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// trySpillInterferences - Try to spill interfering registers instead of the
|
|
|
|
/// current one. Only do it if the accumulated spill weight is smaller than the
|
|
|
|
/// current spill weight.
|
|
|
|
unsigned RAGreedy::trySpillInterferences(LiveInterval &VirtReg,
|
|
|
|
AllocationOrder &Order,
|
|
|
|
SmallVectorImpl<LiveInterval*> &NewVRegs) {
|
|
|
|
NamedRegionTimer T("Spill Interference", TimerGroupName, TimePassesIsEnabled);
|
|
|
|
unsigned BestPhys = 0;
|
2010-12-28 10:07:15 +00:00
|
|
|
float BestWeight = 0;
|
2010-12-22 22:01:30 +00:00
|
|
|
|
|
|
|
Order.rewind();
|
|
|
|
while (unsigned PhysReg = Order.next()) {
|
|
|
|
float Weight = calcInterferenceWeight(VirtReg, PhysReg);
|
|
|
|
if (Weight == HUGE_VALF || Weight >= VirtReg.weight)
|
|
|
|
continue;
|
|
|
|
if (!BestPhys || Weight < BestWeight)
|
|
|
|
BestPhys = PhysReg, BestWeight = Weight;
|
|
|
|
}
|
|
|
|
|
|
|
|
// No candidates found.
|
|
|
|
if (!BestPhys)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
// Collect all interfering registers.
|
|
|
|
SmallVector<LiveInterval*, 8> Spills;
|
|
|
|
for (const unsigned *AI = TRI->getOverlaps(BestPhys); *AI; ++AI) {
|
|
|
|
LiveIntervalUnion::Query &Q = query(VirtReg, *AI);
|
|
|
|
Spills.append(Q.interferingVRegs().begin(), Q.interferingVRegs().end());
|
|
|
|
for (unsigned i = 0, e = Q.interferingVRegs().size(); i != e; ++i) {
|
|
|
|
LiveInterval *VReg = Q.interferingVRegs()[i];
|
|
|
|
PhysReg2LiveUnion[*AI].extract(*VReg);
|
|
|
|
VRM->clearVirt(VReg->reg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Spill them all.
|
|
|
|
DEBUG(dbgs() << "spilling " << Spills.size() << " interferences with weight "
|
|
|
|
<< BestWeight << '\n');
|
|
|
|
for (unsigned i = 0, e = Spills.size(); i != e; ++i)
|
|
|
|
spiller().spill(Spills[i], NewVRegs, Spills);
|
|
|
|
return BestPhys;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Main Entry Point
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
unsigned RAGreedy::selectOrSplit(LiveInterval &VirtReg,
|
|
|
|
SmallVectorImpl<LiveInterval*> &SplitVRegs) {
|
|
|
|
// First try assigning a free register.
|
2010-12-10 22:21:05 +00:00
|
|
|
AllocationOrder Order(VirtReg.reg, *VRM, ReservedRegs);
|
|
|
|
while (unsigned PhysReg = Order.next()) {
|
2010-12-22 22:01:30 +00:00
|
|
|
if (!checkPhysRegInterference(VirtReg, PhysReg))
|
2010-12-08 03:26:16 +00:00
|
|
|
return PhysReg;
|
|
|
|
}
|
2010-12-09 18:15:21 +00:00
|
|
|
|
2010-12-14 00:37:49 +00:00
|
|
|
// Try to reassign interferences.
|
|
|
|
if (unsigned PhysReg = tryReassign(VirtReg, Order))
|
|
|
|
return PhysReg;
|
2010-12-09 18:15:21 +00:00
|
|
|
|
2010-12-14 00:37:49 +00:00
|
|
|
// Try splitting VirtReg or interferences.
|
2010-12-14 00:37:44 +00:00
|
|
|
unsigned PhysReg = trySplit(VirtReg, Order, SplitVRegs);
|
|
|
|
if (PhysReg || !SplitVRegs.empty())
|
|
|
|
return PhysReg;
|
|
|
|
|
2010-12-08 03:26:16 +00:00
|
|
|
// Try to spill another interfering reg with less spill weight.
|
2010-12-22 22:01:30 +00:00
|
|
|
PhysReg = trySpillInterferences(VirtReg, Order, SplitVRegs);
|
|
|
|
if (PhysReg)
|
|
|
|
return PhysReg;
|
2010-12-09 18:15:21 +00:00
|
|
|
|
2010-12-22 22:01:30 +00:00
|
|
|
// Finally spill VirtReg itself.
|
|
|
|
NamedRegionTimer T("Spiller", TimerGroupName, TimePassesIsEnabled);
|
2010-12-08 03:26:16 +00:00
|
|
|
SmallVector<LiveInterval*, 1> pendingSpills;
|
|
|
|
spiller().spill(&VirtReg, SplitVRegs, pendingSpills);
|
|
|
|
|
|
|
|
// The live virtual register requesting allocation was spilled, so tell
|
|
|
|
// the caller not to allocate anything during this round.
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool RAGreedy::runOnMachineFunction(MachineFunction &mf) {
|
|
|
|
DEBUG(dbgs() << "********** GREEDY REGISTER ALLOCATION **********\n"
|
|
|
|
<< "********** Function: "
|
|
|
|
<< ((Value*)mf.getFunction())->getName() << '\n');
|
|
|
|
|
|
|
|
MF = &mf;
|
2010-12-17 23:16:35 +00:00
|
|
|
if (VerifyEnabled)
|
2010-12-18 00:06:56 +00:00
|
|
|
MF->verify(this, "Before greedy register allocator");
|
2010-12-17 23:16:35 +00:00
|
|
|
|
2010-12-10 23:49:00 +00:00
|
|
|
RegAllocBase::init(getAnalysis<VirtRegMap>(), getAnalysis<LiveIntervals>());
|
2011-01-18 21:13:27 +00:00
|
|
|
Indexes = &getAnalysis<SlotIndexes>();
|
2010-12-17 23:16:32 +00:00
|
|
|
DomTree = &getAnalysis<MachineDominatorTree>();
|
2010-12-08 03:26:16 +00:00
|
|
|
ReservedRegs = TRI->getReservedRegs(*MF);
|
2010-12-10 22:54:44 +00:00
|
|
|
SpillerInstance.reset(createInlineSpiller(*this, *MF, *VRM));
|
2010-12-15 23:46:13 +00:00
|
|
|
Loops = &getAnalysis<MachineLoopInfo>();
|
|
|
|
LoopRanges = &getAnalysis<MachineLoopRanges>();
|
2011-01-18 21:13:27 +00:00
|
|
|
Bundles = &getAnalysis<EdgeBundles>();
|
|
|
|
SpillPlacer = &getAnalysis<SpillPlacement>();
|
|
|
|
|
2010-12-15 23:46:13 +00:00
|
|
|
SA.reset(new SplitAnalysis(*MF, *LIS, *Loops));
|
|
|
|
|
2010-12-08 03:26:16 +00:00
|
|
|
allocatePhysRegs();
|
|
|
|
addMBBLiveIns(MF);
|
|
|
|
|
|
|
|
// Run rewriter
|
2010-12-11 00:19:56 +00:00
|
|
|
{
|
|
|
|
NamedRegionTimer T("Rewriter", TimerGroupName, TimePassesIsEnabled);
|
|
|
|
std::auto_ptr<VirtRegRewriter> rewriter(createVirtRegRewriter());
|
|
|
|
rewriter->runOnMachineFunction(*MF, *VRM, LIS);
|
|
|
|
}
|
2010-12-08 03:26:16 +00:00
|
|
|
|
|
|
|
// The pass output is in VirtRegMap. Release all the transient data.
|
|
|
|
releaseMemory();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|