1 //===---- ExecutionUtils.cpp - Utilities for executing functions in Orc ---===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
11
12 #include "llvm/IR/Constants.h"
13 #include "llvm/IR/Function.h"
14 #include "llvm/IR/GlobalVariable.h"
15 #include "llvm/IR/Module.h"
16 #include "llvm/Support/TargetRegistry.h"
17 #include "llvm/Target/TargetMachine.h"
18
19 namespace llvm {
20 namespace orc {
21
CtorDtorIterator(const GlobalVariable * GV,bool End)22 CtorDtorIterator::CtorDtorIterator(const GlobalVariable *GV, bool End)
23 : InitList(
24 GV ? dyn_cast_or_null<ConstantArray>(GV->getInitializer()) : nullptr),
25 I((InitList && End) ? InitList->getNumOperands() : 0) {
26 }
27
operator ==(const CtorDtorIterator & Other) const28 bool CtorDtorIterator::operator==(const CtorDtorIterator &Other) const {
29 assert(InitList == Other.InitList && "Incomparable iterators.");
30 return I == Other.I;
31 }
32
operator !=(const CtorDtorIterator & Other) const33 bool CtorDtorIterator::operator!=(const CtorDtorIterator &Other) const {
34 return !(*this == Other);
35 }
36
operator ++()37 CtorDtorIterator& CtorDtorIterator::operator++() {
38 ++I;
39 return *this;
40 }
41
operator ++(int)42 CtorDtorIterator CtorDtorIterator::operator++(int) {
43 CtorDtorIterator Temp = *this;
44 ++I;
45 return Temp;
46 }
47
operator *() const48 CtorDtorIterator::Element CtorDtorIterator::operator*() const {
49 ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(I));
50 assert(CS && "Unrecognized type in llvm.global_ctors/llvm.global_dtors");
51
52 Constant *FuncC = CS->getOperand(1);
53 Function *Func = nullptr;
54
55 // Extract function pointer, pulling off any casts.
56 while (FuncC) {
57 if (Function *F = dyn_cast_or_null<Function>(FuncC)) {
58 Func = F;
59 break;
60 } else if (ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(FuncC)) {
61 if (CE->isCast())
62 FuncC = dyn_cast_or_null<ConstantExpr>(CE->getOperand(0));
63 else
64 break;
65 } else {
66 // This isn't anything we recognize. Bail out with Func left set to null.
67 break;
68 }
69 }
70
71 ConstantInt *Priority = dyn_cast<ConstantInt>(CS->getOperand(0));
72 Value *Data = CS->getNumOperands() == 3 ? CS->getOperand(2) : nullptr;
73 if (Data && !isa<GlobalValue>(Data))
74 Data = nullptr;
75 return Element(Priority->getZExtValue(), Func, Data);
76 }
77
getConstructors(const Module & M)78 iterator_range<CtorDtorIterator> getConstructors(const Module &M) {
79 const GlobalVariable *CtorsList = M.getNamedGlobal("llvm.global_ctors");
80 return make_range(CtorDtorIterator(CtorsList, false),
81 CtorDtorIterator(CtorsList, true));
82 }
83
getDestructors(const Module & M)84 iterator_range<CtorDtorIterator> getDestructors(const Module &M) {
85 const GlobalVariable *DtorsList = M.getNamedGlobal("llvm.global_dtors");
86 return make_range(CtorDtorIterator(DtorsList, false),
87 CtorDtorIterator(DtorsList, true));
88 }
89
add(iterator_range<CtorDtorIterator> CtorDtors)90 void CtorDtorRunner::add(iterator_range<CtorDtorIterator> CtorDtors) {
91 if (empty(CtorDtors))
92 return;
93
94 MangleAndInterner Mangle(
95 JD.getExecutionSession(),
96 (*CtorDtors.begin()).Func->getParent()->getDataLayout());
97
98 for (const auto &CtorDtor : CtorDtors) {
99 assert(CtorDtor.Func && CtorDtor.Func->hasName() &&
100 "Ctor/Dtor function must be named to be runnable under the JIT");
101
102 // FIXME: Maybe use a symbol promoter here instead.
103 if (CtorDtor.Func->hasLocalLinkage()) {
104 CtorDtor.Func->setLinkage(GlobalValue::ExternalLinkage);
105 CtorDtor.Func->setVisibility(GlobalValue::HiddenVisibility);
106 }
107
108 if (CtorDtor.Data && cast<GlobalValue>(CtorDtor.Data)->isDeclaration()) {
109 dbgs() << " Skipping because why now?\n";
110 continue;
111 }
112
113 CtorDtorsByPriority[CtorDtor.Priority].push_back(
114 Mangle(CtorDtor.Func->getName()));
115 }
116 }
117
run()118 Error CtorDtorRunner::run() {
119 using CtorDtorTy = void (*)();
120
121 SymbolNameSet Names;
122
123 for (auto &KV : CtorDtorsByPriority) {
124 for (auto &Name : KV.second) {
125 auto Added = Names.insert(Name).second;
126 (void)Added;
127 assert(Added && "Ctor/Dtor names clashed");
128 }
129 }
130
131 auto &ES = JD.getExecutionSession();
132 if (auto CtorDtorMap =
133 ES.lookup(JITDylibSearchList({{&JD, true}}), std::move(Names),
134 NoDependenciesToRegister, true)) {
135 for (auto &KV : CtorDtorsByPriority) {
136 for (auto &Name : KV.second) {
137 assert(CtorDtorMap->count(Name) && "No entry for Name");
138 auto CtorDtor = reinterpret_cast<CtorDtorTy>(
139 static_cast<uintptr_t>((*CtorDtorMap)[Name].getAddress()));
140 CtorDtor();
141 }
142 }
143 return Error::success();
144 } else
145 return CtorDtorMap.takeError();
146
147 CtorDtorsByPriority.clear();
148
149 return Error::success();
150 }
151
runDestructors()152 void LocalCXXRuntimeOverridesBase::runDestructors() {
153 auto& CXXDestructorDataPairs = DSOHandleOverride;
154 for (auto &P : CXXDestructorDataPairs)
155 P.first(P.second);
156 CXXDestructorDataPairs.clear();
157 }
158
CXAAtExitOverride(DestructorPtr Destructor,void * Arg,void * DSOHandle)159 int LocalCXXRuntimeOverridesBase::CXAAtExitOverride(DestructorPtr Destructor,
160 void *Arg,
161 void *DSOHandle) {
162 auto& CXXDestructorDataPairs =
163 *reinterpret_cast<CXXDestructorDataPairList*>(DSOHandle);
164 CXXDestructorDataPairs.push_back(std::make_pair(Destructor, Arg));
165 return 0;
166 }
167
enable(JITDylib & JD,MangleAndInterner & Mangle)168 Error LocalCXXRuntimeOverrides::enable(JITDylib &JD,
169 MangleAndInterner &Mangle) {
170 SymbolMap RuntimeInterposes;
171 RuntimeInterposes[Mangle("__dso_handle")] =
172 JITEvaluatedSymbol(toTargetAddress(&DSOHandleOverride),
173 JITSymbolFlags::Exported);
174 RuntimeInterposes[Mangle("__cxa_atexit")] =
175 JITEvaluatedSymbol(toTargetAddress(&CXAAtExitOverride),
176 JITSymbolFlags::Exported);
177
178 return JD.define(absoluteSymbols(std::move(RuntimeInterposes)));
179 }
180
DynamicLibrarySearchGenerator(sys::DynamicLibrary Dylib,const DataLayout & DL,SymbolPredicate Allow)181 DynamicLibrarySearchGenerator::DynamicLibrarySearchGenerator(
182 sys::DynamicLibrary Dylib, const DataLayout &DL, SymbolPredicate Allow)
183 : Dylib(std::move(Dylib)), Allow(std::move(Allow)),
184 GlobalPrefix(DL.getGlobalPrefix()) {}
185
186 Expected<DynamicLibrarySearchGenerator>
Load(const char * FileName,const DataLayout & DL,SymbolPredicate Allow)187 DynamicLibrarySearchGenerator::Load(const char *FileName, const DataLayout &DL,
188 SymbolPredicate Allow) {
189 std::string ErrMsg;
190 auto Lib = sys::DynamicLibrary::getPermanentLibrary(FileName, &ErrMsg);
191 if (!Lib.isValid())
192 return make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode());
193 return DynamicLibrarySearchGenerator(std::move(Lib), DL, std::move(Allow));
194 }
195
196 SymbolNameSet DynamicLibrarySearchGenerator::
operator ()(JITDylib & JD,const SymbolNameSet & Names)197 operator()(JITDylib &JD, const SymbolNameSet &Names) {
198 orc::SymbolNameSet Added;
199 orc::SymbolMap NewSymbols;
200
201 bool HasGlobalPrefix = (GlobalPrefix != '\0');
202
203 for (auto &Name : Names) {
204 if ((*Name).empty())
205 continue;
206
207 if (Allow && !Allow(Name))
208 continue;
209
210 if (HasGlobalPrefix && (*Name).front() != GlobalPrefix)
211 continue;
212
213 std::string Tmp((*Name).data() + (HasGlobalPrefix ? 1 : 0), (*Name).size());
214 if (void *Addr = Dylib.getAddressOfSymbol(Tmp.c_str())) {
215 Added.insert(Name);
216 NewSymbols[Name] = JITEvaluatedSymbol(
217 static_cast<JITTargetAddress>(reinterpret_cast<uintptr_t>(Addr)),
218 JITSymbolFlags::Exported);
219 }
220 }
221
222 // Add any new symbols to JD. Since the generator is only called for symbols
223 // that are not already defined, this will never trigger a duplicate
224 // definition error, so we can wrap this call in a 'cantFail'.
225 if (!NewSymbols.empty())
226 cantFail(JD.define(absoluteSymbols(std::move(NewSymbols))));
227
228 return Added;
229 }
230
231 } // End namespace orc.
232 } // End namespace llvm.
233