[JITLink] Add target features to LinkGraph

[jobnoorman]

Summary

This patch adds SubtargetFeatures to LinkGraph. Similar to Triple, some
targets might use this information while linking.

One example, and the reason this patch was written, is linker relaxation
on RISC-V: different relaxations are possible depending on if the C
extension is enabled.

Note that the features are stored as std::vector<std::string> to prevent a
public dependency on MC. There is still a private dependency to be able to
convert SubtargetFeatures to a vector.

[lhames]

Another quick skim (I'm back in the office on Monday and I can take a proper look then).

However, this introduces a dependency from JITLink on MC and I'm not quite sure if this is warranted. If not, the features could be stored as std::vector<std::string> (the underlying storage of SubtargetFeatures).

Yeah -- we definitely want to avoid the dependence on MC. One of the aims of ORC development over the next year or so is going to be splitting the library up so that ORC core depends only on libObject (and eventually, only on format-specific object file parsing libraries, but we don't have those yet. :) )

• Lang.

[jobnoorman]

In D149522#4318006, @lhames wrote:

Yeah -- we definitely want to avoid the dependence on MC. One of the aims of ORC development over the next year or so is going to be splitting the library up so that ORC core depends only on libObject (and eventually, only on format-specific object file parsing libraries, but we don't have those yet. :) )

That makes sense. Unfortunately, it isn't as easy to avoid as I thought. The problem is that to get the features from an object file, we have to call ObjectFile::getFeatures which returns a SubtargetFeatures and we have to call one of its methods to convert it to a std::vector<std::string>. So I don't immediately see a way around the MC dependency.

On a related note: I wonder why SubtargetFeatures is part of MC and not of, say, TargetParser (like Triple).

[lhames]

In D149522#4318568, @jobnoorman wrote:

In D149522#4318006, @lhames wrote:

Yeah -- we definitely want to avoid the dependence on MC. One of the aims of ORC development over the next year or so is going to be splitting the library up so that ORC core depends only on libObject (and eventually, only on format-specific object file parsing libraries, but we don't have those yet. :) )

That makes sense. Unfortunately, it isn't as easy to avoid as I thought. The problem is that to get the features from an object file, we have to call ObjectFile::getFeatures which returns a SubtargetFeatures and we have to call one of its methods to convert it to a std::vector<std::string>. So I don't immediately see a way around the MC dependency.

On a related note: I wonder why SubtargetFeatures is part of MC and not of, say, TargetParser (like Triple).

Huh. That's a really good question. Maybe we can do this by moving SubtargetFeatures?

If we can't do that (or want a short term solution) then we should use std::vector<std::string> on the LinkGraph and hide the MC dependency in the implementation code. That'll make it easier to fix later without breaking clients.

[jrtc27]

Dumb question perhaps, but why can't JITLink use MC? LLD does and conceptually serves a similar purpose.

[jobnoorman]

In D149522#4320587, @lhames wrote:

In D149522#4318568, @jobnoorman wrote:

On a related note: I wonder why SubtargetFeatures is part of MC and not of, say, TargetParser (like Triple).

Huh. That's a really good question. Maybe we can do this by moving SubtargetFeatures?

fyi: I posted a question about this on Discourse.

[lhames]

In D149522#4320588, @jrtc27 wrote:

Dumb question perhaps, but why can't JITLink use MC? LLD does and conceptually serves a similar purpose.

JITLink is used in some systems where memory and storage are at a premium, so we want our dependencies to be as minimal as possible. We're stuck right now (libObject pulls in LLVM Core), but the eventual goal is to (1) break format-specific parsers out of libObject, and then (2) have a JITLink core library that depends on libSupport only, plus format specific libraries (JITLinkCOFF, JITLinkELF, and JITLinkMachO) that each depend on the corresponding format-specific parser only.

[jobnoorman]

Store features as std::vector<std::string> to prevent a public dependency on MC.

[jobnoorman]

In D149522#4320587, @lhames wrote:

In D149522#4318568, @jobnoorman wrote:

On a related note: I wonder why SubtargetFeatures is part of MC and not of, say, TargetParser (like Triple).

Huh. That's a really good question. Maybe we can do this by moving SubtargetFeatures?

If we can't do that (or want a short term solution) then we should use std::vector<std::string> on the LinkGraph and hide the MC dependency in the implementation code. That'll make it easier to fix later without breaking clients.

Even though I opened D150549 to try and move SubtargetFeatures, I don't expect it to land anytime soon (if ever). Therefore, I've updated this patch to only use MC in implementation code. If that patch does land, we can update how features are stored then.

[lhames]

The cantFails should be resolved (either commented if they truly can't fail, or removed if they could), but otherwise LGTM.

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp

32

I think I missed this the first time around. Why cantFail? There should be a comment explaining why, at this particular call-site, it would be impossible for this call to ever fail. If it could fail then the API needs to be refactored to return an Error / Expected (in the case of constructors this usually means switching to a named constructor idiom, or you could check/retrieve the FeatureVector in the caller, then pass it into this constructor).

[jobnoorman]

Remove all uses of cantFail; propagate errors instead.

[jobnoorman]

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp

32

You're right, this use of cantFail wasn't appropriate. I convinced myself after a cursory glance that getFeatures never fails for any architecture and that cantFail would therefore be an easy solution. This isn't true, however, so I've updated the patch to propagate errors.

[lhames]

LGTM. Thanks very much for all of your work on this @jobnoorman!

Side note, it looks like https://reviews.llvm.org/D150549 got at least one thumbs up already. If/when that lands we would benefit from going back to using SubtargetFeatures in LinkGraph, since it'll save us copying the vector (no that this is going to cost much in practice).

[jobnoorman]

Thanks for the reviews @lhames!

In D149522#4348989, @lhames wrote:

Side note, it looks like https://reviews.llvm.org/D150549 got at least one thumbs up already. If/when that lands we would benefit from going back to using SubtargetFeatures in LinkGraph, since it'll save us copying the vector (no that this is going to cost much in practice).

Agreed. Once that one lands, I'll submit a JITLink patch for this.

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

public:
 
   using const_block_iterator =
       nested_collection_iterator<const_section_iterator,
                                  Section::const_block_iterator, const Block *,
                                  getSectionConstBlocks>;
 
   using GetEdgeKindNameFunction = const char *(*)(Edge::Kind);
 
+  using FeatureVector = std::vector<std::string>;
+
+  LinkGraph(std::string Name, const Triple &TT, FeatureVector Features,
+            unsigned PointerSize, support::endianness Endianness,
+            GetEdgeKindNameFunction GetEdgeKindName)
+      : Name(std::move(Name)), TT(TT), Features(std::move(Features)),
+        PointerSize(PointerSize), Endianness(Endianness),
+        GetEdgeKindName(std::move(GetEdgeKindName)) {}
+
   LinkGraph(std::string Name, const Triple &TT, unsigned PointerSize,
             support::endianness Endianness,
             GetEdgeKindNameFunction GetEdgeKindName)
-      : Name(std::move(Name)), TT(TT), PointerSize(PointerSize),
-        Endianness(Endianness), GetEdgeKindName(std::move(GetEdgeKindName)) {}
+      : LinkGraph(std::move(Name), TT, FeatureVector(), PointerSize, Endianness,
+                  GetEdgeKindName) {}
 
   LinkGraph(const LinkGraph &) = delete;
   LinkGraph &operator=(const LinkGraph &) = delete;
   LinkGraph(LinkGraph &&) = delete;
   LinkGraph &operator=(LinkGraph &&) = delete;
 
   /// Returns the name of this graph (usually the name of the original
   /// underlying MemoryBuffer).
   const std::string &getName() const { return Name; }
 
   /// Returns the target triple for this Graph.
   const Triple &getTargetTriple() const { return TT; }
 
+  /// Return the subtarget features for this Graph.
+  const FeatureVector &getFeatures() const { return Features; }
+
   /// Returns the pointer size for use in this graph.
   unsigned getPointerSize() const { return PointerSize; }
 
   /// Returns the endianness of content in this graph.
   support::endianness getEndianness() const { return Endianness; }
 
   const char *getEdgeKindName(Edge::Kind K) const { return GetEdgeKindName(K); }
 

 
 private:
   // Put the BumpPtrAllocator first so that we don't free any of the underlying
   // memory until the Symbol/Addressable destructors have been run.
   BumpPtrAllocator Allocator;
 
   std::string Name;
   Triple TT;
+  FeatureVector Features;
   unsigned PointerSize;
   support::endianness Endianness;
   GetEdgeKindNameFunction GetEdgeKindName = nullptr;
   DenseMap<StringRef, std::unique_ptr<Section>> Sections;
   ExternalSymbolSet ExternalSymbols;
   ExternalSymbolSet AbsoluteSymbols;
   orc::shared::AllocActions AAs;
 };

llvm/lib/ExecutionEngine/JITLink/CMakeLists.txt

add_llvm_component_library(LLVMJITLink
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/ExecutionEngine/JITLink
 
   DEPENDS
   intrinsics_gen
   JITLinkTableGen
 
   LINK_COMPONENTS
   BinaryFormat
+  MC
   Object
   Option
   OrcTargetProcess
   Support
   TargetParser
   )
 
 target_link_libraries(LLVMJITLink
   PRIVATE
   LLVMObject
   LLVMOrcShared
   LLVMOrcTargetProcess
   LLVMSupport
   LLVMTargetParser
 )

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.h

public:
   virtual ~COFFLinkGraphBuilder();
   Expected<std::unique_ptr<LinkGraph>> buildGraph();
 
 protected:
   using COFFSectionIndex = int32_t;
   using COFFSymbolIndex = int32_t;
 
   COFFLinkGraphBuilder(const object::COFFObjectFile &Obj, Triple TT,
+                       LinkGraph::FeatureVector Features,
                        LinkGraph::GetEdgeKindNameFunction GetEdgeKindName);
 
   LinkGraph &getGraph() const { return *G; }
 
   const object::COFFObjectFile &getObject() const { return Obj; }
 
   virtual Error addRelocations() = 0;
 

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp

 
 static Triple createTripleWithCOFFFormat(Triple T) {
   T.setObjectFormat(Triple::COFF);
   return T;
 }
 
 COFFLinkGraphBuilder::COFFLinkGraphBuilder(
     const object::COFFObjectFile &Obj, Triple TT,
+    LinkGraph::FeatureVector Features,
     LinkGraph::GetEdgeKindNameFunction GetEdgeKindName)
-    : Obj(Obj),
-      G(std::make_unique<LinkGraph>(Obj.getFileName().str(),
-                                    createTripleWithCOFFFormat(TT),
-                                    getPointerSize(Obj), getEndianness(Obj),
-                                    std::move(GetEdgeKindName))) {
+    : Obj(Obj), G(std::make_unique<LinkGraph>(
+                    Obj.getFileName().str(), createTripleWithCOFFFormat(TT),
+                    std::move(Features), getPointerSize(Obj),
+                    getEndianness(Obj), std::move(GetEdgeKindName))) {
   LLVM_DEBUG({
     dbgs() << "Created COFFLinkGraphBuilder for \"" << Obj.getFileName()
            << "\"\n";
   });
 }
 
 COFFLinkGraphBuilder::~COFFLinkGraphBuilder() = default;
 

llvm/lib/ExecutionEngine/JITLink/COFF_x86_64.cpp

Error addSingleRelocation(const object::RelocationRef &Rel,
     });
 
     BlockToFix.addEdge(std::move(GE));
 
     return Error::success();
   }
 
 public:
-  COFFLinkGraphBuilder_x86_64(const object::COFFObjectFile &Obj, const Triple T)
-      : COFFLinkGraphBuilder(Obj, std::move(T), getCOFFX86RelocationKindName) {}
+  COFFLinkGraphBuilder_x86_64(const object::COFFObjectFile &Obj, const Triple T,
+                              const LinkGraph::FeatureVector Features)
+      : COFFLinkGraphBuilder(Obj, std::move(T), std::move(Features),
+                             getCOFFX86RelocationKindName) {}
 };
 
 class COFFLinkGraphLowering_x86_64 {
 public:
   // Lowers COFF x86_64 specific edges to generic x86_64 edges.
   Error lowerCOFFRelocationEdges(LinkGraph &G, JITLinkContext &Ctx) {
     for (auto *B : G.blocks()) {
       for (auto &E : B->edges()) {
LLVM_DEBUG({
     dbgs() << "Building jitlink graph for new input "
            << ObjectBuffer.getBufferIdentifier() << "...\n";
   });
 
   auto COFFObj = object::ObjectFile::createCOFFObjectFile(ObjectBuffer);
   if (!COFFObj)
     return COFFObj.takeError();
 
-  return COFFLinkGraphBuilder_x86_64(**COFFObj, (*COFFObj)->makeTriple())
+  auto Features = (*COFFObj)->getFeatures();
+  if (!Features)
+    return Features.takeError();
+
+  return COFFLinkGraphBuilder_x86_64(**COFFObj, (*COFFObj)->makeTriple(),
+                                     Features->getFeatures())
       .buildGraph();
 }
 
 void link_COFF_x86_64(std::unique_ptr<LinkGraph> G,
                       std::unique_ptr<JITLinkContext> Ctx) {
   PassConfiguration Config;
   const Triple &TT = G->getTargetTriple();
   if (Ctx->shouldAddDefaultTargetPasses(TT)) {

llvm/lib/ExecutionEngine/JITLink/ELFLinkGraphBuilder.h

 /// Ling-graph building code that's specific to the given ELFT, but common
 /// across all architectures.
 template <typename ELFT>
 class ELFLinkGraphBuilder : public ELFLinkGraphBuilderBase {
   using ELFFile = object::ELFFile<ELFT>;
 
 public:
   ELFLinkGraphBuilder(const object::ELFFile<ELFT> &Obj, Triple TT,
-                      StringRef FileName,
+                      LinkGraph::FeatureVector Features, StringRef FileName,
                       LinkGraph::GetEdgeKindNameFunction GetEdgeKindName);
 
   /// Debug sections are included in the graph by default. Use
   /// setProcessDebugSections(false) to ignore them if debug info is not
   /// needed.
   ELFLinkGraphBuilder &setProcessDebugSections(bool ProcessDebugSections) {
     this->ProcessDebugSections = ProcessDebugSections;
     return *this;
protected:
   DenseMap<ELFSymbolIndex, Symbol *> GraphSymbols;
   DenseMap<const typename ELFFile::Elf_Shdr *,
            ArrayRef<typename ELFFile::Elf_Word>>
       ShndxTables;
 };
 
 template <typename ELFT>
 ELFLinkGraphBuilder<ELFT>::ELFLinkGraphBuilder(
-    const ELFFile &Obj, Triple TT, StringRef FileName,
-    LinkGraph::GetEdgeKindNameFunction GetEdgeKindName)
+    const ELFFile &Obj, Triple TT, LinkGraph::FeatureVector Features,
+    StringRef FileName, LinkGraph::GetEdgeKindNameFunction GetEdgeKindName)
     : ELFLinkGraphBuilderBase(std::make_unique<LinkGraph>(
-          FileName.str(), Triple(std::move(TT)), ELFT::Is64Bits ? 8 : 4,
-          support::endianness(ELFT::TargetEndianness),
+          FileName.str(), Triple(std::move(TT)), std::move(Features),
+          ELFT::Is64Bits ? 8 : 4, support::endianness(ELFT::TargetEndianness),
           std::move(GetEdgeKindName))),
       Obj(Obj) {
   LLVM_DEBUG(
       { dbgs() << "Created ELFLinkGraphBuilder for \"" << FileName << "\""; });
 }
 
 template <typename ELFT>
 Expected<std::unique_ptr<LinkGraph>> ELFLinkGraphBuilder<ELFT>::buildGraph() {

llvm/lib/ExecutionEngine/JITLink/ELF_aarch32.cpp

orc::ExecutorAddrDiff getRawOffset(const typename ELFT::Sym &Sym,
     assert((makeTargetFlags(Sym) & Flags) == Flags);
     static constexpr uint64_t ThumbBit = 0x01;
     return Sym.getValue() & ~ThumbBit;
   }
 
 public:
   ELFLinkGraphBuilder_aarch32(StringRef FileName,
                               const llvm::object::ELFFile<ELFT> &Obj, Triple TT,
+                              LinkGraph::FeatureVector Features,
                               aarch32::ArmConfig ArmCfg)
-      : ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), FileName,
-                                  getELFAArch32EdgeKindName),
+      : ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features),
+                                  FileName, getELFAArch32EdgeKindName),
         ArmCfg(std::move(ArmCfg)) {}
 };
 
 template <aarch32::StubsFlavor Flavor>
 Error buildTables_ELF_aarch32(LinkGraph &G) {
   LLVM_DEBUG(dbgs() << "Visiting edges in graph:\n");
 
   aarch32::StubsManager<Flavor> PLT;
   visitExistingEdges(G, PLT);
   return Error::success();
 }
 
 Expected<std::unique_ptr<LinkGraph>>
 createLinkGraphFromELFObject_aarch32(MemoryBufferRef ObjectBuffer) {
   LLVM_DEBUG({
     dbgs() << "Building jitlink graph for new input "
            << ObjectBuffer.getBufferIdentifier() << "...\n";
   });
 
   auto ELFObj = ObjectFile::createELFObjectFile(ObjectBuffer);
   if (!ELFObj)
     return ELFObj.takeError();
 
+  auto Features = (*ELFObj)->getFeatures();
+  if (!Features)
+    return Features.takeError();
+
   // Find out what exact AArch32 instruction set and features we target.
   auto TT = (*ELFObj)->makeTriple();
   ARM::ArchKind AK = ARM::parseArch(TT.getArchName());
   if (AK == ARM::ArchKind::INVALID)
     return make_error<JITLinkError>(
         "Failed to build ELF link graph: Invalid ARM ArchKind");
 
   // Resolve our internal configuration for the target. If at some point the
createLinkGraphFromELFObject_aarch32(MemoryBufferRef ObjectBuffer) {
   }
 
   // Populate the link-graph.
   switch (TT.getArch()) {
   case Triple::arm:
   case Triple::thumb: {
     auto &ELFFile = cast<ELFObjectFile<ELF32LE>>(**ELFObj).getELFFile();
     return ELFLinkGraphBuilder_aarch32<support::little>(
-               (*ELFObj)->getFileName(), ELFFile, TT, ArmCfg)
+               (*ELFObj)->getFileName(), ELFFile, TT, Features->getFeatures(),
+               ArmCfg)
         .buildGraph();
   }
   case Triple::armeb:
   case Triple::thumbeb: {
     auto &ELFFile = cast<ELFObjectFile<ELF32BE>>(**ELFObj).getELFFile();
-    return ELFLinkGraphBuilder_aarch32<support::big>((*ELFObj)->getFileName(),
-                                                     ELFFile, TT, ArmCfg)
+    return ELFLinkGraphBuilder_aarch32<support::big>(
+               (*ELFObj)->getFileName(), ELFFile, TT, Features->getFeatures(),
+               ArmCfg)
         .buildGraph();
   }
   default:
     return make_error<JITLinkError>(
         "Failed to build ELF/aarch32 link graph: Invalid target triple " +
         TT.getTriple());
   }
 }

llvm/lib/ExecutionEngine/JITLink/ELF_aarch64.cpp

case ELFTLSDescCall:
       return "ELFTLSDescCall";
     default:
       return getGenericEdgeKindName(static_cast<Edge::Kind>(R));
     }
   }
 
 public:
   ELFLinkGraphBuilder_aarch64(StringRef FileName,
-                              const object::ELFFile<ELFT> &Obj, Triple TT)
-      : ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), FileName,
-                                  aarch64::getEdgeKindName) {}
+                              const object::ELFFile<ELFT> &Obj, Triple TT,
+                              LinkGraph::FeatureVector Features)
+      : ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features),
+                                  FileName, aarch64::getEdgeKindName) {}
 };
 
 // TLS Info Builder.
 class TLSInfoTableManager_ELF_aarch64
     : public TableManager<TLSInfoTableManager_ELF_aarch64> {
 public:
   static StringRef getSectionName() { return "$__TLSINFO"; }
 
LLVM_DEBUG({
     dbgs() << "Building jitlink graph for new input "
            << ObjectBuffer.getBufferIdentifier() << "...\n";
   });
 
   auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer);
   if (!ELFObj)
     return ELFObj.takeError();
 
