EDInst.h revision 847da55716e9c1d39c08ed052bc86d28796cb91f 
1//===-- EDInst.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// instruction class.  The instruction is responsible for vending the string
12// representation, individual tokens and operands for a single instruction.
13//
14//===----------------------------------------------------------------------===//
15
16#ifndef LLVM_EDINST_H
17#define LLVM_EDINST_H
18
19#include "llvm/ADT/SmallVector.h"
20#include <string>
21#include <vector>
22
23namespace llvm {
24  class MCInst;
25  struct EDInstInfo;
26  struct EDToken;
27  struct EDDisassembler;
28  struct EDOperand;
29
30#ifdef __BLOCKS__
31  typedef int (^EDTokenVisitor_t)(EDToken *token);
32#endif
33
34/// CachedResult - Encapsulates the result of a function along with the validity
35///   of that result, so that slow functions don't need to run twice
36struct CachedResult {
37  /// True if the result has been obtained by executing the function
38  bool Valid;
39  /// The result last obtained from the function
40  int Result;
41
42  /// Constructor - Initializes an invalid result
43  CachedResult() : Valid(false) { }
44  /// valid - Returns true if the result has been obtained by executing the
45  ///   function and false otherwise
46  bool valid() { return Valid; }
47  /// result - Returns the result of the function or an undefined value if
48  ///   valid() is false
49  int result() { return Result; }
50  /// setResult - Sets the result of the function and declares it valid
51  ///   returning the result (so that setResult() can be called from inside a
52  ///   return statement)
53  /// @arg result - The result of the function
54  int setResult(int result) { Result = result; Valid = true; return result; }
55};
56
57/// EDInst - Encapsulates a single instruction, which can be queried for its
58///   string representation, as well as its operands and tokens
59struct EDInst {
60  /// The parent disassembler
61  EDDisassembler &Disassembler;
62  /// The containing MCInst
63  llvm::MCInst *Inst;
64  /// The instruction information provided by TableGen for this instruction
65  const llvm::EDInstInfo *ThisInstInfo;
66  /// The number of bytes for the machine code representation of the instruction
67  uint64_t ByteSize;
68
69  /// The result of the stringify() function
70  CachedResult StringifyResult;
71  /// The string representation of the instruction
72  std::string String;
73  /// The order in which operands from the InstInfo's operand information appear
74  /// in String
75  const char* OperandOrder;
76
77  /// The result of the parseOperands() function
78  CachedResult ParseResult;
79  typedef llvm::SmallVector<EDOperand*, 5> opvec_t;
80  /// The instruction's operands
81  opvec_t Operands;
82  /// The operand corresponding to the target, if the instruction is a branch
83  int BranchTarget;
84  /// The operand corresponding to the source, if the instruction is a move
85  int MoveSource;
86  /// The operand corresponding to the target, if the instruction is a move
87  int MoveTarget;
88
89  /// The result of the tokenize() function
90  CachedResult TokenizeResult;
91  typedef std::vector<EDToken*> tokvec_t;
92  /// The instruction's tokens
93  tokvec_t Tokens;
94
95  /// Constructor - initializes an instruction given the output of the LLVM
96  ///   C++ disassembler
97  ///
98  /// @arg inst         - The MCInst, which will now be owned by this object
99  /// @arg byteSize     - The size of the consumed instruction, in bytes
100  /// @arg disassembler - The parent disassembler
101  /// @arg instInfo     - The instruction information produced by the table
102  ///                     generator for this instruction
103  EDInst(llvm::MCInst *inst,
104         uint64_t byteSize,
105         EDDisassembler &disassembler,
106         const llvm::EDInstInfo *instInfo);
107  ~EDInst();
108
109  /// byteSize - returns the number of bytes consumed by the machine code
110  ///   representation of the instruction
111  uint64_t byteSize();
112  /// instID - returns the LLVM instruction ID of the instruction
113  unsigned instID();
114
115  /// stringify - populates the String and AsmString members of the instruction,
116  ///   returning 0 on success or -1 otherwise
117  int stringify();
118  /// getString - retrieves a pointer to the string representation of the
119  ///   instructinon, returning 0 on success or -1 otherwise
120  ///
121  /// @arg str - A reference to a pointer that, on success, is set to point to
122  ///   the string representation of the instruction; this string is still owned
123  ///   by the instruction and will be deleted when it is
124  int getString(const char *&str);
125
126  /// isBranch - Returns true if the instruction is a branch
127  bool isBranch();
128  /// isMove - Returns true if the instruction is a move
129  bool isMove();
130
131  /// parseOperands - populates the Operands member of the instruction,
132  ///   returning 0 on success or -1 otherwise
133  int parseOperands();
134  /// branchTargetID - returns the ID (suitable for use with getOperand()) of
135  ///   the target operand if the instruction is a branch, or -1 otherwise
136  int branchTargetID();
137  /// moveSourceID - returns the ID of the source operand if the instruction
138  ///   is a move, or -1 otherwise
139  int moveSourceID();
140  /// moveTargetID - returns the ID of the target operand if the instruction
141  ///   is a move, or -1 otherwise
142  int moveTargetID();
143
144  /// numOperands - returns the number of operands available to retrieve, or -1
145  ///   on error
146  int numOperands();
147  /// getOperand - retrieves an operand from the instruction's operand list by
148  ///   index, returning 0 on success or -1 on error
149  ///
150  /// @arg operand  - A reference whose target is pointed at the operand on
151  ///                 success, although the operand is still owned by the EDInst
152  /// @arg index    - The index of the operand in the instruction
153  int getOperand(EDOperand *&operand, unsigned int index);
154
155  /// tokenize - populates the Tokens member of the instruction, returning 0 on
156  ///   success or -1 otherwise
157  int tokenize();
158  /// numTokens - returns the number of tokens in the instruction, or -1 on
159  ///   error
160  int numTokens();
161  /// getToken - retrieves a token from the instruction's token list by index,
162  ///   returning 0 on success or -1 on error
163  ///
164  /// @arg token  - A reference whose target is pointed at the token on success,
165  ///               although the token is still owned by the EDInst
166  /// @arg index  - The index of the token in the instrcutino
167  int getToken(EDToken *&token, unsigned int index);
168
169#ifdef __BLOCKS__
170  /// visitTokens - Visits each token in turn and applies a block to it,
171  ///   returning 0 if all blocks are visited and/or the block signals
172  ///   termination by returning 1; returns -1 on error
173  ///
174  /// @arg visitor  - The visitor block to apply to all tokens.
175  int visitTokens(EDTokenVisitor_t visitor);
176#endif
177};
178
179} // end namespace llvm
180
181#endif
182