mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-30 21:29:28 +00:00
At the time I wrote this code (circa 2007), TargetRegisterInfo was using a std::set to perform these queries. Switching to the static hashtables was an obvious improvement, but in reality there's no reason to do anything other than scan. With this change, total LLC time on a whole-program 403.gcc is reduced by approximately 1.5%, almost all of which comes from a 15% reduction in LiveVariables time. It also reduces the binary size of LLC by 86KB, thanks to eliminating a bunch of very large static tables. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@133051 91177308-0d34-0410-b5e6-96231b3b80d8
148 lines
4.8 KiB
C++
148 lines
4.8 KiB
C++
//===- TargetRegisterInfo.cpp - Target Register Information Implementation ===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the TargetRegisterInfo interface.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Target/TargetMachine.h"
|
|
#include "llvm/Target/TargetRegisterInfo.h"
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
|
#include "llvm/CodeGen/MachineFrameInfo.h"
|
|
#include "llvm/ADT/BitVector.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
using namespace llvm;
|
|
|
|
TargetRegisterInfo::TargetRegisterInfo(const TargetRegisterDesc *D, unsigned NR,
|
|
regclass_iterator RCB, regclass_iterator RCE,
|
|
const char *const *subregindexnames,
|
|
int CFSO, int CFDO)
|
|
: Desc(D), SubRegIndexNames(subregindexnames), NumRegs(NR),
|
|
RegClassBegin(RCB), RegClassEnd(RCE) {
|
|
assert(isPhysicalRegister(NumRegs) &&
|
|
"Target has too many physical registers!");
|
|
|
|
CallFrameSetupOpcode = CFSO;
|
|
CallFrameDestroyOpcode = CFDO;
|
|
}
|
|
|
|
TargetRegisterInfo::~TargetRegisterInfo() {}
|
|
|
|
void PrintReg::print(raw_ostream &OS) const {
|
|
if (!Reg)
|
|
OS << "%noreg";
|
|
else if (TargetRegisterInfo::isStackSlot(Reg))
|
|
OS << "SS#" << TargetRegisterInfo::stackSlot2Index(Reg);
|
|
else if (TargetRegisterInfo::isVirtualRegister(Reg))
|
|
OS << "%vreg" << TargetRegisterInfo::virtReg2Index(Reg);
|
|
else if (TRI && Reg < TRI->getNumRegs())
|
|
OS << '%' << TRI->getName(Reg);
|
|
else
|
|
OS << "%physreg" << Reg;
|
|
if (SubIdx) {
|
|
if (TRI)
|
|
OS << ':' << TRI->getSubRegIndexName(SubIdx);
|
|
else
|
|
OS << ":sub(" << SubIdx << ')';
|
|
}
|
|
}
|
|
|
|
/// getMinimalPhysRegClass - Returns the Register Class of a physical
|
|
/// register of the given type, picking the most sub register class of
|
|
/// the right type that contains this physreg.
|
|
const TargetRegisterClass *
|
|
TargetRegisterInfo::getMinimalPhysRegClass(unsigned reg, EVT VT) const {
|
|
assert(isPhysicalRegister(reg) && "reg must be a physical register");
|
|
|
|
// Pick the most sub register class of the right type that contains
|
|
// this physreg.
|
|
const TargetRegisterClass* BestRC = 0;
|
|
for (regclass_iterator I = regclass_begin(), E = regclass_end(); I != E; ++I){
|
|
const TargetRegisterClass* RC = *I;
|
|
if ((VT == MVT::Other || RC->hasType(VT)) && RC->contains(reg) &&
|
|
(!BestRC || BestRC->hasSubClass(RC)))
|
|
BestRC = RC;
|
|
}
|
|
|
|
assert(BestRC && "Couldn't find the register class");
|
|
return BestRC;
|
|
}
|
|
|
|
/// getAllocatableSetForRC - Toggle the bits that represent allocatable
|
|
/// registers for the specific register class.
|
|
static void getAllocatableSetForRC(const MachineFunction &MF,
|
|
const TargetRegisterClass *RC, BitVector &R){
|
|
for (TargetRegisterClass::iterator I = RC->allocation_order_begin(MF),
|
|
E = RC->allocation_order_end(MF); I != E; ++I)
|
|
R.set(*I);
|
|
}
|
|
|
|
BitVector TargetRegisterInfo::getAllocatableSet(const MachineFunction &MF,
|
|
const TargetRegisterClass *RC) const {
|
|
BitVector Allocatable(NumRegs);
|
|
if (RC) {
|
|
getAllocatableSetForRC(MF, RC, Allocatable);
|
|
} else {
|
|
for (TargetRegisterInfo::regclass_iterator I = regclass_begin(),
|
|
E = regclass_end(); I != E; ++I)
|
|
if ((*I)->isAllocatable())
|
|
getAllocatableSetForRC(MF, *I, Allocatable);
|
|
}
|
|
|
|
// Mask out the reserved registers
|
|
BitVector Reserved = getReservedRegs(MF);
|
|
Allocatable &= Reserved.flip();
|
|
|
|
return Allocatable;
|
|
}
|
|
|
|
const TargetRegisterClass *
|
|
llvm::getCommonSubClass(const TargetRegisterClass *A,
|
|
const TargetRegisterClass *B) {
|
|
// First take care of the trivial cases
|
|
if (A == B)
|
|
return A;
|
|
if (!A || !B)
|
|
return 0;
|
|
|
|
// If B is a subclass of A, it will be handled in the loop below
|
|
if (B->hasSubClass(A))
|
|
return A;
|
|
|
|
const TargetRegisterClass *Best = 0;
|
|
for (TargetRegisterClass::sc_iterator I = A->subclasses_begin();
|
|
const TargetRegisterClass *X = *I; ++I) {
|
|
if (X == B)
|
|
return B; // B is a subclass of A
|
|
|
|
// X must be a common subclass of A and B
|
|
if (!B->hasSubClass(X))
|
|
continue;
|
|
|
|
// A superclass is definitely better.
|
|
if (!Best || Best->hasSuperClass(X)) {
|
|
Best = X;
|
|
continue;
|
|
}
|
|
|
|
// A subclass is definitely worse
|
|
if (Best->hasSubClass(X))
|
|
continue;
|
|
|
|
// Best and *I have no super/sub class relation - pick the larger class, or
|
|
// the smaller spill size.
|
|
int nb = std::distance(Best->begin(), Best->end());
|
|
int ni = std::distance(X->begin(), X->end());
|
|
if (ni>nb || (ni==nb && X->getSize() < Best->getSize()))
|
|
Best = X;
|
|
}
|
|
return Best;
|
|
}
|