[JITLink] Use SubtargetFeatures to store features in LinkGraph

[jobnoorman]

Summary

D149522 introduced target features to LinkGraph. However, to avoid a
public dependency on MC, the features were stored in a std::vector
instead of using SubtargetFeatures directly.

Since SubtargetFeatures was moved from MC to TargetParser (D150549), we
can now use it directly to store the features. This patch implements
that and removes the (private) dependency on MC.

[lhames]

LGTM. Thanks very much @jobnoorman!

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

 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/BinaryStreamWriter.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/TargetParser/SubtargetFeature.h"
 #include "llvm/TargetParser/Triple.h"
 #include <optional>
 
 #include <map>
 #include <string>
 #include <system_error>
 
 namespace llvm {
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,
+  LinkGraph(std::string Name, const Triple &TT, SubtargetFeatures 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)
-      : LinkGraph(std::move(Name), TT, FeatureVector(), PointerSize, Endianness,
-                  GetEdgeKindName) {}
+      : LinkGraph(std::move(Name), TT, SubtargetFeatures(), 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; }
+  const SubtargetFeatures &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;
+  SubtargetFeatures 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,
+                       SubtargetFeatures 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

 namespace jitlink {
 
 static Triple createTripleWithCOFFFormat(Triple T) {
   T.setObjectFormat(Triple::COFF);
   return T;
 }
 
 COFFLinkGraphBuilder::COFFLinkGraphBuilder(
-    const object::COFFObjectFile &Obj, Triple TT,
-    LinkGraph::FeatureVector Features,
+    const object::COFFObjectFile &Obj, Triple TT, SubtargetFeatures Features,
     LinkGraph::GetEdgeKindNameFunction 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";

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,
-                              const LinkGraph::FeatureVector Features)
+                              const SubtargetFeatures 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) {
createLinkGraphFromCOFFObject_x86_64(MemoryBufferRef ObjectBuffer) {
   if (!COFFObj)
     return COFFObj.takeError();
 
   auto Features = (*COFFObj)->getFeatures();
   if (!Features)
     return Features.takeError();
 
   return COFFLinkGraphBuilder_x86_64(**COFFObj, (*COFFObj)->makeTriple(),
-                                     Features->getFeatures())
+                                     std::move(*Features))
       .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,
-                      LinkGraph::FeatureVector Features, StringRef FileName,
+                      SubtargetFeatures 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, LinkGraph::FeatureVector Features,
+    const ELFFile &Obj, Triple TT, SubtargetFeatures Features,
     StringRef FileName, LinkGraph::GetEdgeKindNameFunction GetEdgeKindName)
     : ELFLinkGraphBuilderBase(std::make_unique<LinkGraph>(
           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 << "\""; });

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,
+                              SubtargetFeatures Features,
                               aarch32::ArmConfig ArmCfg)
       : 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) {
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, Features->getFeatures(),
+               (*ELFObj)->getFileName(), ELFFile, TT, std::move(*Features),
                ArmCfg)
         .buildGraph();
   }
   case Triple::armeb:
   case Triple::thumbeb: {
     auto &ELFFile = cast<ELFObjectFile<ELF32BE>>(**ELFObj).getELFFile();
     return ELFLinkGraphBuilder_aarch32<support::big>(
-               (*ELFObj)->getFileName(), ELFFile, TT, Features->getFeatures(),
+               (*ELFObj)->getFileName(), ELFFile, TT, std::move(*Features),
                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

const char *getELFAArch64RelocationKindName(Edge::Kind R) {
     default:
       return getGenericEdgeKindName(static_cast<Edge::Kind>(R));
     }
   }
 
 public:
   ELFLinkGraphBuilder_aarch64(StringRef FileName,
                               const object::ELFFile<ELFT> &Obj, Triple TT,
-                              LinkGraph::FeatureVector Features)
+                              SubtargetFeatures 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:
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(), Features->getFeatures())
+             (*ELFObj)->makeTriple(), std::move(*Features))
       .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, LinkGraph::FeatureVector Features)
+                           Triple TT, SubtargetFeatures 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 "
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(), Features->getFeatures())
+             (*ELFObj)->makeTriple(), std::move(*Features))
       .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,
-                                LinkGraph::FeatureVector Features)
+                                SubtargetFeatures 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;
createLinkGraphFromELFObject_loongarch(MemoryBufferRef ObjectBuffer) {
   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(), Features->getFeatures())
+               (*ELFObj)->makeTriple(), std::move(*Features))
         .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(), Features->getFeatures())
+             (*ELFObj)->makeTriple(), std::move(*Features))
       .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_ppc64.cpp

