1// Copyright 2014, ARM Limited
2// All rights reserved.
3//
4// Redistribution and use in source and binary forms, with or without
5// modification, are permitted provided that the following conditions are met:
6//
7// * Redistributions of source code must retain the above copyright notice,
8// this list of conditions and the following disclaimer.
9// * Redistributions in binary form must reproduce the above copyright notice,
10// this list of conditions and the following disclaimer in the documentation
11// and/or other materials provided with the distribution.
12// * Neither the name of ARM Limited nor the names of its contributors may be
13// used to endorse or promote products derived from this software without
14// specific prior written permission.
15//
16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND
17// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
20// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
23// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26
27#ifndef VIXL_A64_DECODER_A64_H_
28#define VIXL_A64_DECODER_A64_H_
29
30#include <list>
31
32#include "vixl/globals.h"
33#include "vixl/a64/instructions-a64.h"
34
35
36// List macro containing all visitors needed by the decoder class.
37
38#define VISITOR_LIST_THAT_RETURN(V) \
39 V(PCRelAddressing) \
40 V(AddSubImmediate) \
41 V(LogicalImmediate) \
42 V(MoveWideImmediate) \
43 V(Bitfield) \
44 V(Extract) \
45 V(UnconditionalBranch) \
46 V(UnconditionalBranchToRegister) \
47 V(CompareBranch) \
48 V(TestBranch) \
49 V(ConditionalBranch) \
50 V(System) \
51 V(Exception) \
52 V(LoadStorePairPostIndex) \
53 V(LoadStorePairOffset) \
54 V(LoadStorePairPreIndex) \
55 V(LoadStorePairNonTemporal) \
56 V(LoadLiteral) \
57 V(LoadStoreUnscaledOffset) \
58 V(LoadStorePostIndex) \
59 V(LoadStorePreIndex) \
60 V(LoadStoreRegisterOffset) \
61 V(LoadStoreUnsignedOffset) \
62 V(LoadStoreExclusive) \
63 V(LogicalShifted) \
64 V(AddSubShifted) \
65 V(AddSubExtended) \
66 V(AddSubWithCarry) \
67 V(ConditionalCompareRegister) \
68 V(ConditionalCompareImmediate) \
69 V(ConditionalSelect) \
70 V(DataProcessing1Source) \
71 V(DataProcessing2Source) \
72 V(DataProcessing3Source) \
73 V(FPCompare) \
74 V(FPConditionalCompare) \
75 V(FPConditionalSelect) \
76 V(FPImmediate) \
77 V(FPDataProcessing1Source) \
78 V(FPDataProcessing2Source) \
79 V(FPDataProcessing3Source) \
80 V(FPIntegerConvert) \
81 V(FPFixedPointConvert) \
82 V(Crypto2RegSHA) \
83 V(Crypto3RegSHA) \
84 V(CryptoAES) \
85 V(NEON2RegMisc) \
86 V(NEON3Different) \
87 V(NEON3Same) \
88 V(NEONAcrossLanes) \
89 V(NEONByIndexedElement) \
90 V(NEONCopy) \
91 V(NEONExtract) \
92 V(NEONLoadStoreMultiStruct) \
93 V(NEONLoadStoreMultiStructPostIndex) \
94 V(NEONLoadStoreSingleStruct) \
95 V(NEONLoadStoreSingleStructPostIndex) \
96 V(NEONModifiedImmediate) \
97 V(NEONScalar2RegMisc) \
98 V(NEONScalar3Diff) \
99 V(NEONScalar3Same) \
100 V(NEONScalarByIndexedElement) \
101 V(NEONScalarCopy) \
102 V(NEONScalarPairwise) \
103 V(NEONScalarShiftImmediate) \
104 V(NEONShiftImmediate) \
105 V(NEONTable) \
106 V(NEONPerm) \
107
108#define VISITOR_LIST_THAT_DONT_RETURN(V) \
109 V(Unallocated) \
110 V(Unimplemented) \
111
112#define VISITOR_LIST(V) \
113 VISITOR_LIST_THAT_RETURN(V) \
114 VISITOR_LIST_THAT_DONT_RETURN(V) \
115
116namespace vixl {
117
118// The Visitor interface. Disassembler and simulator (and other tools)
119// must provide implementations for all of these functions.
120class DecoderVisitor {
121 public:
122 enum VisitorConstness {
123 kConstVisitor,
124 kNonConstVisitor
125 };
126 explicit DecoderVisitor(VisitorConstness constness = kConstVisitor)
127 : constness_(constness) {}
128
129 virtual ~DecoderVisitor() {}
130
131 #define DECLARE(A) virtual void Visit##A(const Instruction* instr) = 0;
132 VISITOR_LIST(DECLARE)
133 #undef DECLARE
134
135 bool IsConstVisitor() const { return constness_ == kConstVisitor; }
136 Instruction* MutableInstruction(const Instruction* instr) {
137 VIXL_ASSERT(!IsConstVisitor());
138 return const_cast<Instruction*>(instr);
139 }
140
141 private:
142 const VisitorConstness constness_;
143};
144
145
146class Decoder {
147 public:
148 Decoder() {}
149
150 // Top-level wrappers around the actual decoding function.
151 void Decode(const Instruction* instr) {
152 std::list<DecoderVisitor*>::iterator it;
153 for (it = visitors_.begin(); it != visitors_.end(); it++) {
154 VIXL_ASSERT((*it)->IsConstVisitor());
155 }
156 DecodeInstruction(instr);
157 }
158 void Decode(Instruction* instr) {
159 DecodeInstruction(const_cast<const Instruction*>(instr));
160 }
161
162 // Register a new visitor class with the decoder.
163 // Decode() will call the corresponding visitor method from all registered
164 // visitor classes when decoding reaches the leaf node of the instruction
165 // decode tree.
166 // Visitors are called in order.
167 // A visitor can be registered multiple times.
168 //
169 // d.AppendVisitor(V1);
170 // d.AppendVisitor(V2);
171 // d.PrependVisitor(V2);
172 // d.AppendVisitor(V3);
173 //
174 // d.Decode(i);
175 //
176 // will call in order visitor methods in V2, V1, V2, V3.
177 void AppendVisitor(DecoderVisitor* visitor);
178 void PrependVisitor(DecoderVisitor* visitor);
179 // These helpers register `new_visitor` before or after the first instance of
180 // `registered_visiter` in the list.
181 // So if
182 // V1, V2, V1, V2
183 // are registered in this order in the decoder, calls to
184 // d.InsertVisitorAfter(V3, V1);
185 // d.InsertVisitorBefore(V4, V2);
186 // will yield the order
187 // V1, V3, V4, V2, V1, V2
188 //
189 // For more complex modifications of the order of registered visitors, one can
190 // directly access and modify the list of visitors via the `visitors()'
191 // accessor.
192 void InsertVisitorBefore(DecoderVisitor* new_visitor,
193 DecoderVisitor* registered_visitor);
194 void InsertVisitorAfter(DecoderVisitor* new_visitor,
195 DecoderVisitor* registered_visitor);
196
197 // Remove all instances of a previously registered visitor class from the list
198 // of visitors stored by the decoder.
199 void RemoveVisitor(DecoderVisitor* visitor);
200
201 #define DECLARE(A) void Visit##A(const Instruction* instr);
202 VISITOR_LIST(DECLARE)
203 #undef DECLARE
204
205
206 std::list<DecoderVisitor*>* visitors() { return &visitors_; }
207
208 private:
209 // Decodes an instruction and calls the visitor functions registered with the
210 // Decoder class.
211 void DecodeInstruction(const Instruction* instr);
212
213 // Decode the PC relative addressing instruction, and call the corresponding
214 // visitors.
215 // On entry, instruction bits 27:24 = 0x0.
216 void DecodePCRelAddressing(const Instruction* instr);
217
218 // Decode the add/subtract immediate instruction, and call the correspoding
219 // visitors.
220 // On entry, instruction bits 27:24 = 0x1.
221 void DecodeAddSubImmediate(const Instruction* instr);
222
223 // Decode the branch, system command, and exception generation parts of
224 // the instruction tree, and call the corresponding visitors.
225 // On entry, instruction bits 27:24 = {0x4, 0x5, 0x6, 0x7}.
226 void DecodeBranchSystemException(const Instruction* instr);
227
228 // Decode the load and store parts of the instruction tree, and call
229 // the corresponding visitors.
230 // On entry, instruction bits 27:24 = {0x8, 0x9, 0xC, 0xD}.
231 void DecodeLoadStore(const Instruction* instr);
232
233 // Decode the logical immediate and move wide immediate parts of the
234 // instruction tree, and call the corresponding visitors.
235 // On entry, instruction bits 27:24 = 0x2.
236 void DecodeLogical(const Instruction* instr);
237
238 // Decode the bitfield and extraction parts of the instruction tree,
239 // and call the corresponding visitors.
240 // On entry, instruction bits 27:24 = 0x3.
241 void DecodeBitfieldExtract(const Instruction* instr);
242
243 // Decode the data processing parts of the instruction tree, and call the
244 // corresponding visitors.
245 // On entry, instruction bits 27:24 = {0x1, 0xA, 0xB}.
246 void DecodeDataProcessing(const Instruction* instr);
247
248 // Decode the floating point parts of the instruction tree, and call the
249 // corresponding visitors.
250 // On entry, instruction bits 27:24 = {0xE, 0xF}.
251 void DecodeFP(const Instruction* instr);
252
253 // Decode the Advanced SIMD (NEON) load/store part of the instruction tree,
254 // and call the corresponding visitors.
255 // On entry, instruction bits 29:25 = 0x6.
256 void DecodeNEONLoadStore(const Instruction* instr);
257
258 // Decode the Advanced SIMD (NEON) vector data processing part of the
259 // instruction tree, and call the corresponding visitors.
260 // On entry, instruction bits 28:25 = 0x7.
261 void DecodeNEONVectorDataProcessing(const Instruction* instr);
262
263 // Decode the Advanced SIMD (NEON) scalar data processing part of the
264 // instruction tree, and call the corresponding visitors.
265 // On entry, instruction bits 28:25 = 0xF.
266 void DecodeNEONScalarDataProcessing(const Instruction* instr);
267
268 private:
269 // Visitors are registered in a list.
270 std::list<DecoderVisitor*> visitors_;
271};
272
273} // namespace vixl
274
275#endif // VIXL_A64_DECODER_A64_H_
276