// the stub is unused.
DenseMap<void *, SmallPtrSet<const Function*, 1> > StubFnRefs;
- // ExtFnStubs - A map of external function names to stubs which have entries
- // in the JITResolver's ExternalFnToStubMap.
- StringMap<void *> ExtFnStubs;
-
DebugLocTuple PrevDLT;
public:
/// deallocateMemForFunction to also remove stubs no longer referenced.
void AddStubToCurrentFunction(void *Stub);
- /// getExternalFnStubs - Accessor for the JIT to find stubs emitted for
- /// MachineRelocations that reference external functions by name.
- const StringMap<void*> &getExternalFnStubs() const { return ExtFnStubs; }
-
virtual void processDebugLoc(DebugLoc DL, bool BeforePrintingInsn);
virtual void emitLabel(uint64_t LabelID) {
Actual = TheJIT->getPointerToFunction(F);
// If we resolved the symbol to a null address (eg. a weak external)
- // don't emit a stub. Return a null pointer to the application. If dlsym
- // stubs are enabled, not being able to resolve the address is not
- // meaningful.
- if (!Actual && !TheJIT->areDlsymStubsEnabled()) return 0;
+ // don't emit a stub. Return a null pointer to the application.
+ if (!Actual) return 0;
}
// Codegen a new stub, calling the lazy resolver or the actual address of the
if (ResultPtr) return ResultPtr;
// If this is an external function pointer, we can force the JIT to
- // 'compile' it, which really just adds it to the map. In dlsym mode,
- // external functions are forced through a stub, regardless of reloc type.
+ // 'compile' it, which really just adds it to the map.
if (F->isDeclaration() && !F->hasNotBeenReadFromBitcode() &&
- !MayNeedFarStub && !TheJIT->areDlsymStubsEnabled())
+ !MayNeedFarStub)
return TheJIT->getPointerToFunction(F);
// Okay, the function has not been compiled yet, if the target callback
// If the target REALLY wants a stub for this function, emit it now.
if (MR.mayNeedFarStub()) {
- if (!TheJIT->areDlsymStubsEnabled()) {
- ResultPtr = Resolver.getExternalFunctionStub(ResultPtr);
- } else {
- void *&Stub = ExtFnStubs[MR.getExternalSymbol()];
- if (!Stub) {
- Stub = Resolver.getExternalFunctionStub((void *)&Stub);
- AddStubToCurrentFunction(Stub);
- }
- ResultPtr = Stub;
- }
+ ResultPtr = Resolver.getExternalFunctionStub(ResultPtr);
}
} else if (MR.isGlobalValue()) {
ResultPtr = getPointerToGlobal(MR.getGlobalValue(),
StubFnRefs.erase(Stub);
// Invalidate the stub. If it is a GV stub, update the JIT's global
- // mapping for that GV to zero, otherwise, search the string map of
- // external function names to stubs and remove the entry for this stub.
+ // mapping for that GV to zero.
GlobalValue *GV = Resolver.invalidateStub(Stub);
if (GV) {
TheJIT->updateGlobalMapping(GV, 0);
- } else {
- for (StringMapIterator<void*> i = ExtFnStubs.begin(),
- e = ExtFnStubs.end(); i != e; ++i) {
- if (i->second == Stub) {
- ExtFnStubs.erase(i);
- break;
- }
- }
}
}
}
getJITInfo().emitFunctionStubAtAddr(F, Addr, Stub, *getCodeEmitter());
}
-/// updateDlsymStubTable - Emit the data necessary to relocate the stubs
-/// that were emitted during code generation.
-///
-void JIT::updateDlsymStubTable() {
- assert(isa<JITEmitter>(JCE) && "Unexpected MCE?");
- JITEmitter *JE = cast<JITEmitter>(getCodeEmitter());
-
- SmallVector<GlobalValue*, 8> GVs;
- SmallVector<void*, 8> Ptrs;
- const StringMap<void *> &ExtFns = JE->getExternalFnStubs();
-
- JE->getJITResolver().getRelocatableGVs(GVs, Ptrs);
-
- unsigned nStubs = GVs.size() + ExtFns.size();
-
- // If there are no relocatable stubs, return.
- if (nStubs == 0)
- return;
-
- // If there are no new relocatable stubs, return.
- void *CurTable = JE->getMemMgr()->getDlsymTable();
- if (CurTable && (*(unsigned *)CurTable == nStubs))
- return;
-
- // Calculate the size of the stub info
- unsigned offset = 4 + 4 * nStubs + sizeof(intptr_t) * nStubs;
-
- SmallVector<unsigned, 8> Offsets;
- for (unsigned i = 0; i != GVs.size(); ++i) {
- Offsets.push_back(offset);
- offset += GVs[i]->getName().size() + 1;
- }
- for (StringMapConstIterator<void*> i = ExtFns.begin(), e = ExtFns.end();
- i != e; ++i) {
- Offsets.push_back(offset);
- offset += strlen(i->first()) + 1;
- }
-
- // Allocate space for the new "stub", which contains the dlsym table.
- JE->startGVStub(0, offset, 4);
-
- // Emit the number of records
- JE->emitInt32(nStubs);
-
- // Emit the string offsets
- for (unsigned i = 0; i != nStubs; ++i)
- JE->emitInt32(Offsets[i]);
-
- // Emit the pointers. Verify that they are at least 2-byte aligned, and set
- // the low bit to 0 == GV, 1 == Function, so that the client code doing the
- // relocation can write the relocated pointer at the appropriate place in
- // the stub.
- for (unsigned i = 0; i != GVs.size(); ++i) {
- intptr_t Ptr = (intptr_t)Ptrs[i];
- assert((Ptr & 1) == 0 && "Stub pointers must be at least 2-byte aligned!");
-
- if (isa<Function>(GVs[i]))
- Ptr |= (intptr_t)1;
-
- if (sizeof(Ptr) == 8)
- JE->emitInt64(Ptr);
- else
- JE->emitInt32(Ptr);
- }
- for (StringMapConstIterator<void*> i = ExtFns.begin(), e = ExtFns.end();
- i != e; ++i) {
- intptr_t Ptr = (intptr_t)i->second | 1;
-
- if (sizeof(Ptr) == 8)
- JE->emitInt64(Ptr);
- else
- JE->emitInt32(Ptr);
- }
-
- // Emit the strings.
- for (unsigned i = 0; i != GVs.size(); ++i)
- JE->emitString(GVs[i]->getName());
- for (StringMapConstIterator<void*> i = ExtFns.begin(), e = ExtFns.end();
- i != e; ++i)
- JE->emitString(i->first());
-
- // Tell the JIT memory manager where it is. The JIT Memory Manager will
- // deallocate space for the old one, if one existed.
- JE->getMemMgr()->SetDlsymTable(JE->finishGVStub(0));
-}
-
/// freeMachineCodeForFunction - release machine code memory for given Function.
///
void JIT::freeMachineCodeForFunction(Function *F) {
projects / oota-llvm.git / commitdiff