+  auto Features = (*ELFObj)->getFeatures();
+  if (!Features)
+    return Features.takeError();
+
   assert((*ELFObj)->getArch() == Triple::aarch64 &&
          "Only AArch64 (little endian) is supported for now");
 
   auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj);
-  return ELFLinkGraphBuilder_aarch64<object::ELF64LE>((*ELFObj)->getFileName(),
-                                                      ELFObjFile.getELFFile(),
-                                                      (*ELFObj)->makeTriple())
+  return ELFLinkGraphBuilder_aarch64<object::ELF64LE>(
+             (*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
+             (*ELFObj)->makeTriple(), Features->getFeatures())
       .buildGraph();
 }
 
 void link_ELF_aarch64(std::unique_ptr<LinkGraph> G,
                       std::unique_ptr<JITLinkContext> Ctx) {
   PassConfiguration Config;
   const Triple &TT = G->getTargetTriple();
   if (Ctx->shouldAddDefaultTargetPasses(TT)) {

llvm/lib/ExecutionEngine/JITLink/ELF_i386.cpp

Error addSingleRelocation(const typename ELFT::Rel &Rel,
     });
 
     BlockToFix.addEdge(std::move(GE));
     return Error::success();
   }
 
 public:
   ELFLinkGraphBuilder_i386(StringRef FileName, const object::ELFFile<ELFT> &Obj,
-                           Triple TT)
-      : ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), FileName,
-                                  i386::getEdgeKindName) {}
+                           Triple TT, LinkGraph::FeatureVector Features)
+      : ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features),
+                                  FileName, i386::getEdgeKindName) {}
 };
 
 Expected<std::unique_ptr<LinkGraph>>
 createLinkGraphFromELFObject_i386(MemoryBufferRef ObjectBuffer) {
   LLVM_DEBUG({
     dbgs() << "Building jitlink graph for new input "
            << ObjectBuffer.getBufferIdentifier() << "...\n";
   });
 
   auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer);
   if (!ELFObj)
     return ELFObj.takeError();
 
