1 //===-EDInst.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 // instruction class. The instruction is responsible for vending the string
12 // representation, individual tokens and operands for a single instruction.
14 //===----------------------------------------------------------------------===//
19 #include "llvm-c/EnhancedDisassembly.h"
21 #include "llvm/ADT/SmallVector.h"
26 /// CachedResult - Encapsulates the result of a function along with the validity
27 /// of that result, so that slow functions don't need to run twice
29 /// True if the result has been obtained by executing the function
31 /// The result last obtained from the function
34 /// Constructor - Initializes an invalid result
35 CachedResult() : Valid(false) { }
36 /// valid - Returns true if the result has been obtained by executing the
37 /// function and false otherwise
38 bool valid() { return Valid; }
39 /// result - Returns the result of the function or an undefined value if
41 int result() { return Result; }
42 /// setResult - Sets the result of the function and declares it valid
43 /// returning the result (so that setResult() can be called from inside a
45 /// @arg result - The result of the function
46 int setResult(int result) { Result = result; Valid = true; return result; }
49 /// EDInst - Encapsulates a single instruction, which can be queried for its
50 /// string representation, as well as its operands and tokens
52 /// The parent disassembler
53 EDDisassembler &Disassembler;
54 /// The containing MCInst
56 /// The instruction information provided by TableGen for this instruction
57 const InstInfo *ThisInstInfo;
58 /// The number of bytes for the machine code representation of the instruction
61 /// The result of the stringify() function
62 CachedResult StringifyResult;
63 /// The string representation of the instruction
65 /// The order in which operands from the InstInfo's operand information appear
67 const char* OperandOrder;
69 /// The result of the parseOperands() function
70 CachedResult ParseResult;
71 typedef llvm::SmallVector<EDOperand*, 5> opvec_t;
72 /// The instruction's operands
74 /// The operand corresponding to the target, if the instruction is a branch
76 /// The operand corresponding to the source, if the instruction is a move
78 /// The operand corresponding to the target, if the instruction is a move
81 /// The result of the tokenize() function
82 CachedResult TokenizeResult;
83 typedef std::vector<EDToken*> tokvec_t;
84 /// The instruction's tokens
87 /// Constructor - initializes an instruction given the output of the LLVM
90 /// @arg inst - The MCInst, which will now be owned by this object
91 /// @arg byteSize - The size of the consumed instruction, in bytes
92 /// @arg disassembler - The parent disassembler
93 /// @arg instInfo - The instruction information produced by the table
94 /// generator for this instruction
95 EDInst(llvm::MCInst *inst,
97 EDDisassembler &disassembler,
98 const InstInfo *instInfo);
101 /// byteSize - returns the number of bytes consumed by the machine code
102 /// representation of the instruction
104 /// instID - returns the LLVM instruction ID of the instruction
107 /// stringify - populates the String and AsmString members of the instruction,
108 /// returning 0 on success or -1 otherwise
110 /// getString - retrieves a pointer to the string representation of the
111 /// instructinon, returning 0 on success or -1 otherwise
113 /// @arg str - A reference to a pointer that, on success, is set to point to
114 /// the string representation of the instruction; this string is still owned
115 /// by the instruction and will be deleted when it is
116 int getString(const char *&str);
118 /// isBranch - Returns true if the instruction is a branch
120 /// isMove - Returns true if the instruction is a move
123 /// parseOperands - populates the Operands member of the instruction,
124 /// returning 0 on success or -1 otherwise
126 /// branchTargetID - returns the ID (suitable for use with getOperand()) of
127 /// the target operand if the instruction is a branch, or -1 otherwise
128 int branchTargetID();
129 /// moveSourceID - returns the ID of the source operand if the instruction
130 /// is a move, or -1 otherwise
132 /// moveTargetID - returns the ID of the target operand if the instruction
133 /// is a move, or -1 otherwise
136 /// numOperands - returns the number of operands available to retrieve, or -1
139 /// getOperand - retrieves an operand from the instruction's operand list by
140 /// index, returning 0 on success or -1 on error
142 /// @arg operand - A reference whose target is pointed at the operand on
143 /// success, although the operand is still owned by the EDInst
144 /// @arg index - The index of the operand in the instruction
145 int getOperand(EDOperand *&operand, unsigned int index);
147 /// tokenize - populates the Tokens member of the instruction, returning 0 on
148 /// success or -1 otherwise
150 /// numTokens - returns the number of tokens in the instruction, or -1 on
153 /// getToken - retrieves a token from the instruction's token list by index,
154 /// returning 0 on success or -1 on error
156 /// @arg token - A reference whose target is pointed at the token on success,
157 /// although the token is still owned by the EDInst
158 /// @arg index - The index of the token in the instrcutino
159 int getToken(EDToken *&token, unsigned int index);
162 /// visitTokens - Visits each token in turn and applies a block to it,
163 /// returning 0 if all blocks are visited and/or the block signals
164 /// termination by returning 1; returns -1 on error
166 /// @arg visitor - The visitor block to apply to all tokens.
167 int visitTokens(EDTokenVisitor_t visitor);