[JITLink] Relax zero-fill edge assertions.

[sunho]

Summary

Relax zero-fill edge assertions to only consider relocation edges. Keep-alive edges to zero-fill blocks can cause this assertion which is too strict.

[lhames]

Otherwise LGTM.

llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h

306–308

Can this specifically check for K == Edge::KeepAlive for now? Invalid is also a non-relocation edge, but we wouldn't want it sneaking through here.

llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.h

131–132

We don't want to drop this entirely. I think it should be rewritten as:

assert((!B->isZeroFill() ||
        all_of(B->edges(), [](const Edge &E) { return E.getKind() == Edge::KeepAlive; })) &&
       "Non-KeepAlive edges in zero-fill block?");

llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h

void setAlignmentOffset(uint64_t AlignmentOffset) {
     assert(AlignmentOffset < (1ull << P2Align) &&
            "Alignment offset can't exceed alignment");
     this->AlignmentOffset = AlignmentOffset;
   }
 
   /// Add an edge to this block.
   void addEdge(Edge::Kind K, Edge::OffsetT Offset, Symbol &Target,
                Edge::AddendT Addend) {
-    assert(!isZeroFill() && "Adding edge to zero-fill block?");
+    assert((K == Edge::KeepAlive || !isZeroFill()) &&
+           "Adding edge to zero-fill block?");
     Edges.push_back(Edge(K, Offset, Target, Addend));
   }
 
   /// Add an edge by copying an existing one. This is typically used when
   /// moving edges between blocks.
   void addEdge(const Edge &E) { Edges.push_back(E); }
 
   /// Return the list of edges attached to this content.
   iterator_range<edge_iterator> edges() {

llvm/lib/ExecutionEngine/JITLink/JITLinkGeneric.h

private:
   Error fixUpBlocks(LinkGraph &G) const override {
     LLVM_DEBUG(dbgs() << "Fixing up blocks:\n");
 
     for (auto *B : G.blocks()) {
       LLVM_DEBUG(dbgs() << "  " << *B << ":\n");
 
       // Copy Block data and apply fixups.
       LLVM_DEBUG(dbgs() << "    Applying fixups.\n");
-      assert((!B->isZeroFill() || B->edges_size() == 0) &&
-             "Edges in zero-fill block?");
+      assert((!B->isZeroFill() || all_of(B->edges(),
+                                         [](const Edge &E) {
+                                           return E.getKind() ==
+                                                  Edge::KeepAlive;
+                                         })) &&
+             "Non-KeepAlive edges in zero-fill block?");
       for (auto &E : B->edges()) {
 
         // Skip non-relocation edges.
         if (!E.isRelocation())
           continue;
 
         // Dispatch to LinkerImpl for fixup.
         if (auto Err = impl().applyFixup(G, *B, E))