1 files changed, 88 insertions, 97 deletions

diff --git a/lib/ExecutionEngine/JITLink/JITLinkGeneric.h b/lib/ExecutionEngine/JITLink/JITLinkGeneric.h
index e6fd6e38f7a6..07dee6cee200 100644
--- a/lib/ExecutionEngine/JITLink/JITLinkGeneric.h
+++ b/lib/ExecutionEngine/JITLink/JITLinkGeneric.h
@@ -41,39 +41,32 @@ public:
 
 protected:
   struct SegmentLayout {
-    using SectionAtomsList = std::vector<DefinedAtom *>;
-    struct SectionLayout {
-      SectionLayout(Section &S) : S(&S) {}
+    using BlocksList = std::vector<Block *>;
 
-      Section *S;
-      SectionAtomsList Atoms;
-    };
-
-    using SectionLayoutList = std::vector<SectionLayout>;
-
-    SectionLayoutList ContentSections;
-    SectionLayoutList ZeroFillSections;
+    BlocksList ContentBlocks;
+    BlocksList ZeroFillBlocks;
   };
 
   using SegmentLayoutMap = DenseMap<unsigned, SegmentLayout>;
 
   // Phase 1:
-  //   1.1: Build atom graph
+  //   1.1: Build link graph
   //   1.2: Run pre-prune passes
   //   1.2: Prune graph
   //   1.3: Run post-prune passes
-  //   1.4: Sort atoms into segments
+  //   1.4: Sort blocks into segments
   //   1.5: Allocate segment memory
   //   1.6: Identify externals and make an async call to resolve function
   void linkPhase1(std::unique_ptr<JITLinkerBase> Self);
 
   // Phase 2:
   //   2.1: Apply resolution results
-  //   2.2: Fix up atom contents
+  //   2.2: Fix up block contents
   //   2.3: Call OnResolved callback
   //   2.3: Make an async call to transfer and finalize memory.
   void linkPhase2(std::unique_ptr<JITLinkerBase> Self,
-                  Expected<AsyncLookupResult> LookupResult);
+                  Expected<AsyncLookupResult> LookupResult,
+                  SegmentLayoutMap Layout);
 
   // Phase 3:
   //   3.1: Call OnFinalized callback, handing off allocation.
@@ -81,24 +74,37 @@ protected:
 
   // Build a graph from the given object buffer.
   // To be implemented by the client.
-  virtual Expected<std::unique_ptr<AtomGraph>>
+  virtual Expected<std::unique_ptr<LinkGraph>>
   buildGraph(MemoryBufferRef ObjBuffer) = 0;
 
-  // For debug dumping of the atom graph.
+  // For debug dumping of the link graph.
   virtual StringRef getEdgeKindName(Edge::Kind K) const = 0;
 
+  // Alight a JITTargetAddress to conform with block alignment requirements.
+  static JITTargetAddress alignToBlock(JITTargetAddress Addr, Block &B) {
+    uint64_t Delta = (B.getAlignmentOffset() - Addr) % B.getAlignment();
+    return Addr + Delta;
+  }
+
+  // Alight a pointer to conform with block alignment requirements.
+  static char *alignToBlock(char *P, Block &B) {
+    uint64_t PAddr = static_cast<uint64_t>(reinterpret_cast<uintptr_t>(P));
+    uint64_t Delta = (B.getAlignmentOffset() - PAddr) % B.getAlignment();
+    return P + Delta;
+  }
+
 private:
   // Run all passes in the given pass list, bailing out immediately if any pass
   // returns an error.
-  Error runPasses(AtomGraphPassList &Passes, AtomGraph &G);
+  Error runPasses(LinkGraphPassList &Passes);
 
-  // Copy atom contents and apply relocations.
+  // Copy block contents and apply relocations.
   // Implemented in JITLinker.
   virtual Error
-  copyAndFixUpAllAtoms(const SegmentLayoutMap &Layout,
-                       JITLinkMemoryManager::Allocation &Alloc) const = 0;
+  copyAndFixUpBlocks(const SegmentLayoutMap &Layout,
+                     JITLinkMemoryManager::Allocation &Alloc) const = 0;
 
