llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp

   1 //===------- ObjectLinkingLayer.cpp - JITLink 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/ObjectLinkingLayer.h"
  10 #include "llvm/ADT/Optional.h"
  11 #include "llvm/ExecutionEngine/JITLink/EHFrameSupport.h"
  12 #include "llvm/ExecutionEngine/Orc/DebugObjectManagerPlugin.h"
  13 #include "llvm/Support/MemoryBuffer.h"
  14 #include <string>
  15 #include <vector>
  16
  17 #define DEBUG_TYPE "orc"
  18
  19 using namespace llvm;
  20 using namespace llvm::jitlink;
  21 using namespace llvm::orc;
  22
  23 namespace {
  24
  25 class LinkGraphMaterializationUnit : public MaterializationUnit {
  26 private:
  27   struct LinkGraphInterface {
  28     SymbolFlagsMap SymbolFlags;
  29     SymbolStringPtr InitSymbol;
  30   };
  31
  32 public:
  33   static std::unique_ptr<LinkGraphMaterializationUnit>
  34   Create(ObjectLinkingLayer &ObjLinkingLayer, std::unique_ptr<LinkGraph> G) {
  35     auto LGI = scanLinkGraph(ObjLinkingLayer.getExecutionSession(), *G);
  36     return std::unique_ptr<LinkGraphMaterializationUnit>(
  37         new LinkGraphMaterializationUnit(ObjLinkingLayer, std::move(G),
  38                                          std::move(LGI)));
  39   }
  40
  41   StringRef getName() const override { return G->getName(); }
  42   void materialize(std::unique_ptr<MaterializationResponsibility> MR) override {
  43     ObjLinkingLayer.emit(std::move(MR), std::move(G));
  44   }
  45
  46 private:
  47   static LinkGraphInterface scanLinkGraph(ExecutionSession &ES, LinkGraph &G) {
  48
  49     LinkGraphInterface LGI;
  50
  51     for (auto *Sym : G.defined_symbols()) {
  52       // Skip local symbols.
  53       if (Sym->getScope() == Scope::Local)
  54         continue;
  55       assert(Sym->hasName() && "Anonymous non-local symbol?");
  56
  57       JITSymbolFlags Flags;
  58       if (Sym->getScope() == Scope::Default)
  59         Flags |= JITSymbolFlags::Exported;
  60
  61       if (Sym->isCallable())
  62         Flags |= JITSymbolFlags::Callable;
  63
  64       LGI.SymbolFlags[ES.intern(Sym->getName())] = Flags;
  65     }
  66
  67     if (G.getTargetTriple().isOSBinFormatMachO())
  68       if (hasMachOInitSection(G))
  69         LGI.InitSymbol = makeInitSymbol(ES, G);
  70
  71     return LGI;
  72   }
  73
  74   static bool hasMachOInitSection(LinkGraph &G) {
  75     for (auto &Sec : G.sections())
  76       if (Sec.getName() == "__DATA,__obj_selrefs" ||
  77           Sec.getName() == "__DATA,__objc_classlist" ||
  78           Sec.getName() == "__TEXT,__swift5_protos" ||
  79           Sec.getName() == "__TEXT,__swift5_proto" ||
  80           Sec.getName() == "__DATA,__mod_init_func")
  81         return true;
  82     return false;
  83   }
  84
  85   static SymbolStringPtr makeInitSymbol(ExecutionSession &ES, LinkGraph &G) {
  86     std::string InitSymString;
  87     raw_string_ostream(InitSymString)
  88         << "$." << G.getName() << ".__inits" << Counter++;
  89     return ES.intern(InitSymString);
  90   }
  91
  92   LinkGraphMaterializationUnit(ObjectLinkingLayer &ObjLinkingLayer,
  93                                std::unique_ptr<LinkGraph> G,
  94                                LinkGraphInterface LGI)
  95       : MaterializationUnit(std::move(LGI.SymbolFlags),
  96                             std::move(LGI.InitSymbol)),
  97         ObjLinkingLayer(ObjLinkingLayer), G(std::move(G)) {}
  98
  99   void discard(const JITDylib &JD, const SymbolStringPtr &Name) override {
 100     for (auto *Sym : G->defined_symbols())
 101       if (Sym->getName() == *Name) {
 102         assert(Sym->getLinkage() == Linkage::Weak &&
 103                "Discarding non-weak definition");
 104         G->makeExternal(*Sym);
 105         break;
 106       }
 107   }
 108
 109   ObjectLinkingLayer &ObjLinkingLayer;
 110   std::unique_ptr<LinkGraph> G;
 111   static std::atomic<uint64_t> Counter;
 112 };
 113
 114 std::atomic<uint64_t> LinkGraphMaterializationUnit::Counter{0};
 115
 116 } // end anonymous namespace
 117
 118 namespace llvm {
 119 namespace orc {
 120
 121 class ObjectLinkingLayerJITLinkContext final : public JITLinkContext {
 122 public:
 123   ObjectLinkingLayerJITLinkContext(
 124       ObjectLinkingLayer &Layer,
 125       std::unique_ptr<MaterializationResponsibility> MR,
 126       std::unique_ptr<MemoryBuffer> ObjBuffer)
 127       : JITLinkContext(&MR->getTargetJITDylib()), Layer(Layer),
 128         MR(std::move(MR)), ObjBuffer(std::move(ObjBuffer)) {}
 129
 130   ~ObjectLinkingLayerJITLinkContext() {
 131     // If there is an object buffer return function then use it to
 132     // return ownership of the buffer.
 133     if (Layer.ReturnObjectBuffer && ObjBuffer)
 134       Layer.ReturnObjectBuffer(std::move(ObjBuffer));
 135   }
 136
 137   JITLinkMemoryManager &getMemoryManager() override { return Layer.MemMgr; }
 138
 139   void notifyMaterializing(LinkGraph &G) {
 140     for (auto &P : Layer.Plugins)
 141       P->notifyMaterializing(*MR, G, *this,
 142                              ObjBuffer ? ObjBuffer->getMemBufferRef()
 143                              : MemoryBufferRef());
 144   }
 145
 146   void notifyFailed(Error Err) override {
 147     for (auto &P : Layer.Plugins)
 148       Err = joinErrors(std::move(Err), P->notifyFailed(*MR));
 149     Layer.getExecutionSession().reportError(std::move(Err));
 150     MR->failMaterialization();
 151   }
 152
 153   void lookup(const LookupMap &Symbols,
 154               std::unique_ptr<JITLinkAsyncLookupContinuation> LC) override {
 155
 156     JITDylibSearchOrder LinkOrder;
 157     MR->getTargetJITDylib().withLinkOrderDo(
 158         [&](const JITDylibSearchOrder &LO) { LinkOrder = LO; });
 159
 160     auto &ES = Layer.getExecutionSession();
 161
 162     SymbolLookupSet LookupSet;
 163     for (auto &KV : Symbols) {
 164       orc::SymbolLookupFlags LookupFlags;
 165       switch (KV.second) {
 166       case jitlink::SymbolLookupFlags::RequiredSymbol:
 167         LookupFlags = orc::SymbolLookupFlags::RequiredSymbol;
 168         break;
 169       case jitlink::SymbolLookupFlags::WeaklyReferencedSymbol:
 170         LookupFlags = orc::SymbolLookupFlags::WeaklyReferencedSymbol;
 171         break;
 172       }
 173       LookupSet.add(ES.intern(KV.first), LookupFlags);
 174     }
 175
 176     // OnResolve -- De-intern the symbols and pass the result to the linker.
 177     auto OnResolve = [LookupContinuation =
 178                           std::move(LC)](Expected<SymbolMap> Result) mutable {
 179       if (!Result)
 180         LookupContinuation->run(Result.takeError());
 181       else {
 182         AsyncLookupResult LR;
 183         for (auto &KV : *Result)
 184           LR[*KV.first] = KV.second;
 185         LookupContinuation->run(std::move(LR));
 186       }
 187     };
 188
 189     for (auto &KV : InternalNamedSymbolDeps) {
 190       SymbolDependenceMap InternalDeps;
 191       InternalDeps[&MR->getTargetJITDylib()] = std::move(KV.second);
 192       MR->addDependencies(KV.first, InternalDeps);
 193     }
 194
 195     ES.lookup(LookupKind::Static, LinkOrder, std::move(LookupSet),
 196               SymbolState::Resolved, std::move(OnResolve),
 197               [this](const SymbolDependenceMap &Deps) {
 198                 registerDependencies(Deps);
 199               });
 200   }
 201
 202   Error notifyResolved(LinkGraph &G) override {
 203     auto &ES = Layer.getExecutionSession();
 204
 205     SymbolFlagsMap ExtraSymbolsToClaim;
 206     bool AutoClaim = Layer.AutoClaimObjectSymbols;
 207
 208     SymbolMap InternedResult;
 209     for (auto *Sym : G.defined_symbols())
 210       if (Sym->hasName() && Sym->getScope() != Scope::Local) {
 211         auto InternedName = ES.intern(Sym->getName());
 212         JITSymbolFlags Flags;
 213
 214         if (Sym->isCallable())
 215           Flags |= JITSymbolFlags::Callable;
 216         if (Sym->getScope() == Scope::Default)
 217           Flags |= JITSymbolFlags::Exported;
 218
 219         InternedResult[InternedName] =
 220             JITEvaluatedSymbol(Sym->getAddress(), Flags);
 221         if (AutoClaim && !MR->getSymbols().count(InternedName)) {
 222           assert(!ExtraSymbolsToClaim.count(InternedName) &&
 223                  "Duplicate symbol to claim?");
 224           ExtraSymbolsToClaim[InternedName] = Flags;
 225         }
 226       }
 227
 228     for (auto *Sym : G.absolute_symbols())
 229       if (Sym->hasName()) {
 230         auto InternedName = ES.intern(Sym->getName());
 231         JITSymbolFlags Flags;
 232         Flags |= JITSymbolFlags::Absolute;
 233         if (Sym->isCallable())
 234           Flags |= JITSymbolFlags::Callable;
 235         if (Sym->getLinkage() == Linkage::Weak)
 236           Flags |= JITSymbolFlags::Weak;
 237         InternedResult[InternedName] =
 238             JITEvaluatedSymbol(Sym->getAddress(), Flags);
 239         if (AutoClaim && !MR->getSymbols().count(InternedName)) {
 240           assert(!ExtraSymbolsToClaim.count(InternedName) &&
 241                  "Duplicate symbol to claim?");
 242           ExtraSymbolsToClaim[InternedName] = Flags;
 243         }
 244       }
 245
 246     if (!ExtraSymbolsToClaim.empty())
 247       if (auto Err = MR->defineMaterializing(ExtraSymbolsToClaim))
 248         return Err;
 249
 250     {
 251
 252       // Check that InternedResult matches up with MR->getSymbols().
 253       // This guards against faulty transformations / compilers / object caches.
 254
 255       // First check that there aren't any missing symbols.
 256       size_t NumMaterializationSideEffectsOnlySymbols = 0;
 257       SymbolNameVector ExtraSymbols;
 258       SymbolNameVector MissingSymbols;
 259       for (auto &KV : MR->getSymbols()) {
 260
 261         // If this is a materialization-side-effects only symbol then bump
 262         // the counter and make sure it's *not* defined, otherwise make
 263         // sure that it is defined.
 264         if (KV.second.hasMaterializationSideEffectsOnly()) {
 265           ++NumMaterializationSideEffectsOnlySymbols;
 266           if (InternedResult.count(KV.first))
 267             ExtraSymbols.push_back(KV.first);
 268           continue;
 269         } else if (!InternedResult.count(KV.first))
 270           MissingSymbols.push_back(KV.first);
 271       }
 272
 273       // If there were missing symbols then report the error.
 274       if (!MissingSymbols.empty())
 275         return make_error<MissingSymbolDefinitions>(G.getName(),
 276                                                     std::move(MissingSymbols));
 277
 278       // If there are more definitions than expected, add them to the
 279       // ExtraSymbols vector.
 280       if (InternedResult.size() >
 281           MR->getSymbols().size() - NumMaterializationSideEffectsOnlySymbols) {
 282         for (auto &KV : InternedResult)
 283           if (!MR->getSymbols().count(KV.first))
 284             ExtraSymbols.push_back(KV.first);
 285       }
 286
 287       // If there were extra definitions then report the error.
 288       if (!ExtraSymbols.empty())
 289         return make_error<UnexpectedSymbolDefinitions>(G.getName(),
 290                                                        std::move(ExtraSymbols));
 291     }
 292
 293     if (auto Err = MR->notifyResolved(InternedResult))
 294       return Err;
 295
 296     Layer.notifyLoaded(*MR);
 297     return Error::success();
 298   }
 299
 300   void notifyFinalized(
 301       std::unique_ptr<JITLinkMemoryManager::Allocation> A) override {
 302     if (auto Err = Layer.notifyEmitted(*MR, std::move(A))) {
 303       Layer.getExecutionSession().reportError(std::move(Err));
 304       MR->failMaterialization();
 305       return;
 306     }
 307     if (auto Err = MR->notifyEmitted()) {
 308       Layer.getExecutionSession().reportError(std::move(Err));
 309       MR->failMaterialization();
 310     }
 311   }
 312
 313   LinkGraphPassFunction getMarkLivePass(const Triple &TT) const override {
 314     return [this](LinkGraph &G) { return markResponsibilitySymbolsLive(G); };
 315   }
 316
 317   Error modifyPassConfig(LinkGraph &LG, PassConfiguration &Config) override {
 318     // Add passes to mark duplicate defs as should-discard, and to walk the
 319     // link graph to build the symbol dependence graph.
 320     Config.PrePrunePasses.push_back([this](LinkGraph &G) {
 321       return claimOrExternalizeWeakAndCommonSymbols(G);
 322     });
 323
 324     Layer.modifyPassConfig(*MR, LG, Config);
 325
 326     Config.PostPrunePasses.push_back(
 327         [this](LinkGraph &G) { return computeNamedSymbolDependencies(G); });
 328
 329     return Error::success();
 330   }
 331
 332 private:
 333   // Symbol name dependencies:
 334   // Internal: Defined in this graph.
 335   // External: Defined externally.
 336   struct BlockSymbolDependencies {
 337     SymbolNameSet Internal, External;
 338   };
 339
 340   // Lazily populated map of blocks to BlockSymbolDependencies values.
 341   class BlockDependenciesMap {
 342   public:
 343     BlockDependenciesMap(ExecutionSession &ES,
 344                          DenseMap<const Block *, DenseSet<Block *>> BlockDeps)
 345         : ES(ES), BlockDeps(std::move(BlockDeps)) {}
 346
 347     const BlockSymbolDependencies &operator[](const Block &B) {
 348       // Check the cache first.
 349       auto I = BlockTransitiveDepsCache.find(&B);
 350       if (I != BlockTransitiveDepsCache.end())
 351         return I->second;
 352
 353       // No value. Populate the cache.
 354       BlockSymbolDependencies BTDCacheVal;
 355       auto BDI = BlockDeps.find(&B);
 356       assert(BDI != BlockDeps.end() && "No block dependencies");
 357
 358       for (auto *BDep : BDI->second) {
 359         auto &BID = getBlockImmediateDeps(*BDep);
 360         for (auto &ExternalDep : BID.External)
 361           BTDCacheVal.External.insert(ExternalDep);
 362         for (auto &InternalDep : BID.Internal)
 363           BTDCacheVal.Internal.insert(InternalDep);
 364       }
 365
 366       return BlockTransitiveDepsCache
 367           .insert(std::make_pair(&B, std::move(BTDCacheVal)))
 368           .first->second;
 369     }
 370
 371     SymbolStringPtr &getInternedName(Symbol &Sym) {
 372       auto I = NameCache.find(&Sym);
 373       if (I != NameCache.end())
 374         return I->second;
 375
 376       return NameCache.insert(std::make_pair(&Sym, ES.intern(Sym.getName())))
 377           .first->second;
 378     }
 379
 380   private:
 381     BlockSymbolDependencies &getBlockImmediateDeps(Block &B) {
 382       // Check the cache first.
 383       auto I = BlockImmediateDepsCache.find(&B);
 384       if (I != BlockImmediateDepsCache.end())
 385         return I->second;
 386
 387       BlockSymbolDependencies BIDCacheVal;
 388       for (auto &E : B.edges()) {
 389         auto &Tgt = E.getTarget();
 390         if (Tgt.getScope() != Scope::Local) {
 391           if (Tgt.isExternal())
 392             BIDCacheVal.External.insert(getInternedName(Tgt));
 393           else
 394             BIDCacheVal.Internal.insert(getInternedName(Tgt));
 395         }
 396       }
 397
 398       return BlockImmediateDepsCache
 399           .insert(std::make_pair(&B, std::move(BIDCacheVal)))
 400           .first->second;
 401     }
 402
 403     ExecutionSession &ES;
 404     DenseMap<const Block *, DenseSet<Block *>> BlockDeps;
 405     DenseMap<const Symbol *, SymbolStringPtr> NameCache;
 406     DenseMap<const Block *, BlockSymbolDependencies> BlockImmediateDepsCache;
 407     DenseMap<const Block *, BlockSymbolDependencies> BlockTransitiveDepsCache;
 408   };
 409
 410   Error claimOrExternalizeWeakAndCommonSymbols(LinkGraph &G) {
 411     auto &ES = Layer.getExecutionSession();
 412
 413     SymbolFlagsMap NewSymbolsToClaim;
 414     std::vector<std::pair<SymbolStringPtr, Symbol *>> NameToSym;
 415
 416     auto ProcessSymbol = [&](Symbol *Sym) {
 417       if (Sym->hasName() && Sym->getLinkage() == Linkage::Weak) {
 418         auto Name = ES.intern(Sym->getName());
 419         if (!MR->getSymbols().count(ES.intern(Sym->getName()))) {
 420           JITSymbolFlags SF = JITSymbolFlags::Weak;
 421           if (Sym->getScope() == Scope::Default)
 422             SF |= JITSymbolFlags::Exported;
 423           NewSymbolsToClaim[Name] = SF;
 424           NameToSym.push_back(std::make_pair(std::move(Name), Sym));
 425         }
 426       }
 427     };
 428
 429     for (auto *Sym : G.defined_symbols())
 430       ProcessSymbol(Sym);
 431     for (auto *Sym : G.absolute_symbols())
 432       ProcessSymbol(Sym);
 433
 434     // Attempt to claim all weak defs that we're not already responsible for.
 435     // This cannot fail -- any clashes will just result in rejection of our
 436     // claim, at which point we'll externalize that symbol.
 437     cantFail(MR->defineMaterializing(std::move(NewSymbolsToClaim)));
 438
 439     for (auto &KV : NameToSym)
 440       if (!MR->getSymbols().count(KV.first))
 441         G.makeExternal(*KV.second);
 442
 443     return Error::success();
 444   }
 445
 446   Error markResponsibilitySymbolsLive(LinkGraph &G) const {
 447     auto &ES = Layer.getExecutionSession();
 448     for (auto *Sym : G.defined_symbols())
 449       if (Sym->hasName() && MR->getSymbols().count(ES.intern(Sym->getName())))
 450         Sym->setLive(true);
 451     return Error::success();
 452   }
 453
 454   Error computeNamedSymbolDependencies(LinkGraph &G) {
 455     auto &ES = MR->getTargetJITDylib().getExecutionSession();
 456     auto BlockDeps = computeBlockNonLocalDeps(G);
 457
 458     // Compute dependencies for symbols defined in the JITLink graph.
 459     for (auto *Sym : G.defined_symbols()) {
 460
 461       // Skip local symbols: we do not track dependencies for these.
 462       if (Sym->getScope() == Scope::Local)
 463         continue;
 464       assert(Sym->hasName() &&
 465              "Defined non-local jitlink::Symbol should have a name");
 466
 467       auto &SymDeps = BlockDeps[Sym->getBlock()];
 468       if (SymDeps.External.empty() && SymDeps.Internal.empty())
 469         continue;
 470
 471       auto SymName = ES.intern(Sym->getName());
 472       if (!SymDeps.External.empty())
 473         ExternalNamedSymbolDeps[SymName] = SymDeps.External;
 474       if (!SymDeps.Internal.empty())
 475         InternalNamedSymbolDeps[SymName] = SymDeps.Internal;
 476     }
 477
 478     for (auto &P : Layer.Plugins) {
 479       auto SynthDeps = P->getSyntheticSymbolDependencies(*MR);
 480       if (SynthDeps.empty())
 481         continue;
 482
 483       DenseSet<Block *> BlockVisited;
 484       for (auto &KV : SynthDeps) {
 485         auto &Name = KV.first;
 486         auto &DepsForName = KV.second;
 487         for (auto *Sym : DepsForName) {
 488           if (Sym->getScope() == Scope::Local) {
 489             auto &BDeps = BlockDeps[Sym->getBlock()];
 490             for (auto &S : BDeps.Internal)
 491               InternalNamedSymbolDeps[Name].insert(S);
 492             for (auto &S : BDeps.External)
 493               ExternalNamedSymbolDeps[Name].insert(S);
 494           } else {
 495             if (Sym->isExternal())
 496               ExternalNamedSymbolDeps[Name].insert(
 497                   BlockDeps.getInternedName(*Sym));
 498             else
 499               InternalNamedSymbolDeps[Name].insert(
 500                   BlockDeps.getInternedName(*Sym));
 501           }
 502         }
 503       }
 504     }
 505
 506     return Error::success();
 507   }
 508
 509   BlockDependenciesMap computeBlockNonLocalDeps(LinkGraph &G) {
 510     // First calculate the reachable-via-non-local-symbol blocks for each block.
 511     struct BlockInfo {
 512       DenseSet<Block *> Dependencies;
 513       DenseSet<Block *> Dependants;
 514       bool DependenciesChanged = true;
 515     };
 516     DenseMap<Block *, BlockInfo> BlockInfos;
 517     SmallVector<Block *> WorkList;
 518
 519     // Pre-allocate map entries. This prevents any iterator/reference
 520     // invalidation in the next loop.
 521     for (auto *B : G.blocks())
 522       (void)BlockInfos[B];
 523
 524     // Build initial worklist, record block dependencies/dependants and
 525     // non-local symbol dependencies.
 526     for (auto *B : G.blocks()) {
 527       auto &BI = BlockInfos[B];
 528       for (auto &E : B->edges()) {
 529         if (E.getTarget().getScope() == Scope::Local) {
 530           auto &TgtB = E.getTarget().getBlock();
 531           if (&TgtB != B) {
 532             BI.Dependencies.insert(&TgtB);
 533             BlockInfos[&TgtB].Dependants.insert(B);
 534           }
 535         }
 536       }
 537
 538       // If this node has both dependants and dependencies then add it to the
 539       // worklist to propagate the dependencies to the dependants.
 540       if (!BI.Dependants.empty() && !BI.Dependencies.empty())
 541         WorkList.push_back(B);
 542     }
 543
 544     // Propagate block-level dependencies through the block-dependence graph.
 545     while (!WorkList.empty()) {
 546       auto *B = WorkList.back();
 547       WorkList.pop_back();
 548
 549       auto &BI = BlockInfos[B];
 550       assert(BI.DependenciesChanged &&
 551              "Block in worklist has unchanged dependencies");
 552       BI.DependenciesChanged = false;
 553       for (auto *Dependant : BI.Dependants) {
 554         auto &DependantBI = BlockInfos[Dependant];
 555         for (auto *Dependency : BI.Dependencies) {
 556           if (Dependant != Dependency &&
 557               DependantBI.Dependencies.insert(Dependency).second)
 558             if (!DependantBI.DependenciesChanged) {
 559               DependantBI.DependenciesChanged = true;
 560               WorkList.push_back(Dependant);
 561             }
 562         }
 563       }
 564     }
 565
 566     DenseMap<const Block *, DenseSet<Block *>> BlockDeps;
 567     for (auto &KV : BlockInfos)
 568       BlockDeps[KV.first] = std::move(KV.second.Dependencies);
 569
 570     return BlockDependenciesMap(Layer.getExecutionSession(),
 571                                 std::move(BlockDeps));
 572   }
 573
 574   void registerDependencies(const SymbolDependenceMap &QueryDeps) {
 575     for (auto &NamedDepsEntry : ExternalNamedSymbolDeps) {
 576       auto &Name = NamedDepsEntry.first;
 577       auto &NameDeps = NamedDepsEntry.second;
 578       SymbolDependenceMap SymbolDeps;
 579
 580       for (const auto &QueryDepsEntry : QueryDeps) {
 581         JITDylib &SourceJD = *QueryDepsEntry.first;
 582         const SymbolNameSet &Symbols = QueryDepsEntry.second;
 583         auto &DepsForJD = SymbolDeps[&SourceJD];
 584
 585         for (const auto &S : Symbols)
 586           if (NameDeps.count(S))
 587             DepsForJD.insert(S);
 588
 589         if (DepsForJD.empty())
 590           SymbolDeps.erase(&SourceJD);
 591       }
 592
 593       MR->addDependencies(Name, SymbolDeps);
 594     }
 595   }
 596
 597   ObjectLinkingLayer &Layer;
 598   std::unique_ptr<MaterializationResponsibility> MR;
 599   std::unique_ptr<MemoryBuffer> ObjBuffer;
 600   DenseMap<SymbolStringPtr, SymbolNameSet> ExternalNamedSymbolDeps;
 601   DenseMap<SymbolStringPtr, SymbolNameSet> InternalNamedSymbolDeps;
 602 };
 603
 604 ObjectLinkingLayer::Plugin::~Plugin() {}
 605
 606 char ObjectLinkingLayer::ID;
 607
 608 using BaseT = RTTIExtends<ObjectLinkingLayer, ObjectLayer>;
 609
 610 ObjectLinkingLayer::ObjectLinkingLayer(ExecutionSession &ES)
 611     : BaseT(ES), MemMgr(ES.getExecutorProcessControl().getMemMgr()) {
 612   ES.registerResourceManager(*this);
 613 }
 614
 615 ObjectLinkingLayer::ObjectLinkingLayer(ExecutionSession &ES,
 616                                        JITLinkMemoryManager &MemMgr)
 617     : BaseT(ES), MemMgr(MemMgr) {
 618   ES.registerResourceManager(*this);
 619 }
 620
 621 ObjectLinkingLayer::ObjectLinkingLayer(
 622     ExecutionSession &ES, std::unique_ptr<JITLinkMemoryManager> MemMgr)
 623     : BaseT(ES), MemMgr(*MemMgr), MemMgrOwnership(std::move(MemMgr)) {
 624   ES.registerResourceManager(*this);
 625 }
 626
 627 ObjectLinkingLayer::~ObjectLinkingLayer() {
 628   assert(Allocs.empty() && "Layer destroyed with resources still attached");
 629   getExecutionSession().deregisterResourceManager(*this);
 630 }
 631
 632 Error ObjectLinkingLayer::add(ResourceTrackerSP RT,
 633                               std::unique_ptr<LinkGraph> G) {
 634   auto &JD = RT->getJITDylib();
 635   return JD.define(LinkGraphMaterializationUnit::Create(*this, std::move(G)),
 636                    std::move(RT));
 637 }
 638
 639 void ObjectLinkingLayer::emit(std::unique_ptr<MaterializationResponsibility> R,
 640                               std::unique_ptr<MemoryBuffer> O) {
 641   assert(O && "Object must not be null");
 642   MemoryBufferRef ObjBuffer = O->getMemBufferRef();
 643
 644   auto Ctx = std::make_unique<ObjectLinkingLayerJITLinkContext>(
 645       *this, std::move(R), std::move(O));
 646   if (auto G = createLinkGraphFromObject(ObjBuffer)) {
 647     Ctx->notifyMaterializing(**G);
 648     link(std::move(*G), std::move(Ctx));
 649   } else {
 650     Ctx->notifyFailed(G.takeError());
 651   }
 652 }
 653
 654 void ObjectLinkingLayer::emit(std::unique_ptr<MaterializationResponsibility> R,
 655                               std::unique_ptr<LinkGraph> G) {
 656   auto Ctx = std::make_unique<ObjectLinkingLayerJITLinkContext>(
 657       *this, std::move(R), nullptr);
 658   Ctx->notifyMaterializing(*G);
 659   link(std::move(G), std::move(Ctx));
 660 }
 661
 662 void ObjectLinkingLayer::modifyPassConfig(MaterializationResponsibility &MR,
 663                                           LinkGraph &G,
 664                                           PassConfiguration &PassConfig) {
 665   for (auto &P : Plugins)
 666     P->modifyPassConfig(MR, G, PassConfig);
 667 }
 668
 669 void ObjectLinkingLayer::notifyLoaded(MaterializationResponsibility &MR) {
 670   for (auto &P : Plugins)
 671     P->notifyLoaded(MR);
 672 }
 673
 674 Error ObjectLinkingLayer::notifyEmitted(MaterializationResponsibility &MR,
 675                                         AllocPtr Alloc) {
 676   Error Err = Error::success();
 677   for (auto &P : Plugins)
 678     Err = joinErrors(std::move(Err), P->notifyEmitted(MR));
 679
 680   if (Err)
 681     return Err;
 682
 683   return MR.withResourceKeyDo(
 684       [&](ResourceKey K) { Allocs[K].push_back(std::move(Alloc)); });
 685 }
 686
 687 Error ObjectLinkingLayer::handleRemoveResources(ResourceKey K) {
 688
 689   Error Err = Error::success();
 690
 691   for (auto &P : Plugins)
 692     Err = joinErrors(std::move(Err), P->notifyRemovingResources(K));
 693
 694   std::vector<AllocPtr> AllocsToRemove;
 695   getExecutionSession().runSessionLocked([&] {
 696     auto I = Allocs.find(K);
 697     if (I != Allocs.end()) {
 698       std::swap(AllocsToRemove, I->second);
 699       Allocs.erase(I);
 700     }
 701   });
 702
 703   while (!AllocsToRemove.empty()) {
 704     Err = joinErrors(std::move(Err), AllocsToRemove.back()->deallocate());
 705     AllocsToRemove.pop_back();
 706   }
 707
 708   return Err;
 709 }
 710
 711 void ObjectLinkingLayer::handleTransferResources(ResourceKey DstKey,
 712                                                  ResourceKey SrcKey) {
 713   auto I = Allocs.find(SrcKey);
 714   if (I != Allocs.end()) {
 715     auto &SrcAllocs = I->second;
 716     auto &DstAllocs = Allocs[DstKey];
 717     DstAllocs.reserve(DstAllocs.size() + SrcAllocs.size());
 718     for (auto &Alloc : SrcAllocs)
 719       DstAllocs.push_back(std::move(Alloc));
 720
 721     // Erase SrcKey entry using value rather than iterator I: I may have been
 722     // invalidated when we looked up DstKey.
 723     Allocs.erase(SrcKey);
 724   }
 725
 726   for (auto &P : Plugins)
 727     P->notifyTransferringResources(DstKey, SrcKey);
 728 }
 729
 730 EHFrameRegistrationPlugin::EHFrameRegistrationPlugin(
 731     ExecutionSession &ES, std::unique_ptr<EHFrameRegistrar> Registrar)
 732     : ES(ES), Registrar(std::move(Registrar)) {}
 733
 734 void EHFrameRegistrationPlugin::modifyPassConfig(
 735     MaterializationResponsibility &MR, LinkGraph &G,
 736     PassConfiguration &PassConfig) {
 737
 738   PassConfig.PostFixupPasses.push_back(createEHFrameRecorderPass(
 739       G.getTargetTriple(), [this, &MR](JITTargetAddress Addr, size_t Size) {
 740         if (Addr) {
 741           std::lock_guard<std::mutex> Lock(EHFramePluginMutex);
 742           assert(!InProcessLinks.count(&MR) &&
 743                  "Link for MR already being tracked?");
 744           InProcessLinks[&MR] = {Addr, Size};
 745         }
 746       }));
 747 }
 748
 749 Error EHFrameRegistrationPlugin::notifyEmitted(
 750     MaterializationResponsibility &MR) {
 751
 752   EHFrameRange EmittedRange;
 753   {
 754     std::lock_guard<std::mutex> Lock(EHFramePluginMutex);
 755
 756     auto EHFrameRangeItr = InProcessLinks.find(&MR);
 757     if (EHFrameRangeItr == InProcessLinks.end())
 758       return Error::success();
 759
 760     EmittedRange = EHFrameRangeItr->second;
 761     assert(EmittedRange.Addr && "eh-frame addr to register can not be null");
 762     InProcessLinks.erase(EHFrameRangeItr);
 763   }
 764
 765   if (auto Err = MR.withResourceKeyDo(
 766           [&](ResourceKey K) { EHFrameRanges[K].push_back(EmittedRange); }))
 767     return Err;
 768
 769   return Registrar->registerEHFrames(EmittedRange.Addr, EmittedRange.Size);
 770 }
 771
 772 Error EHFrameRegistrationPlugin::notifyFailed(
 773     MaterializationResponsibility &MR) {
 774   std::lock_guard<std::mutex> Lock(EHFramePluginMutex);
 775   InProcessLinks.erase(&MR);
 776   return Error::success();
 777 }
 778
 779 Error EHFrameRegistrationPlugin::notifyRemovingResources(ResourceKey K) {
 780   std::vector<EHFrameRange> RangesToRemove;
 781
 782   ES.runSessionLocked([&] {
 783     auto I = EHFrameRanges.find(K);
 784     if (I != EHFrameRanges.end()) {
 785       RangesToRemove = std::move(I->second);
 786       EHFrameRanges.erase(I);
 787     }
 788   });
 789
 790   Error Err = Error::success();
 791   while (!RangesToRemove.empty()) {
 792     auto RangeToRemove = RangesToRemove.back();
 793     RangesToRemove.pop_back();
 794     assert(RangeToRemove.Addr && "Untracked eh-frame range must not be null");
 795     Err = joinErrors(
 796         std::move(Err),
 797         Registrar->deregisterEHFrames(RangeToRemove.Addr, RangeToRemove.Size));
 798   }
 799
 800   return Err;
 801 }
 802
 803 void EHFrameRegistrationPlugin::notifyTransferringResources(
 804     ResourceKey DstKey, ResourceKey SrcKey) {
 805   auto SI = EHFrameRanges.find(SrcKey);
 806   if (SI == EHFrameRanges.end())
 807     return;
 808
 809   auto DI = EHFrameRanges.find(DstKey);
 810   if (DI != EHFrameRanges.end()) {
 811     auto &SrcRanges = SI->second;
 812     auto &DstRanges = DI->second;
 813     DstRanges.reserve(DstRanges.size() + SrcRanges.size());
 814     for (auto &SrcRange : SrcRanges)
 815       DstRanges.push_back(std::move(SrcRange));
 816     EHFrameRanges.erase(SI);
 817   } else {
 818     // We need to move SrcKey's ranges over without invalidating the SI
 819     // iterator.
 820     auto Tmp = std::move(SI->second);
 821     EHFrameRanges.erase(SI);
 822     EHFrameRanges[DstKey] = std::move(Tmp);
 823   }
 824 }
 825
 826 } // End namespace orc.
 827 } // End namespace llvm.