mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2025-04-17 07:00:05 +00:00
e9b4f95b30
In particular this patch switches RTDyldObjectLinkingLayer to use
orc::SymbolResolver and threads the requried changse (ExecutionSession
references and VModuleKeys) through the existing layer APIs.
The purpose of the new resolver interface is to improve query performance and
better support parallelism, both in JIT'd code and within the compiler itself.
The most visibile change is switch of the <Layer>::addModule signatures from:
Expected<Handle> addModule(std::shared_ptr<ModuleType> Mod,
std::shared_ptr<JITSymbolResolver> Resolver)
to:
Expected<Handle> addModule(VModuleKey K, std::shared_ptr<ModuleType> Mod);
Typical usage of addModule will now look like:
auto K = ES.allocateVModuleKey();
Resolvers[K] = createSymbolResolver(...);
Layer.addModule(K, std::move(Mod));
See the BuildingAJIT tutorial code for example usage.
llvm-svn: 324405
89 lines
2.5 KiB
C++
89 lines
2.5 KiB
C++
//===------- Legacy.cpp - Adapters for ExecutionEngine API interop --------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/ExecutionEngine/Orc/Legacy.h"
|
|
|
|
namespace llvm {
|
|
namespace orc {
|
|
|
|
JITSymbolResolverAdapter::JITSymbolResolverAdapter(ExecutionSession &ES,
|
|
SymbolResolver &R)
|
|
: ES(ES), R(R) {}
|
|
|
|
Expected<JITSymbolResolverAdapter::LookupResult>
|
|
JITSymbolResolverAdapter::lookup(const LookupSet &Symbols) {
|
|
Error Err = Error::success();
|
|
JITSymbolResolver::LookupResult Result;
|
|
|
|
SymbolNameSet InternedSymbols;
|
|
for (auto &S : Symbols)
|
|
InternedSymbols.insert(ES.getSymbolStringPool().intern(S));
|
|
|
|
auto OnResolve = [&](Expected<SymbolMap> R) {
|
|
if (R) {
|
|
for (auto &KV : *R) {
|
|
ResolvedStrings.insert(KV.first);
|
|
Result[*KV.first] = KV.second;
|
|
}
|
|
} else
|
|
Err = joinErrors(std::move(Err), R.takeError());
|
|
};
|
|
|
|
auto OnReady = [](Error Err) {
|
|
// FIXME: Report error to ExecutionSession.
|
|
logAllUnhandledErrors(std::move(Err), errs(),
|
|
"legacy resolver received on-ready error:\n");
|
|
};
|
|
|
|
AsynchronousSymbolQuery Query(InternedSymbols, OnResolve, OnReady);
|
|
|
|
auto UnresolvedSymbols = R.lookup(Query, InternedSymbols);
|
|
|
|
if (!UnresolvedSymbols.empty()) {
|
|
std::string ErrorMsg = "Unresolved symbols: ";
|
|
|
|
ErrorMsg += **UnresolvedSymbols.begin();
|
|
for (auto I = std::next(UnresolvedSymbols.begin()),
|
|
E = UnresolvedSymbols.end();
|
|
I != E; ++I) {
|
|
ErrorMsg += ", ";
|
|
ErrorMsg += **I;
|
|
}
|
|
|
|
Err =
|
|
joinErrors(std::move(Err),
|
|
make_error<StringError>(ErrorMsg, inconvertibleErrorCode()));
|
|
}
|
|
|
|
if (Err)
|
|
return std::move(Err);
|
|
|
|
return Result;
|
|
}
|
|
|
|
Expected<JITSymbolResolverAdapter::LookupFlagsResult>
|
|
JITSymbolResolverAdapter::lookupFlags(const LookupSet &Symbols) {
|
|
SymbolNameSet InternedSymbols;
|
|
for (auto &S : Symbols)
|
|
InternedSymbols.insert(ES.getSymbolStringPool().intern(S));
|
|
|
|
SymbolFlagsMap SymbolFlags;
|
|
R.lookupFlags(SymbolFlags, InternedSymbols);
|
|
LookupFlagsResult Result;
|
|
for (auto &KV : SymbolFlags) {
|
|
ResolvedStrings.insert(KV.first);
|
|
Result[*KV.first] = KV.second;
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
} // End namespace orc.
|
|
} // End namespace llvm.
|