-  void layOutAtoms();
+  SegmentLayoutMap layOutBlocks();
   Error allocateSegments(const SegmentLayoutMap &Layout);
   DenseSet<StringRef> getExternalSymbolNames() const;
   void applyLookupResult(AsyncLookupResult LR);
@@ -108,8 +114,7 @@ private:
 
   std::unique_ptr<JITLinkContext> Ctx;
   PassConfiguration Passes;
-  std::unique_ptr<AtomGraph> G;
-  SegmentLayoutMap Layout;
+  std::unique_ptr<LinkGraph> G;
   std::unique_ptr<JITLinkMemoryManager::Allocation> Alloc;
 };
 
@@ -121,7 +126,7 @@ public:
   /// Link should be called with the constructor arguments for LinkerImpl, which
   /// will be forwarded to the constructor.
   template <typename... ArgTs> static void link(ArgTs &&... Args) {
-    auto L = llvm::make_unique<LinkerImpl>(std::forward<ArgTs>(Args)...);
+    auto L = std::make_unique<LinkerImpl>(std::forward<ArgTs>(Args)...);
 
     // Ownership of the linker is passed into the linker's doLink function to
     // allow it to be passed on to async continuations.
@@ -140,17 +145,17 @@ private:
   }
 
   Error
-  copyAndFixUpAllAtoms(const SegmentLayoutMap &Layout,
-                       JITLinkMemoryManager::Allocation &Alloc) const override {
-    LLVM_DEBUG(dbgs() << "Copying and fixing up atoms:\n");
+  copyAndFixUpBlocks(const SegmentLayoutMap &Layout,
+                     JITLinkMemoryManager::Allocation &Alloc) const override {
+    LLVM_DEBUG(dbgs() << "Copying and fixing up blocks:\n");
     for (auto &KV : Layout) {
       auto &Prot = KV.first;
       auto &SegLayout = KV.second;
 
       auto SegMem = Alloc.getWorkingMemory(
           static_cast<sys::Memory::ProtectionFlags>(Prot));
-      char *LastAtomEnd = SegMem.data();
-      char *AtomDataPtr = LastAtomEnd;
+      char *LastBlockEnd = SegMem.data();
+      char *BlockDataPtr = LastBlockEnd;
 
       LLVM_DEBUG({
         dbgs() << "  Processing segment "
@@ -160,93 +165,79 @@ private:
                << " ]\n    Processing content sections:\n";
       });
 
-      for (auto &SI : SegLayout.ContentSections) {
-        LLVM_DEBUG(dbgs() << "    " << SI.S->getName() << ":\n");
+      for (auto *B : SegLayout.ContentBlocks) {
+        LLVM_DEBUG(dbgs() << "    " << *B << ":\n");
+
+        // Pad to alignment/alignment-offset.
+        BlockDataPtr = alignToBlock(BlockDataPtr, *B);
 
-        AtomDataPtr += alignmentAdjustment(AtomDataPtr, SI.S->getAlignment());
+        LLVM_DEBUG({
+          dbgs() << "      Bumped block pointer to "
+                 << (const void *)BlockDataPtr << " to meet block alignment "
+                 << B->getAlignment() << " and alignment offset "
+                 << B->getAlignmentOffset() << "\n";
+        });
 
+        // Zero pad up to alignment.
         LLVM_DEBUG({
-          dbgs() << "      Bumped atom pointer to " << (const void *)AtomDataPtr
-                 << " to meet section alignment "
-                 << " of " << SI.S->getAlignment() << "\n";
+          if (LastBlockEnd != BlockDataPtr)
+            dbgs() << "      Zero padding from " << (const void *)LastBlockEnd
+                   << " to " << (const void *)BlockDataPtr << "\n";
         });
 
-        for (auto *DA : SI.Atoms) {
-
-          // Align.
-          AtomDataPtr += alignmentAdjustment(AtomDataPtr, DA->getAlignment());
-          LLVM_DEBUG({
-            dbgs() << "      Bumped atom pointer to "
-                   << (const void *)AtomDataPtr << " to meet alignment of "
-                   << DA->getAlignment() << "\n";
-          });
-
-          // Zero pad up to alignment.
-          LLVM_DEBUG({
-            if (LastAtomEnd != AtomDataPtr)
-              dbgs() << "      Zero padding from " << (const void *)LastAtomEnd
-                     << " to " << (const void *)AtomDataPtr << "\n";
-          });
-          while (LastAtomEnd != AtomDataPtr)
-            *LastAtomEnd++ = 0;
-
-          // Copy initial atom content.
-          LLVM_DEBUG({
-            dbgs() << "      Copying atom " << *DA << " content, "
-                   << DA->getContent().size() << " bytes, from "
-                   << (const void *)DA->getContent().data() << " to "
-                   << (const void *)AtomDataPtr << "\n";
-          });
-          memcpy(AtomDataPtr, DA->getContent().data(), DA->getContent().size());
-
-          // Copy atom data and apply fixups.
-          LLVM_DEBUG(dbgs() << "      Applying fixups.\n");
-          for (auto &E : DA->edges()) {
-
-            // Skip non-relocation edges.
-            if (!E.isRelocation())
-              continue;
-
-            // Dispatch to LinkerImpl for fixup.
-            if (auto Err = impl().applyFixup(*DA, E, AtomDataPtr))
-              return Err;
-          }
-
-          // Point the atom's content to the fixed up buffer.
-          DA->setContent(StringRef(AtomDataPtr, DA->getContent().size()));
-
-          // Update atom end pointer.
-          LastAtomEnd = AtomDataPtr + DA->getContent().size();
-          AtomDataPtr = LastAtomEnd;
+        while (LastBlockEnd != BlockDataPtr)
+          *LastBlockEnd++ = 0;
+
+        // Copy initial block content.
+        LLVM_DEBUG({
+          dbgs() << "      Copying block " << *B << " content, "
+                 << B->getContent().size() << " bytes, from "
+                 << (const void *)B->getContent().data() << " to "
+                 << (const void *)BlockDataPtr << "\n";
+        });
+        memcpy(BlockDataPtr, B->getContent().data(), B->getContent().size());
+
+        // Copy Block data and apply fixups.
+        LLVM_DEBUG(dbgs() << "      Applying fixups.\n");
+        for (auto &E : B->edges()) {
+
+          // Skip non-relocation edges.
+          if (!E.isRelocation())
+            continue;
+
+          // Dispatch to LinkerImpl for fixup.
+          if (auto Err = impl().applyFixup(*B, E, BlockDataPtr))
+            return Err;
         }
+
+        // Point the block's content to the fixed up buffer.
+        B->setContent(StringRef(BlockDataPtr, B->getContent().size()));
+
+        // Update block end pointer.
+        LastBlockEnd = BlockDataPtr + B->getContent().size();
+        BlockDataPtr = LastBlockEnd;
       }
 
       // Zero pad the rest of the segment.
       LLVM_DEBUG({
         dbgs() << "    Zero padding end of segment from "
-               << (const void *)LastAtomEnd << " to "
+               << (const void *)LastBlockEnd << " to "
                << (const void *)((char *)SegMem.data() + SegMem.size()) << "\n";
       });
-      while (LastAtomEnd != SegMem.data() + SegMem.size())
-        *LastAtomEnd++ = 0;
+      while (LastBlockEnd != SegMem.data() + SegMem.size())
+        *LastBlockEnd++ = 0;
     }
 
     return Error::success();
   }
 };
 
-/// Dead strips and replaces discarded definitions with external atoms.
+/// Removes dead symbols/blocks/addressables.
 ///
-/// Finds the set of nodes reachable from any node initially marked live
-/// (nodes marked should-discard are treated as not live, even if they are
-/// reachable). All nodes not marked as live at the end of this process,
-/// are deleted. Nodes that are live, but marked should-discard are replaced
-/// with external atoms and all edges to them are re-written.
-void prune(AtomGraph &G);
-
-Error addEHFrame(AtomGraph &G, Section &EHFrameSection,
-                 StringRef EHFrameContent, JITTargetAddress EHFrameAddress,
-                 Edge::Kind FDEToCIERelocKind, Edge::Kind FDEToTargetRelocKind);
+/// Finds the set of symbols and addressables reachable from any symbol
+/// initially marked live. All symbols/addressables not marked live at the end
+/// of this process are removed.
+void prune(LinkGraph &G);
 
 } // end namespace jitlink
 } // end namespace llvm