mirror of
https://github.com/RPCS3/llvm.git
synced 2024-12-09 20:54:10 +00:00
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:
parent
1c55386dae
commit
134d8eec87
@ -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
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
@ -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;
|
||||
|
@ -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,
|
||||
|
@ -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;
|
||||
|
@ -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.
|
||||
|
@ -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.
|
||||
|
Loading…
Reference in New Issue
Block a user