X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FMC%2FMCDisassembler.h;h=d6b0a305b1daee90e9b7c5295135b37260551c70;hb=0f4df6dc6f0811556687bc59f8f34b6343078293;hp=e82b0c12291393ac2d677ee7d7475f3c524fb7ea;hpb=de7cbbfcce5c068f0699bdcb6dac093c0c91ba6f;p=oota-llvm.git

diff --git a/include/llvm/MC/MCDisassembler.h b/include/llvm/MC/MCDisassembler.h
index e82b0c12291..d6b0a305b1d 100644
--- a/include/llvm/MC/MCDisassembler.h
+++ b/include/llvm/MC/MCDisassembler.h
@@ -10,21 +10,20 @@
 #define LLVM_MC_MCDISASSEMBLER_H
 
 #include "llvm-c/Disassembler.h"
-#include "llvm/ADT/OwningPtr.h"
-#include "llvm/MC/MCSymbolizer.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/MC/MCRelocationInfo.h"
+#include "llvm/MC/MCSymbolizer.h"
 #include "llvm/Support/DataTypes.h"
 
 namespace llvm {
 
 class MCInst;
 class MCSubtargetInfo;
-class MemoryObject;
 class raw_ostream;
 class MCContext;
 
-/// MCDisassembler - Superclass for all disassemblers.  Consumes a memory region
-///   and provides an array of assembly instructions.
+/// Superclass for all disassemblers. Consumes a memory region and provides an
+/// array of assembly instructions.
 class MCDisassembler {
 public:
   /// Ternary decode status. Most backends will just use Fail and
@@ -55,54 +54,38 @@ public:
     Success = 3
   };
 
-  /// Constructor     - Performs initial setup for the disassembler.
-  MCDisassembler(const MCSubtargetInfo &STI) : GetOpInfo(0), SymbolLookUp(0),
-                                               DisInfo(0), Ctx(0),
-                                               STI(STI), Symbolizer(0),
-                                               CommentStream(0) {}
+  MCDisassembler(const MCSubtargetInfo &STI, MCContext &Ctx)
+    : Ctx(Ctx), STI(STI), Symbolizer(), CommentStream(nullptr) {}
 
   virtual ~MCDisassembler();
 
-  /// getInstruction  - Returns the disassembly of a single instruction.
+  /// Returns the disassembly of a single instruction.
   ///
-  /// @param instr    - An MCInst to populate with the contents of the
+  /// @param Instr    - An MCInst to populate with the contents of the
   ///                   instruction.
-  /// @param size     - A value to populate with the size of the instruction, or
+  /// @param Size     - A value to populate with the size of the instruction, or
   ///                   the number of bytes consumed while attempting to decode
   ///                   an invalid instruction.
-  /// @param region   - The memory object to use as a source for machine code.
-  /// @param address  - The address, in the memory space of region, of the first
+  /// @param Address  - The address, in the memory space of region, of the first
   ///                   byte of the instruction.
-  /// @param vStream  - The stream to print warnings and diagnostic messages on.
-  /// @param cStream  - The stream to print comments and annotations on.
+  /// @param VStream  - The stream to print warnings and diagnostic messages on.
+  /// @param CStream  - The stream to print comments and annotations on.
   /// @return         - MCDisassembler::Success if the instruction is valid,
   ///                   MCDisassembler::SoftFail if the instruction was
   ///                                            disassemblable but invalid,
   ///                   MCDisassembler::Fail if the instruction was invalid.
-  virtual DecodeStatus  getInstruction(MCInst& instr,
-                                       uint64_t& size,
-                                       const MemoryObject &region,
-                                       uint64_t address,
-                                       raw_ostream &vStream,
-                                       raw_ostream &cStream) const = 0;
+  virtual DecodeStatus getInstruction(MCInst &Instr, uint64_t &Size,
+                                      ArrayRef<uint8_t> Bytes, 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;
+  MCContext &Ctx;
 
 protected:
   // Subtarget information, for instruction decoding predicates if required.
   const MCSubtargetInfo &STI;
-  OwningPtr<MCSymbolizer> Symbolizer;
+  std::unique_ptr<MCSymbolizer> Symbolizer;
 
 public:
   // Helpers around MCSymbolizer
@@ -115,21 +98,11 @@ public:
 
   /// Set \p Symzer as the current symbolizer.
   /// This takes ownership of \p Symzer, and deletes the previously set one.
-  void setSymbolizer(OwningPtr<MCSymbolizer> &Symzer);
-
-  /// Sets up an external symbolizer that uses the C API callbacks.
-  void setupForSymbolicDisassembly(LLVMOpInfoCallback GetOpInfo,
-                                   LLVMSymbolLookupCallback SymbolLookUp,
-                                   void *DisInfo,
-                                   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; }
+  void setSymbolizer(std::unique_ptr<MCSymbolizer> Symzer);
+
+  MCContext& getContext() const { return Ctx; }
+
+  const MCSubtargetInfo& getSubtargetInfo() const { return STI; }
 
   // Marked mutable because we cache it inside the disassembler, rather than
   // having to pass it around as an argument through all the autogenerated code.