llvm/lib/ExecutionEngine/Orc/LazyObjectLinkingLayer.cpp

   1 //===---------- LazyReexports.cpp - Utilities for lazy reexports ----------===//
   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/LazyObjectLinkingLayer.h"
  10
  11 #include "llvm/ExecutionEngine/Orc/LazyReexports.h"
  12 #include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
  13 #include "llvm/ExecutionEngine/Orc/RedirectionManager.h"
  14
  15 using namespace llvm;
  16 using namespace llvm::jitlink;
  17
  18 namespace {
  19
  20 constexpr StringRef FnBodySuffix = "$orc_fnbody";
  21
  22 } // anonymous namespace
  23
  24 namespace llvm::orc {
  25
  26 class LazyObjectLinkingLayer::RenamerPlugin
  27     : public ObjectLinkingLayer::Plugin {
  28 public:
  29   void modifyPassConfig(MaterializationResponsibility &MR,
  30                         jitlink::LinkGraph &LG,
  31                         jitlink::PassConfiguration &Config) override {
  32     // We need to insert this before the mark-live pass to ensure that we don't
  33     // delete the bodies (their names won't match the responsibility set until
  34     // after this pass completes.
  35     Config.PrePrunePasses.insert(
  36         Config.PrePrunePasses.begin(),
  37         [&MR](LinkGraph &G) { return renameFunctionBodies(G, MR); });
  38   }
  39
  40   Error notifyFailed(MaterializationResponsibility &MR) override {
  41     return Error::success();
  42   }
  43
  44   Error notifyRemovingResources(JITDylib &JD, ResourceKey K) override {
  45     return Error::success();
  46   }
  47
  48   void notifyTransferringResources(JITDylib &JD, ResourceKey DstKey,
  49                                    ResourceKey SrcKey) override {}
  50
  51 private:
  52   static Error renameFunctionBodies(LinkGraph &G,
  53                                     MaterializationResponsibility &MR) {
  54     DenseMap<StringRef, NonOwningSymbolStringPtr> SymsToRename;
  55     for (auto &[Name, Flags] : MR.getSymbols())
  56       if ((*Name).ends_with(FnBodySuffix))
  57         SymsToRename[(*Name).drop_back(FnBodySuffix.size())] =
  58             NonOwningSymbolStringPtr(Name);
  59
  60     for (auto *Sym : G.defined_symbols()) {
  61       if (!Sym->hasName())
  62         continue;
  63       auto I = SymsToRename.find(Sym->getName());
  64       if (I == SymsToRename.end())
  65         continue;
  66       Sym->setName(G.allocateName(*I->second));
  67     }
  68
  69     return Error::success();
  70   }
  71 };
  72
  73 LazyObjectLinkingLayer::LazyObjectLinkingLayer(ObjectLinkingLayer &BaseLayer,
  74                                                LazyCallThroughManager &LCTMgr,
  75                                                RedirectableSymbolManager &RSMgr)
  76     : ObjectLayer(BaseLayer.getExecutionSession()), BaseLayer(BaseLayer),
  77       LCTMgr(LCTMgr), RSMgr(RSMgr) {
  78   BaseLayer.addPlugin(std::make_unique<RenamerPlugin>());
  79 }
  80
  81 Error LazyObjectLinkingLayer::add(ResourceTrackerSP RT,
  82                                   std::unique_ptr<MemoryBuffer> O,
  83                                   MaterializationUnit::Interface I) {
  84
  85   // Object files with initializer symbols can't be lazy.
  86   if (I.InitSymbol)
  87     return BaseLayer.add(std::move(RT), std::move(O), std::move(I));
  88
  89   auto &ES = getExecutionSession();
  90   SymbolAliasMap LazySymbols;
  91   for (auto &[Name, Flags] : I.SymbolFlags)
  92     if (Flags.isCallable())
  93       LazySymbols[Name] = {ES.intern((*Name + FnBodySuffix).str()), Flags};
  94
  95   for (auto &[Name, AI] : LazySymbols) {
  96     I.SymbolFlags.erase(Name);
  97     I.SymbolFlags[AI.Aliasee] = AI.AliasFlags;
  98   }
  99
 100   if (auto Err = BaseLayer.add(RT, std::move(O), std::move(I)))
 101     return Err;
 102
 103   auto &JD = RT->getJITDylib();
 104   return JD.define(lazyReexports(LCTMgr, RSMgr, JD, std::move(LazySymbols)),
 105                    std::move(RT));
 106 }
 107
 108 void LazyObjectLinkingLayer::emit(
 109     std::unique_ptr<MaterializationResponsibility> MR,
 110     std::unique_ptr<MemoryBuffer> Obj) {
 111   return BaseLayer.emit(std::move(MR), std::move(Obj));
 112 }
 113
 114 } // namespace llvm::orc