1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
//===--- SimpleExecutorDylibManager.cpp - Executor-side dylib management --===//
//
// 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
//
//===----------------------------------------------------------------------===//
#include "llvm/ExecutionEngine/Orc/TargetProcess/SimpleExecutorDylibManager.h"
#include "llvm/ExecutionEngine/Orc/Shared/OrcRTBridge.h"
#include "llvm/Support/FormatVariadic.h"
#define DEBUG_TYPE "orc"
namespace llvm {
namespace orc {
namespace rt_bootstrap {
SimpleExecutorDylibManager::~SimpleExecutorDylibManager() {
assert(Dylibs.empty() && "shutdown not called?");
}
Expected<tpctypes::DylibHandle>
SimpleExecutorDylibManager::open(const std::string &Path, uint64_t Mode) {
if (Mode != 0)
return make_error<StringError>("open: non-zero mode bits not yet supported",
inconvertibleErrorCode());
const char *PathCStr = Path.empty() ? nullptr : Path.c_str();
std::string ErrMsg;
auto DL = sys::DynamicLibrary::getPermanentLibrary(PathCStr, &ErrMsg);
if (!DL.isValid())
return make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode());
std::lock_guard<std::mutex> Lock(M);
Dylibs[NextId] = std::move(DL);
return NextId++;
}
Expected<std::vector<ExecutorAddr>>
SimpleExecutorDylibManager::lookup(tpctypes::DylibHandle H,
const RemoteSymbolLookupSet &L) {
std::vector<ExecutorAddr> Result;
std::lock_guard<std::mutex> Lock(M);
auto I = Dylibs.find(H);
if (I == Dylibs.end())
return make_error<StringError>("No dylib for handle " + formatv("{0:x}", H),
inconvertibleErrorCode());
auto &DL = I->second;
for (const auto &E : L) {
if (E.Name.empty()) {
if (E.Required)
return make_error<StringError>("Required address for empty symbol \"\"",
inconvertibleErrorCode());
else
Result.push_back(ExecutorAddr());
} else {
const char *DemangledSymName = E.Name.c_str();
#ifdef __APPLE__
if (E.Name.front() != '_')
return make_error<StringError>(Twine("MachO symbol \"") + E.Name +
"\" missing leading '_'",
inconvertibleErrorCode());
++DemangledSymName;
#endif
void *Addr = DL.getAddressOfSymbol(DemangledSymName);
if (!Addr && E.Required)
return make_error<StringError>(Twine("Missing definition for ") +
DemangledSymName,
inconvertibleErrorCode());
Result.push_back(ExecutorAddr::fromPtr(Addr));
}
}
return Result;
}
Error SimpleExecutorDylibManager::shutdown() {
DylibsMap DM;
{
std::lock_guard<std::mutex> Lock(M);
std::swap(DM, Dylibs);
}
// There is no removal of dylibs at the moment, so nothing to do here.
return Error::success();
}
void SimpleExecutorDylibManager::addBootstrapSymbols(
StringMap<ExecutorAddr> &M) {
M[rt::SimpleExecutorDylibManagerInstanceName] = ExecutorAddr::fromPtr(this);
M[rt::SimpleExecutorDylibManagerOpenWrapperName] =
ExecutorAddr::fromPtr(&openWrapper);
M[rt::SimpleExecutorDylibManagerLookupWrapperName] =
ExecutorAddr::fromPtr(&lookupWrapper);
}
llvm::orc::shared::CWrapperFunctionResult
SimpleExecutorDylibManager::openWrapper(const char *ArgData, size_t ArgSize) {
return shared::
WrapperFunction<rt::SPSSimpleExecutorDylibManagerOpenSignature>::handle(
ArgData, ArgSize,
shared::makeMethodWrapperHandler(
&SimpleExecutorDylibManager::open))
.release();
}
llvm::orc::shared::CWrapperFunctionResult
SimpleExecutorDylibManager::lookupWrapper(const char *ArgData, size_t ArgSize) {
return shared::
WrapperFunction<rt::SPSSimpleExecutorDylibManagerLookupSignature>::handle(
ArgData, ArgSize,
shared::makeMethodWrapperHandler(
&SimpleExecutorDylibManager::lookup))
.release();
}
} // namespace rt_bootstrap
} // end namespace orc
} // end namespace llvm
|
