lib/MC/MCDisassembler/EDDisassembler.h

   1 //===-- EDDisassembler.h - LLVM Enhanced Disassembler -----------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines the interface for the Enhanced Disassembly library's
  11 // disassembler class.  The disassembler is responsible for vending individual
  12 // instructions according to a given architecture and disassembly syntax.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #ifndef LLVM_EDDISASSEMBLER_H
  17 #define LLVM_EDDISASSEMBLER_H
  18
  19 #include "EDInfo.h"
  20
  21 #include "llvm/ADT/OwningPtr.h"
  22 #include "llvm/ADT/Triple.h"
  23 #include "llvm/Support/raw_ostream.h"
  24 #include "llvm/Support/Mutex.h"
  25
  26 #include <map>
  27 #include <set>
  28 #include <string>
  29 #include <vector>
  30
  31 namespace llvm {
  32 class AsmLexer;
  33 class AsmParser;
  34 class AsmToken;
  35 class MCContext;
  36 class MCAsmInfo;
  37 class MCAsmLexer;
  38 class MCDisassembler;
  39 class MCInstPrinter;
  40 class MCInst;
  41 class MCParsedAsmOperand;
  42 class MCRegisterInfo;
  43 class MCStreamer;
  44 class MCSubtargetInfo;
  45 class MCTargetAsmLexer;
  46 class MCTargetAsmParser;
  47 template <typename T> class SmallVectorImpl;
  48 class SourceMgr;
  49 class Target;
  50
  51 struct EDInstInfo;
  52 struct EDInst;
  53 struct EDOperand;
  54 struct EDToken;
  55
  56 typedef int (*EDByteReaderCallback)(uint8_t *byte, uint64_t address, void *arg);
  57
  58 /// EDDisassembler - Encapsulates a disassembler for a single architecture and
  59 ///   disassembly syntax.  Also manages the static disassembler registry.
  60 struct EDDisassembler {
  61   typedef enum {
  62     /*! @constant kEDAssemblySyntaxX86Intel Intel syntax for i386 and x86_64. */
  63     kEDAssemblySyntaxX86Intel  = 0,
  64     /*! @constant kEDAssemblySyntaxX86ATT AT&T syntax for i386 and x86_64. */
  65     kEDAssemblySyntaxX86ATT    = 1,
  66     kEDAssemblySyntaxARMUAL    = 2
  67   } AssemblySyntax;
  68
  69
  70   ////////////////////
  71   // Static members //
  72   ////////////////////
  73
  74   /// CPUKey - Encapsulates the descriptor of an architecture/disassembly-syntax
  75   ///   pair
  76   struct CPUKey {
  77     /// The architecture type
  78     std::string Triple;
  79
  80     /// The assembly syntax
  81     AssemblySyntax Syntax;
  82
  83     /// operator== - Equality operator
  84     bool operator==(const CPUKey &key) const {
  85       return (Triple == key.Triple &&
  86               Syntax == key.Syntax);
  87     }
  88
  89     /// operator< - Less-than operator
  90     bool operator<(const CPUKey &key) const {
  91       return ((Triple < key.Triple) ||
  92               ((Triple == key.Triple) && Syntax < (key.Syntax)));
  93     }
  94   };
  95
  96   typedef std::map<CPUKey, EDDisassembler*> DisassemblerMap_t;
  97
  98   /// A map from disassembler specifications to disassemblers.  Populated
  99   ///   lazily.
 100   static DisassemblerMap_t sDisassemblers;
 101
 102   /// getDisassembler - Returns the specified disassemble, or NULL on failure
 103   ///
 104   /// @arg arch   - The desired architecture
 105   /// @arg syntax - The desired disassembly syntax
 106   static EDDisassembler *getDisassembler(llvm::Triple::ArchType arch,
 107                                          AssemblySyntax syntax);
 108
 109   /// getDisassembler - Returns the disassembler for a given combination of
 110   ///   CPU type, CPU subtype, and assembly syntax, or NULL on failure
 111   ///
 112   /// @arg str    - The string representation of the architecture triple, e.g.,
 113   ///               "x86_64-apple-darwin"
 114   /// @arg syntax - The disassembly syntax for the required disassembler
 115   static EDDisassembler *getDisassembler(llvm::StringRef str,
 116                                          AssemblySyntax syntax);
 117
 118   ////////////////////////
 119   // Per-object members //
 120   ////////////////////////
 121
 122   /// True only if the object has been successfully initialized
 123   bool Valid;
 124   /// True if the disassembler can provide semantic information
 125   bool HasSemantics;
 126
 127   /// The stream to write errors to
 128   llvm::raw_ostream &ErrorStream;
 129
 130   /// The triple/syntax pair for the current architecture
 131   CPUKey Key;
 132   /// The Triple fur the current architecture
 133   Triple TgtTriple;
 134   /// The LLVM target corresponding to the disassembler
 135   const llvm::Target *Tgt;
 136   /// The assembly information for the target architecture
 137   llvm::OwningPtr<const llvm::MCAsmInfo> AsmInfo;
 138   /// The subtarget information for the target architecture
 139   llvm::OwningPtr<const llvm::MCSubtargetInfo> STI;
 140   // The register information for the target architecture.
 141   llvm::OwningPtr<const llvm::MCRegisterInfo> MRI;
 142   /// The disassembler for the target architecture
 143   llvm::OwningPtr<const llvm::MCDisassembler> Disassembler;
 144   /// The output string for the instruction printer; must be guarded with
 145   ///   PrinterMutex
 146   llvm::OwningPtr<std::string> InstString;
 147   /// The output stream for the disassembler; must be guarded with
 148   ///   PrinterMutex
 149   llvm::OwningPtr<llvm::raw_string_ostream> InstStream;
 150   /// The instruction printer for the target architecture; must be guarded with
 151   ///   PrinterMutex when printing
 152   llvm::OwningPtr<llvm::MCInstPrinter> InstPrinter;
 153   /// The mutex that guards the instruction printer's printing functions, which
 154   ///   use a shared stream
 155   llvm::sys::Mutex PrinterMutex;
 156   /// The array of instruction information provided by the TableGen backend for
 157   ///   the target architecture
 158   const llvm::EDInstInfo *InstInfos;
 159   /// The target-specific lexer for use in tokenizing strings, in
 160   ///   target-independent and target-specific portions
 161   llvm::OwningPtr<llvm::AsmLexer> GenericAsmLexer;
 162   llvm::OwningPtr<llvm::MCTargetAsmLexer> SpecificAsmLexer;
 163   /// The guard for the above
 164   llvm::sys::Mutex ParserMutex;
 165   /// The LLVM number used for the target disassembly syntax variant
 166   int LLVMSyntaxVariant;
 167
 168   typedef std::vector<std::string> regvec_t;
 169   typedef std::map<std::string, unsigned> regrmap_t;
 170
 171   /// A vector of registers for quick mapping from LLVM register IDs to names
 172   regvec_t RegVec;
 173   /// A map of registers for quick mapping from register names to LLVM IDs
 174   regrmap_t RegRMap;
 175
 176   /// A set of register IDs for aliases of the stack pointer for the current
 177   ///   architecture
 178   std::set<unsigned> stackPointers;
 179   /// A set of register IDs for aliases of the program counter for the current
 180   ///   architecture
 181   std::set<unsigned> programCounters;
 182
 183   /// Constructor - initializes a disassembler with all the necessary objects,
 184   ///   which come pre-allocated from the registry accessor function
 185   ///
 186   /// @arg key                - the architecture and disassembly syntax for the
 187   ///                           disassembler
 188   EDDisassembler(CPUKey& key);
 189
 190   /// valid - reports whether there was a failure in the constructor.
 191   bool valid() {
 192     return Valid;
 193   }
 194
 195   /// hasSemantics - reports whether the disassembler can provide operands and
 196   ///   tokens.
 197   bool hasSemantics() {
 198     return HasSemantics;
 199   }
 200
 201   ~EDDisassembler();
 202
 203   /// createInst - creates and returns an instruction given a callback and
 204   ///   memory address, or NULL on failure
 205   ///
 206   /// @arg byteReader - A callback function that provides machine code bytes
 207   /// @arg address    - The address of the first byte of the instruction,
 208   ///                   suitable for passing to byteReader
 209   /// @arg arg        - An opaque argument for byteReader
 210   EDInst *createInst(EDByteReaderCallback byteReader,
 211                      uint64_t address,
 212                      void *arg);
 213
 214   /// initMaps - initializes regVec and regRMap using the provided register
 215   ///   info
 216   ///
 217   /// @arg registerInfo - the register information to use as a source
 218   void initMaps(const llvm::MCRegisterInfo &registerInfo);
 219   /// nameWithRegisterID - Returns the name (owned by the EDDisassembler) of a
 220   ///   register for a given register ID, or NULL on failure
 221   ///
 222   /// @arg registerID - the ID of the register to be queried
 223   const char *nameWithRegisterID(unsigned registerID) const;
 224   /// registerIDWithName - Returns the ID of a register for a given register
 225   ///   name, or (unsigned)-1 on failure
 226   ///
 227   /// @arg name - The name of the register
 228   unsigned registerIDWithName(const char *name) const;
 229
 230   /// registerIsStackPointer - reports whether a register ID is an alias for the
 231   ///   stack pointer register
 232   ///
 233   /// @arg registerID - The LLVM register ID
 234   bool registerIsStackPointer(unsigned registerID);
 235   /// registerIsStackPointer - reports whether a register ID is an alias for the
 236   ///   stack pointer register
 237   ///
 238   /// @arg registerID - The LLVM register ID
 239   bool registerIsProgramCounter(unsigned registerID);
 240
 241   /// printInst - prints an MCInst to a string, returning 0 on success, or -1
 242   ///   otherwise
 243   ///
 244   /// @arg str  - A reference to a string which is filled in with the string
 245   ///             representation of the instruction
 246   /// @arg inst - A reference to the MCInst to be printed
 247   int printInst(std::string& str,
 248                 llvm::MCInst& inst);
 249
 250   /// parseInst - extracts operands and tokens from a string for use in
 251   ///   tokenizing the string.  Returns 0 on success, or -1 otherwise.
 252   ///
 253   /// @arg operands - A reference to a vector that will be filled in with the
 254   ///                 parsed operands
 255   /// @arg tokens   - A reference to a vector that will be filled in with the
 256   ///                 tokens
 257   /// @arg str      - The string representation of the instruction
 258   int parseInst(llvm::SmallVectorImpl<llvm::MCParsedAsmOperand*> &operands,
 259                 llvm::SmallVectorImpl<llvm::AsmToken> &tokens,
 260                 const std::string &str);
 261
 262   /// llvmSyntaxVariant - returns the LLVM syntax variant for this disassembler
 263   int llvmSyntaxVariant() const;
 264 };
 265
 266 } // end namespace llvm
 267
 268 #endif