Follow up of the introduction of MCSymbolizer.

- Ressurect old MCDisassemble API to soften transition.
- Extend MCTargetDesc to set target specific symbolizer.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@182688 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/MC/MCDisassembler.h

@@ -56,7 +56,9 @@ public:
   };
 
   /// Constructor     - Performs initial setup for the disassembler.
-  MCDisassembler(const MCSubtargetInfo &STI) : STI(STI), Symbolizer(0),
+  MCDisassembler(const MCSubtargetInfo &STI) : GetOpInfo(0), SymbolLookUp(0),
+                                               DisInfo(0), Ctx(0),
+                                               STI(STI), Symbolizer(0),
                                                CommentStream(0) {}
 
   virtual ~MCDisassembler();
@@ -83,12 +85,23 @@ public:
                                        uint64_t address,
                                        raw_ostream &vStream,
                                        raw_ostream &cStream) const = 0;
+private:
+  //
+  // Hooks for symbolic disassembly via the public 'C' interface.
+  //
+  // The function to get the symbolic information for operands.
+  LLVMOpInfoCallback GetOpInfo;
+  // The function to lookup a symbol name.
+  LLVMSymbolLookupCallback SymbolLookUp;
+  // The pointer to the block of symbolic information for above call back.
+  void *DisInfo;
+  // The assembly context for creating symbols and MCExprs in place of
+  // immediate operands when there is symbolic information.
+  MCContext *Ctx;
 
 protected:
   // Subtarget information, for instruction decoding predicates if required.
   const MCSubtargetInfo &STI;
-
-private:
   OwningPtr<MCSymbolizer> Symbolizer;
 
 public:
@@ -111,6 +124,13 @@ public:
                                    MCContext *Ctx,
                                    OwningPtr<MCRelocationInfo> &RelInfo);
 
+  LLVMOpInfoCallback getLLVMOpInfoCallback() const { return GetOpInfo; }
+  LLVMSymbolLookupCallback getLLVMSymbolLookupCallback() const {
+    return SymbolLookUp;
+  }
+  void *getDisInfoBlock() const { return DisInfo; }
+  MCContext *getMCContext() const { return Ctx; }
+
   // Marked mutable because we cache it inside the disassembler, rather than
   // having to pass it around as an argument through all the autogenerated code.
   mutable raw_ostream *CommentStream;

include/llvm/Support/TargetRegistry.h

@@ -21,6 +21,7 @@
 
 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/CodeGen.h"
+#include "llvm-c/Disassembler.h"
 #include <cassert>
 #include <string>
 
