[jitlink/rtdydl][checker] Add TargetFlag dependent disassembler switching support

[Eymay]

Summary

Some targets such as AArch32 make use of TargetFlags to indicate ISA mode. Depending
on the TargetFlag, MCDisassembler and similar target specific objects should be
reinitialized with the correct Target Triple. Backends with similar needs can
easily extend this implementation for their usecase.

The drivers llvm-rtdyld and llvm-jitlink have their SymbolInfo's extended to take
TargetFlag into account. RuntimeDyldChecker can now create necessary TargetInfo
to reinitialize MCDisassembler and MCInstPrinter. The required triple is obtained
from the new getTripleFromTargetFlag function by checking the TargetFlag.

In addition, breaking changes for RuntimeDyld COFF Thumb tests are fixed by making
the backend emit a TargetFlag.

[Eymay]

This patch needs refactoring in areas such as error handling, backend specialization structure for triple manipulation and state management for triple change.

[lhames]

What if you made RuntimeDyldChecker::getInstPrinter and RuntimeDyld::getDisasssembler take a symbol, then check the target flags in each of those methods so that the callees reduce back to, e.g.

auto Dis = Checker.getDisassembler(Symbol); // TT and TF taken from Checker member variables.

if (auto E = Dis.takeError()) {
  errs() << "Error obtaining disassembler: " << toString(std::move(E))
         << "\n";
  return false; // Return false or take appropriate action.
}

llvm/include/llvm/ExecutionEngine/RuntimeDyldChecker.h

138

What about a getTargetFlags method, and let the client do the bitwise ops?

[Eymay]

• Moved TargetFlag checking into getDisassembler
• Introduced getTripleFromTargetFlag for backend specialization
• Replaced hasTargetFlag with getTargetFlag

[Eymay]

In D158280#4599171, @lhames wrote:

What if you made RuntimeDyldChecker::getInstPrinter and RuntimeDyld::getDisasssembler take a symbol, then check the target flags in each of those methods so that the callees reduce back to, e.g.

auto Dis = Checker.getDisassembler(Symbol); // TT and TF taken from Checker member variables.

if (auto E = Dis.takeError()) {
  errs() << "Error obtaining disassembler: " << toString(std::move(E))
         << "\n";
  return false; // Return false or take appropriate action.
}

Thanks for the feedback! It makes sense, moved handling into the getters. Also added getTripleFromTargetFlag function. Now, targets can handle their TargetFlag--Triple mappings inside there.

[lhames]

Minor comments aside this is looking great. Once these are fixed I think that this is ready to land.

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

625–627

This can be removed now that getTargetFlags has been added.

llvm/include/llvm/ExecutionEngine/RuntimeDyldChecker.h

85–90

This constructor should be removed so that clients are forced to specify a flags value explicitly, even if it's just the default.

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp

876–877

This assertion should be removed: 0x1 is only the thumb flag for arm, not other architectures.

[Eymay]

• removed hasTargetFlags and updated its calls in aarch32 jitlink
• removed MemoryRegionInfo constructor without the TargetFlag field
• removed irrelevant assert

[Eymay]

Currently RuntimeDyld/ARM/COFF_Thumb.s fails due to not finding TargetFlag set to Thumb Flag in SymInfo. I'm still investigating the issue.

[Eymay]

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp

931

TODO Added a tri-state for easier debugging, should be removed in the end

944

Somehow this didn't fail but having the same consecutive flag should be failing it. This trickery was done to protect version numbers:

For example armv7-... should not become thumb-.. but instead thumbv7-... I'm a little surprised to not find an API for this case

[Eymay]

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp

890

Maybe getDisassembler and getInstrPrinter could share code for MRI and MAI?

[lhames]

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp

890

Looks like MCContext doesn't take ownership -- we're probably leaking them at the moment.

I don't think I'd worry about sharing them (at least not yet -- we could do it as an optimization later). For now I'd be inclined to add a struct to hold on to the MRI and MAI (and any other types that aren't owned) alongside the disassembler / inst-printer.

[Eymay]

Added getJITSymbolFlags to COFF Thumb RuntimeDyld backend to emit Thumb TargetFlag. Fixed a bug in RuntimeDyld/ARM/COFF_Thumb.s.
Added checks to triple switching arm<->thumb into getTripleFromTargetFlag in RuntimDyldChecker.

[Eymay]

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp

944

checks added for consecutive same triple scenario

[Eymay]

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp

325

Is there a way we could try alternative triples when there is a fail? The reason is if somehow TargetFlag emission has a problem, the triple is wrong and MCDisassembler fails terribly. How should the error be handled in RuntimeDyld setting?

[lhames]

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp

325

What would cause TargetFlag emission to be incorrect? Are you worried that we're missing cases in RuntimeDyld?

If we can fix those cases without too much trouble we should. If it's too tricky to fix RuntimeDyld I'd be ok with adding some special-case logic to the checker specifically for arm / thumb: if arm fails try thumb and vice-versa. We should add a fixme to remove this as soon as RuntimeDyld is gone. It might also be good to put the hack behind a mode flag that we set when the checker is created. If we're in "RuntimeDyldMode" then we try the triple swap, if we're in JITLink we don't. This would prevent us from silently masking errors in JITLink.

[Eymay]

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp

325

I've fixed the issue with RuntimeDyld, MachO emits TargetFlag correctly and I added a fix for COFF. The issue is rather about more informative error messages. I suggest in case of failure the instPrinter can try alternative TargetFlag and give diagnostic about the decoded instruction together with an error message of TargetFlag setting.

[sgraenitz]

Sorry for being late at the party. I was too busy in the last weeks to approach non-trivial reviews. This is looking really good already. Thanks for your help @lhames!!
Here are my 2 cents. Unfortunately, I cannot make inline comments anymore.. might be due to the move from Pharicator to GitHub PRs. I will do my best to keep this readable.

---

Eymay wrote:
Maybe getDisassembler and getInstrPrinter could share code for MRI and MAI?

lhames wrote:
Looks like MCContext doesn't take ownership -- we're probably leaking them at the moment.
I don't think I'd worry about sharing them (at least not yet -- we could do it as an optimization later). For now I'd be inclined to add a struct to hold on to the MRI and MAI (and any other types that aren't owned) alongside the disassembler / inst-printer.

Agree with @lhames: The code sharing is optional, be we must prevent STI, MRI, MAI and Ctx from getting destroyed once their unique_ptrs go out of scope, because Disassembler only takes raw pointers and no ownership. (Same for getInstPrinter with MRI, MAI, MII and InstPrinter). I see two options:
(1) Define a struct with fields for each of them (plus the Disassembler/InstPrinter itself) and return that. This is what Lang was saying.
(2) Inline the code into the calling functions.

I think (1) is clean but adds more effort. (2) is easier, but it would impact the readability of the evalDecodeOperand function significantly. You could consider to outline the respective error reporting code from evalDecodeOperand (from auto InstPrinter to return std::make_pair([...])) and put the getInstrPrinter code in there. I don't see a problem putting the getDisassembler code directly into decodeInst.

---

In RuntimeDyldChecker is there a good reason to have these members them as references? Otherwise let's store them as values, pass them to the ctor by value and forward with std::move.

