replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[RuntimeDyld] Skip relocations for external symbols with 64-bit address ~0ULL. 

Requested by Eugene Rozenfeld of the LLILC team, this feature allows JIT
clients to skip relocations for selected external symbols by returning ~0ULL
from their symbol resolver. If this value is returned for a given symbol,
RuntimeDyld will skip all relocations for that symbol. The client will be
responsible for applying the skipped relocations manually before the code
is executed.

llvm-svn: 241383
This commit is contained in:
Lang Hames 2015-07-04 01:35:26 +00:00
parent b0398827c2
commit 78937c2ae5
4 changed files with 84 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
View File

@ -815,12 +815,16 @@ void RuntimeDyldImpl::resolveExternalSymbols() {
report_fatal_error("Program used external function '" + Name +
"' which could not be resolved!");
DEBUG(dbgs() << "Resolving relocations Name: " << Name << "\t"
<< format("0x%lx", Addr) << "\n");
// This list may have been updated when we called getSymbolAddress, so
// don't change this code to get the list earlier.
RelocationList &Relocs = i->second;
resolveRelocationList(Relocs, Addr);
// If Resolver returned UINT64_MAX, the client wants to handle this symbol
// manually and we shouldn't resolve its relocations.
if (Addr != UINT64_MAX) {
DEBUG(dbgs() << "Resolving relocations Name: " << Name << "\t"
<< format("0x%lx", Addr) << "\n");
// This list may have been updated when we called getSymbolAddress, so
// don't change this code to get the list earlier.
RelocationList &Relocs = i->second;
resolveRelocationList(Relocs, Addr);
}
}
ExternalSymbolRelocations.erase(i);

4
llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp
View File