+  auto Features = (*ELFObj)->getFeatures();
+  if (!Features)
+    return Features.takeError();
+
   assert((*ELFObj)->getArch() == Triple::x86 &&
          "Only i386 (little endian) is supported for now");
 
   auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF32LE>>(**ELFObj);
-  return ELFLinkGraphBuilder_i386<object::ELF32LE>((*ELFObj)->getFileName(),
-                                                   ELFObjFile.getELFFile(),
-                                                   (*ELFObj)->makeTriple())
+  return ELFLinkGraphBuilder_i386<object::ELF32LE>(
+             (*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
+             (*ELFObj)->makeTriple(), Features->getFeatures())
       .buildGraph();
 }
 
 void link_ELF_i386(std::unique_ptr<LinkGraph> G,
                    std::unique_ptr<JITLinkContext> Ctx) {
   PassConfiguration Config;
   const Triple &TT = G->getTargetTriple();
   if (Ctx->shouldAddDefaultTargetPasses(TT)) {

llvm/lib/ExecutionEngine/JITLink/ELF_loongarch.cpp

Error addSingleRelocation(const typename ELFT::Rela &Rel,
 
     BlockToFix.addEdge(std::move(GE));
 
     return Error::success();
   }
 
 public:
   ELFLinkGraphBuilder_loongarch(StringRef FileName,
-                                const object::ELFFile<ELFT> &Obj, Triple TT)
-      : ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), FileName,
-                                  loongarch::getEdgeKindName) {}
+                                const object::ELFFile<ELFT> &Obj, Triple TT,
+                                LinkGraph::FeatureVector Features)
+      : ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features),
+                                  FileName, loongarch::getEdgeKindName) {}
 };
 
 Error buildTables_ELF_loongarch(LinkGraph &G) {
   LLVM_DEBUG(dbgs() << "Visiting edges in graph:\n");
 
   GOTTableManager GOT;
   PLTTableManager PLT(GOT);
   visitExistingEdges(G, GOT, PLT);
LLVM_DEBUG({
     dbgs() << "Building jitlink graph for new input "
            << ObjectBuffer.getBufferIdentifier() << "...\n";
   });
 
   auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer);
   if (!ELFObj)
     return ELFObj.takeError();
 
