1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* * BPF Disassembler *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* *|
7\*===----------------------------------------------------------------------===*/
8
9
10#include "llvm/MC/MCInst.h"
11#include "llvm/MC/MCSubtargetInfo.h"
12#include "llvm/Support/DataTypes.h"
13#include "llvm/Support/Debug.h"
14#include "llvm/Support/LEB128.h"
15#include "llvm/Support/raw_ostream.h"
16#include "llvm/TargetParser/SubtargetFeature.h"
17#include <assert.h>
18
19namespace {
20
21// Helper functions for extracting fields from encoded instructions.
22// InsnType must either be integral or an APInt-like object that must:
23// * be default-constructible and copy-constructible
24// * be constructible from an APInt (this can be private)
25// * Support insertBits(bits, startBit, numBits)
26// * Support extractBitsAsZExtValue(numBits, startBit)
27// * Support the ~, &, ==, and != operators with other objects of the same type
28// * Support the != and bitwise & with uint64_t
29// * Support put (<<) to raw_ostream&
30template <typename InsnType>
31#if defined(_MSC_VER) && !defined(__clang__)
32__declspec(noinline)
33#endif
34static std::enable_if_t<std::is_integral<InsnType>::value, InsnType>
35fieldFromInstruction(const InsnType &insn, unsigned startBit,
36 unsigned numBits) {
37 assert(startBit + numBits <= 64 && "Cannot support >64-bit extractions!");
38 assert(startBit + numBits <= (sizeof(InsnType) * 8) &&
39 "Instruction field out of bounds!");
40 InsnType fieldMask;
41 if (numBits == sizeof(InsnType) * 8)
42 fieldMask = (InsnType)(-1LL);
43 else
44 fieldMask = (((InsnType)1 << numBits) - 1) << startBit;
45 return (insn & fieldMask) >> startBit;
46}
47
48template <typename InsnType>
49static std::enable_if_t<!std::is_integral<InsnType>::value, uint64_t>
50fieldFromInstruction(const InsnType &insn, unsigned startBit,
51 unsigned numBits) {
52 return insn.extractBitsAsZExtValue(numBits, startBit);
53}
54
55// Helper function for inserting bits extracted from an encoded instruction into
56// a field.
57template <typename InsnType>
58static void insertBits(InsnType &field, InsnType bits, unsigned startBit,
59 unsigned numBits) {
60 if constexpr (std::is_integral<InsnType>::value) {
61 assert(startBit + numBits <= sizeof field * 8);
62 (void)numBits;
63 field |= (InsnType)bits << startBit;
64 } else {
65 field.insertBits(bits, startBit, numBits);
66 }
67}
68
69static bool Check(DecodeStatus &Out, DecodeStatus In) {
70 Out = static_cast<DecodeStatus>(Out & In);
71 return Out != MCDisassembler::Fail;
72}
73
74static const uint8_t DecoderTableBPF64[] = {
75/* 0 */ MCD::OPC_ExtractField, 56, 8, // Inst{63-56} ...
76/* 3 */ MCD::OPC_FilterValue, 4, 8, 0, // Skip to: 15
77/* 7 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
78/* 11 */ MCD::OPC_Decode, 196, 2, 0, // Opcode: ADD_ri_32, DecodeIdx: 0
79/* 15 */ MCD::OPC_FilterValue, 5, 4, 0, // Skip to: 23
80/* 19 */ MCD::OPC_Decode, 226, 2, 1, // Opcode: JMP, DecodeIdx: 1
81/* 23 */ MCD::OPC_FilterValue, 6, 4, 0, // Skip to: 31
82/* 27 */ MCD::OPC_Decode, 227, 2, 2, // Opcode: JMPL, DecodeIdx: 2
83/* 31 */ MCD::OPC_FilterValue, 7, 8, 0, // Skip to: 43
84/* 35 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
85/* 39 */ MCD::OPC_Decode, 195, 2, 3, // Opcode: ADD_ri, DecodeIdx: 3
86/* 43 */ MCD::OPC_FilterValue, 12, 8, 0, // Skip to: 55
87/* 47 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
88/* 51 */ MCD::OPC_Decode, 198, 2, 4, // Opcode: ADD_rr_32, DecodeIdx: 4
89/* 55 */ MCD::OPC_FilterValue, 15, 8, 0, // Skip to: 67
90/* 59 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
91/* 63 */ MCD::OPC_Decode, 197, 2, 5, // Opcode: ADD_rr, DecodeIdx: 5
92/* 67 */ MCD::OPC_FilterValue, 20, 8, 0, // Skip to: 79
93/* 71 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
94/* 75 */ MCD::OPC_Decode, 227, 3, 0, // Opcode: SUB_ri_32, DecodeIdx: 0
95/* 79 */ MCD::OPC_FilterValue, 21, 4, 0, // Skip to: 87
96/* 83 */ MCD::OPC_Decode, 222, 2, 6, // Opcode: JEQ_ri, DecodeIdx: 6
97/* 87 */ MCD::OPC_FilterValue, 22, 4, 0, // Skip to: 95
98/* 91 */ MCD::OPC_Decode, 223, 2, 7, // Opcode: JEQ_ri_32, DecodeIdx: 7
99/* 95 */ MCD::OPC_FilterValue, 23, 8, 0, // Skip to: 107
100/* 99 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
101/* 103 */ MCD::OPC_Decode, 226, 3, 3, // Opcode: SUB_ri, DecodeIdx: 3
102/* 107 */ MCD::OPC_FilterValue, 24, 19, 0, // Skip to: 130
103/* 111 */ MCD::OPC_ExtractField, 32, 16, // Inst{47-32} ...
104/* 114 */ MCD::OPC_FilterValueOrFail, 0,
105/* 116 */ MCD::OPC_CheckField, 52, 4, 0, 4, 0, // Skip to: 126
106/* 122 */ MCD::OPC_Decode, 160, 3, 8, // Opcode: LD_imm64, DecodeIdx: 8
107/* 126 */ MCD::OPC_Decode, 161, 3, 9, // Opcode: LD_pseudo, DecodeIdx: 9
108/* 130 */ MCD::OPC_FilterValue, 28, 8, 0, // Skip to: 142
109/* 134 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
110/* 138 */ MCD::OPC_Decode, 229, 3, 4, // Opcode: SUB_rr_32, DecodeIdx: 4
111/* 142 */ MCD::OPC_FilterValue, 29, 4, 0, // Skip to: 150
112/* 146 */ MCD::OPC_Decode, 224, 2, 10, // Opcode: JEQ_rr, DecodeIdx: 10
113/* 150 */ MCD::OPC_FilterValue, 30, 4, 0, // Skip to: 158
114/* 154 */ MCD::OPC_Decode, 225, 2, 11, // Opcode: JEQ_rr_32, DecodeIdx: 11
115/* 158 */ MCD::OPC_FilterValue, 31, 8, 0, // Skip to: 170
116/* 162 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
117/* 166 */ MCD::OPC_Decode, 228, 3, 5, // Opcode: SUB_rr, DecodeIdx: 5
118/* 170 */ MCD::OPC_FilterValue, 32, 4, 0, // Skip to: 178
119/* 174 */ MCD::OPC_Decode, 156, 3, 2, // Opcode: LD_ABS_W, DecodeIdx: 2
120/* 178 */ MCD::OPC_FilterValue, 36, 8, 0, // Skip to: 190
121/* 182 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
122/* 186 */ MCD::OPC_Decode, 180, 3, 0, // Opcode: MUL_ri_32, DecodeIdx: 0
123/* 190 */ MCD::OPC_FilterValue, 37, 4, 0, // Skip to: 198
124/* 194 */ MCD::OPC_Decode, 128, 3, 6, // Opcode: JUGT_ri, DecodeIdx: 6
125/* 198 */ MCD::OPC_FilterValue, 38, 4, 0, // Skip to: 206
126/* 202 */ MCD::OPC_Decode, 129, 3, 7, // Opcode: JUGT_ri_32, DecodeIdx: 7
127/* 206 */ MCD::OPC_FilterValue, 39, 8, 0, // Skip to: 218
128/* 210 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
129/* 214 */ MCD::OPC_Decode, 179, 3, 3, // Opcode: MUL_ri, DecodeIdx: 3
130/* 218 */ MCD::OPC_FilterValue, 40, 4, 0, // Skip to: 226
131/* 222 */ MCD::OPC_Decode, 155, 3, 2, // Opcode: LD_ABS_H, DecodeIdx: 2
132/* 226 */ MCD::OPC_FilterValue, 44, 8, 0, // Skip to: 238
133/* 230 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
134/* 234 */ MCD::OPC_Decode, 182, 3, 4, // Opcode: MUL_rr_32, DecodeIdx: 4
135/* 238 */ MCD::OPC_FilterValue, 45, 4, 0, // Skip to: 246
136/* 242 */ MCD::OPC_Decode, 130, 3, 10, // Opcode: JUGT_rr, DecodeIdx: 10
137/* 246 */ MCD::OPC_FilterValue, 46, 4, 0, // Skip to: 254
138/* 250 */ MCD::OPC_Decode, 131, 3, 11, // Opcode: JUGT_rr_32, DecodeIdx: 11
139/* 254 */ MCD::OPC_FilterValue, 47, 8, 0, // Skip to: 266
140/* 258 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
141/* 262 */ MCD::OPC_Decode, 181, 3, 5, // Opcode: MUL_rr, DecodeIdx: 5
142/* 266 */ MCD::OPC_FilterValue, 48, 4, 0, // Skip to: 274
143/* 270 */ MCD::OPC_Decode, 154, 3, 2, // Opcode: LD_ABS_B, DecodeIdx: 2
144/* 274 */ MCD::OPC_FilterValue, 52, 17, 0, // Skip to: 295
145/* 278 */ MCD::OPC_ExtractField, 32, 16, // Inst{47-32} ...
146/* 281 */ MCD::OPC_FilterValue, 0, 4, 0, // Skip to: 289
147/* 285 */ MCD::OPC_Decode, 216, 2, 0, // Opcode: DIV_ri_32, DecodeIdx: 0
148/* 289 */ MCD::OPC_FilterValueOrFail, 1,
149/* 291 */ MCD::OPC_Decode, 192, 3, 0, // Opcode: SDIV_ri_32, DecodeIdx: 0
150/* 295 */ MCD::OPC_FilterValue, 53, 4, 0, // Skip to: 303
151/* 299 */ MCD::OPC_Decode, 252, 2, 6, // Opcode: JUGE_ri, DecodeIdx: 6
152/* 303 */ MCD::OPC_FilterValue, 54, 4, 0, // Skip to: 311
153/* 307 */ MCD::OPC_Decode, 253, 2, 7, // Opcode: JUGE_ri_32, DecodeIdx: 7
154/* 311 */ MCD::OPC_FilterValue, 55, 17, 0, // Skip to: 332
155/* 315 */ MCD::OPC_ExtractField, 32, 16, // Inst{47-32} ...
156/* 318 */ MCD::OPC_FilterValue, 0, 4, 0, // Skip to: 326
157/* 322 */ MCD::OPC_Decode, 215, 2, 3, // Opcode: DIV_ri, DecodeIdx: 3
158/* 326 */ MCD::OPC_FilterValueOrFail, 1,
159/* 328 */ MCD::OPC_Decode, 191, 3, 3, // Opcode: SDIV_ri, DecodeIdx: 3
160/* 332 */ MCD::OPC_FilterValue, 60, 17, 0, // Skip to: 353
161/* 336 */ MCD::OPC_ExtractField, 32, 16, // Inst{47-32} ...
162/* 339 */ MCD::OPC_FilterValue, 0, 4, 0, // Skip to: 347
163/* 343 */ MCD::OPC_Decode, 218, 2, 4, // Opcode: DIV_rr_32, DecodeIdx: 4
164/* 347 */ MCD::OPC_FilterValueOrFail, 1,
165/* 349 */ MCD::OPC_Decode, 194, 3, 4, // Opcode: SDIV_rr_32, DecodeIdx: 4
166/* 353 */ MCD::OPC_FilterValue, 61, 4, 0, // Skip to: 361
167/* 357 */ MCD::OPC_Decode, 254, 2, 10, // Opcode: JUGE_rr, DecodeIdx: 10
168/* 361 */ MCD::OPC_FilterValue, 62, 4, 0, // Skip to: 369
169/* 365 */ MCD::OPC_Decode, 255, 2, 11, // Opcode: JUGE_rr_32, DecodeIdx: 11
170/* 369 */ MCD::OPC_FilterValue, 63, 17, 0, // Skip to: 390
171/* 373 */ MCD::OPC_ExtractField, 32, 16, // Inst{47-32} ...
172/* 376 */ MCD::OPC_FilterValue, 0, 4, 0, // Skip to: 384
173/* 380 */ MCD::OPC_Decode, 217, 2, 5, // Opcode: DIV_rr, DecodeIdx: 5
174/* 384 */ MCD::OPC_FilterValueOrFail, 1,
175/* 386 */ MCD::OPC_Decode, 193, 3, 5, // Opcode: SDIV_rr, DecodeIdx: 5
176/* 390 */ MCD::OPC_FilterValue, 64, 4, 0, // Skip to: 398
177/* 394 */ MCD::OPC_Decode, 159, 3, 12, // Opcode: LD_IND_W, DecodeIdx: 12
178/* 398 */ MCD::OPC_FilterValue, 68, 8, 0, // Skip to: 410
179/* 402 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
180/* 406 */ MCD::OPC_Decode, 187, 3, 0, // Opcode: OR_ri_32, DecodeIdx: 0
181/* 410 */ MCD::OPC_FilterValue, 69, 4, 0, // Skip to: 418
182/* 414 */ MCD::OPC_Decode, 232, 2, 6, // Opcode: JSET_ri, DecodeIdx: 6
183/* 418 */ MCD::OPC_FilterValue, 70, 4, 0, // Skip to: 426
184/* 422 */ MCD::OPC_Decode, 233, 2, 7, // Opcode: JSET_ri_32, DecodeIdx: 7
185/* 426 */ MCD::OPC_FilterValue, 71, 8, 0, // Skip to: 438
186/* 430 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
187/* 434 */ MCD::OPC_Decode, 186, 3, 3, // Opcode: OR_ri, DecodeIdx: 3
188/* 438 */ MCD::OPC_FilterValue, 72, 4, 0, // Skip to: 446
189/* 442 */ MCD::OPC_Decode, 158, 3, 12, // Opcode: LD_IND_H, DecodeIdx: 12
190/* 446 */ MCD::OPC_FilterValue, 76, 8, 0, // Skip to: 458
191/* 450 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
192/* 454 */ MCD::OPC_Decode, 189, 3, 4, // Opcode: OR_rr_32, DecodeIdx: 4
193/* 458 */ MCD::OPC_FilterValue, 77, 4, 0, // Skip to: 466
194/* 462 */ MCD::OPC_Decode, 234, 2, 10, // Opcode: JSET_rr, DecodeIdx: 10
195/* 466 */ MCD::OPC_FilterValue, 78, 4, 0, // Skip to: 474
196/* 470 */ MCD::OPC_Decode, 235, 2, 11, // Opcode: JSET_rr_32, DecodeIdx: 11
197/* 474 */ MCD::OPC_FilterValue, 79, 8, 0, // Skip to: 486
198/* 478 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
199/* 482 */ MCD::OPC_Decode, 188, 3, 5, // Opcode: OR_rr, DecodeIdx: 5
200/* 486 */ MCD::OPC_FilterValue, 80, 4, 0, // Skip to: 494
201/* 490 */ MCD::OPC_Decode, 157, 3, 12, // Opcode: LD_IND_B, DecodeIdx: 12
202/* 494 */ MCD::OPC_FilterValue, 84, 8, 0, // Skip to: 506
203/* 498 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
204/* 502 */ MCD::OPC_Decode, 200, 2, 0, // Opcode: AND_ri_32, DecodeIdx: 0
205/* 506 */ MCD::OPC_FilterValue, 85, 4, 0, // Skip to: 514
206/* 510 */ MCD::OPC_Decode, 228, 2, 6, // Opcode: JNE_ri, DecodeIdx: 6
207/* 514 */ MCD::OPC_FilterValue, 86, 4, 0, // Skip to: 522
208/* 518 */ MCD::OPC_Decode, 229, 2, 7, // Opcode: JNE_ri_32, DecodeIdx: 7
209/* 522 */ MCD::OPC_FilterValue, 87, 8, 0, // Skip to: 534
210/* 526 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
211/* 530 */ MCD::OPC_Decode, 199, 2, 3, // Opcode: AND_ri, DecodeIdx: 3
212/* 534 */ MCD::OPC_FilterValue, 92, 8, 0, // Skip to: 546
213/* 538 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
214/* 542 */ MCD::OPC_Decode, 202, 2, 4, // Opcode: AND_rr_32, DecodeIdx: 4
215/* 546 */ MCD::OPC_FilterValue, 93, 4, 0, // Skip to: 554
216/* 550 */ MCD::OPC_Decode, 230, 2, 10, // Opcode: JNE_rr, DecodeIdx: 10
217/* 554 */ MCD::OPC_FilterValue, 94, 4, 0, // Skip to: 562
218/* 558 */ MCD::OPC_Decode, 231, 2, 11, // Opcode: JNE_rr_32, DecodeIdx: 11
219/* 562 */ MCD::OPC_FilterValue, 95, 8, 0, // Skip to: 574
220/* 566 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
221/* 570 */ MCD::OPC_Decode, 201, 2, 5, // Opcode: AND_rr, DecodeIdx: 5
222/* 574 */ MCD::OPC_FilterValue, 97, 4, 0, // Skip to: 582
223/* 578 */ MCD::OPC_Decode, 150, 3, 13, // Opcode: LDW, DecodeIdx: 13
224/* 582 */ MCD::OPC_FilterValue, 98, 4, 0, // Skip to: 590
225/* 586 */ MCD::OPC_Decode, 225, 3, 14, // Opcode: STW_imm, DecodeIdx: 14
226/* 590 */ MCD::OPC_FilterValue, 99, 4, 0, // Skip to: 598
227/* 594 */ MCD::OPC_Decode, 222, 3, 15, // Opcode: STW, DecodeIdx: 15
228/* 598 */ MCD::OPC_FilterValue, 100, 8, 0, // Skip to: 610
229/* 602 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
230/* 606 */ MCD::OPC_Decode, 196, 3, 0, // Opcode: SLL_ri_32, DecodeIdx: 0
231/* 610 */ MCD::OPC_FilterValue, 101, 4, 0, // Skip to: 618
232/* 614 */ MCD::OPC_Decode, 240, 2, 6, // Opcode: JSGT_ri, DecodeIdx: 6
233/* 618 */ MCD::OPC_FilterValue, 102, 4, 0, // Skip to: 626
234/* 622 */ MCD::OPC_Decode, 241, 2, 7, // Opcode: JSGT_ri_32, DecodeIdx: 7
235/* 626 */ MCD::OPC_FilterValue, 103, 8, 0, // Skip to: 638
236/* 630 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
237/* 634 */ MCD::OPC_Decode, 195, 3, 3, // Opcode: SLL_ri, DecodeIdx: 3
238/* 638 */ MCD::OPC_FilterValue, 105, 4, 0, // Skip to: 646
239/* 642 */ MCD::OPC_Decode, 146, 3, 13, // Opcode: LDH, DecodeIdx: 13
240/* 646 */ MCD::OPC_FilterValue, 106, 4, 0, // Skip to: 654
241/* 650 */ MCD::OPC_Decode, 221, 3, 14, // Opcode: STH_imm, DecodeIdx: 14
242/* 654 */ MCD::OPC_FilterValue, 107, 4, 0, // Skip to: 662
243/* 658 */ MCD::OPC_Decode, 218, 3, 15, // Opcode: STH, DecodeIdx: 15
244/* 662 */ MCD::OPC_FilterValue, 108, 8, 0, // Skip to: 674
245/* 666 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
246/* 670 */ MCD::OPC_Decode, 198, 3, 4, // Opcode: SLL_rr_32, DecodeIdx: 4
247/* 674 */ MCD::OPC_FilterValue, 109, 4, 0, // Skip to: 682
248/* 678 */ MCD::OPC_Decode, 242, 2, 10, // Opcode: JSGT_rr, DecodeIdx: 10
249/* 682 */ MCD::OPC_FilterValue, 110, 4, 0, // Skip to: 690
250/* 686 */ MCD::OPC_Decode, 243, 2, 11, // Opcode: JSGT_rr_32, DecodeIdx: 11
251/* 690 */ MCD::OPC_FilterValue, 111, 8, 0, // Skip to: 702
252/* 694 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
253/* 698 */ MCD::OPC_Decode, 197, 3, 5, // Opcode: SLL_rr, DecodeIdx: 5
254/* 702 */ MCD::OPC_FilterValue, 113, 4, 0, // Skip to: 710
255/* 706 */ MCD::OPC_Decode, 140, 3, 13, // Opcode: LDB, DecodeIdx: 13
256/* 710 */ MCD::OPC_FilterValue, 114, 4, 0, // Skip to: 718
257/* 714 */ MCD::OPC_Decode, 214, 3, 14, // Opcode: STB_imm, DecodeIdx: 14
258/* 718 */ MCD::OPC_FilterValue, 115, 4, 0, // Skip to: 726
259/* 722 */ MCD::OPC_Decode, 211, 3, 15, // Opcode: STB, DecodeIdx: 15
260/* 726 */ MCD::OPC_FilterValue, 116, 8, 0, // Skip to: 738
261/* 730 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
262/* 734 */ MCD::OPC_Decode, 208, 3, 0, // Opcode: SRL_ri_32, DecodeIdx: 0
263/* 738 */ MCD::OPC_FilterValue, 117, 4, 0, // Skip to: 746
264/* 742 */ MCD::OPC_Decode, 236, 2, 6, // Opcode: JSGE_ri, DecodeIdx: 6
265/* 746 */ MCD::OPC_FilterValue, 118, 4, 0, // Skip to: 754
266/* 750 */ MCD::OPC_Decode, 237, 2, 7, // Opcode: JSGE_ri_32, DecodeIdx: 7
267/* 754 */ MCD::OPC_FilterValue, 119, 8, 0, // Skip to: 766
268/* 758 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
269/* 762 */ MCD::OPC_Decode, 207, 3, 3, // Opcode: SRL_ri, DecodeIdx: 3
270/* 766 */ MCD::OPC_FilterValue, 121, 4, 0, // Skip to: 774
271/* 770 */ MCD::OPC_Decode, 144, 3, 13, // Opcode: LDD, DecodeIdx: 13
272/* 774 */ MCD::OPC_FilterValue, 122, 4, 0, // Skip to: 782
273/* 778 */ MCD::OPC_Decode, 217, 3, 14, // Opcode: STD_imm, DecodeIdx: 14
274/* 782 */ MCD::OPC_FilterValue, 123, 4, 0, // Skip to: 790
275/* 786 */ MCD::OPC_Decode, 215, 3, 15, // Opcode: STD, DecodeIdx: 15
276/* 790 */ MCD::OPC_FilterValue, 124, 8, 0, // Skip to: 802
277/* 794 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
278/* 798 */ MCD::OPC_Decode, 210, 3, 4, // Opcode: SRL_rr_32, DecodeIdx: 4
279/* 802 */ MCD::OPC_FilterValue, 125, 4, 0, // Skip to: 810
280/* 806 */ MCD::OPC_Decode, 238, 2, 10, // Opcode: JSGE_rr, DecodeIdx: 10
281/* 810 */ MCD::OPC_FilterValue, 126, 4, 0, // Skip to: 818
282/* 814 */ MCD::OPC_Decode, 239, 2, 11, // Opcode: JSGE_rr_32, DecodeIdx: 11
283/* 818 */ MCD::OPC_FilterValue, 127, 8, 0, // Skip to: 830
284/* 822 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
285/* 826 */ MCD::OPC_Decode, 209, 3, 5, // Opcode: SRL_rr, DecodeIdx: 5
286/* 830 */ MCD::OPC_FilterValue, 129, 1, 4, 0, // Skip to: 839
287/* 835 */ MCD::OPC_Decode, 153, 3, 13, // Opcode: LDWSX, DecodeIdx: 13
288/* 839 */ MCD::OPC_FilterValue, 132, 1, 4, 0, // Skip to: 848
289/* 844 */ MCD::OPC_Decode, 183, 3, 16, // Opcode: NEG_32, DecodeIdx: 16
290/* 848 */ MCD::OPC_FilterValue, 133, 1, 4, 0, // Skip to: 857
291/* 853 */ MCD::OPC_Decode, 219, 2, 2, // Opcode: JAL, DecodeIdx: 2
292/* 857 */ MCD::OPC_FilterValue, 135, 1, 4, 0, // Skip to: 866
293/* 862 */ MCD::OPC_Decode, 184, 3, 17, // Opcode: NEG_64, DecodeIdx: 17
294/* 866 */ MCD::OPC_FilterValue, 137, 1, 4, 0, // Skip to: 875
295/* 871 */ MCD::OPC_Decode, 149, 3, 13, // Opcode: LDHSX, DecodeIdx: 13
296/* 875 */ MCD::OPC_FilterValue, 141, 1, 4, 0, // Skip to: 884
297/* 880 */ MCD::OPC_Decode, 220, 2, 18, // Opcode: JALX, DecodeIdx: 18
298/* 884 */ MCD::OPC_FilterValue, 145, 1, 4, 0, // Skip to: 893
299/* 889 */ MCD::OPC_Decode, 143, 3, 13, // Opcode: LDBSX, DecodeIdx: 13
300/* 893 */ MCD::OPC_FilterValue, 148, 1, 17, 0, // Skip to: 915
301/* 898 */ MCD::OPC_ExtractField, 32, 16, // Inst{47-32} ...
302/* 901 */ MCD::OPC_FilterValue, 0, 4, 0, // Skip to: 909
303/* 905 */ MCD::OPC_Decode, 166, 3, 0, // Opcode: MOD_ri_32, DecodeIdx: 0
304/* 909 */ MCD::OPC_FilterValueOrFail, 1,
305/* 911 */ MCD::OPC_Decode, 200, 3, 0, // Opcode: SMOD_ri_32, DecodeIdx: 0
306/* 915 */ MCD::OPC_FilterValue, 149, 1, 8, 0, // Skip to: 928
307/* 920 */ MCD::OPC_CheckFieldOrFail, 0, 32, 0,
308/* 924 */ MCD::OPC_Decode, 190, 3, 19, // Opcode: RET, DecodeIdx: 19
309/* 928 */ MCD::OPC_FilterValue, 151, 1, 17, 0, // Skip to: 950
310/* 933 */ MCD::OPC_ExtractField, 32, 16, // Inst{47-32} ...
311/* 936 */ MCD::OPC_FilterValue, 0, 4, 0, // Skip to: 944
312/* 940 */ MCD::OPC_Decode, 165, 3, 3, // Opcode: MOD_ri, DecodeIdx: 3
313/* 944 */ MCD::OPC_FilterValueOrFail, 1,
314/* 946 */ MCD::OPC_Decode, 199, 3, 3, // Opcode: SMOD_ri, DecodeIdx: 3
315/* 950 */ MCD::OPC_FilterValue, 156, 1, 17, 0, // Skip to: 972
316/* 955 */ MCD::OPC_ExtractField, 32, 16, // Inst{47-32} ...
317/* 958 */ MCD::OPC_FilterValue, 0, 4, 0, // Skip to: 966
318/* 962 */ MCD::OPC_Decode, 168, 3, 4, // Opcode: MOD_rr_32, DecodeIdx: 4
319/* 966 */ MCD::OPC_FilterValueOrFail, 1,
320/* 968 */ MCD::OPC_Decode, 202, 3, 4, // Opcode: SMOD_rr_32, DecodeIdx: 4
321/* 972 */ MCD::OPC_FilterValue, 159, 1, 17, 0, // Skip to: 994
322/* 977 */ MCD::OPC_ExtractField, 32, 16, // Inst{47-32} ...
323/* 980 */ MCD::OPC_FilterValue, 0, 4, 0, // Skip to: 988
324/* 984 */ MCD::OPC_Decode, 167, 3, 5, // Opcode: MOD_rr, DecodeIdx: 5
325/* 988 */ MCD::OPC_FilterValueOrFail, 1,
326/* 990 */ MCD::OPC_Decode, 201, 3, 5, // Opcode: SMOD_rr, DecodeIdx: 5
327/* 994 */ MCD::OPC_FilterValue, 164, 1, 8, 0, // Skip to: 1007
328/* 999 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
329/* 1003 */ MCD::OPC_Decode, 248, 3, 0, // Opcode: XOR_ri_32, DecodeIdx: 0
330/* 1007 */ MCD::OPC_FilterValue, 165, 1, 4, 0, // Skip to: 1016
331/* 1012 */ MCD::OPC_Decode, 136, 3, 6, // Opcode: JULT_ri, DecodeIdx: 6
332/* 1016 */ MCD::OPC_FilterValue, 166, 1, 4, 0, // Skip to: 1025
333/* 1021 */ MCD::OPC_Decode, 137, 3, 7, // Opcode: JULT_ri_32, DecodeIdx: 7
334/* 1025 */ MCD::OPC_FilterValue, 167, 1, 8, 0, // Skip to: 1038
335/* 1030 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
336/* 1034 */ MCD::OPC_Decode, 247, 3, 3, // Opcode: XOR_ri, DecodeIdx: 3
337/* 1038 */ MCD::OPC_FilterValue, 172, 1, 8, 0, // Skip to: 1051
338/* 1043 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
339/* 1047 */ MCD::OPC_Decode, 250, 3, 4, // Opcode: XOR_rr_32, DecodeIdx: 4
340/* 1051 */ MCD::OPC_FilterValue, 173, 1, 4, 0, // Skip to: 1060
341/* 1056 */ MCD::OPC_Decode, 138, 3, 10, // Opcode: JULT_rr, DecodeIdx: 10
342/* 1060 */ MCD::OPC_FilterValue, 174, 1, 4, 0, // Skip to: 1069
343/* 1065 */ MCD::OPC_Decode, 139, 3, 11, // Opcode: JULT_rr_32, DecodeIdx: 11
344/* 1069 */ MCD::OPC_FilterValue, 175, 1, 8, 0, // Skip to: 1082
345/* 1074 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
346/* 1078 */ MCD::OPC_Decode, 249, 3, 5, // Opcode: XOR_rr, DecodeIdx: 5
347/* 1082 */ MCD::OPC_FilterValue, 180, 1, 8, 0, // Skip to: 1095
348/* 1087 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
349/* 1091 */ MCD::OPC_Decode, 176, 3, 20, // Opcode: MOV_ri_32, DecodeIdx: 20
350/* 1095 */ MCD::OPC_FilterValue, 181, 1, 4, 0, // Skip to: 1104
351/* 1100 */ MCD::OPC_Decode, 132, 3, 6, // Opcode: JULE_ri, DecodeIdx: 6
352/* 1104 */ MCD::OPC_FilterValue, 182, 1, 4, 0, // Skip to: 1113
353/* 1109 */ MCD::OPC_Decode, 133, 3, 7, // Opcode: JULE_ri_32, DecodeIdx: 7
354/* 1113 */ MCD::OPC_FilterValue, 183, 1, 8, 0, // Skip to: 1126
355/* 1118 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
356/* 1122 */ MCD::OPC_Decode, 175, 3, 8, // Opcode: MOV_ri, DecodeIdx: 8
357/* 1126 */ MCD::OPC_FilterValue, 188, 1, 25, 0, // Skip to: 1156
358/* 1131 */ MCD::OPC_ExtractField, 32, 16, // Inst{47-32} ...
359/* 1134 */ MCD::OPC_FilterValue, 0, 4, 0, // Skip to: 1142
360/* 1138 */ MCD::OPC_Decode, 178, 3, 21, // Opcode: MOV_rr_32, DecodeIdx: 21
361/* 1142 */ MCD::OPC_FilterValue, 8, 4, 0, // Skip to: 1150
362/* 1146 */ MCD::OPC_Decode, 172, 3, 21, // Opcode: MOVSX_rr_32_8, DecodeIdx: 21
363/* 1150 */ MCD::OPC_FilterValueOrFail, 16,
364/* 1152 */ MCD::OPC_Decode, 171, 3, 21, // Opcode: MOVSX_rr_32_16, DecodeIdx: 21
365/* 1156 */ MCD::OPC_FilterValue, 189, 1, 4, 0, // Skip to: 1165
366/* 1161 */ MCD::OPC_Decode, 134, 3, 10, // Opcode: JULE_rr, DecodeIdx: 10
367/* 1165 */ MCD::OPC_FilterValue, 190, 1, 4, 0, // Skip to: 1174
368/* 1170 */ MCD::OPC_Decode, 135, 3, 11, // Opcode: JULE_rr_32, DecodeIdx: 11
369/* 1174 */ MCD::OPC_FilterValue, 191, 1, 41, 0, // Skip to: 1220
370/* 1179 */ MCD::OPC_ExtractField, 32, 16, // Inst{47-32} ...
371/* 1182 */ MCD::OPC_FilterValue, 0, 4, 0, // Skip to: 1190
372/* 1186 */ MCD::OPC_Decode, 177, 3, 22, // Opcode: MOV_rr, DecodeIdx: 22
373/* 1190 */ MCD::OPC_FilterValue, 1, 4, 0, // Skip to: 1198
374/* 1194 */ MCD::OPC_Decode, 194, 2, 23, // Opcode: ADDR_SPACE_CAST, DecodeIdx: 23
375/* 1198 */ MCD::OPC_FilterValue, 8, 4, 0, // Skip to: 1206
376/* 1202 */ MCD::OPC_Decode, 173, 3, 22, // Opcode: MOVSX_rr_8, DecodeIdx: 22
377/* 1206 */ MCD::OPC_FilterValue, 16, 4, 0, // Skip to: 1214
378/* 1210 */ MCD::OPC_Decode, 169, 3, 22, // Opcode: MOVSX_rr_16, DecodeIdx: 22
379/* 1214 */ MCD::OPC_FilterValueOrFail, 32,
380/* 1216 */ MCD::OPC_Decode, 170, 3, 22, // Opcode: MOVSX_rr_32, DecodeIdx: 22
381/* 1220 */ MCD::OPC_FilterValue, 195, 1, 8, 0, // Skip to: 1233
382/* 1225 */ MCD::OPC_CheckFieldOrFail, 4, 4, 0,
383/* 1229 */ MCD::OPC_Decode, 231, 3, 24, // Opcode: XADDW, DecodeIdx: 24
384/* 1233 */ MCD::OPC_FilterValue, 196, 1, 8, 0, // Skip to: 1246
385/* 1238 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
386/* 1242 */ MCD::OPC_Decode, 204, 3, 0, // Opcode: SRA_ri_32, DecodeIdx: 0
387/* 1246 */ MCD::OPC_FilterValue, 197, 1, 4, 0, // Skip to: 1255
388/* 1251 */ MCD::OPC_Decode, 248, 2, 6, // Opcode: JSLT_ri, DecodeIdx: 6
389/* 1255 */ MCD::OPC_FilterValue, 198, 1, 4, 0, // Skip to: 1264
390/* 1260 */ MCD::OPC_Decode, 249, 2, 7, // Opcode: JSLT_ri_32, DecodeIdx: 7
391/* 1264 */ MCD::OPC_FilterValue, 199, 1, 8, 0, // Skip to: 1277
392/* 1269 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
393/* 1273 */ MCD::OPC_Decode, 203, 3, 3, // Opcode: SRA_ri, DecodeIdx: 3
394/* 1277 */ MCD::OPC_FilterValue, 204, 1, 8, 0, // Skip to: 1290
395/* 1282 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
396/* 1286 */ MCD::OPC_Decode, 206, 3, 4, // Opcode: SRA_rr_32, DecodeIdx: 4
397/* 1290 */ MCD::OPC_FilterValue, 205, 1, 4, 0, // Skip to: 1299
398/* 1295 */ MCD::OPC_Decode, 250, 2, 10, // Opcode: JSLT_rr, DecodeIdx: 10
399/* 1299 */ MCD::OPC_FilterValue, 206, 1, 4, 0, // Skip to: 1308
400/* 1304 */ MCD::OPC_Decode, 251, 2, 11, // Opcode: JSLT_rr_32, DecodeIdx: 11
401/* 1308 */ MCD::OPC_FilterValue, 207, 1, 8, 0, // Skip to: 1321
402/* 1313 */ MCD::OPC_CheckFieldOrFail, 32, 16, 0,
403/* 1317 */ MCD::OPC_Decode, 205, 3, 5, // Opcode: SRA_rr, DecodeIdx: 5
404/* 1321 */ MCD::OPC_FilterValue, 212, 1, 25, 0, // Skip to: 1351
405/* 1326 */ MCD::OPC_ExtractField, 0, 32, // Inst{31-0} ...
406/* 1329 */ MCD::OPC_FilterValue, 16, 4, 0, // Skip to: 1337
407/* 1333 */ MCD::OPC_Decode, 162, 3, 17, // Opcode: LE16, DecodeIdx: 17
408/* 1337 */ MCD::OPC_FilterValue, 32, 4, 0, // Skip to: 1345
409/* 1341 */ MCD::OPC_Decode, 163, 3, 17, // Opcode: LE32, DecodeIdx: 17
410/* 1345 */ MCD::OPC_FilterValueOrFail, 64,
411/* 1347 */ MCD::OPC_Decode, 164, 3, 17, // Opcode: LE64, DecodeIdx: 17
412/* 1351 */ MCD::OPC_FilterValue, 213, 1, 4, 0, // Skip to: 1360
413/* 1356 */ MCD::OPC_Decode, 244, 2, 6, // Opcode: JSLE_ri, DecodeIdx: 6
414/* 1360 */ MCD::OPC_FilterValue, 214, 1, 4, 0, // Skip to: 1369
415/* 1365 */ MCD::OPC_Decode, 245, 2, 7, // Opcode: JSLE_ri_32, DecodeIdx: 7
416/* 1369 */ MCD::OPC_FilterValue, 215, 1, 25, 0, // Skip to: 1399
417/* 1374 */ MCD::OPC_ExtractField, 0, 32, // Inst{31-0} ...
418/* 1377 */ MCD::OPC_FilterValue, 16, 4, 0, // Skip to: 1385
419/* 1381 */ MCD::OPC_Decode, 206, 2, 17, // Opcode: BSWAP16, DecodeIdx: 17
420/* 1385 */ MCD::OPC_FilterValue, 32, 4, 0, // Skip to: 1393
421/* 1389 */ MCD::OPC_Decode, 207, 2, 17, // Opcode: BSWAP32, DecodeIdx: 17
422/* 1393 */ MCD::OPC_FilterValueOrFail, 64,
423/* 1395 */ MCD::OPC_Decode, 208, 2, 17, // Opcode: BSWAP64, DecodeIdx: 17
424/* 1399 */ MCD::OPC_FilterValue, 219, 1, 119, 0, // Skip to: 1523
425/* 1404 */ MCD::OPC_ExtractField, 4, 4, // Inst{7-4} ...
426/* 1407 */ MCD::OPC_FilterValue, 0, 24, 0, // Skip to: 1435
427/* 1411 */ MCD::OPC_CheckField, 0, 4, 1, 4, 0, // Skip to: 1421
428/* 1417 */ MCD::OPC_Decode, 237, 3, 24, // Opcode: XFADDD, DecodeIdx: 24
429/* 1421 */ MCD::OPC_CheckField, 8, 1, 1, 4, 0, // Skip to: 1431
430/* 1427 */ MCD::OPC_Decode, 145, 3, 13, // Opcode: LDDACQ, DecodeIdx: 13
431/* 1431 */ MCD::OPC_Decode, 230, 3, 24, // Opcode: XADDD, DecodeIdx: 24
432/* 1435 */ MCD::OPC_FilterValue, 1, 8, 0, // Skip to: 1447
433/* 1439 */ MCD::OPC_CheckFieldOrFail, 8, 1, 1,
434/* 1443 */ MCD::OPC_Decode, 216, 3, 15, // Opcode: STDREL, DecodeIdx: 15
435/* 1447 */ MCD::OPC_FilterValue, 4, 14, 0, // Skip to: 1465
436/* 1451 */ MCD::OPC_CheckField, 0, 4, 1, 4, 0, // Skip to: 1461
437/* 1457 */ MCD::OPC_Decode, 241, 3, 24, // Opcode: XFORD, DecodeIdx: 24
438/* 1461 */ MCD::OPC_Decode, 245, 3, 24, // Opcode: XORD, DecodeIdx: 24
439/* 1465 */ MCD::OPC_FilterValue, 5, 14, 0, // Skip to: 1483
440/* 1469 */ MCD::OPC_CheckField, 0, 4, 1, 4, 0, // Skip to: 1479
441/* 1475 */ MCD::OPC_Decode, 239, 3, 24, // Opcode: XFANDD, DecodeIdx: 24
442/* 1479 */ MCD::OPC_Decode, 233, 3, 24, // Opcode: XANDD, DecodeIdx: 24
443/* 1483 */ MCD::OPC_FilterValue, 10, 14, 0, // Skip to: 1501
444/* 1487 */ MCD::OPC_CheckField, 0, 4, 1, 4, 0, // Skip to: 1497
445/* 1493 */ MCD::OPC_Decode, 243, 3, 24, // Opcode: XFXORD, DecodeIdx: 24
446/* 1497 */ MCD::OPC_Decode, 251, 3, 24, // Opcode: XXORD, DecodeIdx: 24
447/* 1501 */ MCD::OPC_FilterValue, 14, 8, 0, // Skip to: 1513
448/* 1505 */ MCD::OPC_CheckFieldOrFail, 0, 4, 1,
449/* 1509 */ MCD::OPC_Decode, 235, 3, 24, // Opcode: XCHGD, DecodeIdx: 24
450/* 1513 */ MCD::OPC_FilterValueOrFail, 15,
451/* 1515 */ MCD::OPC_CheckFieldOrFail, 0, 4, 1,
452/* 1519 */ MCD::OPC_Decode, 209, 2, 25, // Opcode: CMPXCHGD, DecodeIdx: 25
453/* 1523 */ MCD::OPC_FilterValue, 220, 1, 25, 0, // Skip to: 1553
454/* 1528 */ MCD::OPC_ExtractField, 0, 32, // Inst{31-0} ...
455/* 1531 */ MCD::OPC_FilterValue, 16, 4, 0, // Skip to: 1539
456/* 1535 */ MCD::OPC_Decode, 203, 2, 17, // Opcode: BE16, DecodeIdx: 17
457/* 1539 */ MCD::OPC_FilterValue, 32, 4, 0, // Skip to: 1547
458/* 1543 */ MCD::OPC_Decode, 204, 2, 17, // Opcode: BE32, DecodeIdx: 17
459/* 1547 */ MCD::OPC_FilterValueOrFail, 64,
460/* 1549 */ MCD::OPC_Decode, 205, 2, 17, // Opcode: BE64, DecodeIdx: 17
461/* 1553 */ MCD::OPC_FilterValue, 221, 1, 4, 0, // Skip to: 1562
462/* 1558 */ MCD::OPC_Decode, 246, 2, 10, // Opcode: JSLE_rr, DecodeIdx: 10
463/* 1562 */ MCD::OPC_FilterValue, 222, 1, 4, 0, // Skip to: 1571
464/* 1567 */ MCD::OPC_Decode, 247, 2, 11, // Opcode: JSLE_rr_32, DecodeIdx: 11
465/* 1571 */ MCD::OPC_FilterValueOrFail, 229, 1,
466/* 1574 */ MCD::OPC_Decode, 221, 2, 1, // Opcode: JCOND, DecodeIdx: 1
467/* 1578 */ MCD::OPC_Fail,
468 0
469};
470
471static const uint8_t DecoderTableBPFALU3264[] = {
472/* 0 */ MCD::OPC_ExtractField, 56, 8, // Inst{63-56} ...
473/* 3 */ MCD::OPC_FilterValue, 97, 4, 0, // Skip to: 11
474/* 7 */ MCD::OPC_Decode, 151, 3, 26, // Opcode: LDW32, DecodeIdx: 26
475/* 11 */ MCD::OPC_FilterValue, 99, 4, 0, // Skip to: 19
476/* 15 */ MCD::OPC_Decode, 223, 3, 27, // Opcode: STW32, DecodeIdx: 27
477/* 19 */ MCD::OPC_FilterValue, 105, 4, 0, // Skip to: 27
478/* 23 */ MCD::OPC_Decode, 147, 3, 26, // Opcode: LDH32, DecodeIdx: 26
479/* 27 */ MCD::OPC_FilterValue, 107, 4, 0, // Skip to: 35
480/* 31 */ MCD::OPC_Decode, 219, 3, 27, // Opcode: STH32, DecodeIdx: 27
481/* 35 */ MCD::OPC_FilterValue, 113, 4, 0, // Skip to: 43
482/* 39 */ MCD::OPC_Decode, 141, 3, 26, // Opcode: LDB32, DecodeIdx: 26
483/* 43 */ MCD::OPC_FilterValue, 115, 4, 0, // Skip to: 51
484/* 47 */ MCD::OPC_Decode, 212, 3, 27, // Opcode: STB32, DecodeIdx: 27
485/* 51 */ MCD::OPC_FilterValue, 195, 1, 119, 0, // Skip to: 175
486/* 56 */ MCD::OPC_ExtractField, 4, 4, // Inst{7-4} ...
487/* 59 */ MCD::OPC_FilterValue, 0, 24, 0, // Skip to: 87
488/* 63 */ MCD::OPC_CheckField, 0, 4, 1, 4, 0, // Skip to: 73
489/* 69 */ MCD::OPC_Decode, 238, 3, 28, // Opcode: XFADDW32, DecodeIdx: 28
490/* 73 */ MCD::OPC_CheckField, 8, 1, 1, 4, 0, // Skip to: 83
491/* 79 */ MCD::OPC_Decode, 152, 3, 26, // Opcode: LDWACQ32, DecodeIdx: 26
492/* 83 */ MCD::OPC_Decode, 232, 3, 28, // Opcode: XADDW32, DecodeIdx: 28
493/* 87 */ MCD::OPC_FilterValue, 1, 8, 0, // Skip to: 99
494/* 91 */ MCD::OPC_CheckFieldOrFail, 8, 1, 1,
495/* 95 */ MCD::OPC_Decode, 224, 3, 27, // Opcode: STWREL32, DecodeIdx: 27
496/* 99 */ MCD::OPC_FilterValue, 4, 14, 0, // Skip to: 117
497/* 103 */ MCD::OPC_CheckField, 0, 4, 1, 4, 0, // Skip to: 113
498/* 109 */ MCD::OPC_Decode, 242, 3, 28, // Opcode: XFORW32, DecodeIdx: 28
499/* 113 */ MCD::OPC_Decode, 246, 3, 28, // Opcode: XORW32, DecodeIdx: 28
500/* 117 */ MCD::OPC_FilterValue, 5, 14, 0, // Skip to: 135
501/* 121 */ MCD::OPC_CheckField, 0, 4, 1, 4, 0, // Skip to: 131
502/* 127 */ MCD::OPC_Decode, 240, 3, 28, // Opcode: XFANDW32, DecodeIdx: 28
503/* 131 */ MCD::OPC_Decode, 234, 3, 28, // Opcode: XANDW32, DecodeIdx: 28
504/* 135 */ MCD::OPC_FilterValue, 10, 14, 0, // Skip to: 153
505/* 139 */ MCD::OPC_CheckField, 0, 4, 1, 4, 0, // Skip to: 149
506/* 145 */ MCD::OPC_Decode, 244, 3, 28, // Opcode: XFXORW32, DecodeIdx: 28
507/* 149 */ MCD::OPC_Decode, 252, 3, 28, // Opcode: XXORW32, DecodeIdx: 28
508/* 153 */ MCD::OPC_FilterValue, 14, 8, 0, // Skip to: 165
509/* 157 */ MCD::OPC_CheckFieldOrFail, 0, 4, 1,
510/* 161 */ MCD::OPC_Decode, 236, 3, 28, // Opcode: XCHGW32, DecodeIdx: 28
511/* 165 */ MCD::OPC_FilterValueOrFail, 15,
512/* 167 */ MCD::OPC_CheckFieldOrFail, 0, 4, 1,
513/* 171 */ MCD::OPC_Decode, 210, 2, 29, // Opcode: CMPXCHGW32, DecodeIdx: 29
514/* 175 */ MCD::OPC_FilterValue, 203, 1, 17, 0, // Skip to: 197
515/* 180 */ MCD::OPC_ExtractField, 4, 5, // Inst{8-4} ...
516/* 183 */ MCD::OPC_FilterValue, 16, 4, 0, // Skip to: 191
517/* 187 */ MCD::OPC_Decode, 148, 3, 26, // Opcode: LDHACQ32, DecodeIdx: 26
518/* 191 */ MCD::OPC_FilterValueOrFail, 17,
519/* 193 */ MCD::OPC_Decode, 220, 3, 27, // Opcode: STHREL32, DecodeIdx: 27
520/* 197 */ MCD::OPC_FilterValueOrFail, 211, 1,
521/* 200 */ MCD::OPC_ExtractField, 4, 5, // Inst{8-4} ...
522/* 203 */ MCD::OPC_FilterValue, 16, 4, 0, // Skip to: 211
523/* 207 */ MCD::OPC_Decode, 142, 3, 26, // Opcode: LDBACQ32, DecodeIdx: 26
524/* 211 */ MCD::OPC_FilterValueOrFail, 17,
525/* 213 */ MCD::OPC_Decode, 213, 3, 27, // Opcode: STBREL32, DecodeIdx: 27
526/* 217 */ MCD::OPC_Fail,
527 0
528};
529
530// Handling 30 cases.
531template <typename InsnType>
532static DecodeStatus decodeToMCInst(unsigned Idx, DecodeStatus S, InsnType insn, MCInst &MI, uint64_t Address, const MCDisassembler *Decoder, bool &DecodeComplete) {
533 DecodeComplete = true;
534 using TmpType = std::conditional_t<std::is_integral<InsnType>::value, InsnType, uint64_t>;
535 TmpType tmp;
536 switch (Idx) {
537 default: llvm_unreachable("Invalid index!");
538 case 0:
539 tmp = fieldFromInstruction(insn, 48, 4);
540 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
541 tmp = fieldFromInstruction(insn, 48, 4);
542 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
543 tmp = fieldFromInstruction(insn, 0, 32);
544 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
545 return S;
546 case 1:
547 tmp = fieldFromInstruction(insn, 32, 16);
548 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
549 return S;
550 case 2:
551 tmp = fieldFromInstruction(insn, 0, 32);
552 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
553 return S;
554 case 3:
555 tmp = fieldFromInstruction(insn, 48, 4);
556 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
557 tmp = fieldFromInstruction(insn, 48, 4);
558 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
559 tmp = fieldFromInstruction(insn, 0, 32);
560 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
561 return S;
562 case 4:
563 tmp = fieldFromInstruction(insn, 48, 4);
564 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
565 tmp = fieldFromInstruction(insn, 48, 4);
566 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
567 tmp = fieldFromInstruction(insn, 52, 4);
568 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
569 return S;
570 case 5:
571 tmp = fieldFromInstruction(insn, 48, 4);
572 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
573 tmp = fieldFromInstruction(insn, 48, 4);
574 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
575 tmp = fieldFromInstruction(insn, 52, 4);
576 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
577 return S;
578 case 6:
579 tmp = fieldFromInstruction(insn, 48, 4);
580 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
581 tmp = fieldFromInstruction(insn, 0, 32);
582 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
583 tmp = fieldFromInstruction(insn, 32, 16);
584 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
585 return S;
586 case 7:
587 tmp = fieldFromInstruction(insn, 48, 4);
588 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
589 tmp = fieldFromInstruction(insn, 0, 32);
590 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
591 tmp = fieldFromInstruction(insn, 32, 16);
592 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
593 return S;
594 case 8:
595 tmp = fieldFromInstruction(insn, 48, 4);
596 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
597 tmp = fieldFromInstruction(insn, 0, 32);
598 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
599 return S;
600 case 9:
601 tmp = fieldFromInstruction(insn, 48, 4);
602 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
603 tmp = fieldFromInstruction(insn, 52, 4);
604 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
605 tmp = fieldFromInstruction(insn, 0, 32);
606 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
607 return S;
608 case 10:
609 tmp = fieldFromInstruction(insn, 48, 4);
610 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
611 tmp = fieldFromInstruction(insn, 52, 4);
612 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
613 tmp = fieldFromInstruction(insn, 32, 16);
614 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
615 return S;
616 case 11:
617 tmp = fieldFromInstruction(insn, 48, 4);
618 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
619 tmp = fieldFromInstruction(insn, 52, 4);
620 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
621 tmp = fieldFromInstruction(insn, 32, 16);
622 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
623 return S;
624 case 12:
625 tmp = fieldFromInstruction(insn, 52, 4);
626 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
627 return S;
628 case 13:
629 tmp = fieldFromInstruction(insn, 48, 4);
630 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
631 tmp = 0x0;
632 insertBits(tmp, fieldFromInstruction(insn, 32, 16), 0, 16);
633 insertBits(tmp, fieldFromInstruction(insn, 52, 4), 16, 4);
634 if (!Check(S, decodeMemoryOpValue(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
635 return S;
636 case 14:
637 tmp = fieldFromInstruction(insn, 0, 32);
638 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
639 tmp = fieldFromInstruction(insn, 32, 20);
640 if (!Check(S, decodeMemoryOpValue(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
641 return S;
642 case 15:
643 tmp = fieldFromInstruction(insn, 52, 4);
644 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
645 tmp = fieldFromInstruction(insn, 32, 20);
646 if (!Check(S, decodeMemoryOpValue(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
647 return S;
648 case 16:
649 tmp = fieldFromInstruction(insn, 48, 4);
650 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
651 tmp = fieldFromInstruction(insn, 48, 4);
652 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
653 return S;
654 case 17:
655 tmp = fieldFromInstruction(insn, 48, 4);
656 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
657 tmp = fieldFromInstruction(insn, 48, 4);
658 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
659 return S;
660 case 18:
661 tmp = fieldFromInstruction(insn, 48, 4);
662 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
663 return S;
664 case 19:
665 return S;
666 case 20:
667 tmp = fieldFromInstruction(insn, 48, 4);
668 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
669 tmp = fieldFromInstruction(insn, 0, 32);
670 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
671 return S;
672 case 21:
673 tmp = fieldFromInstruction(insn, 48, 4);
674 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
675 tmp = fieldFromInstruction(insn, 52, 4);
676 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
677 return S;
678 case 22:
679 tmp = fieldFromInstruction(insn, 48, 4);
680 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
681 tmp = fieldFromInstruction(insn, 52, 4);
682 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
683 return S;
684 case 23:
685 tmp = fieldFromInstruction(insn, 48, 4);
686 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
687 tmp = fieldFromInstruction(insn, 52, 4);
688 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
689 tmp = fieldFromInstruction(insn, 16, 16);
690 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
691 tmp = fieldFromInstruction(insn, 0, 16);
692 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
693 return S;
694 case 24:
695 tmp = fieldFromInstruction(insn, 52, 4);
696 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
697 tmp = fieldFromInstruction(insn, 32, 20);
698 if (!Check(S, decodeMemoryOpValue(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
699 tmp = fieldFromInstruction(insn, 52, 4);
700 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
701 return S;
702 case 25:
703 tmp = fieldFromInstruction(insn, 32, 20);
704 if (!Check(S, decodeMemoryOpValue(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
705 tmp = fieldFromInstruction(insn, 52, 4);
706 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
707 return S;
708 case 26:
709 tmp = fieldFromInstruction(insn, 48, 4);
710 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
711 tmp = 0x0;
712 insertBits(tmp, fieldFromInstruction(insn, 32, 16), 0, 16);
713 insertBits(tmp, fieldFromInstruction(insn, 52, 4), 16, 4);
714 if (!Check(S, decodeMemoryOpValue(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
715 return S;
716 case 27:
717 tmp = fieldFromInstruction(insn, 52, 4);
718 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
719 tmp = fieldFromInstruction(insn, 32, 20);
720 if (!Check(S, decodeMemoryOpValue(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
721 return S;
722 case 28:
723 tmp = fieldFromInstruction(insn, 52, 4);
724 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
725 tmp = fieldFromInstruction(insn, 32, 20);
726 if (!Check(S, decodeMemoryOpValue(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
727 tmp = fieldFromInstruction(insn, 52, 4);
728 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
729 return S;
730 case 29:
731 tmp = fieldFromInstruction(insn, 32, 20);
732 if (!Check(S, decodeMemoryOpValue(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
733 tmp = fieldFromInstruction(insn, 52, 4);
734 if (!Check(S, DecodeGPR32RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
735 return S;
736 }
737}
738
739static unsigned decodeNumToSkip(const uint8_t *&Ptr) {
740 unsigned NumToSkip = *Ptr++;
741 NumToSkip |= (*Ptr++) << 8;
742 return NumToSkip;
743}
744
745template <typename InsnType>
746static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
747 InsnType insn, uint64_t Address,
748 const MCDisassembler *DisAsm,
749 const MCSubtargetInfo &STI) {
750
751 const uint8_t *Ptr = DecodeTable;
752 uint64_t CurFieldValue = 0;
753 DecodeStatus S = MCDisassembler::Success;
754 while (true) {
755 ptrdiff_t Loc = Ptr - DecodeTable;
756 const uint8_t DecoderOp = *Ptr++;
757 switch (DecoderOp) {
758 default:
759 errs() << Loc << ": Unexpected decode table opcode: "
760 << (int)DecoderOp << '\n';
761 return MCDisassembler::Fail;
762 case MCD::OPC_ExtractField: {
763 // Decode the start value.
764 unsigned Start = decodeULEB128AndIncUnsafe(p&: Ptr);
765 unsigned Len = *Ptr++;
766 CurFieldValue = fieldFromInstruction(insn, Start, Len);
767 LLVM_DEBUG(dbgs() << Loc << ": OPC_ExtractField(" << Start << ", "
768 << Len << "): " << CurFieldValue << "\n");
769 break;
770 }
771 case MCD::OPC_FilterValue:
772 case MCD::OPC_FilterValueOrFail: {
773 bool IsFail = DecoderOp == MCD::OPC_FilterValueOrFail;
774 // Decode the field value.
775 uint64_t Val = decodeULEB128AndIncUnsafe(p&: Ptr);
776 bool Failed = Val != CurFieldValue;
777 unsigned NumToSkip = IsFail ? 0 : decodeNumToSkip(Ptr);
778
779 // Note: Print NumToSkip even for OPC_FilterValueOrFail to simplify debug
780 // prints.
781 LLVM_DEBUG({
782 StringRef OpName = IsFail ? "OPC_FilterValueOrFail" : "OPC_FilterValue";
783 dbgs() << Loc << ": " << OpName << '(' << Val << ", " << NumToSkip
784 << ") " << (Failed ? "FAIL:" : "PASS:")
785 << " continuing at " << (Ptr - DecodeTable) << '\n';
786 });
787
788 // Perform the filter operation.
789 if (Failed) {
790 if (IsFail)
791 return MCDisassembler::Fail;
792 Ptr += NumToSkip;
793 }
794 break;
795 }
796 case MCD::OPC_CheckField:
797 case MCD::OPC_CheckFieldOrFail: {
798 bool IsFail = DecoderOp == MCD::OPC_CheckFieldOrFail;
799 // Decode the start value.
800 unsigned Start = decodeULEB128AndIncUnsafe(p&: Ptr);
801 unsigned Len = *Ptr;
802 uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);
803 // Decode the field value.
804 unsigned PtrLen = 0;
805 uint64_t ExpectedValue = decodeULEB128(p: ++Ptr, n: &PtrLen);
806 Ptr += PtrLen;
807 bool Failed = ExpectedValue != FieldValue;
808 unsigned NumToSkip = IsFail ? 0 : decodeNumToSkip(Ptr);
809
810 LLVM_DEBUG({
811 StringRef OpName = IsFail ? "OPC_CheckFieldOrFail" : "OPC_CheckField";
812 dbgs() << Loc << ": " << OpName << '(' << Start << ", " << Len << ", "
813 << ExpectedValue << ", " << NumToSkip << "): FieldValue = "
814 << FieldValue << ", ExpectedValue = " << ExpectedValue << ": "
815 << (Failed ? "FAIL\n" : "PASS\n");
816 });
817
818 // If the actual and expected values don't match, skip or fail.
819 if (Failed) {
820 if (IsFail)
821 return MCDisassembler::Fail;
822 Ptr += NumToSkip;
823 }
824 break;
825 }
826 case MCD::OPC_Decode: {
827 // Decode the Opcode value.
828 unsigned Opc = decodeULEB128AndIncUnsafe(p&: Ptr);
829 unsigned DecodeIdx = decodeULEB128AndIncUnsafe(p&: Ptr);
830
831 MI.clear();
832 MI.setOpcode(Opc);
833 bool DecodeComplete;
834 S = decodeToMCInst(DecodeIdx, S, insn, MI, Address, DisAsm, DecodeComplete);
835 assert(DecodeComplete);
836
837 LLVM_DEBUG(dbgs() << Loc << ": OPC_Decode: opcode " << Opc
838 << ", using decoder " << DecodeIdx << ": "
839 << (S != MCDisassembler::Fail ? "PASS\n" : "FAIL\n"));
840 return S;
841 }
842 case MCD::OPC_Fail: {
843 LLVM_DEBUG(dbgs() << Loc << ": OPC_Fail\n");
844 return MCDisassembler::Fail;
845 }
846 }
847 }
848 llvm_unreachable("bogosity detected in disassembler state machine!");
849}
850
851
852} // namespace
853