Triple &TT;
SubtargetFeatures &TF;

---

Eymay wrote:
I suggest in case of failure the instPrinter can try alternative TargetFlag and give diagnostic about the decoded instruction together with an error message of TargetFlag setting.

If that adds significant complexity, then why not keep it as a potential future follow-up? I think the scope of this patch is good as it is now.

[Eymay]

TargetInfo passing is made safer by passing struct. TT and TF are converted to value members rather than references. Minimised boilerplate.

[sgraenitz]

Thanks for the fixes. This looks good to me! I assume all affected tests still pass. So, let's get this landed.

[Eymay]

New commit description

[TWeaver]

Hello and good morning from the UK!

It seems as though this patch has caused test failures on the following buildbots:

https://lab.llvm.org/buildbot/#/builders/230/builds/18341
https://lab.llvm.org/buildbot/#/builders/109/builds/73169
https://lab.llvm.org/buildbot/#/builders/67/builds/12597

Is anyone able to a take a look?

Much obliged,
Tom W

[TWeaver]

My apologies but I'm going to revert this change until the Author can get a good look at the build bot failures.

[Eymay]

Fixed buildbot failures by adding missing plumbing for Subtarget Features and CPU string

[Eymay]

Hi @TWeaver, thanks for reverting. I don't have commit access yet so I appreciate it.

[Eymay]

Closed by commit rG9c017a99d570: [jitlink][rtdyld][checker] Re-apply 4b17c81d5a5 with fixes..

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

public:
   /// Set the visibility for this Symbol.
   void setScope(Scope S) {
     assert((!Name.empty() || S == Scope::Local) &&
            "Can not set anonymous symbol to non-local scope");
     assert((S != Scope::Local || Base->isDefined() || Base->isAbsolute()) &&
            "Invalid visibility for symbol type");
     this->S = static_cast<uint8_t>(S);
   }
 
