Add createMCRelocationInfo() and createMCSymbolizer() to MCTargetMachine.

[dsanders]

Summary

Note that these functions are in libMCDisassembler rather than the libMC.
This is because calling Target::createMCRelocationInfo() or
Target::createMCSymbolizer() would otherwise introduce a dependency from
MC to MCDisassembler in addition to the existing dependency from
MCDisassembler to MC.

Depends on D13858

[dsanders]

ping

[dsanders]

ping

[dsanders]

Refresh patch.

include/llvm/MC/MCTargetMachine.h

 // This file defines the MCTargetMachine classes.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCTARGETMACHINE_H
 #define LLVM_MC_MCTARGETMACHINE_H
 
 #include "llvm/ADT/Triple.h"
+#include "llvm/MC/MCExternalSymbolizer.h"
 #include "llvm/Support/CodeGen.h"
 
 namespace llvm {
 class MCAsmBackend;
 class MCAsmInfo;
 class MCAsmParser;
 class MCCodeEmitter;
 class MCCodeGenInfo;
 class MCContext;
 class MCDisassembler;
 class MCInstPrinter;
 class MCInstrAnalysis;
 class MCInstrInfo;
 class MCRegisterInfo;
+class MCRelocationInfo;
 class MCStreamer;
 class MCSubtargetInfo;
+class MCSymbolizer;
 class MCTargetAsmParser;
 class MCTargetOptions;
 class MCTargetStreamer;
 class Target;
 class Triple;
 class formatted_raw_ostream;
 class raw_pwrite_stream;
 
public:
   virtual MCStreamer *
   createAsmStreamer(MCContext &Ctx, std::unique_ptr<formatted_raw_ostream> OS,
                     bool IsVerboseAsm, bool UseDwarfDirectory,
                     MCInstPrinter *InstPrint, MCCodeEmitter *CE,
                     MCAsmBackend *TAB, bool ShowInst) const;
 
   virtual MCStreamer *createNullStreamer(MCContext &Ctx) const;
   virtual MCTargetStreamer *createNullTargetStreamer(MCStreamer &S) const;
+
+  /// createMCRelocationInfo - Create a target specific MCRelocationInfo.
+  ///
+  /// \param Ctx The target context.
+  MCRelocationInfo *createMCRelocationInfo(MCContext &Ctx) const;
+
+  /// createMCSymbolizer - Create a target specific MCSymbolizer.
+  ///
+  /// \param GetOpInfo The function to get the symbolic information for
+  /// operands.
+  /// \param SymbolLookUp The function to lookup a symbol name.
+  /// \param DisInfo The pointer to the block of symbolic information for above
+  /// call
+  /// back.
+  /// \param Ctx The target context.
+  /// \param RelInfo The relocation information for this target. Takes
+  /// ownership.
+  MCSymbolizer *
+  createMCSymbolizer(LLVMOpInfoCallback GetOpInfo,
+                     LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo,
+                     MCContext *Ctx,
+                     std::unique_ptr<MCRelocationInfo> &&RelInfo) const;
 };
 
 } // End llvm namespace
 
 #endif

include/llvm/Support/TargetRegistry.h

protected:
   }
 
   MCTargetStreamer *createNullTargetStreamer(MCStreamer &S) const {
     if (NullTargetStreamerCtorFn)
       return NullTargetStreamerCtorFn(S);
     return nullptr;
   }
 
