[JITLink] Honor shouldAddDefaultPasses in x86-64 ELF

[rafauler]

Summary

The x86-64 ELF backend still tries to add a single default
pass even if shouldAddDefaultPasses is set to false. This pass doesn't
help much as it depends on x86_64::GOTTableManager being initialized
by buildTables_ELF_x86_64, which never happens when
shouldAddDefaultPasses is false, but the pass still ends up
registering a _GLOBAL_OFFSET_TABLE_ definition that is not very
helpful. When a client asks default passes to not run, I think it
makes sense to treat _GLOBAL_OFFSET_TABLE_ as an external that needs
to be resolved by the client, which is the goal of this patch. This is
used for BOLT, a client that resolves all symbols by itself.

[lhames]

Hi @rafaelauler,

Sounds like a good idea to me, but we shouldn't need to add a new argument for it. I've modified the JITLinker base class to expose this info with a method in commit 265d6bda95b (with a follow-up in 35c9072c908 to fix a bug in the initial commit).

Please let me know if that works for you?

Will you be at the Dev Meeting? I'd love to chat some more about how bolt's using JITLink.

• Lang.

[rafauler]

Thanks a bunch @lhames , that works!

llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp

 };
 
 class ELFJITLinker_x86_64 : public JITLinker<ELFJITLinker_x86_64> {
   friend class JITLinker<ELFJITLinker_x86_64>;
 
 public:
   ELFJITLinker_x86_64(std::unique_ptr<JITLinkContext> Ctx,
                       std::unique_ptr<LinkGraph> G,
-                      PassConfiguration PassConfig)
+                      PassConfiguration PassConfig, bool DefaultPasses)
       : JITLinker(std::move(Ctx), std::move(G), std::move(PassConfig)) {
+    if (DefaultPasses)
       getPassConfig().PostAllocationPasses.push_back(
           [this](LinkGraph &G) { return getOrCreateGOTSymbol(G); });
   }
 
 private:
   Symbol *GOTSymbol = nullptr;
 
   Error getOrCreateGOTSymbol(LinkGraph &G) {
     auto DefineExternalGOTSymbolIfPresent =
         createDefineExternalSectionStartAndEndSymbolsPass(
if (auto *Sec =
       return {*Sec, false};
   }
   return {};
 }
 
 void link_ELF_x86_64(std::unique_ptr<LinkGraph> G,
                      std::unique_ptr<JITLinkContext> Ctx) {
   PassConfiguration Config;
-
+  bool DefaultPasses = false;
   if (Ctx->shouldAddDefaultTargetPasses(G->getTargetTriple())) {
-
+    DefaultPasses = true;
     Config.PrePrunePasses.push_back(DWARFRecordSectionSplitter(".eh_frame"));
     Config.PrePrunePasses.push_back(EHFrameEdgeFixer(
         ".eh_frame", x86_64::PointerSize, x86_64::Pointer32, x86_64::Pointer64,
         x86_64::Delta32, x86_64::Delta64, x86_64::NegDelta32));
     Config.PrePrunePasses.push_back(EHFrameNullTerminator(".eh_frame"));
 
     // Construct a JITLinker and run the link function.
     // Add a mark-live pass.
if (Ctx->shouldAddDefaultTargetPasses(G->getTargetTriple())) {
 
     // Add GOT/Stubs optimizer pass.
     Config.PreFixupPasses.push_back(x86_64::optimizeGOTAndStubAccesses);
   }
 
   if (auto Err = Ctx->modifyPassConfig(*G, Config))
     return Ctx->notifyFailed(std::move(Err));
 
-  ELFJITLinker_x86_64::link(std::move(Ctx), std::move(G), std::move(Config));
+  ELFJITLinker_x86_64::link(std::move(Ctx), std::move(G), std::move(Config),
+                            DefaultPasses);
 }
 } // end namespace jitlink
 } // end namespace llvm