-  /// Check whether the given target flags are set for this Symbol.
-  bool hasTargetFlags(TargetFlagsType Flags) const {
-    return static_cast<TargetFlagsType>(TargetFlags) & Flags;
-  }
+  /// Get the target flags of this Symbol.
+  TargetFlagsType getTargetFlags() const { return TargetFlags; }
 
   /// Set the target flags for this Symbol.
   void setTargetFlags(TargetFlagsType Flags) {
     assert(Flags <= 1 && "Add more bits to store more than single flag");
     TargetFlags = Flags;
   }
 
   /// Returns true if this is a weakly referenced external symbol.

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

 #include "llvm/ExecutionEngine/Orc/Shared/ExecutorAddress.h"
 #include "llvm/Support/ARMBuildAttributes.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace jitlink {
 namespace aarch32 {
 
+/// Check whether the given target flags are set for this Symbol.
+bool hasTargetFlags(Symbol &Sym, TargetFlagsType Flags);
+
 /// JITLink-internal AArch32 fixup kinds
 enum EdgeKind_aarch32 : Edge::Kind {
 
   ///
   /// Relocations of class Data respect target endianness (unless otherwise
   /// specified)
   ///
   FirstDataRelocation = Edge::FirstRelocation,

llvm/include/llvm/ExecutionEngine/RuntimeDyldChecker.h

 //===---- RuntimeDyldChecker.h - RuntimeDyld tester framework -----*- C++ -*-=//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_EXECUTIONENGINE_RUNTIMEDYLDCHECKER_H
 #define LLVM_EXECUTIONENGINE_RUNTIMEDYLDCHECKER_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
 #include "llvm/Support/Endian.h"
+#include "llvm/TargetParser/SubtargetFeature.h"
+#include "llvm/TargetParser/Triple.h"
 #include <optional>
 
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <utility>
 
 namespace llvm {
 
 class StringRef;
 class MCDisassembler;
 class MemoryBuffer;
 class MCInstPrinter;
 class RuntimeDyld;
 class RuntimeDyldCheckerImpl;
 class raw_ostream;
 
+/// Holds target-specific properties for a symbol.
+using TargetFlagsType = uint8_t;
+
 /// RuntimeDyld invariant checker for verifying that RuntimeDyld has
 ///        correctly applied relocations.
 ///
 /// The RuntimeDyldChecker class evaluates expressions against an attached
 /// RuntimeDyld instance to verify that relocations have been applied
 /// correctly.
 ///
 /// The expression language supports basic pointer arithmetic and bit-masking,

 ///             | expr '<<' expr
 ///             | expr '>>' expr
 ///
 class RuntimeDyldChecker {
 public:
   class MemoryRegionInfo {
   public:
     MemoryRegionInfo() = default;
 
-    /// Constructor for symbols/sections with content.
-    MemoryRegionInfo(ArrayRef<char> Content, JITTargetAddress TargetAddress)
+    /// Constructor for symbols/sections with content and TargetFlag.
+    MemoryRegionInfo(ArrayRef<char> Content, JITTargetAddress TargetAddress,
+                     TargetFlagsType TargetFlags)
         : ContentPtr(Content.data()), Size(Content.size()),
-          TargetAddress(TargetAddress) {}
+          TargetAddress(TargetAddress), TargetFlags(TargetFlags) {}
 
     /// Constructor for zero-fill symbols/sections.
     MemoryRegionInfo(uint64_t Size, JITTargetAddress TargetAddress)
         : Size(Size), TargetAddress(TargetAddress) {}
 
     /// Returns true if this is a zero-fill symbol/section.
     bool isZeroFill() const {
       assert(Size && "setContent/setZeroFill must be called first");
public:
     void setTargetAddress(JITTargetAddress TargetAddress) {
       assert(!this->TargetAddress && "TargetAddress already set");
       this->TargetAddress = TargetAddress;
     }
 
     /// Return the target address for this region.
     JITTargetAddress getTargetAddress() const { return TargetAddress; }
 
+    /// Get the target flags for this Symbol.
+    TargetFlagsType getTargetFlags() const { return TargetFlags; }
+
+    /// Set the target flags for this Symbol.
+    void setTargetFlags(TargetFlagsType Flags) {
+      assert(Flags <= 1 && "Add more bits to store more than one flag");
+      TargetFlags = Flags;
+    }
+
   private:
     const char *ContentPtr = nullptr;
     uint64_t Size = 0;
     JITTargetAddress TargetAddress = 0;
+    TargetFlagsType TargetFlags = 0;
   };
 
   using IsSymbolValidFunction = std::function<bool(StringRef Symbol)>;
   using GetSymbolInfoFunction =
       std::function<Expected<MemoryRegionInfo>(StringRef SymbolName)>;
   using GetSectionInfoFunction = std::function<Expected<MemoryRegionInfo>(
       StringRef FileName, StringRef SectionName)>;
   using GetStubInfoFunction = std::function<Expected<MemoryRegionInfo>(
       StringRef StubContainer, StringRef TargetName)>;
   using GetGOTInfoFunction = std::function<Expected<MemoryRegionInfo>(
       StringRef GOTContainer, StringRef TargetName)>;
 
   RuntimeDyldChecker(IsSymbolValidFunction IsSymbolValid,
                      GetSymbolInfoFunction GetSymbolInfo,
                      GetSectionInfoFunction GetSectionInfo,
                      GetStubInfoFunction GetStubInfo,
                      GetGOTInfoFunction GetGOTInfo,
-                     support::endianness Endianness,
-                     MCDisassembler *Disassembler, MCInstPrinter *InstPrinter,
-                     raw_ostream &ErrStream);
+                     support::endianness Endianness, Triple TT, StringRef CPU,
+                     SubtargetFeatures TF, raw_ostream &ErrStream);
   ~RuntimeDyldChecker();
 
   /// Check a single expression against the attached RuntimeDyld
   ///        instance.
   bool check(StringRef CheckExpr) const;
 
   /// Scan the given memory buffer for lines beginning with the string
   ///        in RulePrefix. The remainder of the line is passed to the check

llvm/lib/ExecutionEngine/JITLink/aarch32.cpp

 #include "llvm/Support/MathExtras.h"
 
 #define DEBUG_TYPE "jitlink"
 
 namespace llvm {
 namespace jitlink {
 namespace aarch32 {
 
+/// Check whether the given target flags are set for this Symbol.
+bool hasTargetFlags(Symbol &Sym, TargetFlagsType Flags) {
+  return static_cast<TargetFlagsType>(Sym.getTargetFlags()) & Flags;
+}
+
 /// Encode 22-bit immediate value for branch instructions without J1J2 range
 /// extension (formats B T4, BL T1 and BLX T2).
 ///
 ///   00000:Imm11H:Imm11L:0 -> [ 00000:Imm11H, 00000:Imm11L ]
 ///                                            J1^ ^J2 will always be 1
 ///
 HalfWords encodeImmBT4BlT1BlxT2(int64_t Value) {
   constexpr uint32_t J1J2 = 0x2800;
else
       endian::write32<big>(FixupPtr, Imm);
   };
 
   Edge::Kind Kind = E.getKind();
   uint64_t FixupAddress = (B.getAddress() + E.getOffset()).getValue();
   int64_t Addend = E.getAddend();
   Symbol &TargetSymbol = E.getTarget();
   uint64_t TargetAddress = TargetSymbol.getAddress().getValue();
-  assert(!TargetSymbol.hasTargetFlags(ThumbSymbol));
+  assert(!hasTargetFlags(TargetSymbol, ThumbSymbol));
 
   // Regular data relocations have size 4, alignment 1 and write the full 32-bit
   // result to the place; no need for overflow checking. There are three
   // exceptions: R_ARM_ABS8, R_ARM_ABS16, R_ARM_PREL31
   switch (Kind) {
   case Data_Delta32: {
     int64_t Value = TargetAddress - FixupAddress + Addend;
     if (!isInt<32>(Value))
Error applyFixupThumb(LinkGraph &G, Block &B, const Edge &E,
   WritableThumbRelocation R(B.getAlreadyMutableContent().data() +
                             E.getOffset());
 
   Edge::Kind Kind = E.getKind();
   uint64_t FixupAddress = (B.getAddress() + E.getOffset()).getValue();
   int64_t Addend = E.getAddend();
   Symbol &TargetSymbol = E.getTarget();
   uint64_t TargetAddress = TargetSymbol.getAddress().getValue();
-  if (TargetSymbol.hasTargetFlags(ThumbSymbol))
+  if (hasTargetFlags(TargetSymbol, ThumbSymbol))
     TargetAddress |= 0x01;
 
   switch (Kind) {
   case Thumb_Jump24: {
     if (!checkOpcode<Thumb_Jump24>(R))
       return makeUnexpectedOpcodeError(G, R, Kind);
-    if (!(TargetSymbol.hasTargetFlags(ThumbSymbol)))
+    if (!hasTargetFlags(TargetSymbol, ThumbSymbol))
       return make_error<JITLinkError>("Branch relocation needs interworking "
                                       "stub when bridging to ARM: " +
                                       StringRef(G.getEdgeKindName(Kind)));
 
     int64_t Value = TargetAddress - FixupAddress + Addend;
     if (LLVM_LIKELY(ArmCfg.J1J2BranchEncoding)) {
       if (!isInt<25>(Value))
         return makeTargetOutOfRangeError(G, B, E);
Error applyFixupThumb(LinkGraph &G, Block &B, const Edge &E,
   case Thumb_Call: {
     if (!checkOpcode<Thumb_Call>(R))
       return makeUnexpectedOpcodeError(G, R, Kind);
 
     int64_t Value = TargetAddress - FixupAddress + Addend;
 
     // The call instruction itself is Thumb. The call destination can either be
     // Thumb or Arm. We use BL to stay in Thumb and BLX to change to Arm.
-    bool TargetIsArm = !TargetSymbol.hasTargetFlags(ThumbSymbol);
+    bool TargetIsArm = !hasTargetFlags(TargetSymbol, ThumbSymbol);
     bool InstrIsBlx = (R.Lo & FixupInfo<Thumb_Call>::LoBitNoBlx) == 0;
     if (TargetIsArm != InstrIsBlx) {
       if (LLVM_LIKELY(TargetIsArm)) {
         // Change opcode BL -> BLX and fix range value (account for 4-byte
         // aligned destination while instruction may only be 2-byte aligned
         // and clear Thumb bit).
         R.Lo = R.Lo & ~FixupInfo<Thumb_Call>::LoBitNoBlx;
         R.Lo = R.Lo & ~FixupInfo<Thumb_Call>::LoBitH;

llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp

 }
 
 ExecutorAddr getJITSymbolPtrForSymbol(Symbol &Sym, const Triple &TT) {
   switch (TT.getArch()) {
   case Triple::arm:
   case Triple::armeb:
   case Triple::thumb:
   case Triple::thumbeb:
-    if (Sym.hasTargetFlags(aarch32::ThumbSymbol)) {
+    if (hasTargetFlags(Sym, aarch32::ThumbSymbol)) {
       // Set LSB to indicate thumb target
       assert(Sym.isCallable() && "Only callable symbols can have thumb flag");
       assert((Sym.getAddress().getValue() & 0x01) == 0 && "LSB is clear");
       return Sym.getAddress() + 0x01;
     }
     return Sym.getAddress();
   default:
     return Sym.getAddress();

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp

 //===--- RuntimeDyldChecker.cpp - RuntimeDyld tester framework --*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ExecutionEngine/RuntimeDyldChecker.h"
 #include "RuntimeDyldCheckerImpl.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCInst.h"
+#include "llvm/MC/MCInstPrinter.h"
+#include "llvm/MC/MCInstrInfo.h"
+#include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/MC/MCTargetOptions.h"
+#include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/MSVCErrorWorkarounds.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include <cctype>
 #include <memory>
 #include <utility>
 
 #define DEBUG_TYPE "rtdyld"
 
 using namespace llvm;
 
+namespace {
+struct TargetInfo {
+  const Target *TheTarget;
+  std::unique_ptr<MCSubtargetInfo> STI;
+  std::unique_ptr<MCRegisterInfo> MRI;
+  std::unique_ptr<MCAsmInfo> MAI;
+  std::unique_ptr<MCContext> Ctx;
+  std::unique_ptr<MCDisassembler> Disassembler;
+  std::unique_ptr<MCInstrInfo> MII;
+  std::unique_ptr<MCInstPrinter> InstPrinter;
+};
+} // anonymous namespace
+
 namespace llvm {
 
 // Helper class that implements the language evaluated by RuntimeDyldChecker.
 class RuntimeDyldCheckerExprEval {
 public:
   RuntimeDyldCheckerExprEval(const RuntimeDyldCheckerImpl &Checker,
                              raw_ostream &ErrStream)
       : Checker(Checker) {}
std::pair<EvalResult, StringRef> evalDecodeOperand(StringRef Expr) const {
     MCInst Inst;
     uint64_t Size;
     if (!decodeInst(Symbol, Inst, Size, Offset))
       return std::make_pair(
           EvalResult(("Couldn't decode instruction at '" + Symbol + "'").str()),
           "");
 
     unsigned OpIdx = OpIdxExpr.getValue();
+
+    auto printInst = [this](StringRef Symbol, MCInst Inst,
+                            raw_string_ostream &ErrMsgStream) {
+      auto TT = Checker.getTriplefromTargetFlag(Checker.getTargetFlag(Symbol));
+      auto TI = getTargetInfo(TT, Checker.getCPU(), Checker.getFeatures());
+      if (auto E = TI.takeError()) {
+        errs() << "Error obtaining instruction printer: "
+               << toString(std::move(E)) << "\n";
+        return std::make_pair(EvalResult(ErrMsgStream.str()), "");
+      }
+      Inst.dump_pretty(ErrMsgStream, TI->InstPrinter.get());
+      return std::make_pair(EvalResult(ErrMsgStream.str()), "");
+    };
+
     if (OpIdx >= Inst.getNumOperands()) {
       std::string ErrMsg;
       raw_string_ostream ErrMsgStream(ErrMsg);
       ErrMsgStream << "Invalid operand index '" << format("%i", OpIdx)
                    << "' for instruction '" << Symbol
                    << "'. Instruction has only "
                    << format("%i", Inst.getNumOperands())
                    << " operands.\nInstruction is:\n  ";
-      Inst.dump_pretty(ErrMsgStream, Checker.InstPrinter);
-      return std::make_pair(EvalResult(ErrMsgStream.str()), "");
+
+      return printInst(Symbol, Inst, ErrMsgStream);
     }
 
     const MCOperand &Op = Inst.getOperand(OpIdx);
     if (!Op.isImm()) {
       std::string ErrMsg;
       raw_string_ostream ErrMsgStream(ErrMsg);
       ErrMsgStream << "Operand '" << format("%i", OpIdx) << "' of instruction '"
                    << Symbol << "' is not an immediate.\nInstruction is:\n  ";
-      Inst.dump_pretty(ErrMsgStream, Checker.InstPrinter);
 
-      return std::make_pair(EvalResult(ErrMsgStream.str()), "");
+      return printInst(Symbol, Inst, ErrMsgStream);
     }
 
     return std::make_pair(EvalResult(Op.getImm()), RemainingExpr);
   }
 
   // Evaluate a call to next_pc.
   // Decode the instruction at the given symbol and return the following program
   // counter.
evalComplexExpr(const std::pair<EvalResult, StringRef> &LHSAndRemaining,
     // complex expr.
     EvalResult ThisResult(computeBinOpResult(BinOp, LHSResult, RHSResult));
 
     return evalComplexExpr(std::make_pair(ThisResult, RemainingExpr), PCtx);
   }
 
   bool decodeInst(StringRef Symbol, MCInst &Inst, uint64_t &Size,
                   int64_t Offset) const {
-    MCDisassembler *Dis = Checker.Disassembler;
+    auto TT = Checker.getTriplefromTargetFlag(Checker.getTargetFlag(Symbol));
+    auto TI = getTargetInfo(TT, Checker.getCPU(), Checker.getFeatures());
+
+    if (auto E = TI.takeError()) {
+      errs() << "Error obtaining disassembler: " << toString(std::move(E))
+             << "\n";
+      return false;
+    }
+
     StringRef SymbolMem = Checker.getSymbolContent(Symbol);
     ArrayRef<uint8_t> SymbolBytes(SymbolMem.bytes_begin() + Offset,
                                   SymbolMem.size() - Offset);
 
     MCDisassembler::DecodeStatus S =
-        Dis->getInstruction(Inst, Size, SymbolBytes, 0, nulls());
+        TI->Disassembler->getInstruction(Inst, Size, SymbolBytes, 0, nulls());
 
     return (S == MCDisassembler::Success);
   }
+
+  Expected<TargetInfo> getTargetInfo(const Triple &TT, const StringRef &CPU,
+                                     const SubtargetFeatures &TF) const {
+
+    auto TripleName = TT.str();
+    std::string ErrorStr;
+    const Target *TheTarget =
+        TargetRegistry::lookupTarget(TripleName, ErrorStr);
+    if (!TheTarget)
+      return make_error<StringError>("Error accessing target '" + TripleName +
+                                         "': " + ErrorStr,
+                                     inconvertibleErrorCode());
+
+    std::unique_ptr<MCSubtargetInfo> STI(
+        TheTarget->createMCSubtargetInfo(TripleName, CPU, TF.getString()));
+    if (!STI)
+      return make_error<StringError>("Unable to create subtarget for " +
+                                         TripleName,
+                                     inconvertibleErrorCode());
+
+    std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName));
+    if (!MRI)
+      return make_error<StringError>("Unable to create target register info "
+                                     "for " +
+                                         TripleName,
+                                     inconvertibleErrorCode());
+
+    MCTargetOptions MCOptions;
+    std::unique_ptr<MCAsmInfo> MAI(
+        TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions));
+    if (!MAI)
+      return make_error<StringError>("Unable to create target asm info " +
+                                         TripleName,
+                                     inconvertibleErrorCode());
+
+    auto Ctx = std::make_unique<MCContext>(Triple(TripleName), MAI.get(),
+                                           MRI.get(), STI.get());
+
+    std::unique_ptr<MCDisassembler> Disassembler(
+        TheTarget->createMCDisassembler(*STI, *Ctx));
+    if (!Disassembler)
+      return make_error<StringError>("Unable to create disassembler for " +
+                                         TripleName,
+                                     inconvertibleErrorCode());
+
+    std::unique_ptr<MCInstrInfo> MII(TheTarget->createMCInstrInfo());
+    if (!MII)
+      return make_error<StringError>("Unable to create instruction info for" +
+                                         TripleName,
+                                     inconvertibleErrorCode());
+
+    std::unique_ptr<MCInstPrinter> InstPrinter(TheTarget->createMCInstPrinter(
+        Triple(TripleName), 0, *MAI, *MII, *MRI));
+    if (!InstPrinter)
+      return make_error<StringError>(
+          "Unable to create instruction printer for" + TripleName,
+          inconvertibleErrorCode());
+
+    return TargetInfo({TheTarget, std::move(STI), std::move(MRI),
+                       std::move(MAI), std::move(Ctx), std::move(Disassembler),
+                       std::move(MII), std::move(InstPrinter)});
+  }
 };
 } // namespace llvm
 
 RuntimeDyldCheckerImpl::RuntimeDyldCheckerImpl(
     IsSymbolValidFunction IsSymbolValid, GetSymbolInfoFunction GetSymbolInfo,
     GetSectionInfoFunction GetSectionInfo, GetStubInfoFunction GetStubInfo,
-    GetGOTInfoFunction GetGOTInfo, support::endianness Endianness,
-    MCDisassembler *Disassembler, MCInstPrinter *InstPrinter,
-    raw_ostream &ErrStream)
+    GetGOTInfoFunction GetGOTInfo, support::endianness Endianness, Triple TT,
+    StringRef CPU, SubtargetFeatures TF, raw_ostream &ErrStream)
     : IsSymbolValid(std::move(IsSymbolValid)),
       GetSymbolInfo(std::move(GetSymbolInfo)),
       GetSectionInfo(std::move(GetSectionInfo)),
       GetStubInfo(std::move(GetStubInfo)), GetGOTInfo(std::move(GetGOTInfo)),
-      Endianness(Endianness), Disassembler(Disassembler),
-      InstPrinter(InstPrinter), ErrStream(ErrStream) {}
+      Endianness(Endianness), TT(std::move(TT)), CPU(std::move(CPU)),
+      TF(std::move(TF)), ErrStream(ErrStream) {}
 
 bool RuntimeDyldCheckerImpl::check(StringRef CheckExpr) const {
   CheckExpr = CheckExpr.trim();
   LLVM_DEBUG(dbgs() << "RuntimeDyldChecker: Checking '" << CheckExpr
                     << "'...\n");
   RuntimeDyldCheckerExprEval P(*this, ErrStream);
   bool Result = P.evaluate(CheckExpr);
   (void)Result;
bool RuntimeDyldCheckerImpl::checkAllRulesInBuffer(StringRef RulePrefix,
   return DidAllTestsPass && (NumRules != 0);
 }
 
 bool RuntimeDyldCheckerImpl::isSymbolValid(StringRef Symbol) const {
   return IsSymbolValid(Symbol);
 }
 
 uint64_t RuntimeDyldCheckerImpl::getSymbolLocalAddr(StringRef Symbol) const {
   auto SymInfo = GetSymbolInfo(Symbol);
   if (!SymInfo) {
     logAllUnhandledErrors(SymInfo.takeError(), errs(), "RTDyldChecker: ");
     return 0;
   }
 
   if (SymInfo->isZeroFill())
     return 0;
 
   return static_cast<uint64_t>(
       reinterpret_cast<uintptr_t>(SymInfo->getContent().data()));
 }
 
 uint64_t RuntimeDyldCheckerImpl::getSymbolRemoteAddr(StringRef Symbol) const {
   auto SymInfo = GetSymbolInfo(Symbol);
   if (!SymInfo) {
     logAllUnhandledErrors(SymInfo.takeError(), errs(), "RTDyldChecker: ");
     return 0;
   }
 
   return SymInfo->getTargetAddress();
 }
 
StringRef RuntimeDyldCheckerImpl::getSymbolContent(StringRef Symbol) const {
   auto SymInfo = GetSymbolInfo(Symbol);
   if (!SymInfo) {
     logAllUnhandledErrors(SymInfo.takeError(), errs(), "RTDyldChecker: ");
     return StringRef();
   }
   return {SymInfo->getContent().data(), SymInfo->getContent().size()};
 }
 
+TargetFlagsType RuntimeDyldCheckerImpl::getTargetFlag(StringRef Symbol) const {
+  auto SymInfo = GetSymbolInfo(Symbol);
+  if (!SymInfo) {
+    logAllUnhandledErrors(SymInfo.takeError(), errs(), "RTDyldChecker: ");
+    return TargetFlagsType{};
+  }
+  return SymInfo->getTargetFlags();
+}
+
+Triple
+RuntimeDyldCheckerImpl::getTriplefromTargetFlag(TargetFlagsType Flag) const {
+  Triple TheTriple = TT;
+
+  switch (TT.getArch()) {
+  case Triple::ArchType::arm:
+    if (~Flag & 0x1)
+      return TT;
+    TheTriple.setArchName((Twine("thumb") + TT.getArchName().substr(3)).str());
+    return TheTriple;
+  case Triple::ArchType::thumb:
+    if (Flag & 0x1)
+      return TT;
+    TheTriple.setArchName((Twine("arm") + TT.getArchName().substr(5)).str());
+    return TheTriple;
+
+  default:
+    return TT;
+  }
+}
+
 std::pair<uint64_t, std::string> RuntimeDyldCheckerImpl::getSectionAddr(
     StringRef FileName, StringRef SectionName, bool IsInsideLoad) const {
 
   auto SecInfo = GetSectionInfo(FileName, SectionName);
   if (!SecInfo) {
     std::string ErrMsg;
     {
       raw_string_ostream ErrMsgStream(ErrMsg);
if (IsInsideLoad) {
     Addr = StubInfo->getTargetAddress();
 
   return std::make_pair(Addr, "");
 }
 
 RuntimeDyldChecker::RuntimeDyldChecker(
     IsSymbolValidFunction IsSymbolValid, GetSymbolInfoFunction GetSymbolInfo,
     GetSectionInfoFunction GetSectionInfo, GetStubInfoFunction GetStubInfo,
-    GetGOTInfoFunction GetGOTInfo, support::endianness Endianness,
-    MCDisassembler *Disassembler, MCInstPrinter *InstPrinter,
-    raw_ostream &ErrStream)
+    GetGOTInfoFunction GetGOTInfo, support::endianness Endianness, Triple TT,
+    StringRef CPU, SubtargetFeatures TF, raw_ostream &ErrStream)
     : Impl(::std::make_unique<RuntimeDyldCheckerImpl>(
           std::move(IsSymbolValid), std::move(GetSymbolInfo),
           std::move(GetSectionInfo), std::move(GetStubInfo),
-          std::move(GetGOTInfo), Endianness, Disassembler, InstPrinter,
-          ErrStream)) {}
+          std::move(GetGOTInfo), Endianness, std::move(TT), std::move(CPU),
+          std::move(TF), ErrStream)) {}
 
 RuntimeDyldChecker::~RuntimeDyldChecker() = default;
 
 bool RuntimeDyldChecker::check(StringRef CheckExpr) const {
   return Impl->check(CheckExpr);
 }
 
 bool RuntimeDyldChecker::checkAllRulesInBuffer(StringRef RulePrefix,

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldCheckerImpl.h

 //===-- RuntimeDyldCheckerImpl.h -- RuntimeDyld test framework --*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_RUNTIMEDYLDCHECKERIMPL_H
 #define LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_RUNTIMEDYLDCHECKERIMPL_H
 
 #include "RuntimeDyldImpl.h"
 
 namespace llvm {
 
+/// Holds target-specific properties for a symbol.
+using TargetFlagsType = uint8_t;
+
 class RuntimeDyldCheckerImpl {
   friend class RuntimeDyldChecker;
   friend class RuntimeDyldCheckerExprEval;
 
   using IsSymbolValidFunction =
     RuntimeDyldChecker::IsSymbolValidFunction;
   using GetSymbolInfoFunction = RuntimeDyldChecker::GetSymbolInfoFunction;
   using GetSectionInfoFunction = RuntimeDyldChecker::GetSectionInfoFunction;
   using GetStubInfoFunction = RuntimeDyldChecker::GetStubInfoFunction;
   using GetGOTInfoFunction = RuntimeDyldChecker::GetGOTInfoFunction;
 
 public:
   RuntimeDyldCheckerImpl(
       IsSymbolValidFunction IsSymbolValid, GetSymbolInfoFunction GetSymbolInfo,
       GetSectionInfoFunction GetSectionInfo, GetStubInfoFunction GetStubInfo,
-      GetGOTInfoFunction GetGOTInfo, support::endianness Endianness,
-      MCDisassembler *Disassembler, MCInstPrinter *InstPrinter,
-      llvm::raw_ostream &ErrStream);
+      GetGOTInfoFunction GetGOTInfo, support::endianness Endianness, Triple TT,
+      StringRef CPU, SubtargetFeatures TF, llvm::raw_ostream &ErrStream);
 
   bool check(StringRef CheckExpr) const;
   bool checkAllRulesInBuffer(StringRef RulePrefix, MemoryBuffer *MemBuf) const;
 
 private:
 
   // StubMap typedefs.
 
   Expected<JITSymbolResolver::LookupResult>
   lookup(const JITSymbolResolver::LookupSet &Symbols) const;
 
   bool isSymbolValid(StringRef Symbol) const;
   uint64_t getSymbolLocalAddr(StringRef Symbol) const;
   uint64_t getSymbolRemoteAddr(StringRef Symbol) const;
   uint64_t readMemoryAtAddr(uint64_t Addr, unsigned Size) const;
 
   StringRef getSymbolContent(StringRef Symbol) const;
 
+  TargetFlagsType getTargetFlag(StringRef Symbol) const;
+  Triple getTriplefromTargetFlag(TargetFlagsType Flag) const;
+  StringRef getCPU() const { return CPU; }
+  SubtargetFeatures getFeatures() const { return TF; }
+
   std::pair<uint64_t, std::string> getSectionAddr(StringRef FileName,
                                                   StringRef SectionName,
                                                   bool IsInsideLoad) const;
 
   std::pair<uint64_t, std::string>
   getStubOrGOTAddrFor(StringRef StubContainerName, StringRef Symbol,
                       bool IsInsideLoad, bool IsStubAddr) const;
 
   std::optional<uint64_t> getSectionLoadAddress(void *LocalAddr) const;
 
   IsSymbolValidFunction IsSymbolValid;
   GetSymbolInfoFunction GetSymbolInfo;
   GetSectionInfoFunction GetSectionInfo;
   GetStubInfoFunction GetStubInfo;
   GetGOTInfoFunction GetGOTInfo;
   support::endianness Endianness;
-  MCDisassembler *Disassembler;
-  MCInstPrinter *InstPrinter;
+  Triple TT;
+  std::string CPU;
+  SubtargetFeatures TF;
   llvm::raw_ostream &ErrStream;
 };
 }
 
 #endif

llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFThumb.h

public:
   RuntimeDyldCOFFThumb(RuntimeDyld::MemoryManager &MM,
                        JITSymbolResolver &Resolver)
       : RuntimeDyldCOFF(MM, Resolver, 4, COFF::IMAGE_REL_ARM_ADDR32) {}
 
   unsigned getMaxStubSize() const override {
     return 16; // 8-byte load instructions, 4-byte jump, 4-byte padding
   }
 
+  Expected<JITSymbolFlags> getJITSymbolFlags(const SymbolRef &SR) override {
+
+    auto Flags = RuntimeDyldImpl::getJITSymbolFlags(SR);
+
+    if (!Flags) {
+      return Flags.takeError();
+    }
+    auto SectionIterOrErr = SR.getSection();
+    if (!SectionIterOrErr) {
+      return SectionIterOrErr.takeError();
+    }
+    SectionRef Sec = *SectionIterOrErr.get();
+    const object::COFFObjectFile *COFFObjPtr =
+        cast<object::COFFObjectFile>(Sec.getObject());
+    const coff_section *CoffSec = COFFObjPtr->getCOFFSection(Sec);
+    bool isThumb = CoffSec->Characteristics & COFF::IMAGE_SCN_MEM_16BIT;
+
+    Flags->getTargetFlags() = isThumb;
+
+    return Flags;
+  }
+
   Align getStubAlignment() override { return Align(1); }
 
   Expected<object::relocation_iterator>
   processRelocationRef(unsigned SectionID,
                        object::relocation_iterator RelI,
                        const object::ObjectFile &Obj,
                        ObjSectionToIDMap &ObjSectionToID,
                        StubMap &Stubs) override {

llvm/test/ExecutionEngine/JITLink/AArch32/ELF_static_thumb_reloc.s

 # RUN: llvm-mc -triple=thumbv7-linux-gnueabi -arm-add-build-attributes -filetype=obj -o %t.o %s
 # RUN: llvm-objdump -r %t.o | FileCheck --check-prefix=CHECK-TYPE %s
 # RUN: llvm-objdump --disassemble %t.o | FileCheck --check-prefix=CHECK-INSTR %s
 # RUN: llvm-jitlink -noexec -slab-address 0x76ff0000 -slab-allocate 10Kb \
 # RUN:              -slab-page-size 4096 -show-entry-es -check %s %t.o
 
-# This test requires the RuntimeDyldChecker fix from review D158280
-# XFAIL: *
 
   .text
   .syntax unified
 
 # CHECK-TYPE: {{[0-9a-f]+}} R_ARM_THM_CALL call_target
 # CHECK-INSTR:  00000000 <call_site>:
 # CHECK-INSTR:         0: f7ff fffe     bl      0x0 <call_site>
 # CHECK-INSTR:  00000004 <call_target>:

llvm/test/ExecutionEngine/RuntimeDyld/ARM/COFF_Thumb.s

rel10:
   .long relocations(secrel32)     @ IMAGE_REL_ARM_SECREL
 # rtdyld-check: *{4}rel10 = relocations - section_addr(COFF_Thumb.o, .data)
 rel11:
   .secrel32 relocations       @ IMAGE_REL_ARM_SECREL
 # rtdyld-check: *{4}rel11 = relocations - section_addr(COFF_Thumb.o, .data)
   bx r0
   trap
 
-  .data
+  .text
 
   .p2align 2
 
 branch_to_thumb_func:
 @ rel14:                                                @ IMAGE_REL_ARM_MOV32T
         movw r0, :lower16:function
 # rtdyld-check: decode_operand(branch_to_thumb_func, 1) = (function&0x0000ffff|1)
         movt r0, :upper16:function

llvm/tools/llvm-jitlink/llvm-jitlink-coff.cpp

for (auto *Sym : Sec.symbols()) {
           return make_error<StringError>("zero-fill atom in GOT section",
                                          inconvertibleErrorCode());
 
         // If this is a GOT symbol with size (i.e. not the GOT start symbol)
         // then add it to the GOT entry info table.
         if (Sym->getSize() != 0) {
           if (auto TS = getCOFFGOTTarget(G, Sym->getBlock()))
             FileInfo.GOTEntryInfos[TS->getName()] = {
-                Sym->getSymbolContent(), Sym->getAddress().getValue()};
+                Sym->getSymbolContent(), Sym->getAddress().getValue(),
+                Sym->getTargetFlags()};
           else
             return TS.takeError();
         }
         SectionContainsContent = true;
       } else if (isStubsSection) {
         if (Sym->isSymbolZeroFill())
           return make_error<StringError>("zero-fill atom in Stub section",
                                          inconvertibleErrorCode());
 
         if (auto TS = getCOFFStubTarget(G, Sym->getBlock()))
           FileInfo.StubInfos[TS->getName()] = {Sym->getSymbolContent(),
-                                               Sym->getAddress().getValue()};
+                                               Sym->getAddress().getValue(),
+                                               Sym->getTargetFlags()};
         else
           return TS.takeError();
         SectionContainsContent = true;
       }
 
       if (Sym->hasName()) {
         if (Sym->isSymbolZeroFill()) {
           S.SymbolInfos[Sym->getName()] = {Sym->getSize(),
                                            Sym->getAddress().getValue()};
           SectionContainsZeroFill = true;
         } else {
           S.SymbolInfos[Sym->getName()] = {Sym->getSymbolContent(),
-                                           Sym->getAddress().getValue()};
+                                           Sym->getAddress().getValue(),
+                                           Sym->getTargetFlags()};
           SectionContainsContent = true;
         }
       }
     }
 
     auto SecAddr = FirstSym->getAddress();
     auto SecSize =
         (LastSym->getBlock().getAddress() + LastSym->getBlock().getSize()) -
         SecAddr;
 
     if (SectionContainsZeroFill && SectionContainsContent)
       return make_error<StringError>("Mixed zero-fill and content sections not "
                                      "supported yet",
                                      inconvertibleErrorCode());
 
     if (SectionContainsZeroFill)
       FileInfo.SectionInfos[Sec.getName()] = {SecSize, SecAddr.getValue()};
     else
       FileInfo.SectionInfos[Sec.getName()] = {
           ArrayRef<char>(FirstSym->getBlock().getContent().data(), SecSize),
-          SecAddr.getValue()};
+          SecAddr.getValue(), FirstSym->getTargetFlags()};
   }
 
   return Error::success();
 }
 
 } // end namespace llvm

llvm/tools/llvm-jitlink/llvm-jitlink-elf.cpp

for (auto *Sym : Sec.symbols()) {
           return make_error<StringError>("zero-fill atom in GOT section",
                                          inconvertibleErrorCode());
 
         // If this is a GOT symbol with size (i.e. not the GOT start symbol)
         // then add it to the GOT entry info table.
         if (Sym->getSize() != 0) {
           if (auto TS = getELFGOTTarget(G, Sym->getBlock()))
             FileInfo.GOTEntryInfos[TS->getName()] = {
-                Sym->getSymbolContent(), Sym->getAddress().getValue()};
+                Sym->getSymbolContent(), Sym->getAddress().getValue(),
+                Sym->getTargetFlags()};
           else
             return TS.takeError();
         }
         SectionContainsContent = true;
       } else if (isStubsSection) {
         if (Sym->isSymbolZeroFill())
           return make_error<StringError>("zero-fill atom in Stub section",
                                          inconvertibleErrorCode());
 
         if (auto TS = getELFStubTarget(G, Sym->getBlock()))
           FileInfo.StubInfos[TS->getName()] = {Sym->getSymbolContent(),
-                                               Sym->getAddress().getValue()};
+                                               Sym->getAddress().getValue(),
+                                               Sym->getTargetFlags()};
         else
           return TS.takeError();
         SectionContainsContent = true;
       }
 
       if (Sym->hasName()) {
         if (Sym->isSymbolZeroFill()) {
           S.SymbolInfos[Sym->getName()] = {Sym->getSize(),
                                            Sym->getAddress().getValue()};
           SectionContainsZeroFill = true;
         } else {
           S.SymbolInfos[Sym->getName()] = {Sym->getSymbolContent(),
-                                           Sym->getAddress().getValue()};
+                                           Sym->getAddress().getValue(),
+                                           Sym->getTargetFlags()};
           SectionContainsContent = true;
         }
       }
     }
 
     // Add symbol info for absolute symbols.
     for (auto *Sym : G.absolute_symbols())
       S.SymbolInfos[Sym->getName()] = {Sym->getSize(),
                                        Sym->getAddress().getValue()};
 
     auto SecAddr = FirstSym->getAddress();
     auto SecSize =
         (LastSym->getBlock().getAddress() + LastSym->getBlock().getSize()) -
         SecAddr;
 
     if (SectionContainsZeroFill && SectionContainsContent)
       return make_error<StringError>("Mixed zero-fill and content sections not "
                                      "supported yet",
                                      inconvertibleErrorCode());
     if (SectionContainsZeroFill)
       FileInfo.SectionInfos[Sec.getName()] = {SecSize, SecAddr.getValue()};
     else
       FileInfo.SectionInfos[Sec.getName()] = {
           ArrayRef<char>(FirstSym->getBlock().getContent().data(), SecSize),
-          SecAddr.getValue()};
+          SecAddr.getValue(), FirstSym->getTargetFlags()};
   }
 
   return Error::success();
 }
 
 } // end namespace llvm

llvm/tools/llvm-jitlink/llvm-jitlink-macho.cpp

for (auto *Sym : Sec.symbols()) {
       if (Sym->getAddress() > LastSym->getAddress())
         LastSym = Sym;
       if (isGOTSection) {
         if (Sym->isSymbolZeroFill())
           return make_error<StringError>("zero-fill atom in GOT section",
                                          inconvertibleErrorCode());
 
         if (auto TS = getMachOGOTTarget(G, Sym->getBlock()))
-          FileInfo.GOTEntryInfos[TS->getName()] = {
-              Sym->getSymbolContent(), Sym->getAddress().getValue()};
+          FileInfo.GOTEntryInfos[TS->getName()] = {Sym->getSymbolContent(),
+                                                   Sym->getAddress().getValue(),
+                                                   Sym->getTargetFlags()};
         else
           return TS.takeError();
         SectionContainsContent = true;
       } else if (isStubsSection) {
         if (Sym->isSymbolZeroFill())
           return make_error<StringError>("zero-fill atom in Stub section",
                                          inconvertibleErrorCode());
 
         if (auto TS = getMachOStubTarget(G, Sym->getBlock()))
           FileInfo.StubInfos[TS->getName()] = {Sym->getSymbolContent(),
-                                               Sym->getAddress().getValue()};
+                                               Sym->getAddress().getValue(),
+                                               Sym->getTargetFlags()};
         else
           return TS.takeError();
         SectionContainsContent = true;
       } else if (Sym->hasName()) {
         if (Sym->isSymbolZeroFill()) {
           S.SymbolInfos[Sym->getName()] = {Sym->getSize(),
                                            Sym->getAddress().getValue()};
           SectionContainsZeroFill = true;
         } else {
           S.SymbolInfos[Sym->getName()] = {Sym->getSymbolContent(),
-                                           Sym->getAddress().getValue()};
+                                           Sym->getAddress().getValue(),
+                                           Sym->getTargetFlags()};
           SectionContainsContent = true;
         }
       }
     }
 
     auto SecAddr = FirstSym->getAddress();
     auto SecSize =
         (LastSym->getBlock().getAddress() + LastSym->getBlock().getSize()) -
         SecAddr;
 
     if (SectionContainsZeroFill && SectionContainsContent)
       return make_error<StringError>("Mixed zero-fill and content sections not "
                                      "supported yet",
                                      inconvertibleErrorCode());
     if (SectionContainsZeroFill)
       FileInfo.SectionInfos[Sec.getName()] = {SecSize, SecAddr.getValue()};
     else
       FileInfo.SectionInfos[Sec.getName()] = {
           ArrayRef<char>(FirstSym->getBlock().getContent().data(), SecSize),
-          SecAddr.getValue()};
+          SecAddr.getValue(), FirstSym->getTargetFlags()};
   }
 
   return Error::success();
 }
 
 } // end namespace llvm

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

