llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp

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