mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-26 07:29:55 +00:00
The constraints are represented by the register class of the original virtual register created for the inline asm. If the register class were included in the operand descriptor, we might be able to do this. For now, just give up on regclass inflation when inline asm is involved. No test case, this bug hasn't happened yet. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134226 91177308-0d34-0410-b5e6-96231b3b80d8
220 lines
7.2 KiB
C++
220 lines
7.2 KiB
C++
//===------------------------ CalcSpillWeights.cpp ------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#define DEBUG_TYPE "calcspillweights"
|
|
|
|
#include "llvm/Function.h"
|
|
#include "llvm/ADT/SmallSet.h"
|
|
#include "llvm/CodeGen/CalcSpillWeights.h"
|
|
#include "llvm/CodeGen/LiveIntervalAnalysis.h"
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
|
#include "llvm/CodeGen/MachineLoopInfo.h"
|
|
#include "llvm/CodeGen/MachineRegisterInfo.h"
|
|
#include "llvm/CodeGen/SlotIndexes.h"
|
|
#include "llvm/Support/Debug.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include "llvm/Target/TargetInstrInfo.h"
|
|
#include "llvm/Target/TargetMachine.h"
|
|
#include "llvm/Target/TargetRegisterInfo.h"
|
|
using namespace llvm;
|
|
|
|
char CalculateSpillWeights::ID = 0;
|
|
INITIALIZE_PASS_BEGIN(CalculateSpillWeights, "calcspillweights",
|
|
"Calculate spill weights", false, false)
|
|
INITIALIZE_PASS_DEPENDENCY(LiveIntervals)
|
|
INITIALIZE_PASS_DEPENDENCY(MachineLoopInfo)
|
|
INITIALIZE_PASS_END(CalculateSpillWeights, "calcspillweights",
|
|
"Calculate spill weights", false, false)
|
|
|
|
void CalculateSpillWeights::getAnalysisUsage(AnalysisUsage &au) const {
|
|
au.addRequired<LiveIntervals>();
|
|
au.addRequired<MachineLoopInfo>();
|
|
au.setPreservesAll();
|
|
MachineFunctionPass::getAnalysisUsage(au);
|
|
}
|
|
|
|
bool CalculateSpillWeights::runOnMachineFunction(MachineFunction &fn) {
|
|
|
|
DEBUG(dbgs() << "********** Compute Spill Weights **********\n"
|
|
<< "********** Function: "
|
|
<< fn.getFunction()->getName() << '\n');
|
|
|
|
LiveIntervals &lis = getAnalysis<LiveIntervals>();
|
|
VirtRegAuxInfo vrai(fn, lis, getAnalysis<MachineLoopInfo>());
|
|
for (LiveIntervals::iterator I = lis.begin(), E = lis.end(); I != E; ++I) {
|
|
LiveInterval &li = *I->second;
|
|
if (TargetRegisterInfo::isVirtualRegister(li.reg))
|
|
vrai.CalculateWeightAndHint(li);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Return the preferred allocation register for reg, given a COPY instruction.
|
|
static unsigned copyHint(const MachineInstr *mi, unsigned reg,
|
|
const TargetRegisterInfo &tri,
|
|
const MachineRegisterInfo &mri) {
|
|
unsigned sub, hreg, hsub;
|
|
if (mi->getOperand(0).getReg() == reg) {
|
|
sub = mi->getOperand(0).getSubReg();
|
|
hreg = mi->getOperand(1).getReg();
|
|
hsub = mi->getOperand(1).getSubReg();
|
|
} else {
|
|
sub = mi->getOperand(1).getSubReg();
|
|
hreg = mi->getOperand(0).getReg();
|
|
hsub = mi->getOperand(0).getSubReg();
|
|
}
|
|
|
|
if (!hreg)
|
|
return 0;
|
|
|
|
if (TargetRegisterInfo::isVirtualRegister(hreg))
|
|
return sub == hsub ? hreg : 0;
|
|
|
|
const TargetRegisterClass *rc = mri.getRegClass(reg);
|
|
|
|
// Only allow physreg hints in rc.
|
|
if (sub == 0)
|
|
return rc->contains(hreg) ? hreg : 0;
|
|
|
|
// reg:sub should match the physreg hreg.
|
|
return tri.getMatchingSuperReg(hreg, sub, rc);
|
|
}
|
|
|
|
void VirtRegAuxInfo::CalculateWeightAndHint(LiveInterval &li) {
|
|
MachineRegisterInfo &mri = MF.getRegInfo();
|
|
const TargetRegisterInfo &tri = *MF.getTarget().getRegisterInfo();
|
|
MachineBasicBlock *mbb = 0;
|
|
MachineLoop *loop = 0;
|
|
unsigned loopDepth = 0;
|
|
bool isExiting = false;
|
|
float totalWeight = 0;
|
|
SmallPtrSet<MachineInstr*, 8> visited;
|
|
|
|
// Find the best physreg hist and the best virtreg hint.
|
|
float bestPhys = 0, bestVirt = 0;
|
|
unsigned hintPhys = 0, hintVirt = 0;
|
|
|
|
// Don't recompute a target specific hint.
|
|
bool noHint = mri.getRegAllocationHint(li.reg).first != 0;
|
|
|
|
// Don't recompute spill weight for an unspillable register.
|
|
bool Spillable = li.isSpillable();
|
|
|
|
for (MachineRegisterInfo::reg_iterator I = mri.reg_begin(li.reg);
|
|
MachineInstr *mi = I.skipInstruction();) {
|
|
if (mi->isIdentityCopy() || mi->isImplicitDef() || mi->isDebugValue())
|
|
continue;
|
|
if (!visited.insert(mi))
|
|
continue;
|
|
|
|
float weight = 1.0f;
|
|
if (Spillable) {
|
|
// Get loop info for mi.
|
|
if (mi->getParent() != mbb) {
|
|
mbb = mi->getParent();
|
|
loop = Loops.getLoopFor(mbb);
|
|
loopDepth = loop ? loop->getLoopDepth() : 0;
|
|
isExiting = loop ? loop->isLoopExiting(mbb) : false;
|
|
}
|
|
|
|
// Calculate instr weight.
|
|
bool reads, writes;
|
|
tie(reads, writes) = mi->readsWritesVirtualRegister(li.reg);
|
|
weight = LiveIntervals::getSpillWeight(writes, reads, loopDepth);
|
|
|
|
// Give extra weight to what looks like a loop induction variable update.
|
|
if (writes && isExiting && LIS.isLiveOutOfMBB(li, mbb))
|
|
weight *= 3;
|
|
|
|
totalWeight += weight;
|
|
}
|
|
|
|
// Get allocation hints from copies.
|
|
if (noHint || !mi->isCopy())
|
|
continue;
|
|
unsigned hint = copyHint(mi, li.reg, tri, mri);
|
|
if (!hint)
|
|
continue;
|
|
float hweight = Hint[hint] += weight;
|
|
if (TargetRegisterInfo::isPhysicalRegister(hint)) {
|
|
if (hweight > bestPhys && LIS.isAllocatable(hint))
|
|
bestPhys = hweight, hintPhys = hint;
|
|
} else {
|
|
if (hweight > bestVirt)
|
|
bestVirt = hweight, hintVirt = hint;
|
|
}
|
|
}
|
|
|
|
Hint.clear();
|
|
|
|
// Always prefer the physreg hint.
|
|
if (unsigned hint = hintPhys ? hintPhys : hintVirt) {
|
|
mri.setRegAllocationHint(li.reg, 0, hint);
|
|
// Weakly boost the spill weight of hinted registers.
|
|
totalWeight *= 1.01F;
|
|
}
|
|
|
|
// If the live interval was already unspillable, leave it that way.
|
|
if (!Spillable)
|
|
return;
|
|
|
|
// Mark li as unspillable if all live ranges are tiny.
|
|
if (li.isZeroLength(LIS.getSlotIndexes())) {
|
|
li.markNotSpillable();
|
|
return;
|
|
}
|
|
|
|
// If all of the definitions of the interval are re-materializable,
|
|
// it is a preferred candidate for spilling. If none of the defs are
|
|
// loads, then it's potentially very cheap to re-materialize.
|
|
// FIXME: this gets much more complicated once we support non-trivial
|
|
// re-materialization.
|
|
bool isLoad = false;
|
|
if (LIS.isReMaterializable(li, 0, isLoad)) {
|
|
if (isLoad)
|
|
totalWeight *= 0.9F;
|
|
else
|
|
totalWeight *= 0.5F;
|
|
}
|
|
|
|
li.weight = normalizeSpillWeight(totalWeight, li.getSize());
|
|
}
|
|
|
|
void VirtRegAuxInfo::CalculateRegClass(unsigned reg) {
|
|
MachineRegisterInfo &MRI = MF.getRegInfo();
|
|
const TargetInstrInfo *TII = MF.getTarget().getInstrInfo();
|
|
const TargetRegisterInfo *TRI = MF.getTarget().getRegisterInfo();
|
|
const TargetRegisterClass *OldRC = MRI.getRegClass(reg);
|
|
const TargetRegisterClass *NewRC = TRI->getLargestLegalSuperClass(OldRC);
|
|
|
|
// Stop early if there is no room to grow.
|
|
if (NewRC == OldRC)
|
|
return;
|
|
|
|
// Accumulate constraints from all uses.
|
|
for (MachineRegisterInfo::reg_nodbg_iterator I = MRI.reg_nodbg_begin(reg),
|
|
E = MRI.reg_nodbg_end(); I != E; ++I) {
|
|
// TRI doesn't have accurate enough information to model this yet.
|
|
if (I.getOperand().getSubReg())
|
|
return;
|
|
// Inline asm instuctions don't remember their constraints.
|
|
if (I->isInlineAsm())
|
|
return;
|
|
const TargetRegisterClass *OpRC =
|
|
TII->getRegClass(I->getDesc(), I.getOperandNo(), TRI);
|
|
if (OpRC)
|
|
NewRC = getCommonSubClass(NewRC, OpRC);
|
|
if (!NewRC || NewRC == OldRC)
|
|
return;
|
|
}
|
|
DEBUG(dbgs() << "Inflating " << OldRC->getName() << ':' << PrintReg(reg)
|
|
<< " to " << NewRC->getName() <<".\n");
|
|
MRI.setRegClass(reg, NewRC);
|
|
}
|