1//===- X86DisassemblerTables.cpp - Disassembler tables ----------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file is part of the X86 Disassembler Emitter.
10// It contains the implementation of the disassembler tables.
11// Documentation for the disassembler emitter in general can be found in
12// X86DisassemblerEmitter.h.
13//
14//===----------------------------------------------------------------------===//
15
16#include "X86DisassemblerTables.h"
17#include "X86DisassemblerShared.h"
18#include "X86ModRMFilters.h"
19#include "llvm/ADT/SmallVector.h"
20#include "llvm/Support/ErrorHandling.h"
21#include "llvm/Support/Format.h"
22#include "llvm/Support/raw_ostream.h"
23#include <map>
24
25using namespace llvm;
26using namespace X86Disassembler;
27
28/// stringForContext - Returns a string containing the name of a particular
29/// InstructionContext, usually for diagnostic purposes.
30///
31/// @param insnContext - The instruction class to transform to a string.
32/// @return - A statically-allocated string constant that contains the
33/// name of the instruction class.
34static inline const char *stringForContext(InstructionContext insnContext) {
35 switch (insnContext) {
36 default:
37 llvm_unreachable("Unhandled instruction class");
38#define ENUM_ENTRY(n, r, d) \
39 case n: \
40 return #n; \
41 break;
42#define ENUM_ENTRY_K_B(n, r, d) \
43 ENUM_ENTRY(n, r, d) \
44 ENUM_ENTRY(n##_K_B, r, d) \
45 ENUM_ENTRY(n##_KZ, r, d) \
46 ENUM_ENTRY(n##_K, r, d) ENUM_ENTRY(n##_B, r, d) ENUM_ENTRY(n##_KZ_B, r, d)
47 INSTRUCTION_CONTEXTS
48#undef ENUM_ENTRY
49#undef ENUM_ENTRY_K_B
50 }
51}
52
53/// stringForOperandType - Like stringForContext, but for OperandTypes.
54static inline const char *stringForOperandType(OperandType type) {
55 switch (type) {
56 default:
57 llvm_unreachable("Unhandled type");
58#define ENUM_ENTRY(i, d) \
59 case i: \
60 return #i;
61 TYPES
62#undef ENUM_ENTRY
63 }
64}
65
66/// stringForOperandEncoding - like stringForContext, but for
67/// OperandEncodings.
68static inline const char *stringForOperandEncoding(OperandEncoding encoding) {
69 switch (encoding) {
70 default:
71 llvm_unreachable("Unhandled encoding");
72#define ENUM_ENTRY(i, d) \
73 case i: \
74 return #i;
75 ENCODINGS
76#undef ENUM_ENTRY
77 }
78}
79
80/// inheritsFrom - Indicates whether all instructions in one class also belong
81/// to another class.
82///
83/// @param child - The class that may be the subset
84/// @param parent - The class that may be the superset
85/// @return - True if child is a subset of parent, false otherwise.
86static inline bool inheritsFrom(InstructionContext child,
87 InstructionContext parent, bool noPrefix = true,
88 bool VEX_LIG = false, bool WIG = false,
89 bool AdSize64 = false) {
90 if (child == parent)
91 return true;
92
93 switch (parent) {
94 case IC:
95 return (inheritsFrom(child, parent: IC_64BIT, noPrefix: AdSize64) ||
96 (noPrefix && inheritsFrom(child, parent: IC_OPSIZE, noPrefix)) ||
97 inheritsFrom(child, parent: IC_ADSIZE) ||
98 (noPrefix && inheritsFrom(child, parent: IC_XD, noPrefix)) ||
99 (noPrefix && inheritsFrom(child, parent: IC_XS, noPrefix)));
100 case IC_64BIT:
101 return (inheritsFrom(child, parent: IC_64BIT_REXW) ||
102 inheritsFrom(child, parent: IC_64BIT_REX2) ||
103 (noPrefix && inheritsFrom(child, parent: IC_64BIT_OPSIZE, noPrefix)) ||
104 (!AdSize64 && inheritsFrom(child, parent: IC_64BIT_ADSIZE)) ||
105 (noPrefix && inheritsFrom(child, parent: IC_64BIT_XD, noPrefix)) ||
106 (noPrefix && inheritsFrom(child, parent: IC_64BIT_XS, noPrefix)));
107 case IC_OPSIZE:
108 return inheritsFrom(child, parent: IC_64BIT_OPSIZE) ||
109 inheritsFrom(child, parent: IC_OPSIZE_ADSIZE);
110 case IC_ADSIZE:
111 return (noPrefix && inheritsFrom(child, parent: IC_OPSIZE_ADSIZE, noPrefix));
112 case IC_OPSIZE_ADSIZE:
113 return false;
114 case IC_64BIT_ADSIZE:
115 return (noPrefix && inheritsFrom(child, parent: IC_64BIT_OPSIZE_ADSIZE, noPrefix));
116 case IC_64BIT_OPSIZE_ADSIZE:
117 return false;
118 case IC_XD:
119 return inheritsFrom(child, parent: IC_64BIT_XD);
120 case IC_XS:
121 return inheritsFrom(child, parent: IC_64BIT_XS);
122 case IC_XD_OPSIZE:
123 return inheritsFrom(child, parent: IC_64BIT_XD_OPSIZE);
124 case IC_XS_OPSIZE:
125 return inheritsFrom(child, parent: IC_64BIT_XS_OPSIZE);
126 case IC_XD_ADSIZE:
127 return inheritsFrom(child, parent: IC_64BIT_XD_ADSIZE);
128 case IC_XS_ADSIZE:
129 return inheritsFrom(child, parent: IC_64BIT_XS_ADSIZE);
130 case IC_64BIT_REXW:
131 return ((noPrefix && inheritsFrom(child, parent: IC_64BIT_REXW_XS, noPrefix)) ||
132 (noPrefix && inheritsFrom(child, parent: IC_64BIT_REXW_XD, noPrefix)) ||
133 (noPrefix && inheritsFrom(child, parent: IC_64BIT_REXW_OPSIZE, noPrefix)) ||
134 (!AdSize64 && inheritsFrom(child, parent: IC_64BIT_REXW_ADSIZE)));
135 case IC_64BIT_OPSIZE:
136 return inheritsFrom(child, parent: IC_64BIT_REXW_OPSIZE) ||
137 (!AdSize64 && inheritsFrom(child, parent: IC_64BIT_OPSIZE_ADSIZE)) ||
138 (!AdSize64 && inheritsFrom(child, parent: IC_64BIT_REXW_ADSIZE));
139 case IC_64BIT_XD:
140 return (inheritsFrom(child, parent: IC_64BIT_REXW_XD) ||
141 (!AdSize64 && inheritsFrom(child, parent: IC_64BIT_XD_ADSIZE)));
142 case IC_64BIT_XS:
143 return (inheritsFrom(child, parent: IC_64BIT_REXW_XS) ||
144 (!AdSize64 && inheritsFrom(child, parent: IC_64BIT_XS_ADSIZE)));
145 case IC_64BIT_XD_OPSIZE:
146 case IC_64BIT_XS_OPSIZE:
147 return false;
148 case IC_64BIT_XD_ADSIZE:
149 case IC_64BIT_XS_ADSIZE:
150 return false;
151 case IC_64BIT_REXW_XD:
152 case IC_64BIT_REXW_XS:
153 case IC_64BIT_REXW_OPSIZE:
154 case IC_64BIT_REXW_ADSIZE:
155 case IC_64BIT_REX2_REXW:
156 return false;
157 case IC_64BIT_REX2:
158 return inheritsFrom(child, parent: IC_64BIT_REX2_REXW);
159 case IC_VEX:
160 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_VEX_L_W)) ||
161 (WIG && inheritsFrom(child, parent: IC_VEX_W)) ||
162 (VEX_LIG && inheritsFrom(child, parent: IC_VEX_L));
163 case IC_VEX_XS:
164 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_VEX_L_W_XS)) ||
165 (WIG && inheritsFrom(child, parent: IC_VEX_W_XS)) ||
166 (VEX_LIG && inheritsFrom(child, parent: IC_VEX_L_XS));
167 case IC_VEX_XD:
168 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_VEX_L_W_XD)) ||
169 (WIG && inheritsFrom(child, parent: IC_VEX_W_XD)) ||
170 (VEX_LIG && inheritsFrom(child, parent: IC_VEX_L_XD));
171 case IC_VEX_OPSIZE:
172 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_VEX_L_W_OPSIZE)) ||
173 (WIG && inheritsFrom(child, parent: IC_VEX_W_OPSIZE)) ||
174 (VEX_LIG && inheritsFrom(child, parent: IC_VEX_L_OPSIZE));
175 case IC_VEX_W:
176 return VEX_LIG && inheritsFrom(child, parent: IC_VEX_L_W);
177 case IC_VEX_W_XS:
178 return VEX_LIG && inheritsFrom(child, parent: IC_VEX_L_W_XS);
179 case IC_VEX_W_XD:
180 return VEX_LIG && inheritsFrom(child, parent: IC_VEX_L_W_XD);
181 case IC_VEX_W_OPSIZE:
182 return VEX_LIG && inheritsFrom(child, parent: IC_VEX_L_W_OPSIZE);
183 case IC_VEX_L:
184 return WIG && inheritsFrom(child, parent: IC_VEX_L_W);
185 case IC_VEX_L_XS:
186 return WIG && inheritsFrom(child, parent: IC_VEX_L_W_XS);
187 case IC_VEX_L_XD:
188 return WIG && inheritsFrom(child, parent: IC_VEX_L_W_XD);
189 case IC_VEX_L_OPSIZE:
190 return WIG && inheritsFrom(child, parent: IC_VEX_L_W_OPSIZE);
191 case IC_VEX_L_W:
192 case IC_VEX_L_W_XS:
193 case IC_VEX_L_W_XD:
194 case IC_VEX_L_W_OPSIZE:
195 return false;
196 case IC_EVEX:
197 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W)) ||
198 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W)) ||
199 (WIG && inheritsFrom(child, parent: IC_EVEX_W)) ||
200 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L)) ||
201 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2));
202 case IC_EVEX_XS:
203 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XS)) ||
204 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XS)) ||
205 (WIG && inheritsFrom(child, parent: IC_EVEX_W_XS)) ||
206 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_XS)) ||
207 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_XS));
208 case IC_EVEX_XD:
209 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XD)) ||
210 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XD)) ||
211 (WIG && inheritsFrom(child, parent: IC_EVEX_W_XD)) ||
212 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_XD)) ||
213 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_XD));
214 case IC_EVEX_OPSIZE:
215 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_OPSIZE)) ||
216 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_OPSIZE)) ||
217 (WIG && inheritsFrom(child, parent: IC_EVEX_W_OPSIZE)) ||
218 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_OPSIZE)) ||
219 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_OPSIZE));
220 case IC_EVEX_OPSIZE_ADSIZE:
221 case IC_EVEX_XS_ADSIZE:
222 case IC_EVEX_XD_ADSIZE:
223 return false;
224 case IC_EVEX_K:
225 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_K)) ||
226 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_K)) ||
227 (WIG && inheritsFrom(child, parent: IC_EVEX_W_K)) ||
228 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_K)) ||
229 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_K));
230 case IC_EVEX_XS_K:
231 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XS_K)) ||
232 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XS_K)) ||
233 (WIG && inheritsFrom(child, parent: IC_EVEX_W_XS_K)) ||
234 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_XS_K)) ||
235 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_XS_K));
236 case IC_EVEX_XD_K:
237 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XD_K)) ||
238 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XD_K)) ||
239 (WIG && inheritsFrom(child, parent: IC_EVEX_W_XD_K)) ||
240 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_XD_K)) ||
241 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_XD_K));
242 case IC_EVEX_OPSIZE_K:
243 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_OPSIZE_K)) ||
244 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_OPSIZE_K)) ||
245 (WIG && inheritsFrom(child, parent: IC_EVEX_W_OPSIZE_K)) ||
246 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_OPSIZE_K)) ||
247 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_OPSIZE_K));
248 case IC_EVEX_KZ:
249 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_KZ)) ||
250 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_KZ)) ||
251 (WIG && inheritsFrom(child, parent: IC_EVEX_W_KZ)) ||
252 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_KZ)) ||
253 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_KZ));
254 case IC_EVEX_XS_KZ:
255 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XS_KZ)) ||
256 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XS_KZ)) ||
257 (WIG && inheritsFrom(child, parent: IC_EVEX_W_XS_KZ)) ||
258 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_XS_KZ)) ||
259 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_XS_KZ));
260 case IC_EVEX_XD_KZ:
261 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XD_KZ)) ||
262 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XD_KZ)) ||
263 (WIG && inheritsFrom(child, parent: IC_EVEX_W_XD_KZ)) ||
264 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_XD_KZ)) ||
265 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_XD_KZ));
266 case IC_EVEX_OPSIZE_KZ:
267 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_OPSIZE_KZ)) ||
268 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_OPSIZE_KZ)) ||
269 (WIG && inheritsFrom(child, parent: IC_EVEX_W_OPSIZE_KZ)) ||
270 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_OPSIZE_KZ)) ||
271 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_OPSIZE_KZ));
272 case IC_EVEX_W:
273 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W)) ||
274 inheritsFrom(child, parent: IC_EVEX_W_OPSIZE) ||
275 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W));
276 case IC_EVEX_W_XS:
277 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_XS)) ||
278 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XS));
279 case IC_EVEX_W_XD:
280 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_XD)) ||
281 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XD));
282 case IC_EVEX_W_OPSIZE:
283 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_OPSIZE)) ||
284 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_OPSIZE));
285 case IC_EVEX_W_K:
286 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_K)) ||
287 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_K));
288 case IC_EVEX_W_XS_K:
289 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_XS_K)) ||
290 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XS_K));
291 case IC_EVEX_W_XD_K:
292 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_XD_K)) ||
293 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XD_K));
294 case IC_EVEX_W_OPSIZE_K:
295 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_OPSIZE_K)) ||
296 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_OPSIZE_K));
297 case IC_EVEX_W_KZ:
298 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_KZ)) ||
299 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_KZ));
300 case IC_EVEX_W_XS_KZ:
301 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_XS_KZ)) ||
302 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XS_KZ));
303 case IC_EVEX_W_XD_KZ:
304 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_XD_KZ)) ||
305 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XD_KZ));
306 case IC_EVEX_W_OPSIZE_KZ:
307 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_OPSIZE_KZ)) ||
308 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_OPSIZE_KZ));
309 case IC_EVEX_L:
310 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W);
311 case IC_EVEX_L_XS:
312 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XS);
313 case IC_EVEX_L_XD:
314 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XD);
315 case IC_EVEX_L_OPSIZE:
316 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_OPSIZE);
317 case IC_EVEX_L_K:
318 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_K);
319 case IC_EVEX_L_XS_K:
320 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XS_K);
321 case IC_EVEX_L_XD_K:
322 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XD_K);
323 case IC_EVEX_L_OPSIZE_K:
324 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_OPSIZE_K);
325 case IC_EVEX_L_KZ:
326 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_KZ);
327 case IC_EVEX_L_XS_KZ:
328 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XS_KZ);
329 case IC_EVEX_L_XD_KZ:
330 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XD_KZ);
331 case IC_EVEX_L_OPSIZE_KZ:
332 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_OPSIZE_KZ);
333 case IC_EVEX_L_W:
334 case IC_EVEX_L_W_XS:
335 case IC_EVEX_L_W_XD:
336 case IC_EVEX_L_W_OPSIZE:
337 return false;
338 case IC_EVEX_L_W_K:
339 case IC_EVEX_L_W_XS_K:
340 case IC_EVEX_L_W_XD_K:
341 case IC_EVEX_L_W_OPSIZE_K:
342 return false;
343 case IC_EVEX_L_W_KZ:
344 case IC_EVEX_L_W_XS_KZ:
345 case IC_EVEX_L_W_XD_KZ:
346 case IC_EVEX_L_W_OPSIZE_KZ:
347 return false;
348 case IC_EVEX_L2:
349 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W);
350 case IC_EVEX_L2_XS:
351 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XS);
352 case IC_EVEX_L2_XD:
353 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XD);
354 case IC_EVEX_L2_OPSIZE:
355 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_OPSIZE);
356 case IC_EVEX_L2_K:
357 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_K);
358 case IC_EVEX_L2_XS_K:
359 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XS_K);
360 case IC_EVEX_L2_XD_K:
361 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XD_K);
362 case IC_EVEX_L2_OPSIZE_K:
363 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_OPSIZE_K);
364 case IC_EVEX_L2_KZ:
365 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_KZ);
366 case IC_EVEX_L2_XS_KZ:
367 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XS_KZ);
368 case IC_EVEX_L2_XD_KZ:
369 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XD_KZ);
370 case IC_EVEX_L2_OPSIZE_KZ:
371 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_OPSIZE_KZ);
372 case IC_EVEX_L2_W:
373 case IC_EVEX_L2_W_XS:
374 case IC_EVEX_L2_W_XD:
375 case IC_EVEX_L2_W_OPSIZE:
376 return false;
377 case IC_EVEX_L2_W_K:
378 case IC_EVEX_L2_W_XS_K:
379 case IC_EVEX_L2_W_XD_K:
380 case IC_EVEX_L2_W_OPSIZE_K:
381 return false;
382 case IC_EVEX_L2_W_KZ:
383 case IC_EVEX_L2_W_XS_KZ:
384 case IC_EVEX_L2_W_XD_KZ:
385 case IC_EVEX_L2_W_OPSIZE_KZ:
386 return false;
387 case IC_EVEX_B:
388 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_B)) ||
389 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_B)) ||
390 (WIG && inheritsFrom(child, parent: IC_EVEX_W_B)) ||
391 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_B)) ||
392 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_B));
393 case IC_EVEX_XS_B:
394 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XS_B)) ||
395 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XS_B)) ||
396 (WIG && inheritsFrom(child, parent: IC_EVEX_W_XS_B)) ||
397 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_XS_B)) ||
398 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_XS_B));
399 case IC_EVEX_XD_B:
400 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XD_B)) ||
401 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XD_B)) ||
402 (WIG && inheritsFrom(child, parent: IC_EVEX_W_XD_B)) ||
403 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_XD_B)) ||
404 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_XD_B));
405 case IC_EVEX_OPSIZE_B:
406 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_OPSIZE_B)) ||
407 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_OPSIZE_B)) ||
408 (WIG && inheritsFrom(child, parent: IC_EVEX_W_OPSIZE_B)) ||
409 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_OPSIZE_B)) ||
410 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_OPSIZE_B));
411 case IC_EVEX_K_B:
412 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_K_B)) ||
413 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_K_B)) ||
414 (WIG && inheritsFrom(child, parent: IC_EVEX_W_K_B)) ||
415 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_K_B)) ||
416 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_K_B));
417 case IC_EVEX_XS_K_B:
418 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XS_K_B)) ||
419 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XS_K_B)) ||
420 (WIG && inheritsFrom(child, parent: IC_EVEX_W_XS_K_B)) ||
421 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_XS_K_B)) ||
422 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_XS_K_B));
423 case IC_EVEX_XD_K_B:
424 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XD_K_B)) ||
425 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XD_K_B)) ||
426 (WIG && inheritsFrom(child, parent: IC_EVEX_W_XD_K_B)) ||
427 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_XD_K_B)) ||
428 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_XD_K_B));
429 case IC_EVEX_OPSIZE_K_B:
430 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_OPSIZE_K_B)) ||
431 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_OPSIZE_K_B)) ||
432 (WIG && inheritsFrom(child, parent: IC_EVEX_W_OPSIZE_K_B)) ||
433 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_OPSIZE_K_B)) ||
434 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_OPSIZE_K_B));
435 case IC_EVEX_KZ_B:
436 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_KZ_B)) ||
437 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_KZ_B)) ||
438 (WIG && inheritsFrom(child, parent: IC_EVEX_W_KZ_B)) ||
439 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_KZ_B)) ||
440 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_KZ_B));
441 case IC_EVEX_XS_KZ_B:
442 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XS_KZ_B)) ||
443 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XS_KZ_B)) ||
444 (WIG && inheritsFrom(child, parent: IC_EVEX_W_XS_KZ_B)) ||
445 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_XS_KZ_B)) ||
446 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_XS_KZ_B));
447 case IC_EVEX_XD_KZ_B:
448 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XD_KZ_B)) ||
449 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XD_KZ_B)) ||
450 (WIG && inheritsFrom(child, parent: IC_EVEX_W_XD_KZ_B)) ||
451 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_XD_KZ_B)) ||
452 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_XD_KZ_B));
453 case IC_EVEX_OPSIZE_KZ_B:
454 return (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L_W_OPSIZE_KZ_B)) ||
455 (VEX_LIG && WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_OPSIZE_KZ_B)) ||
456 (WIG && inheritsFrom(child, parent: IC_EVEX_W_OPSIZE_KZ_B)) ||
457 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_OPSIZE_KZ_B)) ||
458 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_OPSIZE_KZ_B));
459 case IC_EVEX_W_B:
460 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_B)) ||
461 inheritsFrom(child, parent: IC_EVEX_W_OPSIZE_B) ||
462 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_B));
463 case IC_EVEX_W_XS_B:
464 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_XS_B)) ||
465 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XS_B));
466 case IC_EVEX_W_XD_B:
467 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_XD_B)) ||
468 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XD_B));
469 case IC_EVEX_W_OPSIZE_B:
470 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_OPSIZE_B)) ||
471 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_OPSIZE_B));
472 case IC_EVEX_W_K_B:
473 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_K_B)) ||
474 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_K_B));
475 case IC_EVEX_W_XS_K_B:
476 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_XS_K_B)) ||
477 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XS_K_B));
478 case IC_EVEX_W_XD_K_B:
479 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_XD_K_B)) ||
480 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XD_K_B));
481 case IC_EVEX_W_OPSIZE_K_B:
482 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_OPSIZE_K_B)) ||
483 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_OPSIZE_K_B));
484 case IC_EVEX_W_KZ_B:
485 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_KZ_B)) ||
486 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_KZ_B));
487 case IC_EVEX_W_XS_KZ_B:
488 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_XS_KZ_B)) ||
489 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XS_KZ_B));
490 case IC_EVEX_W_XD_KZ_B:
491 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_XD_KZ_B)) ||
492 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XD_KZ_B));
493 case IC_EVEX_W_OPSIZE_KZ_B:
494 return (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L_W_OPSIZE_KZ_B)) ||
495 (VEX_LIG && inheritsFrom(child, parent: IC_EVEX_L2_W_OPSIZE_KZ_B));
496 case IC_EVEX_L_B:
497 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_B);
498 case IC_EVEX_L_XS_B:
499 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XS_B);
500 case IC_EVEX_L_XD_B:
501 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XD_B);
502 case IC_EVEX_L_OPSIZE_B:
503 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_OPSIZE_B);
504 case IC_EVEX_L_K_B:
505 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_K_B);
506 case IC_EVEX_L_XS_K_B:
507 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XS_K_B);
508 case IC_EVEX_L_XD_K_B:
509 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XD_K_B);
510 case IC_EVEX_L_OPSIZE_K_B:
511 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_OPSIZE_K_B);
512 case IC_EVEX_L_KZ_B:
513 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_KZ_B);
514 case IC_EVEX_L_XS_KZ_B:
515 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XS_KZ_B);
516 case IC_EVEX_L_XD_KZ_B:
517 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_XD_KZ_B);
518 case IC_EVEX_L_OPSIZE_KZ_B:
519 return WIG && inheritsFrom(child, parent: IC_EVEX_L_W_OPSIZE_KZ_B);
520 case IC_EVEX_L_W_B:
521 case IC_EVEX_L_W_XS_B:
522 case IC_EVEX_L_W_XD_B:
523 case IC_EVEX_L_W_OPSIZE_B:
524 return false;
525 case IC_EVEX_L_W_K_B:
526 case IC_EVEX_L_W_XS_K_B:
527 case IC_EVEX_L_W_XD_K_B:
528 case IC_EVEX_L_W_OPSIZE_K_B:
529 return false;
530 case IC_EVEX_L_W_KZ_B:
531 case IC_EVEX_L_W_XS_KZ_B:
532 case IC_EVEX_L_W_XD_KZ_B:
533 case IC_EVEX_L_W_OPSIZE_KZ_B:
534 return false;
535 case IC_EVEX_L2_B:
536 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_B);
537 case IC_EVEX_L2_XS_B:
538 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XS_B);
539 case IC_EVEX_L2_XD_B:
540 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XD_B);
541 case IC_EVEX_L2_OPSIZE_B:
542 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_OPSIZE_B);
543 case IC_EVEX_L2_K_B:
544 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_K_B);
545 case IC_EVEX_L2_XS_K_B:
546 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XS_K_B);
547 case IC_EVEX_L2_XD_K_B:
548 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XD_K_B);
549 case IC_EVEX_L2_OPSIZE_K_B:
550 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_OPSIZE_K_B);
551 case IC_EVEX_L2_KZ_B:
552 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_KZ_B);
553 case IC_EVEX_L2_XS_KZ_B:
554 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XS_KZ_B);
555 case IC_EVEX_L2_XD_KZ_B:
556 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_XD_KZ_B);
557 case IC_EVEX_L2_OPSIZE_KZ_B:
558 return WIG && inheritsFrom(child, parent: IC_EVEX_L2_W_OPSIZE_KZ_B);
559 case IC_EVEX_L2_W_B:
560 case IC_EVEX_L2_W_XS_B:
561 case IC_EVEX_L2_W_XD_B:
562 case IC_EVEX_L2_W_OPSIZE_B:
563 return false;
564 case IC_EVEX_L2_W_K_B:
565 case IC_EVEX_L2_W_XS_K_B:
566 case IC_EVEX_L2_W_XD_K_B:
567 case IC_EVEX_L2_W_OPSIZE_K_B:
568 return false;
569 case IC_EVEX_L2_W_KZ_B:
570 case IC_EVEX_L2_W_XS_KZ_B:
571 case IC_EVEX_L2_W_XD_KZ_B:
572 case IC_EVEX_L2_W_OPSIZE_KZ_B:
573 return false;
574 case IC_EVEX_NF:
575 return WIG && inheritsFrom(child, parent: IC_EVEX_W_NF);
576 case IC_EVEX_B_NF:
577 return WIG && inheritsFrom(child, parent: IC_EVEX_W_B_NF);
578 case IC_EVEX_OPSIZE_NF:
579 case IC_EVEX_OPSIZE_B_NF:
580 case IC_EVEX_W_NF:
581 case IC_EVEX_W_B_NF:
582 return false;
583 case IC_EVEX_B_U:
584 case IC_EVEX_XS_B_U:
585 case IC_EVEX_XD_B_U:
586 case IC_EVEX_OPSIZE_B_U:
587 case IC_EVEX_W_B_U:
588 case IC_EVEX_W_XS_B_U:
589 case IC_EVEX_W_XD_B_U:
590 case IC_EVEX_W_OPSIZE_B_U:
591 case IC_EVEX_K_B_U:
592 case IC_EVEX_XS_K_B_U:
593 case IC_EVEX_XD_K_B_U:
594 case IC_EVEX_OPSIZE_K_B_U:
595 case IC_EVEX_W_K_B_U:
596 case IC_EVEX_W_XS_K_B_U:
597 case IC_EVEX_W_XD_K_B_U:
598 case IC_EVEX_W_OPSIZE_K_B_U:
599 case IC_EVEX_KZ_B_U:
600 case IC_EVEX_XS_KZ_B_U:
601 case IC_EVEX_XD_KZ_B_U:
602 case IC_EVEX_OPSIZE_KZ_B_U:
603 case IC_EVEX_W_KZ_B_U:
604 case IC_EVEX_W_XS_KZ_B_U:
605 case IC_EVEX_W_XD_KZ_B_U:
606 case IC_EVEX_W_OPSIZE_KZ_B_U:
607 return false;
608 default:
609 errs() << "Unknown instruction class: " << stringForContext(insnContext: parent) << "\n";
610 llvm_unreachable("Unknown instruction class");
611 }
612}
613
614/// outranks - Indicates whether, if an instruction has two different applicable
615/// classes, which class should be preferred when performing decode. This
616/// imposes a total ordering (ties are resolved toward "lower")
617///
618/// @param upper - The class that may be preferable
619/// @param lower - The class that may be less preferable
620/// @return - True if upper is to be preferred, false otherwise.
621static inline bool outranks(InstructionContext upper,
622 InstructionContext lower) {
623 assert(upper < IC_max);
624 assert(lower < IC_max);
625
626#define ENUM_ENTRY(n, r, d) r,
627#define ENUM_ENTRY_K_B(n, r, d) \
628 ENUM_ENTRY(n, r, d) \
629 ENUM_ENTRY(n##_K_B, r, d) \
630 ENUM_ENTRY(n##_KZ_B, r, d) \
631 ENUM_ENTRY(n##_KZ, r, d) ENUM_ENTRY(n##_K, r, d) ENUM_ENTRY(n##_B, r, d)
632 static int ranks[IC_max] = {INSTRUCTION_CONTEXTS};
633#undef ENUM_ENTRY
634#undef ENUM_ENTRY_K_B
635
636 return (ranks[upper] > ranks[lower]);
637}
638
639/// getDecisionType - Determines whether a ModRM decision with 255 entries can
640/// be compacted by eliminating redundant information.
641///
642/// @param decision - The decision to be compacted.
643/// @return - The compactest available representation for the decision.
644static ModRMDecisionType getDecisionType(ModRMDecision &decision) {
645 bool satisfiesOneEntry = true;
646 bool satisfiesSplitRM = true;
647 bool satisfiesSplitReg = true;
648 bool satisfiesSplitMisc = true;
649
650 for (unsigned index = 0; index < 256; ++index) {
651 if (decision.instructionIDs[index] != decision.instructionIDs[0])
652 satisfiesOneEntry = false;
653
654 if (((index & 0xc0) == 0xc0) &&
655 (decision.instructionIDs[index] != decision.instructionIDs[0xc0]))
656 satisfiesSplitRM = false;
657
658 if (((index & 0xc0) != 0xc0) &&
659 (decision.instructionIDs[index] != decision.instructionIDs[0x00]))
660 satisfiesSplitRM = false;
661
662 if (((index & 0xc0) == 0xc0) && (decision.instructionIDs[index] !=
663 decision.instructionIDs[index & 0xf8]))
664 satisfiesSplitReg = false;
665
666 if (((index & 0xc0) != 0xc0) && (decision.instructionIDs[index] !=
667 decision.instructionIDs[index & 0x38]))
668 satisfiesSplitMisc = false;
669 }
670
671 if (satisfiesOneEntry)
672 return MODRM_ONEENTRY;
673
674 if (satisfiesSplitRM)
675 return MODRM_SPLITRM;
676
677 if (satisfiesSplitReg && satisfiesSplitMisc)
678 return MODRM_SPLITREG;
679
680 if (satisfiesSplitMisc)
681 return MODRM_SPLITMISC;
682
683 return MODRM_FULL;
684}
685
686/// stringForDecisionType - Returns a statically-allocated string corresponding
687/// to a particular decision type.
688///
689/// @param dt - The decision type.
690/// @return - A pointer to the statically-allocated string (e.g.,
691/// "MODRM_ONEENTRY" for MODRM_ONEENTRY).
692static const char *stringForDecisionType(ModRMDecisionType dt) {
693#define ENUM_ENTRY(n) \
694 case n: \
695 return #n;
696 switch (dt) {
697 default:
698 llvm_unreachable("Unknown decision type");
699 MODRMTYPES
700 };
701#undef ENUM_ENTRY
702}
703
704DisassemblerTables::DisassemblerTables() {
705 for (unsigned i = 0; i < std::size(Tables); i++)
706 Tables[i] = std::make_unique<ContextDecision>();
707
708 HasConflicts = false;
709}
710
711DisassemblerTables::~DisassemblerTables() = default;
712
713void DisassemblerTables::emitModRMDecision(raw_ostream &o1, raw_ostream &o2,
714 unsigned &i1, unsigned &i2,
715 unsigned &ModRMTableNum,
716 ModRMDecision &decision) const {
717 static uint64_t sEntryNumber = 1;
718 ModRMDecisionType dt = getDecisionType(decision);
719
720 if (dt == MODRM_ONEENTRY && decision.instructionIDs[0] == 0) {
721 // Empty table.
722 o2 << "{" << stringForDecisionType(dt) << ", 0}";
723 return;
724 }
725
726 std::vector<unsigned> ModRMDecision;
727
728 switch (dt) {
729 default:
730 llvm_unreachable("Unknown decision type");
731 case MODRM_ONEENTRY:
732 ModRMDecision.push_back(x: decision.instructionIDs[0]);
733 break;
734 case MODRM_SPLITRM:
735 ModRMDecision.push_back(x: decision.instructionIDs[0x00]);
736 ModRMDecision.push_back(x: decision.instructionIDs[0xc0]);
737 break;
738 case MODRM_SPLITREG:
739 for (unsigned index = 0; index < 64; index += 8)
740 ModRMDecision.push_back(x: decision.instructionIDs[index]);
741 for (unsigned index = 0xc0; index < 256; index += 8)
742 ModRMDecision.push_back(x: decision.instructionIDs[index]);
743 break;
744 case MODRM_SPLITMISC:
745 for (unsigned index = 0; index < 64; index += 8)
746 ModRMDecision.push_back(x: decision.instructionIDs[index]);
747 for (unsigned index = 0xc0; index < 256; ++index)
748 ModRMDecision.push_back(x: decision.instructionIDs[index]);
749 break;
750 case MODRM_FULL:
751 llvm::append_range(C&: ModRMDecision, R&: decision.instructionIDs);
752 break;
753 }
754
755 unsigned &EntryNumber = ModRMTable[ModRMDecision];
756 if (EntryNumber == 0) {
757 EntryNumber = ModRMTableNum;
758
759 ModRMTableNum += ModRMDecision.size();
760 o1 << "/*Table" << EntryNumber << "*/\n";
761 i1++;
762 for (unsigned I : ModRMDecision) {
763 o1.indent(NumSpaces: i1 * 2) << format(Fmt: "0x%hx", Vals: I) << ", /*"
764 << InstructionSpecifiers[I].name << "*/\n";
765 }
766 i1--;
767 }
768
769 o2 << "{" << stringForDecisionType(dt) << ", " << EntryNumber << "}";
770
771 switch (dt) {
772 default:
773 llvm_unreachable("Unknown decision type");
774 case MODRM_ONEENTRY:
775 sEntryNumber += 1;
776 break;
777 case MODRM_SPLITRM:
778 sEntryNumber += 2;
779 break;
780 case MODRM_SPLITREG:
781 sEntryNumber += 16;
782 break;
783 case MODRM_SPLITMISC:
784 sEntryNumber += 8 + 64;
785 break;
786 case MODRM_FULL:
787 sEntryNumber += 256;
788 break;
789 }
790
791 // We assume that the index can fit into uint32_t.
792 assert(sEntryNumber < -1U &&
793 "Index into ModRMDecision is too large for uint32_t!");
794 (void)sEntryNumber;
795}
796
797void DisassemblerTables::emitOpcodeDecision(raw_ostream &o1, raw_ostream &o2,
798 unsigned &i1, unsigned &i2,
799 unsigned &ModRMTableNum,
800 OpcodeDecision &opDecision) const {
801 o2 << "{";
802 ++i2;
803
804 unsigned index;
805 for (index = 0; index < 256; ++index) {
806 auto &decision = opDecision.modRMDecisions[index];
807 ModRMDecisionType dt = getDecisionType(decision);
808 if (!(dt == MODRM_ONEENTRY && decision.instructionIDs[0] == 0))
809 break;
810 }
811 if (index == 256) {
812 // If all 256 entries are MODRM_ONEENTRY, omit output.
813 static_assert(MODRM_ONEENTRY == 0);
814 --i2;
815 o2 << "},\n";
816 } else {
817 o2 << " /* struct OpcodeDecision */ {\n";
818 for (index = 0; index < 256; ++index) {
819 o2.indent(NumSpaces: i2);
820
821 o2 << "/*0x" << format(Fmt: "%02hhx", Vals: index) << "*/";
822
823 emitModRMDecision(o1, o2, i1, i2, ModRMTableNum,
824 decision&: opDecision.modRMDecisions[index]);
825
826 if (index < 255)
827 o2 << ",";
828
829 o2 << "\n";
830 }
831 o2.indent(NumSpaces: i2) << "}\n";
832 --i2;
833 o2.indent(NumSpaces: i2) << "},\n";
834 }
835}
836
837void DisassemblerTables::emitContextDecision(raw_ostream &o1, raw_ostream &o2,
838 unsigned &i1, unsigned &i2,
839 unsigned &ModRMTableNum,
840 ContextDecision &decision,
841 const char *name) const {
842 o2.indent(NumSpaces: i2) << "static const struct ContextDecision " << name
843 << " = {{/* opcodeDecisions */\n";
844 i2++;
845
846 for (unsigned index = 0; index < IC_max; ++index) {
847 o2.indent(NumSpaces: i2) << "/*";
848 o2 << stringForContext(insnContext: (InstructionContext)index);
849 o2 << "*/ ";
850
851 emitOpcodeDecision(o1, o2, i1, i2, ModRMTableNum,
852 opDecision&: decision.opcodeDecisions[index]);
853 }
854
855 i2--;
856 o2.indent(NumSpaces: i2) << "}};"
857 << "\n";
858}
859
860void DisassemblerTables::emitInstructionInfo(raw_ostream &o,
861 unsigned &i) const {
862 unsigned NumInstructions = InstructionSpecifiers.size();
863
864 o << "static const struct OperandSpecifier x86OperandSets[]["
865 << X86_MAX_OPERANDS << "] = {\n";
866
867 using OperandListTy =
868 SmallVector<std::pair<OperandEncoding, OperandType>, X86_MAX_OPERANDS>;
869 std::map<OperandListTy, unsigned> OperandSets;
870
871 unsigned OperandSetNum = 0;
872 for (unsigned Index = 0; Index < NumInstructions; ++Index) {
873 OperandListTy OperandList;
874
875 for (auto Operand : InstructionSpecifiers[Index].operands) {
876 OperandEncoding Encoding = (OperandEncoding)Operand.encoding;
877 OperandType Type = (OperandType)Operand.type;
878 OperandList.emplace_back(Args&: Encoding, Args&: Type);
879 }
880 unsigned &N = OperandSets[OperandList];
881 if (N != 0)
882 continue;
883
884 N = ++OperandSetNum;
885
886 o << " { /* " << (OperandSetNum - 1) << " */\n";
887 for (const auto &[Enc, Ty] : OperandList) {
888 const char *Encoding = stringForOperandEncoding(encoding: Enc);
889 const char *Type = stringForOperandType(type: Ty);
890 o << " { " << Encoding << ", " << Type << " },\n";
891 }
892 o << " },\n";
893 }
894 o << "};"
895 << "\n\n";
896
897 o.indent(NumSpaces: i * 2) << "static const struct InstructionSpecifier ";
898 o << INSTRUCTIONS_STR "[" << InstructionSpecifiers.size() << "] = {\n";
899
900 i++;
901
902 for (unsigned index = 0; index < NumInstructions; ++index) {
903 o.indent(NumSpaces: i * 2) << "{ /* " << index << " */\n";
904 i++;
905
906 OperandListTy OperandList;
907 for (auto Operand : InstructionSpecifiers[index].operands) {
908 OperandEncoding Encoding = (OperandEncoding)Operand.encoding;
909 OperandType Type = (OperandType)Operand.type;
910 OperandList.emplace_back(Args&: Encoding, Args&: Type);
911 }
912 o.indent(NumSpaces: i * 2) << (OperandSets[OperandList] - 1) << ",\n";
913
914 o.indent(NumSpaces: i * 2) << "/* " << InstructionSpecifiers[index].name << " */\n";
915
916 i--;
917 o.indent(NumSpaces: i * 2) << "},\n";
918 }
919
920 i--;
921 o.indent(NumSpaces: i * 2) << "};"
922 << "\n";
923}
924
925void DisassemblerTables::emitContextTable(raw_ostream &o, unsigned &i) const {
926 o.indent(NumSpaces: i * 2) << "static const uint8_t " CONTEXTS_STR "[" << ATTR_max
927 << "] = {\n";
928 i++;
929
930 for (unsigned index = 0; index < ATTR_max; ++index) {
931 o.indent(NumSpaces: i * 2);
932
933 if ((index & ATTR_EVEX) && (index & ATTR_ADSIZE) && (index & ATTR_OPSIZE))
934 o << "IC_EVEX_OPSIZE_ADSIZE";
935 else if ((index & ATTR_EVEX) && (index & ATTR_ADSIZE) && (index & ATTR_XD))
936 o << "IC_EVEX_XD_ADSIZE";
937 else if ((index & ATTR_EVEX) && (index & ATTR_ADSIZE) && (index & ATTR_XS))
938 o << "IC_EVEX_XS_ADSIZE";
939 else if (index & ATTR_EVEXNF) {
940 o << "IC_EVEX";
941 if (index & ATTR_REXW)
942 o << "_W";
943 else if (index & ATTR_OPSIZE)
944 o << "_OPSIZE";
945
946 if (index & ATTR_EVEXB)
947 o << "_B";
948
949 o << "_NF";
950 } else if ((index & ATTR_EVEX) || (index & ATTR_VEX) ||
951 (index & ATTR_VEXL)) {
952 if (index & ATTR_EVEX)
953 o << "IC_EVEX";
954 else
955 o << "IC_VEX";
956
957 if ((index & ATTR_EVEXB) && (index & ATTR_EVEXU))
958 ; // Ignore ATTR_VEXL and ATTR_EVEXL2 under YMM rounding.
959 else if ((index & ATTR_EVEX) && (index & ATTR_EVEXL2))
960 o << "_L2";
961 else if (index & ATTR_VEXL)
962 o << "_L";
963
964 if (index & ATTR_REXW)
965 o << "_W";
966
967 if (index & ATTR_OPSIZE)
968 o << "_OPSIZE";
969 else if (index & ATTR_XD)
970 o << "_XD";
971 else if (index & ATTR_XS)
972 o << "_XS";
973
974 if (index & ATTR_EVEX) {
975 if (index & ATTR_EVEXKZ)
976 o << "_KZ";
977 else if (index & ATTR_EVEXK)
978 o << "_K";
979
980 if (index & ATTR_EVEXB)
981 o << "_B";
982
983 if ((index & ATTR_EVEXB) && (index & ATTR_EVEXU))
984 o << "_U";
985 }
986 } else if ((index & ATTR_64BIT) && (index & ATTR_REX2)) {
987 o << "IC_64BIT_REX2";
988 if (index & ATTR_REXW)
989 o << "_REXW";
990 } else if ((index & ATTR_64BIT) && (index & ATTR_REXW) && (index & ATTR_XS))
991 o << "IC_64BIT_REXW_XS";
992 else if ((index & ATTR_64BIT) && (index & ATTR_REXW) && (index & ATTR_XD))
993 o << "IC_64BIT_REXW_XD";
994 else if ((index & ATTR_64BIT) && (index & ATTR_REXW) &&
995 (index & ATTR_OPSIZE))
996 o << "IC_64BIT_REXW_OPSIZE";
997 else if ((index & ATTR_64BIT) && (index & ATTR_REXW) &&
998 (index & ATTR_ADSIZE))
999 o << "IC_64BIT_REXW_ADSIZE";
1000 else if ((index & ATTR_64BIT) && (index & ATTR_XD) && (index & ATTR_OPSIZE))
1001 o << "IC_64BIT_XD_OPSIZE";
1002 else if ((index & ATTR_64BIT) && (index & ATTR_XD) && (index & ATTR_ADSIZE))
1003 o << "IC_64BIT_XD_ADSIZE";
1004 else if ((index & ATTR_64BIT) && (index & ATTR_XS) && (index & ATTR_OPSIZE))
1005 o << "IC_64BIT_XS_OPSIZE";
1006 else if ((index & ATTR_64BIT) && (index & ATTR_XS) && (index & ATTR_ADSIZE))
1007 o << "IC_64BIT_XS_ADSIZE";
1008 else if ((index & ATTR_64BIT) && (index & ATTR_XS))
1009 o << "IC_64BIT_XS";
1010 else if ((index & ATTR_64BIT) && (index & ATTR_XD))
1011 o << "IC_64BIT_XD";
1012 else if ((index & ATTR_64BIT) && (index & ATTR_OPSIZE) &&
1013 (index & ATTR_ADSIZE))
1014 o << "IC_64BIT_OPSIZE_ADSIZE";
1015 else if ((index & ATTR_64BIT) && (index & ATTR_OPSIZE))
1016 o << "IC_64BIT_OPSIZE";
1017 else if ((index & ATTR_64BIT) && (index & ATTR_ADSIZE))
1018 o << "IC_64BIT_ADSIZE";
1019 else if ((index & ATTR_64BIT) && (index & ATTR_REXW))
1020 o << "IC_64BIT_REXW";
1021 else if ((index & ATTR_64BIT))
1022 o << "IC_64BIT";
1023 else if ((index & ATTR_XS) && (index & ATTR_OPSIZE))
1024 o << "IC_XS_OPSIZE";
1025 else if ((index & ATTR_XD) && (index & ATTR_OPSIZE))
1026 o << "IC_XD_OPSIZE";
1027 else if ((index & ATTR_XS) && (index & ATTR_ADSIZE))
1028 o << "IC_XS_ADSIZE";
1029 else if ((index & ATTR_XD) && (index & ATTR_ADSIZE))
1030 o << "IC_XD_ADSIZE";
1031 else if (index & ATTR_XS)
1032 o << "IC_XS";
1033 else if (index & ATTR_XD)
1034 o << "IC_XD";
1035 else if ((index & ATTR_OPSIZE) && (index & ATTR_ADSIZE))
1036 o << "IC_OPSIZE_ADSIZE";
1037 else if (index & ATTR_OPSIZE)
1038 o << "IC_OPSIZE";
1039 else if (index & ATTR_ADSIZE)
1040 o << "IC_ADSIZE";
1041 else
1042 o << "IC";
1043
1044 o << ", // " << index << "\n";
1045 }
1046
1047 i--;
1048 o.indent(NumSpaces: i * 2) << "};"
1049 << "\n";
1050}
1051
1052void DisassemblerTables::emitContextDecisions(raw_ostream &o1, raw_ostream &o2,
1053 unsigned &i1, unsigned &i2,
1054 unsigned &ModRMTableNum) const {
1055 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, decision&: *Tables[0], ONEBYTE_STR);
1056 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, decision&: *Tables[1], TWOBYTE_STR);
1057 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, decision&: *Tables[2],
1058 THREEBYTE38_STR);
1059 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, decision&: *Tables[3],
1060 THREEBYTE3A_STR);
1061 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, decision&: *Tables[4], XOP8_MAP_STR);
1062 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, decision&: *Tables[5], XOP9_MAP_STR);
1063 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, decision&: *Tables[6], XOPA_MAP_STR);
1064 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, decision&: *Tables[7],
1065 THREEDNOW_MAP_STR);
1066 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, decision&: *Tables[8], MAP4_STR);
1067 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, decision&: *Tables[9], MAP5_STR);
1068 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, decision&: *Tables[10], MAP6_STR);
1069 emitContextDecision(o1, o2, i1, i2, ModRMTableNum, decision&: *Tables[11], MAP7_STR);
1070}
1071
1072void DisassemblerTables::emit(raw_ostream &o) const {
1073 unsigned i1 = 0;
1074 unsigned i2 = 0;
1075
1076 std::string s1;
1077 std::string s2;
1078
1079 raw_string_ostream o1(s1);
1080 raw_string_ostream o2(s2);
1081
1082 emitInstructionInfo(o, i&: i2);
1083 o << "\n";
1084
1085 emitContextTable(o, i&: i2);
1086 o << "\n";
1087
1088 unsigned ModRMTableNum = 0;
1089
1090 o << "static const InstrUID modRMTable[] = {\n";
1091 i1++;
1092 std::vector<unsigned> EmptyTable(1, 0);
1093 ModRMTable[EmptyTable] = ModRMTableNum;
1094 ModRMTableNum += EmptyTable.size();
1095 o1 << "/*EmptyTable*/\n";
1096 o1.indent(NumSpaces: i1 * 2) << "0x0,\n";
1097 i1--;
1098 emitContextDecisions(o1, o2, i1, i2, ModRMTableNum);
1099
1100 o << s1;
1101 o << " 0x0\n";
1102 o << "};\n";
1103 o << "\n";
1104 o << s2;
1105 o << "\n";
1106 o << "\n";
1107}
1108
1109void DisassemblerTables::setTableFields(ModRMDecision &decision,
1110 const ModRMFilter &filter, InstrUID uid,
1111 uint8_t opcode) {
1112 for (unsigned index = 0; index < 256; ++index) {
1113 if (filter.accepts(modRM: index)) {
1114 if (decision.instructionIDs[index] == uid)
1115 continue;
1116
1117 if (decision.instructionIDs[index] != 0) {
1118 InstructionSpecifier &newInfo = InstructionSpecifiers[uid];
1119 InstructionSpecifier &previousInfo =
1120 InstructionSpecifiers[decision.instructionIDs[index]];
1121
1122 if (previousInfo.name == "NOOP" &&
1123 (newInfo.name == "XCHG16ar" || newInfo.name == "XCHG32ar" ||
1124 newInfo.name == "XCHG64ar"))
1125 continue; // special case for XCHG*ar and NOOP
1126
1127 if (outranks(upper: previousInfo.insnContext, lower: newInfo.insnContext))
1128 continue;
1129
1130 if (previousInfo.insnContext == newInfo.insnContext) {
1131 errs() << "Error: Primary decode conflict: ";
1132 errs() << newInfo.name << " would overwrite " << previousInfo.name;
1133 errs() << "\n";
1134 errs() << "ModRM " << index << "\n";
1135 errs() << "Opcode " << (uint16_t)opcode << "\n";
1136 errs() << "Context " << stringForContext(insnContext: newInfo.insnContext) << "\n";
1137 HasConflicts = true;
1138 }
1139 }
1140
1141 decision.instructionIDs[index] = uid;
1142 }
1143 }
1144}
1145
1146void DisassemblerTables::setTableFields(
1147 OpcodeType type, InstructionContext insnContext, uint8_t opcode,
1148 const ModRMFilter &filter, InstrUID uid, bool is32bit, bool noPrefix,
1149 bool ignoresVEX_L, bool ignoresW, unsigned addressSize) {
1150 ContextDecision &decision = *Tables[type];
1151
1152 for (unsigned index = 0; index < IC_max; ++index) {
1153 if ((is32bit || addressSize == 16) &&
1154 inheritsFrom(child: (InstructionContext)index, parent: IC_64BIT))
1155 continue;
1156
1157 bool adSize64 = addressSize == 64;
1158 if (inheritsFrom(child: (InstructionContext)index,
1159 parent: InstructionSpecifiers[uid].insnContext, noPrefix,
1160 VEX_LIG: ignoresVEX_L, WIG: ignoresW, AdSize64: adSize64))
1161 setTableFields(decision&: decision.opcodeDecisions[index].modRMDecisions[opcode],
1162 filter, uid, opcode);
1163 }
1164}
1165