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] = std::move(KV.second);
  42           OnResolved(Result);
  43         };
  44
  45     // Register dependencies for all symbols contained in this set.
  46     auto RegisterDependencies = [&](const SymbolDependenceMap &Deps) {
  47       MR.addDependenciesForAll(Deps);
  48     };
  49
  50     JITDylibSearchOrder LinkOrder;
  51     MR.getTargetJITDylib().withLinkOrderDo(
  52         [&](const JITDylibSearchOrder &LO) { LinkOrder = LO; });
  53     ES.lookup(LookupKind::Static, LinkOrder, InternedSymbols,
  54               SymbolState::Resolved, std::move(OnResolvedWithUnwrap),
  55               RegisterDependencies);
  56   }
  57
  58   Expected<LookupSet> getResponsibilitySet(const LookupSet &Symbols) override {
  59     LookupSet Result;
  60
  61     for (auto &KV : MR.getSymbols()) {
  62       if (Symbols.count(*KV.first))
  63         Result.insert(*KV.first);
  64     }
  65
  66     return Result;
  67   }
  68
  69 private:
  70   MaterializationResponsibility &MR;
  71 };
  72
  73 } // end anonymous namespace
  74
  75 namespace llvm {
  76 namespace orc {
  77
  78 char RTDyldObjectLinkingLayer::ID;
  79
  80 using BaseT = RTTIExtends<RTDyldObjectLinkingLayer, ObjectLayer>;
  81
  82 RTDyldObjectLinkingLayer::RTDyldObjectLinkingLayer(
  83     ExecutionSession &ES, GetMemoryManagerFunction GetMemoryManager)
  84     : BaseT(ES), GetMemoryManager(GetMemoryManager) {
  85   ES.registerResourceManager(*this);
  86 }
  87
  88 RTDyldObjectLinkingLayer::~RTDyldObjectLinkingLayer() {
  89   assert(MemMgrs.empty() && "Layer destroyed with resources still attached");
  90 }
  91
  92 void RTDyldObjectLinkingLayer::emit(
  93     std::unique_ptr<MaterializationResponsibility> R,
  94     std::unique_ptr<MemoryBuffer> O) {
  95   assert(O && "Object must not be null");
  96
  97   auto &ES = getExecutionSession();
  98
  99   auto Obj = object::ObjectFile::createObjectFile(*O);
 100
 101   if (!Obj) {
 102     getExecutionSession().reportError(Obj.takeError());
 103     R->failMaterialization();
 104     return;
 105   }
 106
 107   // Collect the internal symbols from the object file: We will need to
 108   // filter these later.
 109   auto InternalSymbols = std::make_shared<std::set<StringRef>>();
 110   {
 111     for (auto &Sym : (*Obj)->symbols()) {
 112
 113       // Skip file symbols.
 114       if (auto SymType = Sym.getType()) {
 115         if (*SymType == object::SymbolRef::ST_File)
 116           continue;
 117       } else {
 118         ES.reportError(SymType.takeError());
 119         R->failMaterialization();
 120         return;
 121       }
 122
 123       Expected<uint32_t> SymFlagsOrErr = Sym.getFlags();
 124       if (!SymFlagsOrErr) {
 125         // TODO: Test this error.
 126         ES.reportError(SymFlagsOrErr.takeError());
 127         R->failMaterialization();
 128         return;
 129       }
 130
 131       // Don't include symbols that aren't global.
 132       if (!(*SymFlagsOrErr & object::BasicSymbolRef::SF_Global)) {
 133         if (auto SymName = Sym.getName())
 134           InternalSymbols->insert(*SymName);
 135         else {
 136           ES.reportError(SymName.takeError());
 137           R->failMaterialization();
 138           return;
 139         }
 140       }
 141     }
 142   }
 143
 144   auto MemMgr = GetMemoryManager();
 145   auto &MemMgrRef = *MemMgr;
 146
 147   // Switch to shared ownership of MR so that it can be captured by both
 148   // lambdas below.
 149   std::shared_ptr<MaterializationResponsibility> SharedR(std::move(R));
 150
 151   JITDylibSearchOrderResolver Resolver(*SharedR);
 152
 153   jitLinkForORC(
 154       object::OwningBinary<object::ObjectFile>(std::move(*Obj), std::move(O)),
 155       MemMgrRef, Resolver, ProcessAllSections,
 156       [this, SharedR, &MemMgrRef, InternalSymbols](
 157           const object::ObjectFile &Obj,
 158           RuntimeDyld::LoadedObjectInfo &LoadedObjInfo,
 159           std::map<StringRef, JITEvaluatedSymbol> ResolvedSymbols) {
 160         return onObjLoad(*SharedR, Obj, MemMgrRef, LoadedObjInfo,
 161                          ResolvedSymbols, *InternalSymbols);
 162       },
 163       [this, SharedR, MemMgr = std::move(MemMgr)](
 164           object::OwningBinary<object::ObjectFile> Obj,
 165           std::unique_ptr<RuntimeDyld::LoadedObjectInfo> LoadedObjInfo,
 166           Error Err) mutable {
 167         onObjEmit(*SharedR, std::move(Obj), std::move(MemMgr),
 168                   std::move(LoadedObjInfo), std::move(Err));
 169       });
 170 }
 171
 172 void RTDyldObjectLinkingLayer::registerJITEventListener(JITEventListener &L) {
 173   std::lock_guard<std::mutex> Lock(RTDyldLayerMutex);
 174   assert(!llvm::is_contained(EventListeners, &L) &&
 175          "Listener has already been registered");
 176   EventListeners.push_back(&L);
 177 }
 178
 179 void RTDyldObjectLinkingLayer::unregisterJITEventListener(JITEventListener &L) {
 180   std::lock_guard<std::mutex> Lock(RTDyldLayerMutex);
 181   auto I = llvm::find(EventListeners, &L);
 182   assert(I != EventListeners.end() && "Listener not registered");
 183   EventListeners.erase(I);
 184 }
 185
 186 Error RTDyldObjectLinkingLayer::onObjLoad(
 187     MaterializationResponsibility &R, const object::ObjectFile &Obj,
 188     RuntimeDyld::MemoryManager &MemMgr,
 189     RuntimeDyld::LoadedObjectInfo &LoadedObjInfo,
 190     std::map<StringRef, JITEvaluatedSymbol> Resolved,
 191     std::set<StringRef> &InternalSymbols) {
 192   SymbolFlagsMap ExtraSymbolsToClaim;
 193   SymbolMap Symbols;
 194
 195   // Hack to support COFF constant pool comdats introduced during compilation:
 196   // (See http://llvm.org/PR40074)
 197   if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(&Obj)) {
 198     auto &ES = getExecutionSession();
 199
 200     // For all resolved symbols that are not already in the responsibilty set:
 201     // check whether the symbol is in a comdat section and if so mark it as
 202     // weak.
 203     for (auto &Sym : COFFObj->symbols()) {
 204       // getFlags() on COFF symbols can't fail.
 205       uint32_t SymFlags = cantFail(Sym.getFlags());
 206       if (SymFlags & object::BasicSymbolRef::SF_Undefined)
 207         continue;
 208       auto Name = Sym.getName();
 209       if (!Name)
 210         return Name.takeError();
 211       auto I = Resolved.find(*Name);
 212
 213       // Skip unresolved symbols, internal symbols, and symbols that are
 214       // already in the responsibility set.
 215       if (I == Resolved.end() || InternalSymbols.count(*Name) ||
 216           R.getSymbols().count(ES.intern(*Name)))
 217         continue;
 218       auto Sec = Sym.getSection();
 219       if (!Sec)
 220         return Sec.takeError();
 221       if (*Sec == COFFObj->section_end())
 222         continue;
 223       auto &COFFSec = *COFFObj->getCOFFSection(**Sec);
 224       if (COFFSec.Characteristics & COFF::IMAGE_SCN_LNK_COMDAT)
 225         I->second.setFlags(I->second.getFlags() | JITSymbolFlags::Weak);
 226     }
 227   }
 228
 229   for (auto &KV : Resolved) {
 230     // Scan the symbols and add them to the Symbols map for resolution.
 231
 232     // We never claim internal symbols.
 233     if (InternalSymbols.count(KV.first))
 234       continue;
 235
 236     auto InternedName = getExecutionSession().intern(KV.first);
 237     auto Flags = KV.second.getFlags();
 238
 239     // Override object flags and claim responsibility for symbols if
 240     // requested.
 241     if (OverrideObjectFlags || AutoClaimObjectSymbols) {
 242       auto I = R.getSymbols().find(InternedName);
 243
 244       if (OverrideObjectFlags && I != R.getSymbols().end())
 245         Flags = I->second;
 246       else if (AutoClaimObjectSymbols && I == R.getSymbols().end())
 247         ExtraSymbolsToClaim[InternedName] = Flags;
 248     }
 249
 250     Symbols[InternedName] = JITEvaluatedSymbol(KV.second.getAddress(), Flags);
 251   }
 252
 253   if (!ExtraSymbolsToClaim.empty()) {
 254     if (auto Err = R.defineMaterializing(ExtraSymbolsToClaim))
 255       return Err;
 256
 257     // If we claimed responsibility for any weak symbols but were rejected then
 258     // we need to remove them from the resolved set.
 259     for (auto &KV : ExtraSymbolsToClaim)
 260       if (KV.second.isWeak() && !R.getSymbols().count(KV.first))
 261         Symbols.erase(KV.first);
 262   }
 263
 264   if (auto Err = R.notifyResolved(Symbols)) {
 265     R.failMaterialization();
 266     return Err;
 267   }
 268
 269   if (NotifyLoaded)
 270     NotifyLoaded(R, Obj, LoadedObjInfo);
 271
 272   return Error::success();
 273 }
 274
 275 void RTDyldObjectLinkingLayer::onObjEmit(
 276     MaterializationResponsibility &R,
 277     object::OwningBinary<object::ObjectFile> O,
 278     std::unique_ptr<RuntimeDyld::MemoryManager> MemMgr,
 279     std::unique_ptr<RuntimeDyld::LoadedObjectInfo> LoadedObjInfo, Error Err) {
 280   if (Err) {
 281     getExecutionSession().reportError(std::move(Err));
 282     R.failMaterialization();
 283     return;
 284   }
 285
 286   if (auto Err = R.notifyEmitted()) {
 287     getExecutionSession().reportError(std::move(Err));
 288     R.failMaterialization();
 289     return;
 290   }
 291
 292   std::unique_ptr<object::ObjectFile> Obj;
 293   std::unique_ptr<MemoryBuffer> ObjBuffer;
 294   std::tie(Obj, ObjBuffer) = O.takeBinary();
 295
 296   // Run EventListener notifyLoaded callbacks.
 297   {
 298     std::lock_guard<std::mutex> Lock(RTDyldLayerMutex);
 299     for (auto *L : EventListeners)
 300       L->notifyObjectLoaded(pointerToJITTargetAddress(MemMgr.get()), *Obj,
 301                             *LoadedObjInfo);
 302   }
 303
 304   if (NotifyEmitted)
 305     NotifyEmitted(R, std::move(ObjBuffer));
 306
 307   if (auto Err = R.withResourceKeyDo(
 308           [&](ResourceKey K) { MemMgrs[K].push_back(std::move(MemMgr)); })) {
 309     getExecutionSession().reportError(std::move(Err));
 310     R.failMaterialization();
 311   }
 312 }
 313
 314 Error RTDyldObjectLinkingLayer::handleRemoveResources(ResourceKey K) {
 315
 316   std::vector<MemoryManagerUP> MemMgrsToRemove;
 317
 318   getExecutionSession().runSessionLocked([&] {
 319     auto I = MemMgrs.find(K);
 320     if (I != MemMgrs.end()) {
 321       std::swap(MemMgrsToRemove, I->second);
 322       MemMgrs.erase(I);
 323     }
 324   });
 325
 326   {
 327     std::lock_guard<std::mutex> Lock(RTDyldLayerMutex);
 328     for (auto &MemMgr : MemMgrsToRemove) {
 329       for (auto *L : EventListeners)
 330         L->notifyFreeingObject(pointerToJITTargetAddress(MemMgr.get()));
 331       MemMgr->deregisterEHFrames();
 332     }
 333   }
 334
 335   return Error::success();
 336 }
 337
 338 void RTDyldObjectLinkingLayer::handleTransferResources(ResourceKey DstKey,
 339                                                        ResourceKey SrcKey) {
 340   auto I = MemMgrs.find(SrcKey);
 341   if (I != MemMgrs.end()) {
 342     auto &SrcMemMgrs = I->second;
 343     auto &DstMemMgrs = MemMgrs[DstKey];
 344     DstMemMgrs.reserve(DstMemMgrs.size() + SrcMemMgrs.size());
 345     for (auto &MemMgr : SrcMemMgrs)
 346       DstMemMgrs.push_back(std::move(MemMgr));
 347
 348     // Erase SrcKey entry using value rather than iterator I: I may have been
 349     // invalidated when we looked up DstKey.
 350     MemMgrs.erase(SrcKey);
 351   }
 352 }
 353
 354 } // End namespace orc.
 355 } // End namespace llvm.