2008-10-02 18:29:27 +00:00
|
|
|
//===------ RegAllocPBQP.cpp ---- PBQP Register Allocator -------*- C++ -*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
2009-01-08 15:50:22 +00:00
|
|
|
//
|
2008-10-02 18:29:27 +00:00
|
|
|
// This file contains a Partitioned Boolean Quadratic Programming (PBQP) based
|
|
|
|
// register allocator for LLVM. This allocator works by constructing a PBQP
|
|
|
|
// problem representing the register allocation problem under consideration,
|
|
|
|
// solving this using a PBQP solver, and mapping the solution back to a
|
|
|
|
// register assignment. If any variables are selected for spilling then spill
|
2009-01-08 15:50:22 +00:00
|
|
|
// code is inserted and the process repeated.
|
2008-10-02 18:29:27 +00:00
|
|
|
//
|
|
|
|
// The PBQP solver (pbqp.c) provided for this allocator uses a heuristic tuned
|
|
|
|
// for register allocation. For more information on PBQP for register
|
2009-01-08 16:40:25 +00:00
|
|
|
// allocation, see the following papers:
|
2008-10-02 18:29:27 +00:00
|
|
|
//
|
|
|
|
// (1) Hames, L. and Scholz, B. 2006. Nearly optimal register allocation with
|
|
|
|
// PBQP. In Proceedings of the 7th Joint Modular Languages Conference
|
|
|
|
// (JMLC'06). LNCS, vol. 4228. Springer, New York, NY, USA. 346-361.
|
|
|
|
//
|
|
|
|
// (2) Scholz, B., Eckstein, E. 2002. Register allocation for irregular
|
|
|
|
// architectures. In Proceedings of the Joint Conference on Languages,
|
|
|
|
// Compilers and Tools for Embedded Systems (LCTES'02), ACM Press, New York,
|
|
|
|
// NY, USA, 139-148.
|
2009-01-08 15:50:22 +00:00
|
|
|
//
|
2008-10-02 18:29:27 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2012-12-03 16:50:05 +00:00
|
|
|
#include "llvm/CodeGen/RegAllocPBQP.h"
|
2011-06-26 21:41:06 +00:00
|
|
|
#include "RegisterCoalescer.h"
|
2012-12-03 16:50:05 +00:00
|
|
|
#include "Spiller.h"
|
2011-12-06 01:45:57 +00:00
|
|
|
#include "llvm/Analysis/AliasAnalysis.h"
|
2009-12-14 06:49:42 +00:00
|
|
|
#include "llvm/CodeGen/CalcSpillWeights.h"
|
2008-10-02 18:29:27 +00:00
|
|
|
#include "llvm/CodeGen/LiveIntervalAnalysis.h"
|
2012-04-02 22:44:18 +00:00
|
|
|
#include "llvm/CodeGen/LiveRangeEdit.h"
|
2008-11-16 12:12:54 +00:00
|
|
|
#include "llvm/CodeGen/LiveStackAnalysis.h"
|
2013-06-17 19:00:36 +00:00
|
|
|
#include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
|
2011-12-06 01:45:57 +00:00
|
|
|
#include "llvm/CodeGen/MachineDominators.h"
|
2009-01-08 15:50:22 +00:00
|
|
|
#include "llvm/CodeGen/MachineFunctionPass.h"
|
2013-07-01 20:47:47 +00:00
|
|
|
#include "llvm/CodeGen/MachineLoopInfo.h"
|
2009-01-08 15:50:22 +00:00
|
|
|
#include "llvm/CodeGen/MachineRegisterInfo.h"
|
|
|
|
#include "llvm/CodeGen/RegAllocRegistry.h"
|
2012-11-28 19:13:06 +00:00
|
|
|
#include "llvm/CodeGen/VirtRegMap.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/Module.h"
|
2008-10-02 18:29:27 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
2014-04-29 23:26:49 +00:00
|
|
|
#include "llvm/Support/FileSystem.h"
|
2009-07-25 00:23:56 +00:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2009-01-08 15:50:22 +00:00
|
|
|
#include "llvm/Target/TargetInstrInfo.h"
|
|
|
|
#include "llvm/Target/TargetMachine.h"
|
2014-08-04 21:25:23 +00:00
|
|
|
#include "llvm/Target/TargetSubtargetInfo.h"
|
2009-01-08 15:50:22 +00:00
|
|
|
#include <limits>
|
|
|
|
#include <memory>
|
2008-10-02 18:29:27 +00:00
|
|
|
#include <set>
|
2012-03-26 23:07:23 +00:00
|
|
|
#include <sstream>
|
2008-10-02 18:29:27 +00:00
|
|
|
#include <vector>
|
|
|
|
|
2010-09-23 04:28:54 +00:00
|
|
|
using namespace llvm;
|
2010-09-18 09:07:10 +00:00
|
|
|
|
2014-04-22 02:02:50 +00:00
|
|
|
#define DEBUG_TYPE "regalloc"
|
|
|
|
|
2008-10-02 18:29:27 +00:00
|
|
|
static RegisterRegAlloc
|
2010-02-18 14:10:41 +00:00
|
|
|
registerPBQPRepAlloc("pbqp", "PBQP register allocator",
|
2010-09-23 04:28:54 +00:00
|
|
|
createDefaultPBQPRegisterAllocator);
|
2008-10-02 18:29:27 +00:00
|
|
|
|
2009-08-19 01:36:14 +00:00
|
|
|
static cl::opt<bool>
|
|
|
|
pbqpCoalescing("pbqp-coalescing",
|
2010-01-26 04:49:58 +00:00
|
|
|
cl::desc("Attempt coalescing during PBQP register allocation."),
|
|
|
|
cl::init(false), cl::Hidden);
|
2009-08-19 01:36:14 +00:00
|
|
|
|
2012-03-26 23:07:23 +00:00
|
|
|
#ifndef NDEBUG
|
|
|
|
static cl::opt<bool>
|
|
|
|
pbqpDumpGraphs("pbqp-dump-graphs",
|
|
|
|
cl::desc("Dump graphs for each function/round in the compilation unit."),
|
|
|
|
cl::init(false), cl::Hidden);
|
|
|
|
#endif
|
|
|
|
|
2010-09-23 04:28:54 +00:00
|
|
|
namespace {
|
|
|
|
|
|
|
|
///
|
|
|
|
/// PBQP based allocators solve the register allocation problem by mapping
|
|
|
|
/// register allocation problems to Partitioned Boolean Quadratic
|
|
|
|
/// Programming problems.
|
|
|
|
class RegAllocPBQP : public MachineFunctionPass {
|
|
|
|
public:
|
|
|
|
|
|
|
|
static char ID;
|
|
|
|
|
|
|
|
/// Construct a PBQP register allocator.
|
2014-07-19 21:19:45 +00:00
|
|
|
RegAllocPBQP(std::unique_ptr<PBQPBuilder> b, char *cPassID = nullptr)
|
|
|
|
: MachineFunctionPass(ID), builder(std::move(b)), customPassID(cPassID) {
|
2010-10-19 17:21:58 +00:00
|
|
|
initializeSlotIndexesPass(*PassRegistry::getPassRegistry());
|
|
|
|
initializeLiveIntervalsPass(*PassRegistry::getPassRegistry());
|
|
|
|
initializeLiveStacksPass(*PassRegistry::getPassRegistry());
|
|
|
|
initializeVirtRegMapPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
2010-09-23 04:28:54 +00:00
|
|
|
|
|
|
|
/// Return the pass name.
|
2014-03-07 09:26:03 +00:00
|
|
|
const char* getPassName() const override {
|
2010-09-23 04:28:54 +00:00
|
|
|
return "PBQP Register Allocator";
|
|
|
|
}
|
|
|
|
|
|
|
|
/// PBQP analysis usage.
|
2014-03-07 09:26:03 +00:00
|
|
|
void getAnalysisUsage(AnalysisUsage &au) const override;
|
2010-09-23 04:28:54 +00:00
|
|
|
|
|
|
|
/// Perform register allocation
|
2014-03-07 09:26:03 +00:00
|
|
|
bool runOnMachineFunction(MachineFunction &MF) override;
|
2010-09-23 04:28:54 +00:00
|
|
|
|
|
|
|
private:
|
|
|
|
|
|
|
|
typedef std::map<const LiveInterval*, unsigned> LI2NodeMap;
|
|
|
|
typedef std::vector<const LiveInterval*> Node2LIMap;
|
|
|
|
typedef std::vector<unsigned> AllowedSet;
|
|
|
|
typedef std::vector<AllowedSet> AllowedSetMap;
|
|
|
|
typedef std::pair<unsigned, unsigned> RegPair;
|
|
|
|
typedef std::map<RegPair, PBQP::PBQPNum> CoalesceMap;
|
|
|
|
typedef std::set<unsigned> RegSet;
|
|
|
|
|
2014-03-06 05:51:42 +00:00
|
|
|
std::unique_ptr<PBQPBuilder> builder;
|
2010-09-23 04:28:54 +00:00
|
|
|
|
2011-06-17 07:09:01 +00:00
|
|
|
char *customPassID;
|
|
|
|
|
2010-09-23 04:28:54 +00:00
|
|
|
MachineFunction *mf;
|
|
|
|
const TargetMachine *tm;
|
|
|
|
const TargetRegisterInfo *tri;
|
|
|
|
const TargetInstrInfo *tii;
|
|
|
|
MachineRegisterInfo *mri;
|
2013-06-17 19:00:36 +00:00
|
|
|
const MachineBlockFrequencyInfo *mbfi;
|
2010-09-23 04:28:54 +00:00
|
|
|
|
2014-03-06 05:51:42 +00:00
|
|
|
std::unique_ptr<Spiller> spiller;
|
2010-09-23 04:28:54 +00:00
|
|
|
LiveIntervals *lis;
|
|
|
|
LiveStacks *lss;
|
|
|
|
VirtRegMap *vrm;
|
|
|
|
|
|
|
|
RegSet vregsToAlloc, emptyIntervalVRegs;
|
|
|
|
|
|
|
|
/// \brief Finds the initial set of vreg intervals to allocate.
|
|
|
|
void findVRegIntervalsToAlloc();
|
|
|
|
|
|
|
|
/// \brief Given a solved PBQP problem maps this solution back to a register
|
|
|
|
/// assignment.
|
|
|
|
bool mapPBQPToRegAlloc(const PBQPRAProblem &problem,
|
|
|
|
const PBQP::Solution &solution);
|
|
|
|
|
|
|
|
/// \brief Postprocessing before final spilling. Sets basic block "live in"
|
|
|
|
/// variables.
|
|
|
|
void finalizeAlloc() const;
|
|
|
|
|
|
|
|
};
|
|
|
|
|
2010-09-18 09:07:10 +00:00
|
|
|
char RegAllocPBQP::ID = 0;
|
|
|
|
|
2010-09-23 04:28:54 +00:00
|
|
|
} // End anonymous namespace.
|
|
|
|
|
2014-03-03 18:50:05 +00:00
|
|
|
unsigned PBQPRAProblem::getVRegForNode(PBQPRAGraph::NodeId node) const {
|
2010-09-18 09:07:10 +00:00
|
|
|
Node2VReg::const_iterator vregItr = node2VReg.find(node);
|
|
|
|
assert(vregItr != node2VReg.end() && "No vreg for node.");
|
|
|
|
return vregItr->second;
|
|
|
|
}
|
|
|
|
|
2014-03-03 18:50:05 +00:00
|
|
|
PBQPRAGraph::NodeId PBQPRAProblem::getNodeForVReg(unsigned vreg) const {
|
2010-09-18 09:07:10 +00:00
|
|
|
VReg2Node::const_iterator nodeItr = vreg2Node.find(vreg);
|
|
|
|
assert(nodeItr != vreg2Node.end() && "No node for vreg.");
|
|
|
|
return nodeItr->second;
|
2012-02-10 04:10:26 +00:00
|
|
|
|
2010-09-18 09:07:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
const PBQPRAProblem::AllowedSet&
|
|
|
|
PBQPRAProblem::getAllowedSet(unsigned vreg) const {
|
|
|
|
AllowedSetMap::const_iterator allowedSetItr = allowedSets.find(vreg);
|
|
|
|
assert(allowedSetItr != allowedSets.end() && "No pregs for vreg.");
|
|
|
|
const AllowedSet &allowedSet = allowedSetItr->second;
|
|
|
|
return allowedSet;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned PBQPRAProblem::getPRegForOption(unsigned vreg, unsigned option) const {
|
|
|
|
assert(isPRegOption(vreg, option) && "Not a preg option.");
|
|
|
|
|
|
|
|
const AllowedSet& allowedSet = getAllowedSet(vreg);
|
|
|
|
assert(option <= allowedSet.size() && "Option outside allowed set.");
|
|
|
|
return allowedSet[option - 1];
|
|
|
|
}
|
|
|
|
|
2013-04-15 12:06:32 +00:00
|
|
|
PBQPRAProblem *PBQPBuilder::build(MachineFunction *mf, const LiveIntervals *lis,
|
2013-06-17 19:00:36 +00:00
|
|
|
const MachineBlockFrequencyInfo *mbfi,
|
2013-04-15 12:06:32 +00:00
|
|
|
const RegSet &vregs) {
|
2010-09-18 09:07:10 +00:00
|
|
|
|
2012-06-20 22:32:05 +00:00
|
|
|
LiveIntervals *LIS = const_cast<LiveIntervals*>(lis);
|
2010-09-18 09:07:10 +00:00
|
|
|
MachineRegisterInfo *mri = &mf->getRegInfo();
|
2014-08-04 21:25:23 +00:00
|
|
|
const TargetRegisterInfo *tri =
|
|
|
|
mf->getTarget().getSubtargetImpl()->getRegisterInfo();
|
2010-09-18 09:07:10 +00:00
|
|
|
|
2014-03-06 05:51:42 +00:00
|
|
|
std::unique_ptr<PBQPRAProblem> p(new PBQPRAProblem());
|
2014-03-03 18:50:05 +00:00
|
|
|
PBQPRAGraph &g = p->getGraph();
|
2010-09-18 09:07:10 +00:00
|
|
|
RegSet pregs;
|
|
|
|
|
|
|
|
// Collect the set of preg intervals, record that they're used in the MF.
|
2012-06-20 21:25:05 +00:00
|
|
|
for (unsigned Reg = 1, e = tri->getNumRegs(); Reg != e; ++Reg) {
|
2012-06-20 22:32:05 +00:00
|
|
|
if (mri->def_empty(Reg))
|
2012-06-20 21:25:05 +00:00
|
|
|
continue;
|
|
|
|
pregs.insert(Reg);
|
|
|
|
mri->setPhysRegUsed(Reg);
|
2010-09-18 09:07:10 +00:00
|
|
|
}
|
|
|
|
|
2012-02-10 04:10:26 +00:00
|
|
|
// Iterate over vregs.
|
2010-09-18 09:07:10 +00:00
|
|
|
for (RegSet::const_iterator vregItr = vregs.begin(), vregEnd = vregs.end();
|
|
|
|
vregItr != vregEnd; ++vregItr) {
|
|
|
|
unsigned vreg = *vregItr;
|
|
|
|
const TargetRegisterClass *trc = mri->getRegClass(vreg);
|
2012-06-20 22:32:05 +00:00
|
|
|
LiveInterval *vregLI = &LIS->getInterval(vreg);
|
|
|
|
|
|
|
|
// Record any overlaps with regmask operands.
|
2012-10-10 06:39:48 +00:00
|
|
|
BitVector regMaskOverlaps;
|
2012-06-20 22:32:05 +00:00
|
|
|
LIS->checkRegMaskInterference(*vregLI, regMaskOverlaps);
|
2010-09-18 09:07:10 +00:00
|
|
|
|
|
|
|
// Compute an initial allowed set for the current vreg.
|
|
|
|
typedef std::vector<unsigned> VRAllowed;
|
|
|
|
VRAllowed vrAllowed;
|
2014-04-04 05:16:06 +00:00
|
|
|
ArrayRef<MCPhysReg> rawOrder = trc->getRawAllocationOrder(*mf);
|
2011-06-16 20:37:45 +00:00
|
|
|
for (unsigned i = 0; i != rawOrder.size(); ++i) {
|
|
|
|
unsigned preg = rawOrder[i];
|
2012-10-15 21:57:41 +00:00
|
|
|
if (mri->isReserved(preg))
|
2012-06-20 22:32:05 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
// vregLI crosses a regmask operand that clobbers preg.
|
2012-10-10 06:39:48 +00:00
|
|
|
if (!regMaskOverlaps.empty() && !regMaskOverlaps.test(preg))
|
2012-06-20 22:32:05 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
// vregLI overlaps fixed regunit interference.
|
2012-06-22 16:46:44 +00:00
|
|
|
bool Interference = false;
|
|
|
|
for (MCRegUnitIterator Units(preg, tri); Units.isValid(); ++Units) {
|
|
|
|
if (vregLI->overlaps(LIS->getRegUnit(*Units))) {
|
|
|
|
Interference = true;
|
|
|
|
break;
|
2012-06-20 22:32:05 +00:00
|
|
|
}
|
2010-09-18 09:07:10 +00:00
|
|
|
}
|
2012-06-22 16:46:44 +00:00
|
|
|
if (Interference)
|
|
|
|
continue;
|
2012-06-20 22:32:05 +00:00
|
|
|
|
|
|
|
// preg is usable for this virtual register.
|
|
|
|
vrAllowed.push_back(preg);
|
2010-09-18 09:07:10 +00:00
|
|
|
}
|
|
|
|
|
2014-03-03 18:50:05 +00:00
|
|
|
PBQP::Vector nodeCosts(vrAllowed.size() + 1, 0);
|
New PBQP solver, and updates to the PBQP graph.
The previous PBQP solver was very robust but consumed a lot of memory,
performed a lot of redundant computation, and contained some unnecessarily tight
coupling that prevented experimentation with novel solution techniques. This new
solver is an attempt to address these shortcomings.
Important/interesting changes:
1) The domain-independent PBQP solver class, HeuristicSolverImpl, is gone.
It is replaced by a register allocation specific solver, PBQP::RegAlloc::Solver
(see RegAllocSolver.h).
The optimal reduction rules and the backpropagation algorithm have been extracted
into stand-alone functions (see ReductionRules.h), which can be used to build
domain specific PBQP solvers. This provides many more opportunities for
domain-specific knowledge to inform the PBQP solvers' decisions. In theory this
should allow us to generate better solutions. In practice, we can at least test
out ideas now.
As a side benefit, I believe the new solver is more readable than the old one.
2) The solver type is now a template parameter of the PBQP graph.
This allows the graph to notify the solver of any modifications made (e.g. by
domain independent rules) without the overhead of a virtual call. It also allows
the solver to supply policy information to the graph (see below).
3) Significantly reduced memory overhead.
Memory management policy is now an explicit property of the PBQP graph (via
the CostAllocator typedef on the graph's solver template argument). Because PBQP
graphs for register allocation tend to contain many redundant instances of
single values (E.g. the value representing an interference constraint between
GPRs), the new RASolver class uses a uniquing scheme. This massively reduces
memory consumption for large register allocation problems. For example, looking
at the largest interference graph in each of the SPEC2006 benchmarks (the
largest graph will always set the memory consumption high-water mark for PBQP),
the average memory reduction for the PBQP costs was 400x. That's times, not
percent. The highest was 1400x. Yikes. So - this is fixed.
"PBQP: No longer feasting upon every last byte of your RAM".
Minor details:
- Fully C++11'd. Never copy-construct another vector/matrix!
- Cute tricks with cost metadata: Metadata that is derived solely from cost
matrices/vectors is attached directly to the cost instances themselves. That way
if you unique the costs you never have to recompute the metadata. 400x less
memory means 400x less cost metadata (re)computation.
Special thanks to Arnaud de Grandmaison, who has been the source of much
encouragement, and of many very useful test cases.
This new solver forms the basis for future work, of which there's plenty to do.
I will be adding TODO notes shortly.
- Lang.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@202551 91177308-0d34-0410-b5e6-96231b3b80d8
2014-02-28 22:25:24 +00:00
|
|
|
|
2014-02-28 22:44:44 +00:00
|
|
|
PBQP::PBQPNum spillCost = (vregLI->weight != 0.0) ?
|
|
|
|
vregLI->weight : std::numeric_limits<PBQP::PBQPNum>::min();
|
|
|
|
|
2014-03-03 18:50:05 +00:00
|
|
|
addSpillCosts(nodeCosts, spillCost);
|
|
|
|
|
|
|
|
// Construct the node.
|
|
|
|
PBQPRAGraph::NodeId nId = g.addNode(std::move(nodeCosts));
|
|
|
|
|
|
|
|
// Record the mapping and allowed set in the problem.
|
|
|
|
p->recordVReg(vreg, nId, vrAllowed.begin(), vrAllowed.end());
|
|
|
|
|
2010-09-18 09:07:10 +00:00
|
|
|
}
|
|
|
|
|
2010-09-18 09:49:08 +00:00
|
|
|
for (RegSet::const_iterator vr1Itr = vregs.begin(), vrEnd = vregs.end();
|
2010-09-18 09:07:10 +00:00
|
|
|
vr1Itr != vrEnd; ++vr1Itr) {
|
|
|
|
unsigned vr1 = *vr1Itr;
|
|
|
|
const LiveInterval &l1 = lis->getInterval(vr1);
|
|
|
|
const PBQPRAProblem::AllowedSet &vr1Allowed = p->getAllowedSet(vr1);
|
|
|
|
|
2014-03-02 12:27:27 +00:00
|
|
|
for (RegSet::const_iterator vr2Itr = std::next(vr1Itr); vr2Itr != vrEnd;
|
|
|
|
++vr2Itr) {
|
2010-09-18 09:07:10 +00:00
|
|
|
unsigned vr2 = *vr2Itr;
|
|
|
|
const LiveInterval &l2 = lis->getInterval(vr2);
|
|
|
|
const PBQPRAProblem::AllowedSet &vr2Allowed = p->getAllowedSet(vr2);
|
|
|
|
|
|
|
|
assert(!l2.empty() && "Empty interval in vreg set?");
|
|
|
|
if (l1.overlaps(l2)) {
|
2014-03-03 18:50:05 +00:00
|
|
|
PBQP::Matrix edgeCosts(vr1Allowed.size()+1, vr2Allowed.size()+1, 0);
|
|
|
|
addInterferenceCosts(edgeCosts, vr1Allowed, vr2Allowed, tri);
|
2010-09-18 09:07:10 +00:00
|
|
|
|
2014-03-03 18:50:05 +00:00
|
|
|
g.addEdge(p->getNodeForVReg(vr1), p->getNodeForVReg(vr2),
|
|
|
|
std::move(edgeCosts));
|
2010-09-18 09:07:10 +00:00
|
|
|
}
|
2008-10-02 18:29:27 +00:00
|
|
|
}
|
2010-09-18 09:07:10 +00:00
|
|
|
}
|
|
|
|
|
2014-03-05 10:19:29 +00:00
|
|
|
return p.release();
|
2010-09-18 09:07:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void PBQPBuilder::addSpillCosts(PBQP::Vector &costVec,
|
|
|
|
PBQP::PBQPNum spillCost) {
|
|
|
|
costVec[0] = spillCost;
|
|
|
|
}
|
|
|
|
|
2010-09-21 13:19:36 +00:00
|
|
|
void PBQPBuilder::addInterferenceCosts(
|
|
|
|
PBQP::Matrix &costMat,
|
|
|
|
const PBQPRAProblem::AllowedSet &vr1Allowed,
|
|
|
|
const PBQPRAProblem::AllowedSet &vr2Allowed,
|
|
|
|
const TargetRegisterInfo *tri) {
|
2010-09-18 09:07:10 +00:00
|
|
|
assert(costMat.getRows() == vr1Allowed.size() + 1 && "Matrix height mismatch.");
|
|
|
|
assert(costMat.getCols() == vr2Allowed.size() + 1 && "Matrix width mismatch.");
|
2008-10-02 18:29:27 +00:00
|
|
|
|
2010-11-12 05:47:21 +00:00
|
|
|
for (unsigned i = 0; i != vr1Allowed.size(); ++i) {
|
2010-09-18 09:07:10 +00:00
|
|
|
unsigned preg1 = vr1Allowed[i];
|
2008-10-02 18:29:27 +00:00
|
|
|
|
2010-11-12 05:47:21 +00:00
|
|
|
for (unsigned j = 0; j != vr2Allowed.size(); ++j) {
|
2010-09-18 09:07:10 +00:00
|
|
|
unsigned preg2 = vr2Allowed[j];
|
2010-07-17 06:31:41 +00:00
|
|
|
|
2010-09-18 09:07:10 +00:00
|
|
|
if (tri->regsOverlap(preg1, preg2)) {
|
|
|
|
costMat[i + 1][j + 1] = std::numeric_limits<PBQP::PBQPNum>::infinity();
|
2010-07-17 06:31:41 +00:00
|
|
|
}
|
2010-09-18 09:07:10 +00:00
|
|
|
}
|
|
|
|
}
|
2008-10-02 18:29:27 +00:00
|
|
|
}
|
|
|
|
|
2013-04-15 12:06:32 +00:00
|
|
|
PBQPRAProblem *PBQPBuilderWithCoalescing::build(MachineFunction *mf,
|
2010-09-21 13:19:36 +00:00
|
|
|
const LiveIntervals *lis,
|
2013-06-17 19:00:36 +00:00
|
|
|
const MachineBlockFrequencyInfo *mbfi,
|
2010-09-21 13:19:36 +00:00
|
|
|
const RegSet &vregs) {
|
|
|
|
|
2014-03-06 05:51:42 +00:00
|
|
|
std::unique_ptr<PBQPRAProblem> p(PBQPBuilder::build(mf, lis, mbfi, vregs));
|
2014-03-03 18:50:05 +00:00
|
|
|
PBQPRAGraph &g = p->getGraph();
|
2010-09-21 13:19:36 +00:00
|
|
|
|
|
|
|
const TargetMachine &tm = mf->getTarget();
|
2014-08-04 21:25:23 +00:00
|
|
|
CoalescerPair cp(*tm.getSubtargetImpl()->getRegisterInfo());
|
2010-09-21 13:19:36 +00:00
|
|
|
|
|
|
|
// Scan the machine function and add a coalescing cost whenever CoalescerPair
|
|
|
|
// gives the Ok.
|
2014-04-30 22:17:38 +00:00
|
|
|
for (const auto &mbb : *mf) {
|
|
|
|
for (const auto &mi : mbb) {
|
|
|
|
if (!cp.setRegisters(&mi)) {
|
2010-09-21 13:19:36 +00:00
|
|
|
continue; // Not coalescable.
|
2010-11-12 05:47:21 +00:00
|
|
|
}
|
2010-09-21 13:19:36 +00:00
|
|
|
|
2010-11-12 05:47:21 +00:00
|
|
|
if (cp.getSrcReg() == cp.getDstReg()) {
|
2010-09-21 13:19:36 +00:00
|
|
|
continue; // Already coalesced.
|
2010-11-12 05:47:21 +00:00
|
|
|
}
|
2010-09-21 13:19:36 +00:00
|
|
|
|
2010-09-23 04:28:54 +00:00
|
|
|
unsigned dst = cp.getDstReg(),
|
|
|
|
src = cp.getSrcReg();
|
2010-09-21 13:19:36 +00:00
|
|
|
|
2010-09-23 04:28:54 +00:00
|
|
|
const float copyFactor = 0.5; // Cost of copy relative to load. Current
|
|
|
|
// value plucked randomly out of the air.
|
2012-02-10 04:10:26 +00:00
|
|
|
|
2010-09-23 04:28:54 +00:00
|
|
|
PBQP::PBQPNum cBenefit =
|
2014-04-30 22:17:38 +00:00
|
|
|
copyFactor * LiveIntervals::getSpillWeight(false, true, mbfi, &mi);
|
2010-09-21 13:19:36 +00:00
|
|
|
|
2010-09-23 04:28:54 +00:00
|
|
|
if (cp.isPhys()) {
|
2012-10-15 22:14:34 +00:00
|
|
|
if (!mf->getRegInfo().isAllocatable(dst)) {
|
2010-09-23 04:28:54 +00:00
|
|
|
continue;
|
2010-11-12 05:47:21 +00:00
|
|
|
}
|
2010-09-21 13:19:36 +00:00
|
|
|
|
2010-09-23 04:28:54 +00:00
|
|
|
const PBQPRAProblem::AllowedSet &allowed = p->getAllowedSet(src);
|
2012-02-10 04:10:26 +00:00
|
|
|
unsigned pregOpt = 0;
|
2010-11-12 05:47:21 +00:00
|
|
|
while (pregOpt < allowed.size() && allowed[pregOpt] != dst) {
|
2010-09-23 04:28:54 +00:00
|
|
|
++pregOpt;
|
2010-11-12 05:47:21 +00:00
|
|
|
}
|
2010-09-23 04:28:54 +00:00
|
|
|
if (pregOpt < allowed.size()) {
|
|
|
|
++pregOpt; // +1 to account for spill option.
|
2014-03-03 18:50:05 +00:00
|
|
|
PBQPRAGraph::NodeId node = p->getNodeForVReg(src);
|
|
|
|
llvm::dbgs() << "Reading node costs for node " << node << "\n";
|
|
|
|
llvm::dbgs() << "Source node: " << &g.getNodeCosts(node) << "\n";
|
|
|
|
PBQP::Vector newCosts(g.getNodeCosts(node));
|
|
|
|
addPhysRegCoalesce(newCosts, pregOpt, cBenefit);
|
|
|
|
g.setNodeCosts(node, newCosts);
|
2010-09-23 04:28:54 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
const PBQPRAProblem::AllowedSet *allowed1 = &p->getAllowedSet(dst);
|
|
|
|
const PBQPRAProblem::AllowedSet *allowed2 = &p->getAllowedSet(src);
|
2014-03-03 18:50:05 +00:00
|
|
|
PBQPRAGraph::NodeId node1 = p->getNodeForVReg(dst);
|
|
|
|
PBQPRAGraph::NodeId node2 = p->getNodeForVReg(src);
|
|
|
|
PBQPRAGraph::EdgeId edge = g.findEdge(node1, node2);
|
2013-11-09 03:08:56 +00:00
|
|
|
if (edge == g.invalidEdgeId()) {
|
2014-03-03 18:50:05 +00:00
|
|
|
PBQP::Matrix costs(allowed1->size() + 1, allowed2->size() + 1, 0);
|
|
|
|
addVirtRegCoalesce(costs, *allowed1, *allowed2, cBenefit);
|
|
|
|
g.addEdge(node1, node2, costs);
|
2010-09-21 13:19:36 +00:00
|
|
|
} else {
|
2014-03-03 18:50:05 +00:00
|
|
|
if (g.getEdgeNode1Id(edge) == node2) {
|
2010-09-23 04:28:54 +00:00
|
|
|
std::swap(node1, node2);
|
|
|
|
std::swap(allowed1, allowed2);
|
2010-09-21 13:19:36 +00:00
|
|
|
}
|
2014-03-03 18:50:05 +00:00
|
|
|
PBQP::Matrix costs(g.getEdgeCosts(edge));
|
|
|
|
addVirtRegCoalesce(costs, *allowed1, *allowed2, cBenefit);
|
|
|
|
g.setEdgeCosts(edge, costs);
|
2010-09-21 13:19:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-05 10:19:29 +00:00
|
|
|
return p.release();
|
2010-09-21 13:19:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void PBQPBuilderWithCoalescing::addPhysRegCoalesce(PBQP::Vector &costVec,
|
|
|
|
unsigned pregOption,
|
|
|
|
PBQP::PBQPNum benefit) {
|
|
|
|
costVec[pregOption] += -benefit;
|
|
|
|
}
|
|
|
|
|
|
|
|
void PBQPBuilderWithCoalescing::addVirtRegCoalesce(
|
|
|
|
PBQP::Matrix &costMat,
|
|
|
|
const PBQPRAProblem::AllowedSet &vr1Allowed,
|
|
|
|
const PBQPRAProblem::AllowedSet &vr2Allowed,
|
|
|
|
PBQP::PBQPNum benefit) {
|
|
|
|
|
|
|
|
assert(costMat.getRows() == vr1Allowed.size() + 1 && "Size mismatch.");
|
|
|
|
assert(costMat.getCols() == vr2Allowed.size() + 1 && "Size mismatch.");
|
|
|
|
|
2010-11-12 05:47:21 +00:00
|
|
|
for (unsigned i = 0; i != vr1Allowed.size(); ++i) {
|
2010-09-21 13:19:36 +00:00
|
|
|
unsigned preg1 = vr1Allowed[i];
|
2010-11-12 05:47:21 +00:00
|
|
|
for (unsigned j = 0; j != vr2Allowed.size(); ++j) {
|
2010-09-21 13:19:36 +00:00
|
|
|
unsigned preg2 = vr2Allowed[j];
|
|
|
|
|
|
|
|
if (preg1 == preg2) {
|
|
|
|
costMat[i + 1][j + 1] += -benefit;
|
2012-02-10 04:10:26 +00:00
|
|
|
}
|
2010-09-21 13:19:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2008-10-02 18:29:27 +00:00
|
|
|
|
2010-09-18 09:07:10 +00:00
|
|
|
|
|
|
|
void RegAllocPBQP::getAnalysisUsage(AnalysisUsage &au) const {
|
2011-12-06 01:45:57 +00:00
|
|
|
au.setPreservesCFG();
|
|
|
|
au.addRequired<AliasAnalysis>();
|
|
|
|
au.addPreserved<AliasAnalysis>();
|
2010-09-18 09:07:10 +00:00
|
|
|
au.addRequired<SlotIndexes>();
|
|
|
|
au.addPreserved<SlotIndexes>();
|
|
|
|
au.addRequired<LiveIntervals>();
|
2012-10-04 04:50:53 +00:00
|
|
|
au.addPreserved<LiveIntervals>();
|
2010-09-18 09:07:10 +00:00
|
|
|
//au.addRequiredID(SplitCriticalEdgesID);
|
2011-06-17 07:09:01 +00:00
|
|
|
if (customPassID)
|
|
|
|
au.addRequiredID(*customPassID);
|
2010-09-18 09:07:10 +00:00
|
|
|
au.addRequired<LiveStacks>();
|
|
|
|
au.addPreserved<LiveStacks>();
|
2013-06-17 19:00:36 +00:00
|
|
|
au.addRequired<MachineBlockFrequencyInfo>();
|
|
|
|
au.addPreserved<MachineBlockFrequencyInfo>();
|
2013-07-01 20:47:47 +00:00
|
|
|
au.addRequired<MachineLoopInfo>();
|
|
|
|
au.addPreserved<MachineLoopInfo>();
|
2011-12-06 01:45:57 +00:00
|
|
|
au.addRequired<MachineDominatorTree>();
|
|
|
|
au.addPreserved<MachineDominatorTree>();
|
2010-09-18 09:07:10 +00:00
|
|
|
au.addRequired<VirtRegMap>();
|
2012-10-04 04:50:53 +00:00
|
|
|
au.addPreserved<VirtRegMap>();
|
2010-09-18 09:07:10 +00:00
|
|
|
MachineFunctionPass::getAnalysisUsage(au);
|
|
|
|
}
|
|
|
|
|
|
|
|
void RegAllocPBQP::findVRegIntervalsToAlloc() {
|
2008-11-16 12:12:54 +00:00
|
|
|
|
|
|
|
// Iterate over all live ranges.
|
2012-06-20 21:25:05 +00:00
|
|
|
for (unsigned i = 0, e = mri->getNumVirtRegs(); i != e; ++i) {
|
|
|
|
unsigned Reg = TargetRegisterInfo::index2VirtReg(i);
|
|
|
|
if (mri->reg_nodbg_empty(Reg))
|
2008-11-16 12:12:54 +00:00
|
|
|
continue;
|
2012-06-20 21:25:05 +00:00
|
|
|
LiveInterval *li = &lis->getInterval(Reg);
|
2008-11-16 12:12:54 +00:00
|
|
|
|
|
|
|
// If this live interval is non-empty we will use pbqp to allocate it.
|
|
|
|
// Empty intervals we allocate in a simple post-processing stage in
|
|
|
|
// finalizeAlloc.
|
|
|
|
if (!li->empty()) {
|
2010-09-18 09:07:10 +00:00
|
|
|
vregsToAlloc.insert(li->reg);
|
2010-11-12 05:47:21 +00:00
|
|
|
} else {
|
2010-09-18 09:07:10 +00:00
|
|
|
emptyIntervalVRegs.insert(li->reg);
|
2008-11-16 12:12:54 +00:00
|
|
|
}
|
|
|
|
}
|
2008-10-02 18:29:27 +00:00
|
|
|
}
|
|
|
|
|
2010-09-23 04:28:54 +00:00
|
|
|
bool RegAllocPBQP::mapPBQPToRegAlloc(const PBQPRAProblem &problem,
|
|
|
|
const PBQP::Solution &solution) {
|
2010-09-18 09:07:10 +00:00
|
|
|
// Set to true if we have any spills
|
|
|
|
bool anotherRoundNeeded = false;
|
|
|
|
|
|
|
|
// Clear the existing allocation.
|
|
|
|
vrm->clearAllVirt();
|
|
|
|
|
2014-03-03 18:50:05 +00:00
|
|
|
const PBQPRAGraph &g = problem.getGraph();
|
2010-09-18 09:07:10 +00:00
|
|
|
// Iterate over the nodes mapping the PBQP solution to a register
|
|
|
|
// assignment.
|
2014-03-03 18:50:05 +00:00
|
|
|
for (auto NId : g.nodeIds()) {
|
|
|
|
unsigned vreg = problem.getVRegForNode(NId);
|
|
|
|
unsigned alloc = solution.getSelection(NId);
|
2010-09-18 09:07:10 +00:00
|
|
|
|
|
|
|
if (problem.isPRegOption(vreg, alloc)) {
|
2012-02-10 04:10:26 +00:00
|
|
|
unsigned preg = problem.getPRegForOption(vreg, alloc);
|
2012-05-23 12:12:58 +00:00
|
|
|
DEBUG(dbgs() << "VREG " << PrintReg(vreg, tri) << " -> "
|
|
|
|
<< tri->getName(preg) << "\n");
|
2010-09-18 09:07:10 +00:00
|
|
|
assert(preg != 0 && "Invalid preg selected.");
|
2012-02-10 04:10:26 +00:00
|
|
|
vrm->assignVirt2Phys(vreg, preg);
|
2010-09-18 09:07:10 +00:00
|
|
|
} else if (problem.isSpillOption(vreg, alloc)) {
|
|
|
|
vregsToAlloc.erase(vreg);
|
2013-08-14 23:50:04 +00:00
|
|
|
SmallVector<unsigned, 8> newSpills;
|
2012-05-19 05:25:46 +00:00
|
|
|
LiveRangeEdit LRE(&lis->getInterval(vreg), newSpills, *mf, *lis, vrm);
|
2011-11-12 23:17:52 +00:00
|
|
|
spiller->spill(LRE);
|
|
|
|
|
2012-05-23 12:12:58 +00:00
|
|
|
DEBUG(dbgs() << "VREG " << PrintReg(vreg, tri) << " -> SPILLED (Cost: "
|
2011-11-12 23:17:52 +00:00
|
|
|
<< LRE.getParent().weight << ", New vregs: ");
|
2010-09-18 09:07:10 +00:00
|
|
|
|
|
|
|
// Copy any newly inserted live intervals into the list of regs to
|
|
|
|
// allocate.
|
2011-11-12 23:17:52 +00:00
|
|
|
for (LiveRangeEdit::iterator itr = LRE.begin(), end = LRE.end();
|
2010-09-18 09:07:10 +00:00
|
|
|
itr != end; ++itr) {
|
2013-08-14 23:50:04 +00:00
|
|
|
LiveInterval &li = lis->getInterval(*itr);
|
|
|
|
assert(!li.empty() && "Empty spill range.");
|
|
|
|
DEBUG(dbgs() << PrintReg(li.reg, tri) << " ");
|
|
|
|
vregsToAlloc.insert(li.reg);
|
2008-11-16 12:12:54 +00:00
|
|
|
}
|
|
|
|
|
2010-01-05 01:25:43 +00:00
|
|
|
DEBUG(dbgs() << ")\n");
|
2008-10-02 18:29:27 +00:00
|
|
|
|
|
|
|
// We need another round if spill intervals were added.
|
2011-11-12 23:17:52 +00:00
|
|
|
anotherRoundNeeded |= !LRE.empty();
|
2010-09-18 09:07:10 +00:00
|
|
|
} else {
|
2012-02-05 08:31:47 +00:00
|
|
|
llvm_unreachable("Unknown allocation option.");
|
2008-10-02 18:29:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return !anotherRoundNeeded;
|
|
|
|
}
|
|
|
|
|
2010-09-18 09:07:10 +00:00
|
|
|
|
|
|
|
void RegAllocPBQP::finalizeAlloc() const {
|
2008-11-16 12:12:54 +00:00
|
|
|
// First allocate registers for the empty intervals.
|
2010-09-18 09:07:10 +00:00
|
|
|
for (RegSet::const_iterator
|
|
|
|
itr = emptyIntervalVRegs.begin(), end = emptyIntervalVRegs.end();
|
2008-11-16 12:12:54 +00:00
|
|
|
itr != end; ++itr) {
|
2010-09-18 09:07:10 +00:00
|
|
|
LiveInterval *li = &lis->getInterval(*itr);
|
2008-11-16 12:12:54 +00:00
|
|
|
|
2012-12-04 00:30:22 +00:00
|
|
|
unsigned physReg = mri->getSimpleHint(li->reg);
|
2009-08-06 23:32:48 +00:00
|
|
|
|
2008-11-16 12:12:54 +00:00
|
|
|
if (physReg == 0) {
|
|
|
|
const TargetRegisterClass *liRC = mri->getRegClass(li->reg);
|
2011-06-16 20:37:45 +00:00
|
|
|
physReg = liRC->getRawAllocationOrder(*mf).front();
|
2008-11-16 12:12:54 +00:00
|
|
|
}
|
2009-01-08 15:50:22 +00:00
|
|
|
|
|
|
|
vrm->assignVirt2Phys(li->reg, physReg);
|
2008-11-16 12:12:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-18 09:07:10 +00:00
|
|
|
bool RegAllocPBQP::runOnMachineFunction(MachineFunction &MF) {
|
2008-11-16 12:12:54 +00:00
|
|
|
|
2008-10-02 18:29:27 +00:00
|
|
|
mf = &MF;
|
|
|
|
tm = &mf->getTarget();
|
2014-08-04 21:25:23 +00:00
|
|
|
tri = tm->getSubtargetImpl()->getRegisterInfo();
|
|
|
|
tii = tm->getSubtargetImpl()->getInstrInfo();
|
2012-02-10 04:10:26 +00:00
|
|
|
mri = &mf->getRegInfo();
|
2008-10-02 18:29:27 +00:00
|
|
|
|
2008-11-16 12:12:54 +00:00
|
|
|
lis = &getAnalysis<LiveIntervals>();
|
|
|
|
lss = &getAnalysis<LiveStacks>();
|
2013-06-17 19:00:36 +00:00
|
|
|
mbfi = &getAnalysis<MachineBlockFrequencyInfo>();
|
2008-10-02 18:29:27 +00:00
|
|
|
|
2013-11-11 19:04:45 +00:00
|
|
|
calculateSpillWeightsAndHints(*lis, MF, getAnalysis<MachineLoopInfo>(),
|
|
|
|
*mbfi);
|
2013-11-10 17:46:31 +00:00
|
|
|
|
2009-03-13 05:55:11 +00:00
|
|
|
vrm = &getAnalysis<VirtRegMap>();
|
2011-11-12 23:17:52 +00:00
|
|
|
spiller.reset(createInlineSpiller(*this, MF, *vrm));
|
2008-10-02 18:29:27 +00:00
|
|
|
|
2012-11-28 00:21:29 +00:00
|
|
|
mri->freezeReservedRegs(MF);
|
|
|
|
|
2012-08-22 06:07:19 +00:00
|
|
|
DEBUG(dbgs() << "PBQP Register Allocating for " << mf->getName() << "\n");
|
2008-11-16 12:12:54 +00:00
|
|
|
|
2008-10-02 18:29:27 +00:00
|
|
|
// Allocator main loop:
|
2009-01-08 15:50:22 +00:00
|
|
|
//
|
2008-10-02 18:29:27 +00:00
|
|
|
// * Map current regalloc problem to a PBQP problem
|
|
|
|
// * Solve the PBQP problem
|
|
|
|
// * Map the solution back to a register allocation
|
|
|
|
// * Spill if necessary
|
2009-01-08 15:50:22 +00:00
|
|
|
//
|
2008-10-02 18:29:27 +00:00
|
|
|
// This process is continued till no more spills are generated.
|
|
|
|
|
2008-11-16 12:12:54 +00:00
|
|
|
// Find the vreg intervals in need of allocation.
|
|
|
|
findVRegIntervalsToAlloc();
|
2009-01-08 15:50:22 +00:00
|
|
|
|
2012-08-22 06:07:19 +00:00
|
|
|
#ifndef NDEBUG
|
2012-03-26 23:07:23 +00:00
|
|
|
const Function* func = mf->getFunction();
|
|
|
|
std::string fqn =
|
|
|
|
func->getParent()->getModuleIdentifier() + "." +
|
|
|
|
func->getName().str();
|
2012-08-22 06:07:19 +00:00
|
|
|
#endif
|
2012-03-26 23:07:23 +00:00
|
|
|
|
2008-11-16 12:12:54 +00:00
|
|
|
// If there are non-empty intervals allocate them using pbqp.
|
2010-09-18 09:07:10 +00:00
|
|
|
if (!vregsToAlloc.empty()) {
|
2008-11-16 12:12:54 +00:00
|
|
|
|
|
|
|
bool pbqpAllocComplete = false;
|
|
|
|
unsigned round = 0;
|
|
|
|
|
2010-10-04 12:13:07 +00:00
|
|
|
while (!pbqpAllocComplete) {
|
|
|
|
DEBUG(dbgs() << " PBQP Regalloc round " << round << ":\n");
|
2009-08-06 23:32:48 +00:00
|
|
|
|
2014-03-06 05:51:42 +00:00
|
|
|
std::unique_ptr<PBQPRAProblem> problem(
|
|
|
|
builder->build(mf, lis, mbfi, vregsToAlloc));
|
2012-03-26 23:07:23 +00:00
|
|
|
|
|
|
|
#ifndef NDEBUG
|
|
|
|
if (pbqpDumpGraphs) {
|
|
|
|
std::ostringstream rs;
|
|
|
|
rs << round;
|
|
|
|
std::string graphFileName(fqn + "." + rs.str() + ".pbqpgraph");
|
|
|
|
std::string tmp;
|
2014-02-24 18:20:12 +00:00
|
|
|
raw_fd_ostream os(graphFileName.c_str(), tmp, sys::fs::F_Text);
|
2012-03-26 23:07:23 +00:00
|
|
|
DEBUG(dbgs() << "Dumping graph for round " << round << " to \""
|
|
|
|
<< graphFileName << "\"\n");
|
|
|
|
problem->getGraph().dump(os);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-10-04 12:13:07 +00:00
|
|
|
PBQP::Solution solution =
|
2014-03-03 18:50:05 +00:00
|
|
|
PBQP::RegAlloc::solve(problem->getGraph());
|
2009-08-18 23:34:50 +00:00
|
|
|
|
2010-10-04 12:13:07 +00:00
|
|
|
pbqpAllocComplete = mapPBQPToRegAlloc(*problem, solution);
|
2008-10-02 18:29:27 +00:00
|
|
|
|
2010-10-04 12:13:07 +00:00
|
|
|
++round;
|
2008-11-16 12:12:54 +00:00
|
|
|
}
|
2008-10-02 18:29:27 +00:00
|
|
|
}
|
|
|
|
|
2008-11-16 12:12:54 +00:00
|
|
|
// Finalise allocation, allocate empty ranges.
|
|
|
|
finalizeAlloc();
|
2010-09-18 09:07:10 +00:00
|
|
|
vregsToAlloc.clear();
|
|
|
|
emptyIntervalVRegs.clear();
|
2008-10-02 18:29:27 +00:00
|
|
|
|
2010-01-05 01:25:43 +00:00
|
|
|
DEBUG(dbgs() << "Post alloc VirtRegMap:\n" << *vrm << "\n");
|
2008-11-16 12:12:54 +00:00
|
|
|
|
2009-01-08 15:50:22 +00:00
|
|
|
return true;
|
2008-10-02 18:29:27 +00:00
|
|
|
}
|
|
|
|
|
2014-03-06 05:51:42 +00:00
|
|
|
FunctionPass *
|
2014-07-19 21:19:45 +00:00
|
|
|
llvm::createPBQPRegisterAllocator(std::unique_ptr<PBQPBuilder> builder,
|
2014-03-06 05:51:42 +00:00
|
|
|
char *customPassID) {
|
2014-07-19 21:19:45 +00:00
|
|
|
return new RegAllocPBQP(std::move(builder), customPassID);
|
2008-10-02 18:29:27 +00:00
|
|
|
}
|
|
|
|
|
2010-09-23 04:28:54 +00:00
|
|
|
FunctionPass* llvm::createDefaultPBQPRegisterAllocator() {
|
2014-03-06 05:51:42 +00:00
|
|
|
std::unique_ptr<PBQPBuilder> Builder;
|
2013-04-15 12:06:32 +00:00
|
|
|
if (pbqpCoalescing)
|
2014-07-19 21:19:45 +00:00
|
|
|
Builder = llvm::make_unique<PBQPBuilderWithCoalescing>();
|
2013-04-15 12:06:32 +00:00
|
|
|
else
|
2014-07-19 21:19:45 +00:00
|
|
|
Builder = llvm::make_unique<PBQPBuilder>();
|
|
|
|
return createPBQPRegisterAllocator(std::move(Builder));
|
2010-09-18 09:07:10 +00:00
|
|
|
}
|
2008-10-02 18:29:27 +00:00
|
|
|
|
|
|
|
#undef DEBUG_TYPE
|