+  auto Features = (*ELFObj)->getFeatures();
+  if (!Features)
+    return Features.takeError();
+
   if ((*ELFObj)->getArch() == Triple::loongarch64) {
     auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj);
     return ELFLinkGraphBuilder_loongarch<object::ELF64LE>(
                (*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
-               (*ELFObj)->makeTriple())
+               (*ELFObj)->makeTriple(), Features->getFeatures())
         .buildGraph();
   }
 
   assert((*ELFObj)->getArch() == Triple::loongarch32 &&
          "Invalid triple for LoongArch ELF object file");
   auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF32LE>>(**ELFObj);
   return ELFLinkGraphBuilder_loongarch<object::ELF32LE>(
              (*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
-             (*ELFObj)->makeTriple())
+             (*ELFObj)->makeTriple(), Features->getFeatures())
       .buildGraph();
 }
 
 void link_ELF_loongarch(std::unique_ptr<LinkGraph> G,
                         std::unique_ptr<JITLinkContext> Ctx) {
   PassConfiguration Config;
   const Triple &TT = G->getTargetTriple();
   if (Ctx->shouldAddDefaultTargetPasses(TT)) {

llvm/lib/ExecutionEngine/JITLink/ELF_riscv.cpp

Error addSingleRelocation(const typename ELFT::Rela &Rel,
     });
 
     BlockToFix.addEdge(std::move(GE));
     return Error::success();
   }
 
 public:
   ELFLinkGraphBuilder_riscv(StringRef FileName,
-                            const object::ELFFile<ELFT> &Obj, Triple TT)
-      : ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), FileName,
-                                  riscv::getEdgeKindName) {}
+                            const object::ELFFile<ELFT> &Obj, Triple TT,
+                            LinkGraph::FeatureVector Features)
+      : ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features),
+                                  FileName, riscv::getEdgeKindName) {}
 };
 
 Expected<std::unique_ptr<LinkGraph>>
 createLinkGraphFromELFObject_riscv(MemoryBufferRef ObjectBuffer) {
   LLVM_DEBUG({
     dbgs() << "Building jitlink graph for new input "
            << ObjectBuffer.getBufferIdentifier() << "...\n";
   });
 
   auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer);
   if (!ELFObj)
     return ELFObj.takeError();
 