if (AddrStr.getAsInteger(0, Addr))
                                          "\" in absolute symbol definition \"" +
                                          AbsDefStmt + "\"",
                                      inconvertibleErrorCode());
     ExecutorSymbolDef AbsDef(ExecutorAddr(Addr), JITSymbolFlags::Exported);
     if (auto Err = JD.define(absoluteSymbols({{S.ES.intern(Name), AbsDef}})))
       return Err;
 
     // Register the absolute symbol with the session symbol infos.
-    S.SymbolInfos[Name] = {ArrayRef<char>(), Addr};
+    S.SymbolInfos[Name] = {ArrayRef<char>(), Addr,
+                           AbsDef.getFlags().getTargetFlags()};
   }
 
   return Error::success();
 }
 
 static Error addAliases(Session &S,
                         const std::map<unsigned, JITDylib *> &IdxToJD) {
   // Define absolute symbols.
getTargetInfo(const Triple &TT,
   if (!InstPrinter)
     ExitOnErr(make_error<StringError>(
         "Unable to create instruction printer for" + TripleName,
         inconvertibleErrorCode()));
   return {TheTarget,      std::move(STI), std::move(MRI),
           std::move(MAI), std::move(Ctx), std::move(Disassembler),
           std::move(MII), std::move(MIA), std::move(InstPrinter)};
 }
-
-static Error runChecks(Session &S) {
+static Error runChecks(Session &S, Triple TT, SubtargetFeatures Features) {
   if (CheckFiles.empty())
     return Error::success();
 
   LLVM_DEBUG(dbgs() << "Running checks...\n");
 
-  auto TI = getTargetInfo(S.ES.getTargetTriple(), S.Features);
-
   auto IsSymbolValid = [&S](StringRef Symbol) {
     return S.isSymbolRegistered(Symbol);
   };
 
   auto GetSymbolInfo = [&S](StringRef Symbol) {
     return S.findSymbolInfo(Symbol, "Can not get symbol info");
   };
 
   auto GetSectionInfo = [&S](StringRef FileName, StringRef SectionName) {
     return S.findSectionInfo(FileName, SectionName);
   };
 
   auto GetStubInfo = [&S](StringRef FileName, StringRef SectionName) {
     return S.findStubInfo(FileName, SectionName);
   };
 
   auto GetGOTInfo = [&S](StringRef FileName, StringRef SectionName) {
     return S.findGOTEntryInfo(FileName, SectionName);
   };
 
   RuntimeDyldChecker Checker(
       IsSymbolValid, GetSymbolInfo, GetSectionInfo, GetStubInfo, GetGOTInfo,
       S.ES.getTargetTriple().isLittleEndian() ? support::little : support::big,
-      TI.Disassembler.get(), TI.InstPrinter.get(), dbgs());
+      TT, StringRef(), Features, dbgs());
 
   std::string CheckLineStart = "# " + CheckName + ":";
   for (auto &CheckFile : CheckFiles) {
     auto CheckerFileBuf = ExitOnErr(getFile(CheckFile));
     if (!Checker.checkAllRulesInBuffer(CheckLineStart, &*CheckerFileBuf))
       ExitOnErr(make_error<StringError>(
           "Some checks in " + CheckFile + " failed", inconvertibleErrorCode()));
   }
int main(int argc, char *argv[]) {
 
   /// If timers are enabled, create a JITLinkTimers instance.
   std::unique_ptr<JITLinkTimers> Timers =
       ShowTimes ? std::make_unique<JITLinkTimers>() : nullptr;
 
   auto [TT, Features] = getFirstFileTripleAndFeatures();
   ExitOnErr(sanitizeArguments(TT, argv[0]));
 
-  auto S = ExitOnErr(Session::Create(std::move(TT), std::move(Features)));
+  auto S = ExitOnErr(Session::Create(TT, Features));
 
   enableStatistics(*S, !OrcRuntime.empty());
 
   {
     TimeRegion TR(Timers ? &Timers->LoadObjectsTimer : nullptr);
     ExitOnErr(addSessionInputs(*S));
   }
 
int main(int argc, char *argv[]) {
 
   if (!EntryPoint) {
     if (Timers)
       Timers->JITLinkTG.printAll(errs());
     reportLLVMJITLinkError(EntryPoint.takeError());
     exit(1);
   }
 
-  ExitOnErr(runChecks(*S));
+  ExitOnErr(runChecks(*S, std::move(TT), std::move(Features)));
 
   int Result = 0;
   if (!NoExec) {
     LLVM_DEBUG(dbgs() << "Running \"" << EntryPointName << "\"...\n");
     TimeRegion TR(Timers ? &Timers->RunTimer : nullptr);
     if (!OrcRuntime.empty())
       Result =
           ExitOnErr(runWithRuntime(*S, ExecutorAddr(EntryPoint->getAddress())));

llvm/tools/llvm-rtdyld/llvm-rtdyld.cpp

#endif
     // default-constructed StringRef).
     if (auto *SymAddr = Dyld.getSymbolLocalAddress(Symbol)) {
       unsigned SectionID = Dyld.getSymbolSectionID(Symbol);
       if (SectionID != ~0U) {
         char *CSymAddr = static_cast<char *>(SymAddr);
         StringRef SecContent = Dyld.getSectionContent(SectionID);
         uint64_t SymSize = SecContent.size() - (CSymAddr - SecContent.data());
         SymInfo.setContent(ArrayRef<char>(CSymAddr, SymSize));
+        SymInfo.setTargetFlags(
+            Dyld.getSymbol(Symbol).getFlags().getTargetFlags());
       }
     }
     return SymInfo;
   };
 
   auto IsSymbolValid = [&Dyld, GetSymbolInfo](StringRef Symbol) {
     if (Dyld.getSymbol(Symbol))
       return true;
for (auto &InputFile : InputFileList) {
     }
 
     ObjectFile &Obj = **MaybeObj;
 
     if (!Checker)
       Checker = std::make_unique<RuntimeDyldChecker>(
           IsSymbolValid, GetSymbolInfo, GetSectionInfo, GetStubInfo,
           GetStubInfo, Obj.isLittleEndian() ? support::little : support::big,
-          Disassembler.get(), InstPrinter.get(), dbgs());
+          TheTriple, MCPU, SubtargetFeatures(), dbgs());
 
     auto FileName = sys::path::filename(InputFile);
     MemMgr.setSectionIDsMap(&FileToSecIDMap[FileName]);
 
     // Load the object file
     Dyld.loadObject(Obj);
     if (Dyld.hasError()) {
       ErrorAndExit(Dyld.getErrorString());