1 //===-EDDisassembler.h - LLVM Enhanced Disassembler -------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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.
14 //===----------------------------------------------------------------------===//
16 #ifndef EDDisassembler_
17 #define EDDisassembler_
21 #include "llvm-c/EnhancedDisassembly.h"
23 #include "llvm/ADT/OwningPtr.h"
24 #include "llvm/ADT/Triple.h"
25 #include "llvm/Support/raw_ostream.h"
26 #include "llvm/System/Mutex.h"
41 class TargetAsmParser;
45 class MCParsedAsmOperand;
47 template <typename T> class SmallVectorImpl;
50 class TargetRegisterInfo;
53 /// EDDisassembler - Encapsulates a disassembler for a single architecture and
54 /// disassembly syntax. Also manages the static disassembler registry.
55 struct EDDisassembler {
60 /// CPUKey - Encapsulates the descriptor of an architecture/disassembly-syntax
63 /// The architecture type
64 llvm::Triple::ArchType Arch;
66 /// The assembly syntax
67 EDAssemblySyntax_t Syntax;
69 /// operator== - Equality operator
70 bool operator==(const CPUKey &key) const {
71 return (Arch == key.Arch &&
72 Syntax == key.Syntax);
75 /// operator< - Less-than operator
76 bool operator<(const CPUKey &key) const {
79 if(Syntax >= key.Syntax)
85 typedef std::map<CPUKey, EDDisassembler*> DisassemblerMap_t;
87 /// True if the disassembler registry has been initialized; false if not
88 static bool sInitialized;
89 /// A map from disassembler specifications to disassemblers. Populated
91 static DisassemblerMap_t sDisassemblers;
93 /// getDisassembler - Returns the specified disassemble, or NULL on failure
95 /// @arg arch - The desired architecture
96 /// @arg syntax - The desired disassembly syntax
97 static EDDisassembler *getDisassembler(llvm::Triple::ArchType arch,
98 EDAssemblySyntax_t syntax);
100 /// getDisassembler - Returns the disassembler for a given combination of
101 /// CPU type, CPU subtype, and assembly syntax, or NULL on failure
103 /// @arg str - The string representation of the architecture triple, e.g.,
104 /// "x86_64-apple-darwin"
105 /// @arg syntax - The disassembly syntax for the required disassembler
106 static EDDisassembler *getDisassembler(llvm::StringRef str,
107 EDAssemblySyntax_t syntax);
109 /// initialize - Initializes the disassembler registry and the LLVM backend
110 static void initialize();
112 ////////////////////////
113 // Per-object members //
114 ////////////////////////
116 /// True only if the object has been fully and successfully initialized
119 /// The string that stores disassembler errors from the backend
120 std::string ErrorString;
121 /// The stream that wraps the ErrorString
122 llvm::raw_string_ostream ErrorStream;
124 /// The architecture/syntax pair for the current architecture
126 /// The LLVM target corresponding to the disassembler
127 const llvm::Target *Tgt;
128 /// The assembly information for the target architecture
129 llvm::OwningPtr<const llvm::MCAsmInfo> AsmInfo;
130 /// The disassembler for the target architecture
131 llvm::OwningPtr<const llvm::MCDisassembler> Disassembler;
132 /// The output string for the instruction printer; must be guarded with
134 llvm::OwningPtr<std::string> InstString;
135 /// The output stream for the disassembler; must be guarded with
137 llvm::OwningPtr<llvm::raw_string_ostream> InstStream;
138 /// The instruction printer for the target architecture; must be guarded with
139 /// PrinterMutex when printing
140 llvm::OwningPtr<llvm::MCInstPrinter> InstPrinter;
141 /// The mutex that guards the instruction printer's printing functions, which
142 /// use a shared stream
143 llvm::sys::Mutex PrinterMutex;
144 /// The array of instruction information provided by the TableGen backend for
145 /// the target architecture
146 const InstInfo *InstInfos;
147 /// The target-specific lexer for use in tokenizing strings, in
148 /// target-independent and target-specific portions
149 llvm::OwningPtr<llvm::AsmLexer> GenericAsmLexer;
150 llvm::OwningPtr<llvm::TargetAsmLexer> SpecificAsmLexer;
151 /// The guard for the above
152 llvm::sys::Mutex ParserMutex;
153 /// The LLVM number used for the target disassembly syntax variant
154 int LLVMSyntaxVariant;
156 typedef std::vector<std::string> regvec_t;
157 typedef std::map<std::string, unsigned> regrmap_t;
159 /// A vector of registers for quick mapping from LLVM register IDs to names
161 /// A map of registers for quick mapping from register names to LLVM IDs
164 /// A set of register IDs for aliases of the stack pointer for the current
166 std::set<unsigned> stackPointers;
167 /// A set of register IDs for aliases of the program counter for the current
169 std::set<unsigned> programCounters;
171 /// Constructor - initializes a disassembler with all the necessary objects,
172 /// which come pre-allocated from the registry accessor function
174 /// @arg key - the architecture and disassembly syntax for the
176 EDDisassembler(CPUKey& key);
178 /// valid - reports whether there was a failure in the constructor.
185 /// createInst - creates and returns an instruction given a callback and
186 /// memory address, or NULL on failure
188 /// @arg byteReader - A callback function that provides machine code bytes
189 /// @arg address - The address of the first byte of the instruction,
190 /// suitable for passing to byteReader
191 /// @arg arg - An opaque argument for byteReader
192 EDInst *createInst(EDByteReaderCallback byteReader,
196 /// initMaps - initializes regVec and regRMap using the provided register
199 /// @arg registerInfo - the register information to use as a source
200 void initMaps(const llvm::TargetRegisterInfo ®isterInfo);
201 /// nameWithRegisterID - Returns the name (owned by the EDDisassembler) of a
202 /// register for a given register ID, or NULL on failure
204 /// @arg registerID - the ID of the register to be queried
205 const char *nameWithRegisterID(unsigned registerID) const;
206 /// registerIDWithName - Returns the ID of a register for a given register
207 /// name, or (unsigned)-1 on failure
209 /// @arg name - The name of the register
210 unsigned registerIDWithName(const char *name) const;
212 /// registerIsStackPointer - reports whether a register ID is an alias for the
213 /// stack pointer register
215 /// @arg registerID - The LLVM register ID
216 bool registerIsStackPointer(unsigned registerID);
217 /// registerIsStackPointer - reports whether a register ID is an alias for the
218 /// stack pointer register
220 /// @arg registerID - The LLVM register ID
221 bool registerIsProgramCounter(unsigned registerID);
223 /// printInst - prints an MCInst to a string, returning 0 on success, or -1
226 /// @arg str - A reference to a string which is filled in with the string
227 /// representation of the instruction
228 /// @arg inst - A reference to the MCInst to be printed
229 int printInst(std::string& str,
232 /// parseInst - extracts operands and tokens from a string for use in
233 /// tokenizing the string. Returns 0 on success, or -1 otherwise.
235 /// @arg operands - A reference to a vector that will be filled in with the
237 /// @arg tokens - A reference to a vector that will be filled in with the
239 /// @arg str - The string representation of the instruction
240 int parseInst(llvm::SmallVectorImpl<llvm::MCParsedAsmOperand*> &operands,
241 llvm::SmallVectorImpl<llvm::AsmToken> &tokens,
242 const std::string &str);
244 /// llvmSyntaxVariant - returns the LLVM syntax variant for this disassembler
245 int llvmSyntaxVariant() const;