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 #include "llvm/ExecutionEngine/Orc/Layer.h" 11 #include "llvm/ExecutionEngine/Orc/ObjectFileInterface.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/MC/TargetRegistry.h" 17 #include "llvm/Object/MachOUniversal.h" 18 #include "llvm/Support/FormatVariadic.h" 19 #include "llvm/Target/TargetMachine.h" 20 #include <string> 21 22 namespace llvm { 23 namespace orc { 24 25 CtorDtorIterator::CtorDtorIterator(const GlobalVariable *GV, bool End) 26 : InitList( 27 GV ? dyn_cast_or_null<ConstantArray>(GV->getInitializer()) : nullptr), 28 I((InitList && End) ? InitList->getNumOperands() : 0) { 29 } 30 31 bool CtorDtorIterator::operator==(const CtorDtorIterator &Other) const { 32 assert(InitList == Other.InitList && "Incomparable iterators."); 33 return I == Other.I; 34 } 35 36 bool CtorDtorIterator::operator!=(const CtorDtorIterator &Other) const { 37 return !(*this == Other); 38 } 39 40 CtorDtorIterator& CtorDtorIterator::operator++() { 41 ++I; 42 return *this; 43 } 44 45 CtorDtorIterator CtorDtorIterator::operator++(int) { 46 CtorDtorIterator Temp = *this; 47 ++I; 48 return Temp; 49 } 50 51 CtorDtorIterator::Element CtorDtorIterator::operator*() const { 52 ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(I)); 53 assert(CS && "Unrecognized type in llvm.global_ctors/llvm.global_dtors"); 54 55 Constant *FuncC = CS->getOperand(1); 56 Function *Func = nullptr; 57 58 // Extract function pointer, pulling off any casts. 59 while (FuncC) { 60 if (Function *F = dyn_cast_or_null<Function>(FuncC)) { 61 Func = F; 62 break; 63 } else if (ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(FuncC)) { 64 if (CE->isCast()) 65 FuncC = CE->getOperand(0); 66 else 67 break; 68 } else { 69 // This isn't anything we recognize. Bail out with Func left set to null. 70 break; 71 } 72 } 73 74 auto *Priority = cast<ConstantInt>(CS->getOperand(0)); 75 Value *Data = CS->getNumOperands() == 3 ? CS->getOperand(2) : nullptr; 76 if (Data && !isa<GlobalValue>(Data)) 77 Data = nullptr; 78 return Element(Priority->getZExtValue(), Func, Data); 79 } 80 81 iterator_range<CtorDtorIterator> getConstructors(const Module &M) { 82 const GlobalVariable *CtorsList = M.getNamedGlobal("llvm.global_ctors"); 83 return make_range(CtorDtorIterator(CtorsList, false), 84 CtorDtorIterator(CtorsList, true)); 85 } 86 87 iterator_range<CtorDtorIterator> getDestructors(const Module &M) { 88 const GlobalVariable *DtorsList = M.getNamedGlobal("llvm.global_dtors"); 89 return make_range(CtorDtorIterator(DtorsList, false), 90 CtorDtorIterator(DtorsList, true)); 91 } 92 93 bool StaticInitGVIterator::isStaticInitGlobal(GlobalValue &GV) { 94 if (GV.isDeclaration()) 95 return false; 96 97 if (GV.hasName() && (GV.getName() == "llvm.global_ctors" || 98 GV.getName() == "llvm.global_dtors")) 99 return true; 100 101 if (ObjFmt == Triple::MachO) { 102 // FIXME: These section checks are too strict: We should match first and 103 // second word split by comma. 104 if (GV.hasSection() && 105 (GV.getSection().startswith("__DATA,__objc_classlist") || 106 GV.getSection().startswith("__DATA,__objc_selrefs"))) 107 return true; 108 } 109 110 return false; 111 } 112 113 void CtorDtorRunner::add(iterator_range<CtorDtorIterator> CtorDtors) { 114 if (CtorDtors.empty()) 115 return; 116 117 MangleAndInterner Mangle( 118 JD.getExecutionSession(), 119 (*CtorDtors.begin()).Func->getParent()->getDataLayout()); 120 121 for (auto CtorDtor : CtorDtors) { 122 assert(CtorDtor.Func && CtorDtor.Func->hasName() && 123 "Ctor/Dtor function must be named to be runnable under the JIT"); 124 125 // FIXME: Maybe use a symbol promoter here instead. 126 if (CtorDtor.Func->hasLocalLinkage()) { 127 CtorDtor.Func->setLinkage(GlobalValue::ExternalLinkage); 128 CtorDtor.Func->setVisibility(GlobalValue::HiddenVisibility); 129 } 130 131 if (CtorDtor.Data && cast<GlobalValue>(CtorDtor.Data)->isDeclaration()) { 132 dbgs() << " Skipping because why now?\n"; 133 continue; 134 } 135 136 CtorDtorsByPriority[CtorDtor.Priority].push_back( 137 Mangle(CtorDtor.Func->getName())); 138 } 139 } 140 141 Error CtorDtorRunner::run() { 142 using CtorDtorTy = void (*)(); 143 144 SymbolLookupSet LookupSet; 145 for (auto &KV : CtorDtorsByPriority) 146 for (auto &Name : KV.second) 147 LookupSet.add(Name); 148 assert(!LookupSet.containsDuplicates() && 149 "Ctor/Dtor list contains duplicates"); 150 151 auto &ES = JD.getExecutionSession(); 152 if (auto CtorDtorMap = ES.lookup( 153 makeJITDylibSearchOrder(&JD, JITDylibLookupFlags::MatchAllSymbols), 154 std::move(LookupSet))) { 155 for (auto &KV : CtorDtorsByPriority) { 156 for (auto &Name : KV.second) { 157 assert(CtorDtorMap->count(Name) && "No entry for Name"); 158 auto CtorDtor = reinterpret_cast<CtorDtorTy>( 159 static_cast<uintptr_t>((*CtorDtorMap)[Name].getAddress())); 160 CtorDtor(); 161 } 162 } 163 CtorDtorsByPriority.clear(); 164 return Error::success(); 165 } else 166 return CtorDtorMap.takeError(); 167 } 168 169 void LocalCXXRuntimeOverridesBase::runDestructors() { 170 auto& CXXDestructorDataPairs = DSOHandleOverride; 171 for (auto &P : CXXDestructorDataPairs) 172 P.first(P.second); 173 CXXDestructorDataPairs.clear(); 174 } 175 176 int LocalCXXRuntimeOverridesBase::CXAAtExitOverride(DestructorPtr Destructor, 177 void *Arg, 178 void *DSOHandle) { 179 auto& CXXDestructorDataPairs = 180 *reinterpret_cast<CXXDestructorDataPairList*>(DSOHandle); 181 CXXDestructorDataPairs.push_back(std::make_pair(Destructor, Arg)); 182 return 0; 183 } 184 185 Error LocalCXXRuntimeOverrides::enable(JITDylib &JD, 186 MangleAndInterner &Mangle) { 187 SymbolMap RuntimeInterposes; 188 RuntimeInterposes[Mangle("__dso_handle")] = 189 JITEvaluatedSymbol(toTargetAddress(&DSOHandleOverride), 190 JITSymbolFlags::Exported); 191 RuntimeInterposes[Mangle("__cxa_atexit")] = 192 JITEvaluatedSymbol(toTargetAddress(&CXAAtExitOverride), 193 JITSymbolFlags::Exported); 194 195 return JD.define(absoluteSymbols(std::move(RuntimeInterposes))); 196 } 197 198 void ItaniumCXAAtExitSupport::registerAtExit(void (*F)(void *), void *Ctx, 199 void *DSOHandle) { 200 std::lock_guard<std::mutex> Lock(AtExitsMutex); 201 AtExitRecords[DSOHandle].push_back({F, Ctx}); 202 } 203 204 void ItaniumCXAAtExitSupport::runAtExits(void *DSOHandle) { 205 std::vector<AtExitRecord> AtExitsToRun; 206 207 { 208 std::lock_guard<std::mutex> Lock(AtExitsMutex); 209 auto I = AtExitRecords.find(DSOHandle); 210 if (I != AtExitRecords.end()) { 211 AtExitsToRun = std::move(I->second); 212 AtExitRecords.erase(I); 213 } 214 } 215 216 while (!AtExitsToRun.empty()) { 217 AtExitsToRun.back().F(AtExitsToRun.back().Ctx); 218 AtExitsToRun.pop_back(); 219 } 220 } 221 222 DynamicLibrarySearchGenerator::DynamicLibrarySearchGenerator( 223 sys::DynamicLibrary Dylib, char GlobalPrefix, SymbolPredicate Allow) 224 : Dylib(std::move(Dylib)), Allow(std::move(Allow)), 225 GlobalPrefix(GlobalPrefix) {} 226 227 Expected<std::unique_ptr<DynamicLibrarySearchGenerator>> 228 DynamicLibrarySearchGenerator::Load(const char *FileName, char GlobalPrefix, 229 SymbolPredicate Allow) { 230 std::string ErrMsg; 231 auto Lib = sys::DynamicLibrary::getPermanentLibrary(FileName, &ErrMsg); 232 if (!Lib.isValid()) 233 return make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode()); 234 return std::make_unique<DynamicLibrarySearchGenerator>( 235 std::move(Lib), GlobalPrefix, std::move(Allow)); 236 } 237 238 Error DynamicLibrarySearchGenerator::tryToGenerate( 239 LookupState &LS, LookupKind K, JITDylib &JD, 240 JITDylibLookupFlags JDLookupFlags, const SymbolLookupSet &Symbols) { 241 orc::SymbolMap NewSymbols; 242 243 bool HasGlobalPrefix = (GlobalPrefix != '\0'); 244 245 for (auto &KV : Symbols) { 246 auto &Name = KV.first; 247 248 if ((*Name).empty()) 249 continue; 250 251 if (Allow && !Allow(Name)) 252 continue; 253 254 if (HasGlobalPrefix && (*Name).front() != GlobalPrefix) 255 continue; 256 257 std::string Tmp((*Name).data() + HasGlobalPrefix, 258 (*Name).size() - HasGlobalPrefix); 259 if (void *Addr = Dylib.getAddressOfSymbol(Tmp.c_str())) { 260 NewSymbols[Name] = JITEvaluatedSymbol( 261 static_cast<JITTargetAddress>(reinterpret_cast<uintptr_t>(Addr)), 262 JITSymbolFlags::Exported); 263 } 264 } 265 266 if (NewSymbols.empty()) 267 return Error::success(); 268 269 return JD.define(absoluteSymbols(std::move(NewSymbols))); 270 } 271 272 Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>> 273 StaticLibraryDefinitionGenerator::Load( 274 ObjectLayer &L, const char *FileName, 275 GetObjectFileInterface GetObjFileInterface) { 276 auto ArchiveBuffer = MemoryBuffer::getFile(FileName); 277 278 if (!ArchiveBuffer) 279 return createFileError(FileName, ArchiveBuffer.getError()); 280 281 return Create(L, std::move(*ArchiveBuffer), std::move(GetObjFileInterface)); 282 } 283 284 Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>> 285 StaticLibraryDefinitionGenerator::Load( 286 ObjectLayer &L, const char *FileName, const Triple &TT, 287 GetObjectFileInterface GetObjFileInterface) { 288 289 auto B = object::createBinary(FileName); 290 if (!B) 291 return createFileError(FileName, B.takeError()); 292 293 // If this is a regular archive then create an instance from it. 294 if (isa<object::Archive>(B->getBinary())) 295 return Create(L, std::move(B->takeBinary().second), 296 std::move(GetObjFileInterface)); 297 298 // If this is a universal binary then search for a slice matching the given 299 // Triple. 300 if (auto *UB = cast<object::MachOUniversalBinary>(B->getBinary())) { 301 for (const auto &Obj : UB->objects()) { 302 auto ObjTT = Obj.getTriple(); 303 if (ObjTT.getArch() == TT.getArch() && 304 ObjTT.getSubArch() == TT.getSubArch() && 305 (TT.getVendor() == Triple::UnknownVendor || 306 ObjTT.getVendor() == TT.getVendor())) { 307 // We found a match. Create an instance from a buffer covering this 308 // slice. 309 auto SliceBuffer = MemoryBuffer::getFileSlice(FileName, Obj.getSize(), 310 Obj.getOffset()); 311 if (!SliceBuffer) 312 return make_error<StringError>( 313 Twine("Could not create buffer for ") + TT.str() + " slice of " + 314 FileName + ": [ " + formatv("{0:x}", Obj.getOffset()) + 315 " .. " + formatv("{0:x}", Obj.getOffset() + Obj.getSize()) + 316 ": " + SliceBuffer.getError().message(), 317 SliceBuffer.getError()); 318 return Create(L, std::move(*SliceBuffer), 319 std::move(GetObjFileInterface)); 320 } 321 } 322 323 return make_error<StringError>(Twine("Universal binary ") + FileName + 324 " does not contain a slice for " + 325 TT.str(), 326 inconvertibleErrorCode()); 327 } 328 329 return make_error<StringError>(Twine("Unrecognized file type for ") + 330 FileName, 331 inconvertibleErrorCode()); 332 } 333 334 Expected<std::unique_ptr<StaticLibraryDefinitionGenerator>> 335 StaticLibraryDefinitionGenerator::Create( 336 ObjectLayer &L, std::unique_ptr<MemoryBuffer> ArchiveBuffer, 337 GetObjectFileInterface GetObjFileInterface) { 338 Error Err = Error::success(); 339 340 std::unique_ptr<StaticLibraryDefinitionGenerator> ADG( 341 new StaticLibraryDefinitionGenerator( 342 L, std::move(ArchiveBuffer), std::move(GetObjFileInterface), Err)); 343 344 if (Err) 345 return std::move(Err); 346 347 return std::move(ADG); 348 } 349 350 Error StaticLibraryDefinitionGenerator::tryToGenerate( 351 LookupState &LS, LookupKind K, JITDylib &JD, 352 JITDylibLookupFlags JDLookupFlags, const SymbolLookupSet &Symbols) { 353 354 // Don't materialize symbols from static archives unless this is a static 355 // lookup. 356 if (K != LookupKind::Static) 357 return Error::success(); 358 359 // Bail out early if we've already freed the archive. 360 if (!Archive) 361 return Error::success(); 362 363 DenseSet<std::pair<StringRef, StringRef>> ChildBufferInfos; 364 365 for (const auto &KV : Symbols) { 366 const auto &Name = KV.first; 367 auto Child = Archive->findSym(*Name); 368 if (!Child) 369 return Child.takeError(); 370 if (*Child == None) 371 continue; 372 auto ChildBuffer = (*Child)->getMemoryBufferRef(); 373 if (!ChildBuffer) 374 return ChildBuffer.takeError(); 375 ChildBufferInfos.insert( 376 {ChildBuffer->getBuffer(), ChildBuffer->getBufferIdentifier()}); 377 } 378 379 for (auto ChildBufferInfo : ChildBufferInfos) { 380 MemoryBufferRef ChildBufferRef(ChildBufferInfo.first, 381 ChildBufferInfo.second); 382 383 auto I = GetObjFileInterface(L.getExecutionSession(), ChildBufferRef); 384 if (!I) 385 return I.takeError(); 386 387 if (auto Err = L.add(JD, MemoryBuffer::getMemBuffer(ChildBufferRef, false), 388 std::move(*I))) 389 return Err; 390 } 391 392 return Error::success(); 393 } 394 395 StaticLibraryDefinitionGenerator::StaticLibraryDefinitionGenerator( 396 ObjectLayer &L, std::unique_ptr<MemoryBuffer> ArchiveBuffer, 397 GetObjectFileInterface GetObjFileInterface, Error &Err) 398 : L(L), GetObjFileInterface(std::move(GetObjFileInterface)), 399 ArchiveBuffer(std::move(ArchiveBuffer)), 400 Archive(std::make_unique<object::Archive>(*this->ArchiveBuffer, Err)) { 401 402 if (!this->GetObjFileInterface) 403 this->GetObjFileInterface = getObjectFileInterface; 404 } 405 406 } // End namespace orc. 407 } // End namespace llvm. 408