Error addSingleRelocation(const typename ELFT::Rela &Rel,
     return make_error<JITLinkError>(
         "In " + G->getName() + ": Unsupported ppc64 relocation type " +
         object::getELFRelocationTypeName(ELF::EM_PPC64, ELFReloc));
   }
 
 public:
   ELFLinkGraphBuilder_ppc64(StringRef FileName,
                             const object::ELFFile<ELFT> &Obj, Triple TT,
-                            LinkGraph::FeatureVector Features)
+                            SubtargetFeatures Features)
       : ELFLinkGraphBuilder<ELFT>(Obj, std::move(TT), std::move(Features),
                                   FileName, ppc64::getEdgeKindName) {}
 };
 
 template <support::endianness Endianness>
 class ELFJITLinker_ppc64 : public JITLinker<ELFJITLinker_ppc64<Endianness>> {
   using JITLinkerBase = JITLinker<ELFJITLinker_ppc64<Endianness>>;
   friend JITLinkerBase;
createLinkGraphFromELFObject_ppc64(MemoryBufferRef ObjectBuffer) {
   auto Features = (*ELFObj)->getFeatures();
   if (!Features)
     return Features.takeError();
 
   using ELFT = object::ELFType<Endianness, true>;
   auto &ELFObjFile = cast<object::ELFObjectFile<ELFT>>(**ELFObj);
   return ELFLinkGraphBuilder_ppc64<Endianness>(
              (*ELFObj)->getFileName(), ELFObjFile.getELFFile(),
-             (*ELFObj)->makeTriple(), Features->getFeatures())
+             (*ELFObj)->makeTriple(), std::move(*Features))
       .buildGraph();
 }
 
 template <support::endianness Endianness>
 void link_ELF_ppc64(std::unique_ptr<LinkGraph> G,
                     std::unique_ptr<JITLinkContext> Ctx) {
   PassConfiguration Config;
 

llvm/lib/ExecutionEngine/JITLink/ELF_riscv.cpp

static bool isRelaxable(const Edge &E) {
   case AlignRelaxable:
     return true;
   }
 }
 
 static RelaxAux initRelaxAux(LinkGraph &G) {
   RelaxAux Aux;
   Aux.Config.IsRV32 = G.getTargetTriple().isRISCV32();
-  const auto &Features = G.getFeatures();
+  const auto &Features = G.getFeatures().getFeatures();
   Aux.Config.HasRVC =
       std::find(Features.begin(), Features.end(), "+c") != Features.end();
 
   for (auto &S : G.sections()) {
     if (!shouldRelax(S))
       continue;
     for (auto *B : S.blocks()) {
       auto BlockEmplaceResult = Aux.Blocks.try_emplace(B);
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,
-                            LinkGraph::FeatureVector Features)
+                            SubtargetFeatures 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(), Features->getFeatures())
+               (*ELFObj)->makeTriple(), std::move(*Features))
         .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(), Features->getFeatures())
+               (*ELFObj)->makeTriple(), std::move(*Features))
         .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,
-                             LinkGraph::FeatureVector Features)
+                             SubtargetFeatures 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>;
 
createLinkGraphFromELFObject_x86_64(MemoryBufferRef ObjectBuffer) {
 
   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(),
-                                    Features->getFeatures())
+                                    std::move(*Features))
       .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,
+                        SubtargetFeatures 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,
+    const object::MachOObjectFile &Obj, Triple TT, SubtargetFeatures Features,
     LinkGraph::GetEdgeKindNameFunction GetEdgeKindName)
     : Obj(Obj),
       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;

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,
-                              LinkGraph::FeatureVector Features)
+                              SubtargetFeatures Features)
       : MachOLinkGraphBuilder(Obj, Triple("arm64-apple-darwin"),
                               std::move(Features), aarch64::getEdgeKindName),
         NumSymbols(Obj.getSymtabLoadCommand().nsyms) {}
 
 private:
   enum MachOARM64RelocationKind : Edge::Kind {
     MachOBranch26 = Edge::FirstRelocation,
     MachOPointer32,
createLinkGraphFromMachOObject_arm64(MemoryBufferRef ObjectBuffer) {
   auto MachOObj = object::ObjectFile::createMachOObjectFile(ObjectBuffer);
   if (!MachOObj)
     return MachOObj.takeError();
 
   auto Features = (*MachOObj)->getFeatures();
   if (!Features)
     return Features.takeError();
 
-  return MachOLinkGraphBuilder_arm64(**MachOObj, Features->getFeatures())
+  return MachOLinkGraphBuilder_arm64(**MachOObj, std::move(*Features))
       .buildGraph();
 }
 
 void link_MachO_arm64(std::unique_ptr<LinkGraph> G,
                       std::unique_ptr<JITLinkContext> Ctx) {
 
   PassConfiguration Config;
 

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,
-                               LinkGraph::FeatureVector Features)
+                               SubtargetFeatures Features)
       : MachOLinkGraphBuilder(Obj, Triple("x86_64-apple-darwin"),
                               std::move(Features), x86_64::getEdgeKindName) {}
 
 private:
   enum MachONormalizedRelocationType : unsigned {
     MachOBranch32,
     MachOPointer32,
     MachOPointer64,
createLinkGraphFromMachOObject_x86_64(MemoryBufferRef ObjectBuffer) {
   auto MachOObj = object::ObjectFile::createMachOObjectFile(ObjectBuffer);
   if (!MachOObj)
     return MachOObj.takeError();
 
   auto Features = (*MachOObj)->getFeatures();
   if (!Features)
     return Features.takeError();
 
-  return MachOLinkGraphBuilder_x86_64(**MachOObj, Features->getFeatures())
+  return MachOLinkGraphBuilder_x86_64(**MachOObj, std::move(*Features))
       .buildGraph();
 }
 
 void link_MachO_x86_64(std::unique_ptr<LinkGraph> G,
                        std::unique_ptr<JITLinkContext> Ctx) {
 
   PassConfiguration Config;