-public:
   /// createMCRelocationInfo - Create a target specific MCRelocationInfo.
   ///
   /// \param TT The target triple.
   /// \param Ctx The target context.
   MCRelocationInfo *createMCRelocationInfo(StringRef TT, MCContext &Ctx) const {
     MCRelocationInfoCtorTy Fn = MCRelocationInfoCtorFn
                                     ? MCRelocationInfoCtorFn
                                     : llvm::createMCRelocationInfo;

lib/MC/MCDisassembler/CMakeLists.txt

 add_llvm_library(LLVMMCDisassembler
   Disassembler.cpp
   MCRelocationInfo.cpp
   MCExternalSymbolizer.cpp
   MCDisassembler.cpp
+  MCTargetMachine.cpp
   )

lib/MC/MCDisassembler/Disassembler.cpp

LLVMCreateDisasmCPUFeatures(const char *TTStr, const char *CPU,
   if (!Ctx)
     return nullptr;
 
   // Set up disassembler.
   MCDisassembler *DisAsm = MTM->createMCDisassembler(*STI, *Ctx);
   if (!DisAsm)
     return nullptr;
 
-  std::unique_ptr<MCRelocationInfo> RelInfo(
-      TheTarget->createMCRelocationInfo(TTStr, *Ctx));
+  std::unique_ptr<MCRelocationInfo> RelInfo(MTM->createMCRelocationInfo(*Ctx));
   if (!RelInfo)
     return nullptr;
 
-  std::unique_ptr<MCSymbolizer> Symbolizer(TheTarget->createMCSymbolizer(
-      TTStr, GetOpInfo, SymbolLookUp, DisInfo, Ctx, std::move(RelInfo)));
+  std::unique_ptr<MCSymbolizer> Symbolizer(MTM->createMCSymbolizer(
+      GetOpInfo, SymbolLookUp, DisInfo, Ctx, std::move(RelInfo)));
   DisAsm->setSymbolizer(std::move(Symbolizer));
 
   // Set up the instruction printer.
   int AsmPrinterVariant = MAI->getAssemblerDialect();
   MCInstPrinter *IP =
       MTM->createMCInstPrinter(AsmPrinterVariant, *MAI, *MII, *MRI);
   if (!IP)
     return nullptr;

lib/MC/MCDisassembler/MCTargetMachine.cpp

+//===-- MCTargetMachine.cpp - General Target Information -------------------==//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file describes the disassembler part of a MC Target machine.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/MC/MCTargetMachine.h"
+#include "llvm/Support/TargetRegistry.h"
+using namespace llvm;
+
+MCRelocationInfo *
+MCTargetMachine::createMCRelocationInfo(MCContext &Ctx) const {
+  return TheTarget.createMCRelocationInfo(TheTriple.str(), Ctx);
+}
+
+MCSymbolizer *MCTargetMachine::createMCSymbolizer(
+    LLVMOpInfoCallback GetOpInfo, LLVMSymbolLookupCallback SymbolLookUp,
+    void *DisInfo, MCContext *Ctx,
+    std::unique_ptr<MCRelocationInfo> &&RelInfo) const {
+  return TheTarget.createMCSymbolizer(TheTriple.str(), GetOpInfo, SymbolLookUp,
+                                      DisInfo, Ctx, std::move(RelInfo));
+}

tools/llvm-objdump/MachODump.cpp

static void DisassembleMachO(StringRef Filename, MachOObjectFile *MachOOF,
   std::unique_ptr<const MCRegisterInfo> MRI(MTM->createMCRegisterInfo());
   std::unique_ptr<const MCAsmInfo> AsmInfo(MTM->createMCAsmInfo(*MRI));
   std::unique_ptr<const MCSubtargetInfo> STI(
       MTM->createMCSubtargetInfo(MCPU, FeaturesStr));
   MCContext Ctx(AsmInfo.get(), MRI.get(), nullptr);
   std::unique_ptr<MCDisassembler> DisAsm(MTM->createMCDisassembler(*STI, Ctx));
   std::unique_ptr<MCSymbolizer> Symbolizer;
   struct DisassembleInfo SymbolizerInfo;
-  std::unique_ptr<MCRelocationInfo> RelInfo(
-      TheTarget->createMCRelocationInfo(TripleName, Ctx));
+  std::unique_ptr<MCRelocationInfo> RelInfo(MTM->createMCRelocationInfo(Ctx));
   if (RelInfo) {
-    Symbolizer.reset(TheTarget->createMCSymbolizer(
-        TripleName, SymbolizerGetOpInfo, SymbolizerSymbolLookUp,
+    Symbolizer.reset(
+        MTM->createMCSymbolizer(SymbolizerGetOpInfo, SymbolizerSymbolLookUp,
                                 &SymbolizerInfo, &Ctx, std::move(RelInfo)));
     DisAsm->setSymbolizer(std::move(Symbolizer));
   }
   int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
   std::unique_ptr<MCInstPrinter> IP(
       MTM->createMCInstPrinter(AsmPrinterVariant, *AsmInfo, *InstrInfo, *MRI));
   // Set the display preference for hex vs. decimal immediates.
   IP->setPrintImmHex(PrintImmHex);
   // Comment stream and backing vector.
if (ThumbTarget) {
     Triple ThumbTT(ThumbTripleName);
     ThumbMTM.reset(ThumbTarget->createMCTargetMachine(ThumbTT));
     ThumbMRI.reset(ThumbMTM->createMCRegisterInfo());
     ThumbAsmInfo.reset(ThumbMTM->createMCAsmInfo(*ThumbMRI));
     ThumbSTI.reset(ThumbMTM->createMCSubtargetInfo(MCPU, FeaturesStr));
     ThumbCtx.reset(new MCContext(ThumbAsmInfo.get(), ThumbMRI.get(), nullptr));
     ThumbDisAsm.reset(ThumbMTM->createMCDisassembler(*ThumbSTI, *ThumbCtx));
     MCContext *PtrThumbCtx = ThumbCtx.get();
-    ThumbRelInfo.reset(
-        ThumbTarget->createMCRelocationInfo(ThumbTripleName, *PtrThumbCtx));
+    ThumbRelInfo.reset(ThumbMTM->createMCRelocationInfo(*PtrThumbCtx));
     if (ThumbRelInfo) {
-      ThumbSymbolizer.reset(ThumbTarget->createMCSymbolizer(
-          ThumbTripleName, SymbolizerGetOpInfo, SymbolizerSymbolLookUp,
-          &ThumbSymbolizerInfo, PtrThumbCtx, std::move(ThumbRelInfo)));
+      ThumbSymbolizer.reset(MTM->createMCSymbolizer(
+          SymbolizerGetOpInfo, SymbolizerSymbolLookUp, &ThumbSymbolizerInfo,
+          PtrThumbCtx, std::move(ThumbRelInfo)));
       ThumbDisAsm->setSymbolizer(std::move(ThumbSymbolizer));
     }
     int ThumbAsmPrinterVariant = ThumbAsmInfo->getAssemblerDialect();
     ThumbInstrInfo.reset(ThumbMTM->createMCInstrInfo());
     ThumbIP.reset(ThumbMTM->createMCInstPrinter(
         ThumbAsmPrinterVariant, *ThumbAsmInfo, *ThumbInstrInfo, *ThumbMRI));
     // Set the display preference for hex vs. decimal immediates.
     ThumbIP->setPrintImmHex(PrintImmHex);