@@ -41,6 +42,7 @@ namespace llvm {
   class MCRegisterInfo;
   class MCStreamer;
   class MCSubtargetInfo;
+  class MCSymbolizer;
   class MCRelocationInfo;
   class MCTargetAsmParser;
   class TargetMachine;
@@ -57,7 +59,13 @@ namespace llvm {
                                 MCAsmBackend *TAB,
                                 bool ShowInst);
 
-  MCRelocationInfo *createMCRelocationInfo(MCContext &Ctx);
+  MCRelocationInfo *createMCRelocationInfo(StringRef TT, MCContext &Ctx);
+
+  MCSymbolizer *createMCSymbolizer(StringRef TT, LLVMOpInfoCallback GetOpInfo,
+                                   LLVMSymbolLookupCallback SymbolLookUp,
+                                   void *DisInfo,
+                                   MCContext *Ctx,
+                                   MCRelocationInfo *RelInfo);
 
   /// Target - Wrapper for Target specific information.
   ///
@@ -132,6 +140,12 @@ namespace llvm {
                                              bool ShowInst);
     typedef MCRelocationInfo *(*MCRelocationInfoCtorTy)(StringRef TT,
                                                         MCContext &Ctx);
+    typedef MCSymbolizer *(*MCSymbolizerCtorTy)(StringRef TT,
+                                   LLVMOpInfoCallback GetOpInfo,
+                                   LLVMSymbolLookupCallback SymbolLookUp,
+                                   void *DisInfo,
+                                   MCContext *Ctx,
+                                   MCRelocationInfo *RelInfo);
 
   private:
     /// Next - The next registered target in the linked list, maintained by the
@@ -215,8 +229,14 @@ namespace llvm {
     /// MCRelocationInfo, if registered (default = llvm::createMCRelocationInfo)
     MCRelocationInfoCtorTy MCRelocationInfoCtorFn;
 
+    /// MCSymbolizerCtorFn - Construction function for this target's
+    /// MCSymbolizer, if registered (default = llvm::createMCSymbolizer)
+    MCSymbolizerCtorTy MCSymbolizerCtorFn;
+
   public:
-    Target() : AsmStreamerCtorFn(llvm::createAsmStreamer) {}
+    Target() : AsmStreamerCtorFn(llvm::createAsmStreamer),
+               MCRelocationInfoCtorFn(llvm::createMCRelocationInfo),
+               MCSymbolizerCtorFn(llvm::createMCSymbolizer) {}
 
     /// @name Target Information
     /// @{
@@ -448,10 +468,27 @@ namespace llvm {
     /// \param Ctx The target context.
     MCRelocationInfo *
       createMCRelocationInfo(StringRef TT, MCContext &Ctx) const {
-      // MCRelocationInfoCtorFn defaults to createMCRelocationInfo
       return MCRelocationInfoCtorFn(TT, Ctx);
     }
 
+    /// createMCSymbolizer - Create a target specific MCSymbolizer.
+    ///
+    /// \param TT The target triple.
+    /// \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(StringRef TT, LLVMOpInfoCallback GetOpInfo,
+                       LLVMSymbolLookupCallback SymbolLookUp,
+                       void *DisInfo,
+                       MCContext *Ctx, MCRelocationInfo *RelInfo) const {
+      return MCSymbolizerCtorFn(TT, GetOpInfo, SymbolLookUp, DisInfo,
+                                Ctx, RelInfo);
+    }
+
     /// @}
   };
 
@@ -790,10 +827,25 @@ namespace llvm {
     /// @param Fn - A function to construct an MCRelocationInfo for the target.
     static void RegisterMCRelocationInfo(Target &T,
                                          Target::MCRelocationInfoCtorTy Fn) {
-      if (!T.MCRelocationInfoCtorFn)
+      if (T.MCRelocationInfoCtorFn == llvm::createMCRelocationInfo)
         T.MCRelocationInfoCtorFn = Fn;
     }
 
+    /// RegisterMCSymbolizer - Register an MCSymbolizer
+    /// implementation for the given target.
+    ///
+    /// Clients are responsible for ensuring that registration doesn't occur
+    /// while another thread is attempting to access the registry. Typically
+    /// this is done by initializing all targets at program startup.
+    ///
+    /// @param T - The target being registered.
+    /// @param Fn - A function to construct an MCSymbolizer for the target.
+    static void RegisterMCSymbolizer(Target &T,
+                                     Target::MCSymbolizerCtorTy Fn) {
+      if (T.MCSymbolizerCtorFn == llvm::createMCSymbolizer)
+        T.MCSymbolizerCtorFn = Fn;
+    }
+
     /// @}
   };
 

lib/MC/MCDisassembler.cpp

@@ -23,9 +23,14 @@ MCDisassembler::setupForSymbolicDisassembly(
     void *DisInfo,
     MCContext *Ctx,
     OwningPtr<MCRelocationInfo> &RelInfo) {
+  this->GetOpInfo = GetOpInfo;
+  this->SymbolLookUp = SymbolLookUp;
+  this->DisInfo = DisInfo;
+  this->Ctx = Ctx;
   assert(Ctx != 0 && "No MCContext given for symbolic disassembly");
-  Symbolizer.reset(new MCExternalSymbolizer(*Ctx, RelInfo, GetOpInfo,
+  if (!Symbolizer)
-                                            SymbolLookUp, DisInfo));
+    Symbolizer.reset(new MCExternalSymbolizer(*Ctx, RelInfo, GetOpInfo,
+                                              SymbolLookUp, DisInfo));
 }
 
 bool MCDisassembler::tryAddingSymbolicOperand(MCInst &Inst, int64_t Value,

lib/MC/MCDisassembler/Disassembler.cpp

@@ -18,6 +18,7 @@
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCRelocationInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/MC/MCSymbolizer.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MemoryObject.h"
 #include "llvm/Support/TargetRegistry.h"
@@ -80,9 +81,12 @@ LLVMDisasmContextRef LLVMCreateDisasmCPU(const char *Triple, const char *CPU,
   if (!RelInfo)
     return 0;
 
+  OwningPtr<MCSymbolizer> Symbolizer(
+    TheTarget->createMCSymbolizer(Triple, GetOpInfo, SymbolLookUp, DisInfo,
+                                  Ctx, RelInfo.take()));
+  DisAsm->setSymbolizer(Symbolizer);
   DisAsm->setupForSymbolicDisassembly(GetOpInfo, SymbolLookUp, DisInfo,
                                       Ctx, RelInfo);
-
   // Set up the instruction printer.
   int AsmPrinterVariant = MAI->getAssemblerDialect();
   MCInstPrinter *IP = TheTarget->createMCInstPrinter(AsmPrinterVariant,

lib/MC/MCExternalSymbolizer.cpp

@@ -144,3 +144,17 @@ void MCExternalSymbolizer::tryAddingPcLoadReferenceComment(raw_ostream &cStream,
       cStream << "literal pool for: " << ReferenceName;
   }
 }
+
+namespace llvm {
+MCSymbolizer *createMCSymbolizer(StringRef TT, LLVMOpInfoCallback GetOpInfo,
+                                 LLVMSymbolLookupCallback SymbolLookUp,
+                                 void *DisInfo,
+                                 MCContext *Ctx,
+                                 MCRelocationInfo *RelInfo) {
+  assert(Ctx != 0 && "No MCContext given for symbolic disassembly");
+
+  OwningPtr<MCRelocationInfo> RelInfoOwingPtr(RelInfo);
+  return new MCExternalSymbolizer(*Ctx, RelInfoOwingPtr, GetOpInfo,
+                                  SymbolLookUp, DisInfo);
+}
+}

lib/MC/MCRelocationInfo.cpp

@@ -34,6 +34,6 @@ MCRelocationInfo::createExprForCAPIVariantKind(const MCExpr *SubExpr,
   return SubExpr;
 }
 
-MCRelocationInfo *llvm::createMCRelocationInfo(MCContext &Ctx) {
+MCRelocationInfo *llvm::createMCRelocationInfo(StringRef TT, MCContext &Ctx) {
   return new MCRelocationInfo(Ctx);
 }

lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.cpp

@@ -212,12 +212,13 @@ static MCInstPrinter *createARMMCInstPrinter(const Target &T,
   return 0;
 }
 
-static MCRelocationInfo *createMCRelocationInfo(StringRef TT, MCContext &Ctx) {
+static MCRelocationInfo *createARMMCRelocationInfo(StringRef TT,
+                                                   MCContext &Ctx) {
   Triple TheTriple(TT);
   if (TheTriple.isEnvironmentMachO())
     return createARMMachORelocationInfo(Ctx);
   // Default to the stock relocation info.
-  return llvm::createMCRelocationInfo(Ctx);
+  return llvm::createMCRelocationInfo(TT, Ctx);
 }
 
 namespace {
@@ -307,7 +308,7 @@ extern "C" void LLVMInitializeARMTargetMC() {
 
   // Register the MC relocation info.
   TargetRegistry::RegisterMCRelocationInfo(TheARMTarget,
-                                           createMCRelocationInfo);
+                                           createARMMCRelocationInfo);
   TargetRegistry::RegisterMCRelocationInfo(TheThumbTarget,
-                                           createMCRelocationInfo);
+                                           createARMMCRelocationInfo);
 }

lib/Target/X86/MCTargetDesc/X86MCTargetDesc.cpp

@@ -384,14 +384,15 @@ static MCInstPrinter *createX86MCInstPrinter(const Target &T,
   return 0;
 }
 
-static MCRelocationInfo *createMCRelocationInfo(StringRef TT, MCContext &Ctx) {
+static MCRelocationInfo *createX86MCRelocationInfo(StringRef TT,
+                                                   MCContext &Ctx) {
   Triple TheTriple(TT);
   if (TheTriple.isEnvironmentMachO() && TheTriple.getArch() == Triple::x86_64)
     return createX86_64MachORelocationInfo(Ctx);
   else if (TheTriple.isOSBinFormatELF())
     return createX86_64ELFRelocationInfo(Ctx);
   // Default to the stock relocation info.
-  return llvm::createMCRelocationInfo(Ctx);
+  return llvm::createMCRelocationInfo(TT, Ctx);
 }
 
 static MCInstrAnalysis *createX86MCInstrAnalysis(const MCInstrInfo *Info) {
@@ -454,7 +455,7 @@ extern "C" void LLVMInitializeX86TargetMC() {
 
   // Register the MC relocation info.
   TargetRegistry::RegisterMCRelocationInfo(TheX86_32Target,
-                                           createMCRelocationInfo);
+                                           createX86MCRelocationInfo);
   TargetRegistry::RegisterMCRelocationInfo(TheX86_64Target,
-                                           createMCRelocationInfo);
+                                           createX86MCRelocationInfo);
 }