@ -727,7 +727,9 @@ bool RuntimeDyldCheckerImpl::checkAllRulesInBuffer(StringRef RulePrefix,
}
bool RuntimeDyldCheckerImpl::isSymbolValid(StringRef Symbol) const {
return getRTDyld().getSymbolLocalAddress(Symbol) != nullptr;
if (getRTDyld().getSymbolLocalAddress(Symbol))
return true;
return !!getRTDyld().Resolver.findSymbol(Symbol);
}
uint64_t RuntimeDyldCheckerImpl::getSymbolLocalAddr(StringRef Symbol) const {

13
llvm/test/ExecutionEngine/RuntimeDyld/X86/MachO_x86-64_PIC_relocations.s
View File

@ -1,5 +1,5 @@
# RUN: llvm-mc -triple=x86_64-apple-macosx10.9 -relocation-model=pic -filetype=obj -o %T/test_x86-64.o %s
# RUN: llvm-rtdyld -triple=x86_64-apple-macosx10.9 -verify -check=%s %/T/test_x86-64.o
# RUN: llvm-rtdyld -triple=x86_64-apple-macosx10.9 -dummy-extern ds1=0xfffffffffffffffe -dummy-extern ds2=0xffffffffffffffff -verify -check=%s %/T/test_x86-64.o
.section __TEXT,__text,regular,pure_instructions
.globl foo
@ -46,4 +46,15 @@ eh_frame_test:
x:
.long 5
# Test dummy-extern relocation.
# rtdyld-check: *{8}z1 = ds1
z1:
.quad ds1
# Test external-symbol relocation bypass: symbols with addr 0xffffffffffffffff
# don't have their relocations applied.
# rtdyld-check: *{8}z2 = 0
z2:
.quad ds2
.subsections_via_symbols

72
llvm/tools/llvm-rtdyld/llvm-rtdyld.cpp
View File

@ -115,8 +115,17 @@ TargetSectionSep("target-section-sep",
static cl::list<std::string>
SpecificSectionMappings("map-section",
cl::desc("Map a section to a specific address."),
cl::ZeroOrMore);
cl::desc("For -verify only: Map a section to a "
"specific address."),
cl::ZeroOrMore,
cl::Hidden);
static cl::list<std::string>
DummySymbolMappings("dummy-extern",
cl::desc("For -verify only: Inject a symbol into the extern "
"symbol table."),
cl::ZeroOrMore,
cl::Hidden);
/* *** */
@ -147,10 +156,25 @@ public:
// relocations) will get to the data cache but not to the instruction cache.
virtual void invalidateInstructionCache();
void addDummySymbol(const std::string &Name, uint64_t Addr) {
DummyExterns[Name] = Addr;
}
RuntimeDyld::SymbolInfo findSymbol(const std::string &Name) override {
auto I = DummyExterns.find(Name);
if (I != DummyExterns.end())
return RuntimeDyld::SymbolInfo(I->second, JITSymbolFlags::Exported);
return RTDyldMemoryManager::findSymbol(Name);
}
void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr,
size_t Size) override {}
void deregisterEHFrames(uint8_t *Addr, uint64_t LoadAddr,
size_t Size) override {}
private:
std::map<std::string, uint64_t> DummyExterns;
};
uint8_t *TrivialMemoryManager::allocateCodeSection(uintptr_t Size,
@ -401,7 +425,7 @@ applySpecificSectionMappings(RuntimeDyldChecker &Checker) {
for (StringRef Mapping : SpecificSectionMappings) {
size_t EqualsIdx = Mapping.find_first_of("=");
StringRef SectionIDStr = Mapping.substr(0, EqualsIdx);
std::string SectionIDStr = Mapping.substr(0, EqualsIdx);
size_t ComaIdx = Mapping.find_first_of(",");
if (ComaIdx == StringRef::npos) {
@ -410,8 +434,8 @@ applySpecificSectionMappings(RuntimeDyldChecker &Checker) {
exit(1);
}
StringRef FileName = SectionIDStr.substr(0, ComaIdx);
StringRef SectionName = SectionIDStr.substr(ComaIdx + 1);
std::string FileName = SectionIDStr.substr(0, ComaIdx);
std::string SectionName = SectionIDStr.substr(ComaIdx + 1);
uint64_t OldAddrInt;
std::string ErrorMsg;
@ -425,11 +449,11 @@ applySpecificSectionMappings(RuntimeDyldChecker &Checker) {
void* OldAddr = reinterpret_cast<void*>(static_cast<uintptr_t>(OldAddrInt));
StringRef NewAddrStr = Mapping.substr(EqualsIdx + 1);
std::string NewAddrStr = Mapping.substr(EqualsIdx + 1);
uint64_t NewAddr;
if (NewAddrStr.getAsInteger(0, NewAddr)) {
errs() << "Invalid section address in mapping: " << Mapping << "\n";
if (StringRef(NewAddrStr).getAsInteger(0, NewAddr)) {
errs() << "Invalid section address in mapping '" << Mapping << "'.\n";
exit(1);
}
@ -451,9 +475,9 @@ applySpecificSectionMappings(RuntimeDyldChecker &Checker) {
// Defaults to zero. Set to something big
// (e.g. 1 << 32) to stress-test stubs, GOTs, etc.
//
static void remapSections(const llvm::Triple &TargetTriple,
const TrivialMemoryManager &MemMgr,
RuntimeDyldChecker &Checker) {
static void remapSectionsAndSymbols(const llvm::Triple &TargetTriple,
TrivialMemoryManager &MemMgr,
RuntimeDyldChecker &Checker) {
// Set up a work list (section addr/size pairs).
typedef std::list<std::pair<void*, uint64_t>> WorklistT;
@ -516,6 +540,27 @@ static void remapSections(const llvm::Triple &TargetTriple,
Checker.getRTDyld().mapSectionAddress(CurEntry.first, NextSectionAddr);
}
// Add dummy symbols to the memory manager.
for (const auto &Mapping : DummySymbolMappings) {
size_t EqualsIdx = Mapping.find_first_of("=");
if (EqualsIdx == StringRef::npos) {
errs() << "Invalid dummy symbol specification '" << Mapping
<< "'. Should be '<symbol name>=<addr>'\n";
exit(1);
}
std::string Symbol = Mapping.substr(0, EqualsIdx);
std::string AddrStr = Mapping.substr(EqualsIdx + 1);
uint64_t Addr;
if (StringRef(AddrStr).getAsInteger(0, Addr)) {
errs() << "Invalid symbol mapping '" << Mapping << "'.\n";
exit(1);
}
MemMgr.addDummySymbol(Symbol, Addr);
}
}
// Load and link the objects specified on the command line, but do not execute
@ -604,8 +649,9 @@ static int linkAndVerify() {
}
}
// Re-map the section addresses into the phony target address space.
remapSections(TheTriple, MemMgr, Checker);
// Re-map the section addresses into the phony target address space and add
// dummy symbols.
remapSectionsAndSymbols(TheTriple, MemMgr, Checker);
// Resolve all the relocations we can.
Dyld.resolveRelocations();