remove the JIT "NeedsExactSize" feature and supporting logic.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@109167 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2010-07-22 21:17:55 +00:00
parent 1c55386dae
commit 134d8eec87
6 changed files with 4 additions and 94 deletions

View File

@ -29,10 +29,9 @@ namespace llvm {
class JITMemoryManager {
protected:
bool HasGOT;
bool SizeRequired;
public:
JITMemoryManager() : HasGOT(false), SizeRequired(false) {}
JITMemoryManager() : HasGOT(false) {}
virtual ~JITMemoryManager();
/// CreateDefaultMemManager - This is used to create the default
@ -71,12 +70,6 @@ public:
/// return a pointer to its base.
virtual uint8_t *getGOTBase() const = 0;
/// NeedsExactSize - If the memory manager requires to know the size of the
/// objects to be emitted
bool NeedsExactSize() const {
return SizeRequired;
}
//===--------------------------------------------------------------------===//
// Main Allocation Functions
//===--------------------------------------------------------------------===//

View File

@ -573,11 +573,6 @@ public:
return 0;
}
/// GetFunctionSizeInBytes - Returns the size of the specified
/// MachineFunction.
///
virtual unsigned GetFunctionSizeInBytes(const MachineFunction &MF) const = 0;
/// Measure the specified inline asm to determine an approximation of its
/// length.
virtual unsigned getInlineAsmLength(const char *Str,
@ -621,7 +616,6 @@ public:
virtual bool isSchedulingBoundary(const MachineInstr *MI,
const MachineBasicBlock *MBB,
const MachineFunction &MF) const;
virtual unsigned GetFunctionSizeInBytes(const MachineFunction &MF) const;
virtual ScheduleHazardRecognizer *
CreateTargetPostRAHazardRecognizer(const InstrItineraryData&) const;

View File

@ -178,19 +178,6 @@ MachineInstr *TargetInstrInfoImpl::duplicate(MachineInstr *Orig,
return MF.CloneMachineInstr(Orig);
}
unsigned
TargetInstrInfoImpl::GetFunctionSizeInBytes(const MachineFunction &MF) const {
unsigned FnSize = 0;
for (MachineFunction::const_iterator MBBI = MF.begin(), E = MF.end();
MBBI != E; ++MBBI) {
const MachineBasicBlock &MBB = *MBBI;
for (MachineBasicBlock::const_iterator I = MBB.begin(),E = MBB.end();
I != E; ++I)
FnSize += GetInstSizeInBytes(I);
}
return FnSize;
}
// If the COPY instruction in MI can be folded to a stack operation, return
// the register class to use.
static const TargetRegisterClass *canFoldCopy(const MachineInstr *MI,

View File

@ -831,7 +831,7 @@ void JITEmitter::processDebugLoc(DebugLoc DL, bool BeforePrintingInsn) {
if (DL.isUnknown()) return;
if (!BeforePrintingInsn) return;
const LLVMContext& Context = EmissionDetails.MF->getFunction()->getContext();
const LLVMContext &Context = EmissionDetails.MF->getFunction()->getContext();
if (DL.getScope(Context) != 0 && PrevDL != DL) {
JITEvent_EmittedFunctionDetails::LineStart NextLine;
@ -859,23 +859,6 @@ static unsigned GetConstantPoolSizeInBytes(MachineConstantPool *MCP,
return Size;
}
static unsigned GetJumpTableSizeInBytes(MachineJumpTableInfo *MJTI, JIT *jit) {
const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
if (JT.empty()) return 0;
unsigned NumEntries = 0;
for (unsigned i = 0, e = JT.size(); i != e; ++i)
NumEntries += JT[i].MBBs.size();
return NumEntries * MJTI->getEntrySize(*jit->getTargetData());
}
static uintptr_t RoundUpToAlign(uintptr_t Size, unsigned Alignment) {
if (Alignment == 0) Alignment = 1;
// Since we do not know where the buffer will be allocated, be pessimistic.
return Size + Alignment;
}
/// addSizeOfGlobal - add the size of the global (plus any alignment padding)
/// into the running total Size.
@ -1044,43 +1027,8 @@ void JITEmitter::startFunction(MachineFunction &F) {
uintptr_t ActualSize = 0;
// Set the memory writable, if it's not already
MemMgr->setMemoryWritable();
if (MemMgr->NeedsExactSize()) {
DEBUG(dbgs() << "JIT: ExactSize\n");
const TargetInstrInfo* TII = F.getTarget().getInstrInfo();
MachineConstantPool *MCP = F.getConstantPool();
// Ensure the constant pool/jump table info is at least 4-byte aligned.
ActualSize = RoundUpToAlign(ActualSize, 16);
// Add the alignment of the constant pool
ActualSize = RoundUpToAlign(ActualSize, MCP->getConstantPoolAlignment());
// Add the constant pool size
ActualSize += GetConstantPoolSizeInBytes(MCP, TheJIT->getTargetData());
if (MachineJumpTableInfo *MJTI = F.getJumpTableInfo()) {
// Add the aligment of the jump table info
ActualSize = RoundUpToAlign(ActualSize,
MJTI->getEntryAlignment(*TheJIT->getTargetData()));
// Add the jump table size
ActualSize += GetJumpTableSizeInBytes(MJTI, TheJIT);
}
// Add the alignment for the function
ActualSize = RoundUpToAlign(ActualSize,
std::max(F.getFunction()->getAlignment(), 8U));
// Add the function size
ActualSize += TII->GetFunctionSizeInBytes(F);
DEBUG(dbgs() << "JIT: ActualSize before globals " << ActualSize << "\n");
// Add the size of the globals that will be allocated after this function.
// These are all the ones referenced from this function that were not
// previously allocated.
ActualSize += GetSizeOfGlobalsInBytes(F);
DEBUG(dbgs() << "JIT: ActualSize after globals " << ActualSize << "\n");
} else if (SizeEstimate > 0) {
if (SizeEstimate > 0) {
// SizeEstimate will be non-zero on reallocation attempts.
ActualSize = SizeEstimate;
}
@ -1268,9 +1216,6 @@ bool JITEmitter::finishFunction(MachineFunction &F) {
SavedBufferEnd = BufferEnd;
SavedCurBufferPtr = CurBufferPtr;
if (MemMgr->NeedsExactSize())
ActualSize = DE->GetDwarfTableSizeInBytes(F, *this, FnStart, FnEnd);
BufferBegin = CurBufferPtr = MemMgr->startExceptionTable(F.getFunction(),
ActualSize);
BufferEnd = BufferBegin+ActualSize;

View File

@ -2945,11 +2945,6 @@ bool X86InstrInfo::isX86_64ExtendedReg(unsigned RegNo) {
return false;
}
unsigned X86InstrInfo::GetInstSizeInBytes(const MachineInstr *MI) const {
assert(0 && "X86InstrInfo::GetInstSizeInBytes isn't implemented");
abort();
}
/// getGlobalBaseReg - Return a virtual register initialized with the
/// the global base register value. Output instructions required to
/// initialize the register in the function entry block, if necessary.

View File

@ -825,10 +825,6 @@ public:
/// higher) register? e.g. r8, xmm8, xmm13, etc.
static bool isX86_64ExtendedReg(unsigned RegNo);
/// GetInstSize - Returns the size of the specified MachineInstr.
///
virtual unsigned GetInstSizeInBytes(const MachineInstr *MI) const;
/// getGlobalBaseReg - Return a virtual register initialized with the
/// the global base register value. Output instructions required to
/// initialize the register in the function entry block, if necessary.