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