+  auto Features = (*ELFObj)->getFeatures();
+  if (!Features)
+    return Features.takeError();
+
   if ((*ELFObj)->getArch() == Triple::riscv64) {
     auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj);
     return ELFLinkGraphBuilder_riscv<object::ELF64LE>(
                (*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
-               (*ELFObj)->makeTriple())
+               (*ELFObj)->makeTriple(), Features->getFeatures())
         .buildGraph();
   } else {
     assert((*ELFObj)->getArch() == Triple::riscv32 &&
            "Invalid triple for RISCV ELF object file");
     auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF32LE>>(**ELFObj);
     return ELFLinkGraphBuilder_riscv<object::ELF32LE>(
                (*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
-               (*ELFObj)->makeTriple())
+               (*ELFObj)->makeTriple(), Features->getFeatures())
         .buildGraph();
   }
 }
 
 void link_ELF_riscv(std::unique_ptr<LinkGraph> G,
                     std::unique_ptr<JITLinkContext> Ctx) {
   PassConfiguration Config;
   const Triple &TT = G->getTargetTriple();

llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp

Error addSingleRelocation(const typename ELFT::Rela &Rel,
     });
 
     BlockToFix.addEdge(std::move(GE));
     return Error::success();
   }
 
 public:
   ELFLinkGraphBuilder_x86_64(StringRef FileName,
-                             const object::ELFFile<object::ELF64LE> &Obj)
-      : ELFLinkGraphBuilder(Obj, Triple("x86_64-unknown-linux"), FileName,
+                             const object::ELFFile<object::ELF64LE> &Obj,
+                             LinkGraph::FeatureVector Features)
+      : ELFLinkGraphBuilder(Obj, Triple("x86_64-unknown-linux"),
+                            std::move(Features), FileName,
                             x86_64::getEdgeKindName) {}
 };
 
 class ELFJITLinker_x86_64 : public JITLinker<ELFJITLinker_x86_64> {
   friend class JITLinker<ELFJITLinker_x86_64>;
 
 public:
   ELFJITLinker_x86_64(std::unique_ptr<JITLinkContext> Ctx,
LLVM_DEBUG({
     dbgs() << "Building jitlink graph for new input "
            << ObjectBuffer.getBufferIdentifier() << "...\n";
   });
 
   auto ELFObj = object::ObjectFile::createELFObjectFile(ObjectBuffer);
   if (!ELFObj)
     return ELFObj.takeError();
 
+  auto Features = (*ELFObj)->getFeatures();
+  if (!Features)
+    return Features.takeError();
+
   auto &ELFObjFile = cast<object::ELFObjectFile<object::ELF64LE>>(**ELFObj);
   return ELFLinkGraphBuilder_x86_64((*ELFObj)->getFileName(),
-                                    ELFObjFile.getELFFile())
+                                    ELFObjFile.getELFFile(),
+                                    Features->getFeatures())
       .buildGraph();
 }
 
 static SectionRangeSymbolDesc
 identifyELFSectionStartAndEndSymbols(LinkGraph &G, Symbol &Sym) {
   constexpr StringRef StartSymbolPrefix = "__start";
   constexpr StringRef EndSymbolPrefix = "__end";
 

llvm/lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.h

public:
     const char *Data = nullptr;
     Section *GraphSection = nullptr;
     std::map<orc::ExecutorAddr, Symbol *> CanonicalSymbols;
   };
 
   using SectionParserFunction = std::function<Error(NormalizedSection &S)>;
 
   MachOLinkGraphBuilder(const object::MachOObjectFile &Obj, Triple TT,
+                        LinkGraph::FeatureVector Features,
                         LinkGraph::GetEdgeKindNameFunction GetEdgeKindName);
 
   LinkGraph &getGraph() const { return *G; }
 
   const object::MachOObjectFile &getObject() const { return Obj; }
 
   void addCustomSectionParser(StringRef SectionName,
                               SectionParserFunction Parse);

