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

This reverts commit 4b17c81d5a5d3e0f514026c2b7f9b623d901cc04.

Caused buildbot failures:
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

5 files changed, 28 insertions, 194 deletions

diff --git a/llvm/lib/ExecutionEngine/JITLink/aarch32.cpp b/llvm/lib/ExecutionEngine/JITLink/aarch32.cpp
index 01c9e8b..e9221a8 100644
--- a/llvm/lib/ExecutionEngine/JITLink/aarch32.cpp
+++ b/llvm/lib/ExecutionEngine/JITLink/aarch32.cpp
@@ -25,11 +25,6 @@ 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).
 ///
@@ -292,7 +287,7 @@ Error applyFixupData(LinkGraph &G, Block &B, const Edge &E) {
   int64_t Addend = E.getAddend();
   Symbol &TargetSymbol = E.getTarget();
   uint64_t TargetAddress = TargetSymbol.getAddress().getValue();
-  assert(!hasTargetFlags(TargetSymbol, ThumbSymbol));
+  assert(!TargetSymbol.hasTargetFlags(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
@@ -346,14 +341,14 @@ Error applyFixupThumb(LinkGraph &G, Block &B, const Edge &E,
   int64_t Addend = E.getAddend();
   Symbol &TargetSymbol = E.getTarget();
   uint64_t TargetAddress = TargetSymbol.getAddress().getValue();
-  if (hasTargetFlags(TargetSymbol, ThumbSymbol))
+  if (TargetSymbol.hasTargetFlags(ThumbSymbol))
     TargetAddress |= 0x01;
 
   switch (Kind) {
   case Thumb_Jump24: {
     if (!checkOpcode<Thumb_Jump24>(R))
       return makeUnexpectedOpcodeError(G, R, Kind);
-    if (!hasTargetFlags(TargetSymbol, ThumbSymbol))
+    if (!(TargetSymbol.hasTargetFlags(ThumbSymbol)))
       return make_error<JITLinkError>("Branch relocation needs interworking "
                                       "stub when bridging to ARM: " +
                                       StringRef(G.getEdgeKindName(Kind)));
@@ -380,7 +375,7 @@ Error applyFixupThumb(LinkGraph &G, Block &B, const Edge &E,
 
     // 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 = !hasTargetFlags(TargetSymbol, ThumbSymbol);
+    bool TargetIsArm = !TargetSymbol.hasTargetFlags(ThumbSymbol);
     bool InstrIsBlx = (R.Lo & FixupInfo<Thumb_Call>::LoBitNoBlx) == 0;
     if (TargetIsArm != InstrIsBlx) {
       if (LLVM_LIKELY(TargetIsArm)) {
diff --git a/llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp b/llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp
index 3d77f82..a29f3d1 100644
--- a/llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp
+++ b/llvm/lib/ExecutionEngine/Orc/ObjectLinkingLayer.cpp
@@ -46,7 +46,7 @@ ExecutorAddr getJITSymbolPtrForSymbol(Symbol &Sym, const Triple &TT) {
   case Triple::armeb:
   case Triple::thumb:
   case Triple::thumbeb:
-    if (hasTargetFlags(Sym, aarch32::ThumbSymbol)) {
+    if (Sym.hasTargetFlags(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");
diff --git a/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp b/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp
index b4f0a71..ab561ec 100644
--- a/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp
+++ b/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp
@@ -10,16 +10,9 @@
 #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"
@@ -32,19 +25,6 @@
 
 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.
@@ -296,20 +276,6 @@ private:
           "");
 
     unsigned OpIdx = OpIdxExpr.getValue();
-
-    auto printInst = [this](StringRef Symbol, MCInst Inst,
-                            raw_string_ostream &ErrMsgStream) {
-      auto TI = getTargetInfo(
-          Checker.getTripleFromTargetFlag(Checker.getTargetFlag(Symbol)));
-      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);
@@ -318,8 +284,8 @@ private:
                    << "'. Instruction has only "
                    << format("%i", Inst.getNumOperands())
                    << " operands.\nInstruction is:\n  ";
-
-      return printInst(Symbol, Inst, ErrMsgStream);
+      Inst.dump_pretty(ErrMsgStream, Checker.InstPrinter);
+      return std::make_pair(EvalResult(ErrMsgStream.str()), "");
     }
 
     const MCOperand &Op = Inst.getOperand(OpIdx);
@@ -328,8 +294,9 @@ private:
       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 printInst(Symbol, Inst, ErrMsgStream);
+      return std::make_pair(EvalResult(ErrMsgStream.str()), "");
     }
 
     return std::make_pair(EvalResult(Op.getImm()), RemainingExpr);
@@ -720,101 +687,31 @@ private:
 
   bool decodeInst(StringRef Symbol, MCInst &Inst, uint64_t &Size,
                   int64_t Offset) const {
-    auto TI = getTargetInfo(
-        Checker.getTripleFromTargetFlag(Checker.getTargetFlag(Symbol)));
-
-    if (auto E = TI.takeError()) {
-      errs() << "Error obtaining disassembler: " << toString(std::move(E))
-             << "\n";
-      return false;
-    }
-
+    MCDisassembler *Dis = Checker.Disassembler;
     StringRef SymbolMem = Checker.getSymbolContent(Symbol);
     ArrayRef<uint8_t> SymbolBytes(SymbolMem.bytes_begin() + Offset,
                                   SymbolMem.size() - Offset);
 
     MCDisassembler::DecodeStatus S =
-        TI->Disassembler->getInstruction(Inst, Size, SymbolBytes, 0, nulls());
+        Dis->getInstruction(Inst, Size, SymbolBytes, 0, nulls());
 
     return (S == MCDisassembler::Success);
   }
-
-  Expected<TargetInfo>
-  getTargetInfo(const Triple &TT,
-                const SubtargetFeatures &TF = SubtargetFeatures()) 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, "", 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, Triple TT,
-    SubtargetFeatures TF, raw_ostream &ErrStream)
+    GetGOTInfoFunction GetGOTInfo, support::endianness Endianness,
+    MCDisassembler *Disassembler, MCInstPrinter *InstPrinter,
+    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), TT(std::move(TT)), TF(std::move(TF)),
-      ErrStream(ErrStream) {}
+      Endianness(Endianness), Disassembler(Disassembler),
+      InstPrinter(InstPrinter), ErrStream(ErrStream) {}
 
 bool RuntimeDyldCheckerImpl::check(StringRef CheckExpr) const {
   CheckExpr = CheckExpr.trim();
@@ -925,36 +822,6 @@ StringRef RuntimeDyldCheckerImpl::getSymbolContent(StringRef Symbol) const {
   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 {
 
@@ -1017,12 +884,13 @@ std::pair<uint64_t, std::string> RuntimeDyldCheckerImpl::getStubOrGOTAddrFor(
 RuntimeDyldChecker::RuntimeDyldChecker(
     IsSymbolValidFunction IsSymbolValid, GetSymbolInfoFunction GetSymbolInfo,
     GetSectionInfoFunction GetSectionInfo, GetStubInfoFunction GetStubInfo,
-    GetGOTInfoFunction GetGOTInfo, support::endianness Endianness, Triple TT,
-    SubtargetFeatures TF, raw_ostream &ErrStream)
+    GetGOTInfoFunction GetGOTInfo, support::endianness Endianness,
+    MCDisassembler *Disassembler, MCInstPrinter *InstPrinter,
+    raw_ostream &ErrStream)
     : Impl(::std::make_unique<RuntimeDyldCheckerImpl>(
           std::move(IsSymbolValid), std::move(GetSymbolInfo),
           std::move(GetSectionInfo), std::move(GetStubInfo),
-          std::move(GetGOTInfo), Endianness, std::move(TT), std::move(TF),
+          std::move(GetGOTInfo), Endianness, Disassembler, InstPrinter,
           ErrStream)) {}
 
 RuntimeDyldChecker::~RuntimeDyldChecker() = default;
diff --git a/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldCheckerImpl.h b/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldCheckerImpl.h
index 8596b33..f564b00 100644
--- a/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldCheckerImpl.h
+++ b/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldCheckerImpl.h
@@ -13,9 +13,6 @@
 
 namespace llvm {
 
-/// Holds target-specific properties for a symbol.
-using TargetFlagsType = uint8_t;
-
 class RuntimeDyldCheckerImpl {
   friend class RuntimeDyldChecker;
   friend class RuntimeDyldCheckerExprEval;
@@ -28,13 +25,12 @@ class RuntimeDyldCheckerImpl {
   using GetGOTInfoFunction = RuntimeDyldChecker::GetGOTInfoFunction;
 
 public:
-  RuntimeDyldCheckerImpl(IsSymbolValidFunction IsSymbolValid,
-                         GetSymbolInfoFunction GetSymbolInfo,
-                         GetSectionInfoFunction GetSectionInfo,
-                         GetStubInfoFunction GetStubInfo,
-                         GetGOTInfoFunction GetGOTInfo,
-                         support::endianness Endianness, Triple TT,
-                         SubtargetFeatures TF, llvm::raw_ostream &ErrStream);
+  RuntimeDyldCheckerImpl(
+      IsSymbolValidFunction IsSymbolValid, GetSymbolInfoFunction GetSymbolInfo,
+      GetSectionInfoFunction GetSectionInfo, GetStubInfoFunction GetStubInfo,
+      GetGOTInfoFunction GetGOTInfo, support::endianness Endianness,
+      MCDisassembler *Disassembler, MCInstPrinter *InstPrinter,
+      llvm::raw_ostream &ErrStream);
 
   bool check(StringRef CheckExpr) const;
   bool checkAllRulesInBuffer(StringRef RulePrefix, MemoryBuffer *MemBuf) const;
@@ -53,9 +49,6 @@ private:
 
   StringRef getSymbolContent(StringRef Symbol) const;
 
-  TargetFlagsType getTargetFlag(StringRef Symbol) const;
-  Triple getTripleFromTargetFlag(TargetFlagsType Flag) const;
-
   std::pair<uint64_t, std::string> getSectionAddr(StringRef FileName,
                                                   StringRef SectionName,
                                                   bool IsInsideLoad) const;
@@ -72,8 +65,8 @@ private:
   GetStubInfoFunction GetStubInfo;
   GetGOTInfoFunction GetGOTInfo;
   support::endianness Endianness;
-  Triple TT;
-  SubtargetFeatures TF;
+  MCDisassembler *Disassembler;
+  MCInstPrinter *InstPrinter;
   llvm::raw_ostream &ErrStream;
 };
 }
diff --git a/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFThumb.h b/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFThumb.h
index a3e66c6..22f1cf3 100644
--- a/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFThumb.h
+++ b/llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFThumb.h
@@ -54,28 +54,6 @@ public:
     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>