[llvm] 6c56b13 - [JITLink] Working memory shouldn't be subject to alignment constraints.

[Lang Hames via llvm-commits]

Author: Lang Hames
Date: 2021-09-11T11:26:38+10:00
New Revision: 6c56b13331b4fa646ad5a46d36aa81557dfee007

URL: https://github.com/llvm/llvm-project/commit/6c56b13331b4fa646ad5a46d36aa81557dfee007
DIFF: https://github.com/llvm/llvm-project/commit/6c56b13331b4fa646ad5a46d36aa81557dfee007.diff

LOG: [JITLink] Working memory shouldn't be subject to alignment constraints.

Refactors copyBlockContentToWorkingMemory to use offsets rather than direct
pointers to working memory. This simplifies the problem of maintaining
alignments between blocks in working memory, without requiring the working
memory itself to be aligned.

Added: 
    

Modified: 
    llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp

Removed: 
    


################################################################################
diff  --git a/llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp b/llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp
index 5b163ab6316dc..8bb61a247b1cc 100644
--- a/llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp
+++ b/llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.cpp
@@ -361,8 +361,6 @@ void JITLinkerBase::copyBlockContentToWorkingMemory(
 
     auto SegMem =
         Alloc.getWorkingMemory(static_cast<sys::Memory::ProtectionFlags>(Prot));
-    char *LastBlockEnd = SegMem.data();
-    char *BlockDataPtr = LastBlockEnd;
 
     LLVM_DEBUG({
       dbgs() << "  Processing segment "
@@ -372,53 +370,64 @@ void JITLinkerBase::copyBlockContentToWorkingMemory(
              << " ]\n    Processing content sections:\n";
     });
 
+    if (SegLayout.ContentBlocks.empty()) {
+      LLVM_DEBUG(dbgs() << "    No content blocks.\n");
+      continue;
+    }
+
+    size_t BlockOffset = 0;
+    size_t LastBlockEnd = 0;
+
     for (auto *B : SegLayout.ContentBlocks) {
       LLVM_DEBUG(dbgs() << "    " << *B << ":\n");
 
       // Pad to alignment/alignment-offset.
-      BlockDataPtr = alignToBlock(BlockDataPtr, *B);
+      BlockOffset = alignToBlock(BlockOffset, *B);
 
       LLVM_DEBUG({
-        dbgs() << "      Bumped block pointer to " << (const void *)BlockDataPtr
-               << " to meet block alignment " << B->getAlignment()
-               << " and alignment offset " << B->getAlignmentOffset() << "\n";
+        dbgs() << "      Bumped block offset to "
+               << formatv("{0:x}", BlockOffset) << " to meet block alignment "
+               << B->getAlignment() << " and alignment offset "
+               << B->getAlignmentOffset() << "\n";
       });
 
       // Zero pad up to alignment.
       LLVM_DEBUG({
-        if (LastBlockEnd != BlockDataPtr)
-          dbgs() << "      Zero padding from " << (const void *)LastBlockEnd
-                 << " to " << (const void *)BlockDataPtr << "\n";
+        if (LastBlockEnd != BlockOffset)
+          dbgs() << "      Zero padding from " << formatv("{0:x}", LastBlockEnd)
+                 << " to " << formatv("{0:x}", BlockOffset) << "\n";
       });
 
-      while (LastBlockEnd != BlockDataPtr)
-        *LastBlockEnd++ = 0;
+      for (; LastBlockEnd != BlockOffset; ++LastBlockEnd)
+        *(SegMem.data() + 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";
+               << (const void *)B->getContent().data() << " to offset "
+               << formatv("{0:x}", BlockOffset) << "\n";
       });
-      memcpy(BlockDataPtr, B->getContent().data(), B->getContent().size());
+      memcpy(SegMem.data() + BlockOffset, B->getContent().data(),
+             B->getContent().size());
 
       // Point the block's content to the fixed up buffer.
-      B->setMutableContent({BlockDataPtr, B->getContent().size()});
+      B->setMutableContent(
+          {SegMem.data() + BlockOffset, B->getContent().size()});
 
       // Update block end pointer.
-      LastBlockEnd = BlockDataPtr + B->getContent().size();
-      BlockDataPtr = LastBlockEnd;
+      LastBlockEnd = BlockOffset + B->getContent().size();
+      BlockOffset = LastBlockEnd;
     }
 
     // Zero pad the rest of the segment.
     LLVM_DEBUG({
-      dbgs() << "    Zero padding end of segment from "
-             << (const void *)LastBlockEnd << " to "
-             << (const void *)((char *)SegMem.data() + SegMem.size()) << "\n";
+      dbgs() << "    Zero padding end of segment from offset "
+             << formatv("{0:x}", LastBlockEnd) << " to "
+             << formatv("{0:x}", SegMem.size()) << "\n";
     });
-    while (LastBlockEnd != SegMem.data() + SegMem.size())
-      *LastBlockEnd++ = 0;
+    for (; LastBlockEnd != SegMem.size(); ++LastBlockEnd)
+      *(SegMem.data() + LastBlockEnd) = 0;
   }
 }