1 //===---- ExecutionUtils.cpp - Utilities for executing functions in Orc ---===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "llvm/ExecutionEngine/Orc/ExecutionUtils.h" 10 11 #include "llvm/ExecutionEngine/Orc/Layer.h" 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 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 28 bool CtorDtorIterator::operator==(const CtorDtorIterator &Other) const { 29 assert(InitList == Other.InitList && "Incomparable iterators."); 30 return I == Other.I; 31 } 32 33 bool CtorDtorIterator::operator!=(const CtorDtorIterator &Other) const { 34 return !(*this == Other); 35 } 36 37 CtorDtorIterator& CtorDtorIterator::operator++() { 38 ++I; 39 return *this; 40 } 41 42 CtorDtorIterator CtorDtorIterator::operator++(int) { 43 CtorDtorIterator Temp = *this; 44 ++I; 45 return Temp; 46 } 47 48 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 auto *Priority = 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 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 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 90 void CtorDtorRunner::add(iterator_range<CtorDtorIterator> CtorDtors) { 91 if (CtorDtors.empty()) 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 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 for (auto &KV : CtorDtorsByPriority) { 135 for (auto &Name : KV.second) { 136 assert(CtorDtorMap->count(Name) && "No entry for Name"); 137 auto CtorDtor = reinterpret_cast<CtorDtorTy>( 138 static_cast<uintptr_t>((*CtorDtorMap)[Name].getAddress())); 139 CtorDtor(); 140 } 141 } 142 CtorDtorsByPriority.clear(); 143 return Error::success(); 144 } else 145 return CtorDtorMap.takeError(); 146 } 147 148 void LocalCXXRuntimeOverridesBase::runDestructors() { 149 auto& CXXDestructorDataPairs = DSOHandleOverride; 150 for (auto &P : CXXDestructorDataPairs) 151 P.first(P.second); 152 CXXDestructorDataPairs.clear(); 153 } 154 155 int LocalCXXRuntimeOverridesBase::CXAAtExitOverride(DestructorPtr Destructor, 156 void *Arg, 157 void *DSOHandle) { 158 auto& CXXDestructorDataPairs = 159 *reinterpret_cast<CXXDestructorDataPairList*>(DSOHandle); 160 CXXDestructorDataPairs.push_back(std::make_pair(Destructor, Arg)); 161 return 0; 162 } 163 164 Error LocalCXXRuntimeOverrides::enable(JITDylib &JD, 165 MangleAndInterner &Mangle) { 166 SymbolMap RuntimeInterposes; 167 RuntimeInterposes[Mangle("__dso_handle")] = 168 JITEvaluatedSymbol(toTargetAddress(&DSOHandleOverride), 169 JITSymbolFlags::Exported); 170 RuntimeInterposes[Mangle("__cxa_atexit")] = 171 JITEvaluatedSymbol(toTargetAddress(&CXAAtExitOverride), 172 JITSymbolFlags::Exported); 173 174 return JD.define(absoluteSymbols(std::move(RuntimeInterposes))); 175 } 176 177 DynamicLibrarySearchGenerator::DynamicLibrarySearchGenerator( 178 sys::DynamicLibrary Dylib, char GlobalPrefix, SymbolPredicate Allow) 179 : Dylib(std::move(Dylib)), Allow(std::move(Allow)), 180 GlobalPrefix(GlobalPrefix) {} 181 182 Expected<std::unique_ptr<DynamicLibrarySearchGenerator>> 183 DynamicLibrarySearchGenerator::Load(const char *FileName, char GlobalPrefix, 184 SymbolPredicate Allow) { 185 std::string ErrMsg; 186 auto Lib = sys::DynamicLibrary::getPermanentLibrary(FileName, &ErrMsg); 187 if (!Lib.isValid()) 188 return make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode()); 189 return std::make_unique<DynamicLibrarySearchGenerator>( 190 std::move(Lib), GlobalPrefix, std::move(Allow)); 191 } 192 193 Expected<SymbolNameSet> 194 DynamicLibrarySearchGenerator::tryToGenerate(JITDylib &JD, 195 const SymbolNameSet &Names) { 196 orc::SymbolNameSet Added; 197 orc::SymbolMap NewSymbols; 198 199 bool HasGlobalPrefix = (GlobalPrefix != '\0'); 200 201 for (auto &Name : Names) { 202 if ((*Name).empty()) 203 continue; 204 205 if (Allow && !Allow(Name)) 206 continue; 207 208 if (HasGlobalPrefix && (*Name).front() != GlobalPrefix) 209 continue; 210 211 std::string Tmp((*Name).data() + HasGlobalPrefix, 212 (*Name).size() - HasGlobalPrefix); 213 if (void *Addr = Dylib.getAddressOfSymbol(Tmp.c_str())) { 214 Added.insert(Name); 215 NewSymbols[Name] = JITEvaluatedSymbol( 216 static_cast<JITTargetAddress>(reinterpret_cast<uintptr_t>(Addr)), 217 JITSymbolFlags::Exported); 218 } 219 } 220 221 // Add any new symbols to JD. Since the generator is only called for symbols 222 // that are not already defined, this will never trigger a duplicate 223 // definition error, so we can wrap this call in a 'cantFail'. 224 if (!NewSymbols.empty()) 225 cantFail(JD.define(absoluteSymbols(std::move(NewSymbols)))); 226 227 return Added; 228 } 229 230 Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>> 231 StaticLibraryDefinitionGenerator::Load(ObjectLayer &L, const char *FileName) { 232 auto ArchiveBuffer = errorOrToExpected(MemoryBuffer::getFile(FileName)); 233 234 if (!ArchiveBuffer) 235 return ArchiveBuffer.takeError(); 236 237 return Create(L, std::move(*ArchiveBuffer)); 238 } 239 240 Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>> 241 StaticLibraryDefinitionGenerator::Create( 242 ObjectLayer &L, std::unique_ptr<MemoryBuffer> ArchiveBuffer) { 243 Error Err = Error::success(); 244 245 std::unique_ptr<StaticLibraryDefinitionGenerator> ADG( 246 new StaticLibraryDefinitionGenerator(L, std::move(ArchiveBuffer), Err)); 247 248 if (Err) 249 return std::move(Err); 250 251 return std::move(ADG); 252 } 253 254 Expected<SymbolNameSet> 255 StaticLibraryDefinitionGenerator::tryToGenerate(JITDylib &JD, 256 const SymbolNameSet &Names) { 257 258 DenseSet<std::pair<StringRef, StringRef>> ChildBufferInfos; 259 SymbolNameSet NewDefs; 260 261 for (const auto &Name : Names) { 262 auto Child = Archive.findSym(*Name); 263 if (!Child) 264 return Child.takeError(); 265 if (*Child == None) 266 continue; 267 auto ChildBuffer = (*Child)->getMemoryBufferRef(); 268 if (!ChildBuffer) 269 return ChildBuffer.takeError(); 270 ChildBufferInfos.insert( 271 {ChildBuffer->getBuffer(), ChildBuffer->getBufferIdentifier()}); 272 NewDefs.insert(Name); 273 } 274 275 for (auto ChildBufferInfo : ChildBufferInfos) { 276 MemoryBufferRef ChildBufferRef(ChildBufferInfo.first, 277 ChildBufferInfo.second); 278 279 if (auto Err = 280 L.add(JD, MemoryBuffer::getMemBuffer(ChildBufferRef), VModuleKey())) 281 return std::move(Err); 282 283 --UnrealizedObjects; 284 } 285 286 return NewDefs; 287 } 288 289 StaticLibraryDefinitionGenerator::StaticLibraryDefinitionGenerator( 290 ObjectLayer &L, std::unique_ptr<MemoryBuffer> ArchiveBuffer, Error &Err) 291 : L(L), ArchiveBuffer(std::move(ArchiveBuffer)), 292 Archive(*this->ArchiveBuffer, Err) { 293 294 if (Err) 295 return; 296 297 Error Err2 = Error::success(); 298 for (auto _ : Archive.children(Err2)) { 299 (void)_; 300 ++UnrealizedObjects; 301 } 302 303 // No need to check this: We will leave it to the caller. 304 Err = std::move(Err2); 305 } 306 307 } // End namespace orc. 308 } // End namespace llvm. 309