llvm/lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.cpp

Expected<std::unique_ptr<LinkGraph>> MachOLinkGraphBuilder::buildGraph() {
   if (auto Err = addRelocations())
     return std::move(Err);
 
   return std::move(G);
 }
 
 MachOLinkGraphBuilder::MachOLinkGraphBuilder(
     const object::MachOObjectFile &Obj, Triple TT,
+    LinkGraph::FeatureVector Features,
     LinkGraph::GetEdgeKindNameFunction GetEdgeKindName)
     : Obj(Obj),
-      G(std::make_unique<LinkGraph>(
-          std::string(Obj.getFileName()), std::move(TT), getPointerSize(Obj),
-          getEndianness(Obj), std::move(GetEdgeKindName))) {
+      G(std::make_unique<LinkGraph>(std::string(Obj.getFileName()),
+                                    std::move(TT), std::move(Features),
+                                    getPointerSize(Obj), getEndianness(Obj),
+                                    std::move(GetEdgeKindName))) {
   auto &MachHeader = Obj.getHeader64();
   SubsectionsViaSymbols = MachHeader.flags & MachO::MH_SUBSECTIONS_VIA_SYMBOLS;
 }
 
 void MachOLinkGraphBuilder::addCustomSectionParser(
     StringRef SectionName, SectionParserFunction Parser) {
   assert(!CustomSectionParserFunctions.count(SectionName) &&
          "Custom parser for this section already exists");

llvm/lib/ExecutionEngine/JITLink/MachO_arm64.cpp

 
 using namespace llvm;
 using namespace llvm::jitlink;
 
 namespace {
 
 class MachOLinkGraphBuilder_arm64 : public MachOLinkGraphBuilder {
 public:
-  MachOLinkGraphBuilder_arm64(const object::MachOObjectFile &Obj)
+  MachOLinkGraphBuilder_arm64(const object::MachOObjectFile &Obj,
+                              LinkGraph::FeatureVector Features)
       : MachOLinkGraphBuilder(Obj, Triple("arm64-apple-darwin"),
-                              aarch64::getEdgeKindName),
+                              std::move(Features), aarch64::getEdgeKindName),
         NumSymbols(Obj.getSymtabLoadCommand().nsyms) {}
 
 private:
   enum MachOARM64RelocationKind : Edge::Kind {
     MachOBranch26 = Edge::FirstRelocation,
     MachOPointer32,
     MachOPointer64,
     MachOPointer64Anon,
private:
   uint64_t NullValue = 0;
 };
 
 Expected<std::unique_ptr<LinkGraph>>
 createLinkGraphFromMachOObject_arm64(MemoryBufferRef ObjectBuffer) {
   auto MachOObj = object::ObjectFile::createMachOObjectFile(ObjectBuffer);
   if (!MachOObj)
     return MachOObj.takeError();
-  return MachOLinkGraphBuilder_arm64(**MachOObj).buildGraph();
+
+  auto Features = (*MachOObj)->getFeatures();
+  if (!Features)
+    return Features.takeError();
+
+  return MachOLinkGraphBuilder_arm64(**MachOObj, Features->getFeatures())
+      .buildGraph();
 }
 
 void link_MachO_arm64(std::unique_ptr<LinkGraph> G,
                       std::unique_ptr<JITLinkContext> Ctx) {
 
   PassConfiguration Config;
 
   if (Ctx->shouldAddDefaultTargetPasses(G->getTargetTriple())) {

llvm/lib/ExecutionEngine/JITLink/MachO_x86_64.cpp

 
 using namespace llvm;
 using namespace llvm::jitlink;
 
 namespace {
 
 class MachOLinkGraphBuilder_x86_64 : public MachOLinkGraphBuilder {
 public:
-  MachOLinkGraphBuilder_x86_64(const object::MachOObjectFile &Obj)
+  MachOLinkGraphBuilder_x86_64(const object::MachOObjectFile &Obj,
+                               LinkGraph::FeatureVector Features)
       : MachOLinkGraphBuilder(Obj, Triple("x86_64-apple-darwin"),
-                              x86_64::getEdgeKindName) {}
+                              std::move(Features), x86_64::getEdgeKindName) {}
 
 private:
   enum MachONormalizedRelocationType : unsigned {
     MachOBranch32,
     MachOPointer32,
     MachOPointer64,
     MachOPointer64Anon,
     MachOPCRel32,
private:
   }
 };
 
 Expected<std::unique_ptr<LinkGraph>>
 createLinkGraphFromMachOObject_x86_64(MemoryBufferRef ObjectBuffer) {
   auto MachOObj = object::ObjectFile::createMachOObjectFile(ObjectBuffer);
   if (!MachOObj)
     return MachOObj.takeError();
-  return MachOLinkGraphBuilder_x86_64(**MachOObj).buildGraph();
+
+  auto Features = (*MachOObj)->getFeatures();
+  if (!Features)
+    return Features.takeError();
+
+  return MachOLinkGraphBuilder_x86_64(**MachOObj, Features->getFeatures())
+      .buildGraph();
 }
 
 void link_MachO_x86_64(std::unique_ptr<LinkGraph> G,
                        std::unique_ptr<JITLinkContext> Ctx) {
 
   PassConfiguration Config;
 
   if (Ctx->shouldAddDefaultTargetPasses(G->getTargetTriple())) {