llvm/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp

   1 //===-- RTDyldObjectLinkingLayer.cpp - RuntimeDyld backed ORC ObjectLayer -===//
   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/RTDyldObjectLinkingLayer.h"
  10 #include "llvm/Object/COFF.h"
  11
  12 namespace {
  13
  14 using namespace llvm;
  15 using namespace llvm::orc;
  16
  17 class JITDylibSearchOrderResolver : public JITSymbolResolver {
  18 public:
  19   JITDylibSearchOrderResolver(MaterializationResponsibility &MR) : MR(MR) {}
  20
  21   void lookup(const LookupSet &Symbols, OnResolvedFunction OnResolved) override {
  22     auto &ES = MR.getTargetJITDylib().getExecutionSession();
  23     SymbolLookupSet InternedSymbols;
  24
  25     // Intern the requested symbols: lookup takes interned strings.
  26     for (auto &S : Symbols)
  27       InternedSymbols.add(ES.intern(S));
  28
  29     // Build an OnResolve callback to unwrap the interned strings and pass them
  30     // to the OnResolved callback.
  31     auto OnResolvedWithUnwrap =
  32         [OnResolved = std::move(OnResolved)](
  33             Expected<SymbolMap> InternedResult) mutable {
  34           if (!InternedResult) {
  35             OnResolved(InternedResult.takeError());
  36             return;
  37           }
  38
  39           LookupResult Result;
  40           for (auto &KV : *InternedResult)
  41             Result[*KV.first] = {KV.second.getAddress().getValue(),
  42                                  KV.second.getFlags()};
  43           OnResolved(Result);
  44         };
  45
  46     // Register dependencies for all symbols contained in this set.
  47     auto RegisterDependencies = [&](const SymbolDependenceMap &Deps) {
  48       MR.addDependenciesForAll(Deps);
  49     };
  50
  51     JITDylibSearchOrder LinkOrder;
  52     MR.getTargetJITDylib().withLinkOrderDo(
  53         [&](const JITDylibSearchOrder &LO) { LinkOrder = LO; });
  54     ES.lookup(LookupKind::Static, LinkOrder, InternedSymbols,
  55               SymbolState::Resolved, std::move(OnResolvedWithUnwrap),
  56               RegisterDependencies);
  57   }
  58
  59   Expected<LookupSet> getResponsibilitySet(const LookupSet &Symbols) override {
  60     LookupSet Result;
  61
  62     for (auto &KV : MR.getSymbols()) {
  63       if (Symbols.count(*KV.first))
  64         Result.insert(*KV.first);
  65     }
  66
  67     return Result;
  68   }
  69
  70 private:
  71   MaterializationResponsibility &MR;
  72 };
  73
  74 } // end anonymous namespace
  75
  76 namespace llvm {
  77 namespace orc {
  78
  79 char RTDyldObjectLinkingLayer::ID;
  80
  81 using BaseT = RTTIExtends<RTDyldObjectLinkingLayer, ObjectLayer>;
  82
  83 RTDyldObjectLinkingLayer::RTDyldObjectLinkingLayer(
  84     ExecutionSession &ES, GetMemoryManagerFunction GetMemoryManager)
  85     : BaseT(ES), GetMemoryManager(std::move(GetMemoryManager)) {
  86   ES.registerResourceManager(*this);
  87 }
  88
  89 RTDyldObjectLinkingLayer::~RTDyldObjectLinkingLayer() {
  90   assert(MemMgrs.empty() && "Layer destroyed with resources still attached");
  91 }
  92
  93 void RTDyldObjectLinkingLayer::emit(
  94     std::unique_ptr<MaterializationResponsibility> R,
  95     std::unique_ptr<MemoryBuffer> O) {
  96   assert(O && "Object must not be null");
  97
  98   auto &ES = getExecutionSession();
  99
 100   auto Obj = object::ObjectFile::createObjectFile(*O);
 101
 102   if (!Obj) {
 103     getExecutionSession().reportError(Obj.takeError());
 104     R->failMaterialization();
 105     return;
 106   }
 107
 108   // Collect the internal symbols from the object file: We will need to
 109   // filter these later.
 110   auto InternalSymbols = std::make_shared<std::set<StringRef>>();
 111   {
 112     SymbolFlagsMap ExtraSymbolsToClaim;
 113     for (auto &Sym : (*Obj)->symbols()) {
 114
 115       // Skip file symbols.
 116       if (auto SymType = Sym.getType()) {
 117         if (*SymType == object::SymbolRef::ST_File)
 118           continue;
 119       } else {
 120         ES.reportError(SymType.takeError());
 121         R->failMaterialization();
 122         return;
 123       }
 124
 125       Expected<uint32_t> SymFlagsOrErr = Sym.getFlags();
 126       if (!SymFlagsOrErr) {
 127         // TODO: Test this error.
 128         ES.reportError(SymFlagsOrErr.takeError());
 129         R->failMaterialization();
 130         return;
 131       }
 132
 133       // Try to claim responsibility of weak symbols
 134       // if AutoClaimObjectSymbols flag is set.
 135       if (AutoClaimObjectSymbols &&
 136           (*SymFlagsOrErr & object::BasicSymbolRef::SF_Weak)) {
 137         auto SymName = Sym.getName();
 138         if (!SymName) {
 139           ES.reportError(SymName.takeError());
 140           R->failMaterialization();
 141           return;
 142         }
 143
 144         // Already included in responsibility set, skip it
 145         SymbolStringPtr SymbolName = ES.intern(*SymName);
 146         if (R->getSymbols().count(SymbolName))
 147           continue;
 148
 149         auto SymFlags = JITSymbolFlags::fromObjectSymbol(Sym);
 150         if (!SymFlags) {
 151           ES.reportError(SymFlags.takeError());
 152           R->failMaterialization();
 153           return;
 154         }
 155
 156         ExtraSymbolsToClaim[SymbolName] = *SymFlags;
 157         continue;
 158       }
 159
 160       // Don't include symbols that aren't global.
 161       if (!(*SymFlagsOrErr & object::BasicSymbolRef::SF_Global)) {
 162         if (auto SymName = Sym.getName())
 163           InternalSymbols->insert(*SymName);
 164         else {
 165           ES.reportError(SymName.takeError());
 166           R->failMaterialization();
 167           return;
 168         }
 169       }
 170     }
 171
 172     if (!ExtraSymbolsToClaim.empty()) {
 173       if (auto Err = R->defineMaterializing(ExtraSymbolsToClaim)) {
 174         ES.reportError(std::move(Err));
 175         R->failMaterialization();
 176       }
 177     }
 178   }
 179
 180   auto MemMgr = GetMemoryManager();
 181   auto &MemMgrRef = *MemMgr;
 182
 183   // Switch to shared ownership of MR so that it can be captured by both
 184   // lambdas below.
 185   std::shared_ptr<MaterializationResponsibility> SharedR(std::move(R));
 186
 187   JITDylibSearchOrderResolver Resolver(*SharedR);
 188
 189   jitLinkForORC(
 190       object::OwningBinary<object::ObjectFile>(std::move(*Obj), std::move(O)),
 191       MemMgrRef, Resolver, ProcessAllSections,
 192       [this, SharedR, &MemMgrRef, InternalSymbols](
 193           const object::ObjectFile &Obj,
 194           RuntimeDyld::LoadedObjectInfo &LoadedObjInfo,
 195           std::map<StringRef, JITEvaluatedSymbol> ResolvedSymbols) {
 196         return onObjLoad(*SharedR, Obj, MemMgrRef, LoadedObjInfo,
 197                          ResolvedSymbols, *InternalSymbols);
 198       },
 199       [this, SharedR, MemMgr = std::move(MemMgr)](
 200           object::OwningBinary<object::ObjectFile> Obj,
 201           std::unique_ptr<RuntimeDyld::LoadedObjectInfo> LoadedObjInfo,
 202           Error Err) mutable {
 203         onObjEmit(*SharedR, std::move(Obj), std::move(MemMgr),
 204                   std::move(LoadedObjInfo), std::move(Err));
 205       });
 206 }
 207
 208 void RTDyldObjectLinkingLayer::registerJITEventListener(JITEventListener &L) {
 209   std::lock_guard<std::mutex> Lock(RTDyldLayerMutex);
 210   assert(!llvm::is_contained(EventListeners, &L) &&
 211          "Listener has already been registered");
 212   EventListeners.push_back(&L);
 213 }
 214
 215 void RTDyldObjectLinkingLayer::unregisterJITEventListener(JITEventListener &L) {
 216   std::lock_guard<std::mutex> Lock(RTDyldLayerMutex);
 217   auto I = llvm::find(EventListeners, &L);
 218   assert(I != EventListeners.end() && "Listener not registered");
 219   EventListeners.erase(I);
 220 }
 221
 222 Error RTDyldObjectLinkingLayer::onObjLoad(
 223     MaterializationResponsibility &R, const object::ObjectFile &Obj,
 224     RuntimeDyld::MemoryManager &MemMgr,
 225     RuntimeDyld::LoadedObjectInfo &LoadedObjInfo,
 226     std::map<StringRef, JITEvaluatedSymbol> Resolved,
 227     std::set<StringRef> &InternalSymbols) {
 228   SymbolFlagsMap ExtraSymbolsToClaim;
 229   SymbolMap Symbols;
 230
 231   // Hack to support COFF constant pool comdats introduced during compilation:
 232   // (See http://llvm.org/PR40074)
 233   if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(&Obj)) {
 234     auto &ES = getExecutionSession();
 235
 236     // For all resolved symbols that are not already in the responsibility set:
 237     // check whether the symbol is in a comdat section and if so mark it as
 238     // weak.
 239     for (auto &Sym : COFFObj->symbols()) {
 240       // getFlags() on COFF symbols can't fail.
 241       uint32_t SymFlags = cantFail(Sym.getFlags());
 242       if (SymFlags & object::BasicSymbolRef::SF_Undefined)
 243         continue;
 244       auto Name = Sym.getName();
 245       if (!Name)
 246         return Name.takeError();
 247       auto I = Resolved.find(*Name);
 248
 249       // Skip unresolved symbols, internal symbols, and symbols that are
 250       // already in the responsibility set.
 251       if (I == Resolved.end() || InternalSymbols.count(*Name) ||
 252           R.getSymbols().count(ES.intern(*Name)))
 253         continue;
 254       auto Sec = Sym.getSection();
 255       if (!Sec)
 256         return Sec.takeError();
 257       if (*Sec == COFFObj->section_end())
 258         continue;
 259       auto &COFFSec = *COFFObj->getCOFFSection(**Sec);
 260       if (COFFSec.Characteristics & COFF::IMAGE_SCN_LNK_COMDAT)
 261         I->second.setFlags(I->second.getFlags() | JITSymbolFlags::Weak);
 262     }
 263
 264     // Handle any aliases.
 265     for (auto &Sym : COFFObj->symbols()) {
 266       uint32_t SymFlags = cantFail(Sym.getFlags());
 267       if (SymFlags & object::BasicSymbolRef::SF_Undefined)
 268         continue;
 269       auto Name = Sym.getName();
 270       if (!Name)
 271         return Name.takeError();
 272       auto I = Resolved.find(*Name);
 273
 274       // Skip already-resolved symbols, and symbols that we're not responsible
 275       // for.
 276       if (I != Resolved.end() || !R.getSymbols().count(ES.intern(*Name)))
 277         continue;
 278
 279       // Skip anything other than weak externals.
 280       auto COFFSym = COFFObj->getCOFFSymbol(Sym);
 281       if (!COFFSym.isWeakExternal())
 282         continue;
 283       auto *WeakExternal = COFFSym.getAux<object::coff_aux_weak_external>();
 284       if (WeakExternal->Characteristics != COFF::IMAGE_WEAK_EXTERN_SEARCH_ALIAS)
 285         continue;
 286
 287       // We found an alias. Reuse the resolution of the alias target for the
 288       // alias itself.
 289       Expected<object::COFFSymbolRef> TargetSymbol =
 290           COFFObj->getSymbol(WeakExternal->TagIndex);
 291       if (!TargetSymbol)
 292         return TargetSymbol.takeError();
 293       Expected<StringRef> TargetName = COFFObj->getSymbolName(*TargetSymbol);
 294       if (!TargetName)
 295         return TargetName.takeError();
 296       auto J = Resolved.find(*TargetName);
 297       if (J == Resolved.end())
 298         return make_error<StringError>("Could alias target " + *TargetName +
 299                                            " not resolved",
 300                                        inconvertibleErrorCode());
 301       Resolved[*Name] = J->second;
 302     }
 303   }
 304
 305   for (auto &KV : Resolved) {
 306     // Scan the symbols and add them to the Symbols map for resolution.
 307
 308     // We never claim internal symbols.
 309     if (InternalSymbols.count(KV.first))
 310       continue;
 311
 312     auto InternedName = getExecutionSession().intern(KV.first);
 313     auto Flags = KV.second.getFlags();
 314     auto I = R.getSymbols().find(InternedName);
 315     if (I != R.getSymbols().end()) {
 316       // Override object flags and claim responsibility for symbols if
 317       // requested.
 318       if (OverrideObjectFlags)
 319         Flags = I->second;
 320       else {
 321         // RuntimeDyld/MCJIT's weak tracking isn't compatible with ORC's. Even
 322         // if we're not overriding flags in general we should set the weak flag
 323         // according to the MaterializationResponsibility object symbol table.
 324         if (I->second.isWeak())
 325           Flags |= JITSymbolFlags::Weak;
 326       }
 327     } else if (AutoClaimObjectSymbols)
 328       ExtraSymbolsToClaim[InternedName] = Flags;
 329
 330     Symbols[InternedName] = {ExecutorAddr(KV.second.getAddress()), Flags};
 331   }
 332
 333   if (!ExtraSymbolsToClaim.empty()) {
 334     if (auto Err = R.defineMaterializing(ExtraSymbolsToClaim))
 335       return Err;
 336
 337     // If we claimed responsibility for any weak symbols but were rejected then
 338     // we need to remove them from the resolved set.
 339     for (auto &KV : ExtraSymbolsToClaim)
 340       if (KV.second.isWeak() && !R.getSymbols().count(KV.first))
 341         Symbols.erase(KV.first);
 342   }
 343
 344   if (auto Err = R.notifyResolved(Symbols)) {
 345     R.failMaterialization();
 346     return Err;
 347   }
 348
 349   if (NotifyLoaded)
 350     NotifyLoaded(R, Obj, LoadedObjInfo);
 351
 352   return Error::success();
 353 }
 354
 355 void RTDyldObjectLinkingLayer::onObjEmit(
 356     MaterializationResponsibility &R,
 357     object::OwningBinary<object::ObjectFile> O,
 358     std::unique_ptr<RuntimeDyld::MemoryManager> MemMgr,
 359     std::unique_ptr<RuntimeDyld::LoadedObjectInfo> LoadedObjInfo, Error Err) {
 360   if (Err) {
 361     getExecutionSession().reportError(std::move(Err));
 362     R.failMaterialization();
 363     return;
 364   }
 365
 366   if (auto Err = R.notifyEmitted()) {
 367     getExecutionSession().reportError(std::move(Err));
 368     R.failMaterialization();
 369     return;
 370   }
 371
 372   std::unique_ptr<object::ObjectFile> Obj;
 373   std::unique_ptr<MemoryBuffer> ObjBuffer;
 374   std::tie(Obj, ObjBuffer) = O.takeBinary();
 375
 376   // Run EventListener notifyLoaded callbacks.
 377   {
 378     std::lock_guard<std::mutex> Lock(RTDyldLayerMutex);
 379     for (auto *L : EventListeners)
 380       L->notifyObjectLoaded(pointerToJITTargetAddress(MemMgr.get()), *Obj,
 381                             *LoadedObjInfo);
 382   }
 383
 384   if (NotifyEmitted)
 385     NotifyEmitted(R, std::move(ObjBuffer));
 386
 387   if (auto Err = R.withResourceKeyDo(
 388           [&](ResourceKey K) { MemMgrs[K].push_back(std::move(MemMgr)); })) {
 389     getExecutionSession().reportError(std::move(Err));
 390     R.failMaterialization();
 391   }
 392 }
 393
 394 Error RTDyldObjectLinkingLayer::handleRemoveResources(JITDylib &JD,
 395                                                       ResourceKey K) {
 396
 397   std::vector<MemoryManagerUP> MemMgrsToRemove;
 398
 399   getExecutionSession().runSessionLocked([&] {
 400     auto I = MemMgrs.find(K);
 401     if (I != MemMgrs.end()) {
 402       std::swap(MemMgrsToRemove, I->second);
 403       MemMgrs.erase(I);
 404     }
 405   });
 406
 407   {
 408     std::lock_guard<std::mutex> Lock(RTDyldLayerMutex);
 409     for (auto &MemMgr : MemMgrsToRemove) {
 410       for (auto *L : EventListeners)
 411         L->notifyFreeingObject(pointerToJITTargetAddress(MemMgr.get()));
 412       MemMgr->deregisterEHFrames();
 413     }
 414   }
 415
 416   return Error::success();
 417 }
 418
 419 void RTDyldObjectLinkingLayer::handleTransferResources(JITDylib &JD,
 420                                                        ResourceKey DstKey,
 421                                                        ResourceKey SrcKey) {
 422   auto I = MemMgrs.find(SrcKey);
 423   if (I != MemMgrs.end()) {
 424     auto &SrcMemMgrs = I->second;
 425     auto &DstMemMgrs = MemMgrs[DstKey];
 426     DstMemMgrs.reserve(DstMemMgrs.size() + SrcMemMgrs.size());
 427     for (auto &MemMgr : SrcMemMgrs)
 428       DstMemMgrs.push_back(std::move(MemMgr));
 429
 430     // Erase SrcKey entry using value rather than iterator I: I may have been
 431     // invalidated when we looked up DstKey.
 432     MemMgrs.erase(SrcKey);
 433   }
 434 }
 435
 436 } // End namespace orc.
 437 } // End namespace llvm.