2015-03-08 04:21:27 +08:00
|
|
|
//===-- RuntimeDyldCOFF.cpp - Run-time dynamic linker for MC-JIT -*- C++ -*-==//
|
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2015-03-08 04:21:27 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// Implementation of COFF support for the MC-JIT runtime dynamic linker.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "RuntimeDyldCOFF.h"
|
2019-11-20 16:51:03 +08:00
|
|
|
#include "Targets/RuntimeDyldCOFFAArch64.h"
|
2015-11-01 09:26:15 +08:00
|
|
|
#include "Targets/RuntimeDyldCOFFI386.h"
|
2016-06-24 22:11:44 +08:00
|
|
|
#include "Targets/RuntimeDyldCOFFThumb.h"
|
2015-03-08 04:21:27 +08:00
|
|
|
#include "Targets/RuntimeDyldCOFFX86_64.h"
|
|
|
|
#include "llvm/ADT/STLExtras.h"
|
|
|
|
#include "llvm/ADT/Triple.h"
|
|
|
|
#include "llvm/Object/ObjectFile.h"
|
2020-03-10 07:56:07 +08:00
|
|
|
#include "llvm/Support/FormatVariadic.h"
|
2015-03-08 04:21:27 +08:00
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
using namespace llvm::object;
|
|
|
|
|
|
|
|
#define DEBUG_TYPE "dyld"
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
2015-08-06 04:20:29 +08:00
|
|
|
class LoadedCOFFObjectInfo final
|
2017-07-05 23:23:56 +08:00
|
|
|
: public LoadedObjectInfoHelper<LoadedCOFFObjectInfo,
|
|
|
|
RuntimeDyld::LoadedObjectInfo> {
|
2015-03-08 04:21:27 +08:00
|
|
|
public:
|
2017-07-05 23:23:56 +08:00
|
|
|
LoadedCOFFObjectInfo(
|
|
|
|
RuntimeDyldImpl &RTDyld,
|
|
|
|
RuntimeDyld::LoadedObjectInfo::ObjSectionToIDMap ObjSecToIDMap)
|
2015-07-29 01:52:11 +08:00
|
|
|
: LoadedObjectInfoHelper(RTDyld, std::move(ObjSecToIDMap)) {}
|
2015-03-08 04:21:27 +08:00
|
|
|
|
|
|
|
OwningBinary<ObjectFile>
|
|
|
|
getObjectForDebug(const ObjectFile &Obj) const override {
|
|
|
|
return OwningBinary<ObjectFile>();
|
|
|
|
}
|
|
|
|
};
|
2015-06-23 17:49:53 +08:00
|
|
|
}
|
2015-03-08 04:21:27 +08:00
|
|
|
|
|
|
|
namespace llvm {
|
|
|
|
|
|
|
|
std::unique_ptr<RuntimeDyldCOFF>
|
[MCJIT][Orc] Refactor RTDyldMemoryManager, weave RuntimeDyld::SymbolInfo through
MCJIT.
This patch decouples the two responsibilities of the RTDyldMemoryManager class,
memory management and symbol resolution, into two new classes:
RuntimeDyld::MemoryManager and RuntimeDyld::SymbolResolver.
The symbol resolution interface is modified slightly, from:
uint64_t getSymbolAddress(const std::string &Name);
to:
RuntimeDyld::SymbolInfo findSymbol(const std::string &Name);
The latter passes symbol flags along with symbol addresses, allowing RuntimeDyld
and others to reason about non-strong/non-exported symbols.
The memory management interface removes the following method:
void notifyObjectLoaded(ExecutionEngine *EE,
const object::ObjectFile &) {}
as it is not related to memory management. (Note: Backwards compatibility *is*
maintained for this method in MCJIT and OrcMCJITReplacement, see below).
The RTDyldMemoryManager class remains in-tree for backwards compatibility.
It inherits directly from RuntimeDyld::SymbolResolver, and indirectly from
RuntimeDyld::MemoryManager via the new MCJITMemoryManager class, which
just subclasses RuntimeDyld::MemoryManager and reintroduces the
notifyObjectLoaded method for backwards compatibility).
The EngineBuilder class retains the existing method:
EngineBuilder&
setMCJITMemoryManager(std::unique_ptr<RTDyldMemoryManager> mcjmm);
and includes two new methods:
EngineBuilder&
setMemoryManager(std::unique_ptr<MCJITMemoryManager> MM);
EngineBuilder&
setSymbolResolver(std::unique_ptr<RuntimeDyld::SymbolResolver> SR);
Clients should use EITHER:
A single call to setMCJITMemoryManager with an RTDyldMemoryManager.
OR (exclusive)
One call each to each of setMemoryManager and setSymbolResolver.
This patch should be fully compatible with existing uses of RTDyldMemoryManager.
If it is not it should be considered a bug, and the patch either fixed or
reverted.
If clients find the new API to be an improvement the goal will be to deprecate
and eventually remove the RTDyldMemoryManager class in favor of the new classes.
llvm-svn: 233509
2015-03-30 11:37:06 +08:00
|
|
|
llvm::RuntimeDyldCOFF::create(Triple::ArchType Arch,
|
|
|
|
RuntimeDyld::MemoryManager &MemMgr,
|
2016-08-02 04:49:11 +08:00
|
|
|
JITSymbolResolver &Resolver) {
|
2015-03-08 04:21:27 +08:00
|
|
|
switch (Arch) {
|
2016-06-24 22:11:44 +08:00
|
|
|
default: llvm_unreachable("Unsupported target for RuntimeDyldCOFF.");
|
2015-11-01 09:26:15 +08:00
|
|
|
case Triple::x86:
|
2019-08-15 23:54:37 +08:00
|
|
|
return std::make_unique<RuntimeDyldCOFFI386>(MemMgr, Resolver);
|
2016-06-24 22:11:44 +08:00
|
|
|
case Triple::thumb:
|
2019-08-15 23:54:37 +08:00
|
|
|
return std::make_unique<RuntimeDyldCOFFThumb>(MemMgr, Resolver);
|
2015-03-08 04:21:27 +08:00
|
|
|
case Triple::x86_64:
|
2019-08-15 23:54:37 +08:00
|
|
|
return std::make_unique<RuntimeDyldCOFFX86_64>(MemMgr, Resolver);
|
2019-11-20 16:51:03 +08:00
|
|
|
case Triple::aarch64:
|
|
|
|
return std::make_unique<RuntimeDyldCOFFAArch64>(MemMgr, Resolver);
|
2015-03-08 04:21:27 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
std::unique_ptr<RuntimeDyld::LoadedObjectInfo>
|
|
|
|
RuntimeDyldCOFF::loadObject(const object::ObjectFile &O) {
|
2016-06-24 22:11:44 +08:00
|
|
|
if (auto ObjSectionToIDOrErr = loadObjectImpl(O)) {
|
2019-08-15 23:54:37 +08:00
|
|
|
return std::make_unique<LoadedCOFFObjectInfo>(*this, *ObjSectionToIDOrErr);
|
2016-06-24 22:11:44 +08:00
|
|
|
} else {
|
2016-04-28 04:24:48 +08:00
|
|
|
HasError = true;
|
|
|
|
raw_string_ostream ErrStream(ErrorStr);
|
2018-11-11 09:46:03 +08:00
|
|
|
logAllUnhandledErrors(ObjSectionToIDOrErr.takeError(), ErrStream);
|
2016-04-28 04:24:48 +08:00
|
|
|
return nullptr;
|
|
|
|
}
|
2015-03-08 04:21:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
uint64_t RuntimeDyldCOFF::getSymbolOffset(const SymbolRef &Sym) {
|
2015-06-25 03:27:53 +08:00
|
|
|
// The value in a relocatable COFF object is the offset.
|
|
|
|
return Sym.getValue();
|
2015-03-08 04:21:27 +08:00
|
|
|
}
|
|
|
|
|
2020-03-10 07:56:07 +08:00
|
|
|
uint64_t RuntimeDyldCOFF::getDLLImportOffset(unsigned SectionID, StubMap &Stubs,
|
|
|
|
StringRef Name,
|
|
|
|
bool SetSectionIDMinus1) {
|
|
|
|
LLVM_DEBUG(dbgs() << "Getting DLLImport entry for " << Name << "... ");
|
|
|
|
assert(Name.startswith(getImportSymbolPrefix()) && "Not a DLLImport symbol?");
|
|
|
|
RelocationValueRef Reloc;
|
|
|
|
Reloc.SymbolName = Name.data();
|
|
|
|
auto I = Stubs.find(Reloc);
|
|
|
|
if (I != Stubs.end()) {
|
|
|
|
LLVM_DEBUG(dbgs() << format("{0:x8}", I->second) << "\n");
|
|
|
|
return I->second;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(SectionID < Sections.size() && "SectionID out of range");
|
|
|
|
auto &Sec = Sections[SectionID];
|
|
|
|
auto EntryOffset = alignTo(Sec.getStubOffset(), PointerSize);
|
|
|
|
Sec.advanceStubOffset(EntryOffset + PointerSize - Sec.getStubOffset());
|
|
|
|
Stubs[Reloc] = EntryOffset;
|
|
|
|
|
|
|
|
RelocationEntry RE(SectionID, EntryOffset, PointerReloc, 0, false,
|
|
|
|
Log2_64(PointerSize));
|
|
|
|
// Hack to tell I386/Thumb resolveRelocation that this isn't section relative.
|
|
|
|
if (SetSectionIDMinus1)
|
|
|
|
RE.Sections.SectionA = -1;
|
|
|
|
addRelocationForSymbol(RE, Name.drop_front(getImportSymbolPrefix().size()));
|
|
|
|
|
|
|
|
LLVM_DEBUG({
|
|
|
|
dbgs() << "Creating entry at "
|
|
|
|
<< formatv("{0:x16} + {1:x8} ( {2:x16} )", Sec.getLoadAddress(),
|
|
|
|
EntryOffset, Sec.getLoadAddress() + EntryOffset)
|
|
|
|
<< "\n";
|
|
|
|
});
|
|
|
|
return EntryOffset;
|
|
|
|
}
|
|
|
|
|
2015-03-08 04:21:27 +08:00
|
|
|
bool RuntimeDyldCOFF::isCompatibleFile(const object::ObjectFile &Obj) const {
|
|
|
|
return Obj.isCOFF();
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace llvm
|