1 /*
2 * Copyright 2013 The Native Client Authors. All rights reserved.
3 * Use of this source code is governed by a BSD-style license that can
4 * be found in the LICENSE file.
5 */
6
7 // DO NOT EDIT: GENERATED CODE
8
9 #ifndef NACL_TRUSTED_BUT_NOT_TCB
10 #error This file is not meant for use in the TCB
11 #endif
12
13
14 #include "gtest/gtest.h"
15 #include "native_client/src/trusted/validator_arm/actual_vs_baseline.h"
16 #include "native_client/src/trusted/validator_arm/arm_helpers.h"
17 #include "native_client/src/trusted/validator_arm/gen/arm32_decode_named_bases.h"
18
19 using nacl_arm_dec::Instruction;
20 using nacl_arm_dec::ClassDecoder;
21 using nacl_arm_dec::Register;
22 using nacl_arm_dec::RegisterList;
23
24 namespace nacl_arm_test {
25
26 // The following classes are derived class decoder testers that
27 // add row pattern constraints and decoder restrictions to each tester.
28 // This is done so that it can be used to make sure that the
29 // corresponding pattern is not tested for cases that would be excluded
30 // due to row checks, or restrictions specified by the row restrictions.
31
32
33 // op1(26:20)=0010000 & op2(7:4)=0000 & Rn(19:16)=xxx1 & $pattern(31:0)=xxxxxxxxxxxx000x000000x0xxxx0000
34 // = {actual: Actual_BLX_immediate_1111101hiiiiiiiiiiiiiiiiiiiiiiii_case_1,
35 // baseline: SETEND_1111000100000001000000i000000000_case_0,
36 // defs: {},
37 // pattern: 1111000100000001000000i000000000,
38 // rule: SETEND,
39 // safety: [true => FORBIDDEN],
40 // true: true,
41 // uses: {}}
42 class SETEND_1111000100000001000000i000000000_case_0TesterCase0
43 : public Arm32DecoderTester {
44 public:
SETEND_1111000100000001000000i000000000_case_0TesterCase0(const NamedClassDecoder & decoder)45 SETEND_1111000100000001000000i000000000_case_0TesterCase0(const NamedClassDecoder& decoder)
46 : Arm32DecoderTester(decoder) {}
47 virtual bool PassesParsePreconditions(
48 nacl_arm_dec::Instruction inst,
49 const NamedClassDecoder& decoder);
50 };
51
52 bool SETEND_1111000100000001000000i000000000_case_0TesterCase0
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)53 ::PassesParsePreconditions(
54 nacl_arm_dec::Instruction inst,
55 const NamedClassDecoder& decoder) {
56
57 // Check that row patterns apply to pattern being checked.'
58 // op1(26:20)=~0010000
59 if ((inst.Bits() & 0x07F00000) !=
60 0x01000000) return false;
61 // op2(7:4)=~0000
62 if ((inst.Bits() & 0x000000F0) !=
63 0x00000000) return false;
64 // Rn(19:16)=~xxx1
65 if ((inst.Bits() & 0x00010000) !=
66 0x00010000) return false;
67 // $pattern(31:0)=~xxxxxxxxxxxx000x000000x0xxxx0000
68 if ((inst.Bits() & 0x000EFD0F) !=
69 0x00000000) return false;
70
71 // Check other preconditions defined for the base decoder.
72 return Arm32DecoderTester::
73 PassesParsePreconditions(inst, decoder);
74 }
75
76 // op1(26:20)=0010000 & op2(7:4)=xx0x & Rn(19:16)=xxx0 & $pattern(31:0)=xxxxxxxxxxxxxxxx0000000xxxxxxxxx
77 // = {actual: Actual_BLX_immediate_1111101hiiiiiiiiiiiiiiiiiiiiiiii_case_1,
78 // baseline: CPS_111100010000iii00000000iii0iiiii_case_0,
79 // defs: {},
80 // pattern: 111100010000iii00000000iii0iiiii,
81 // rule: CPS,
82 // safety: [true => FORBIDDEN],
83 // true: true,
84 // uses: {}}
85 class CPS_111100010000iii00000000iii0iiiii_case_0TesterCase1
86 : public Arm32DecoderTester {
87 public:
CPS_111100010000iii00000000iii0iiiii_case_0TesterCase1(const NamedClassDecoder & decoder)88 CPS_111100010000iii00000000iii0iiiii_case_0TesterCase1(const NamedClassDecoder& decoder)
89 : Arm32DecoderTester(decoder) {}
90 virtual bool PassesParsePreconditions(
91 nacl_arm_dec::Instruction inst,
92 const NamedClassDecoder& decoder);
93 };
94
95 bool CPS_111100010000iii00000000iii0iiiii_case_0TesterCase1
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)96 ::PassesParsePreconditions(
97 nacl_arm_dec::Instruction inst,
98 const NamedClassDecoder& decoder) {
99
100 // Check that row patterns apply to pattern being checked.'
101 // op1(26:20)=~0010000
102 if ((inst.Bits() & 0x07F00000) !=
103 0x01000000) return false;
104 // op2(7:4)=~xx0x
105 if ((inst.Bits() & 0x00000020) !=
106 0x00000000) return false;
107 // Rn(19:16)=~xxx0
108 if ((inst.Bits() & 0x00010000) !=
109 0x00000000) return false;
110 // $pattern(31:0)=~xxxxxxxxxxxxxxxx0000000xxxxxxxxx
111 if ((inst.Bits() & 0x0000FE00) !=
112 0x00000000) return false;
113
114 // Check other preconditions defined for the base decoder.
115 return Arm32DecoderTester::
116 PassesParsePreconditions(inst, decoder);
117 }
118
119 // op1(26:20)=1010011
120 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
121 // baseline: Unnamed_111101010011xxxxxxxxxxxxxxxxxxxx_case_0,
122 // defs: {},
123 // pattern: 111101010011xxxxxxxxxxxxxxxxxxxx,
124 // safety: [true => UNPREDICTABLE],
125 // true: true,
126 // uses: {}}
127 class Unnamed_111101010011xxxxxxxxxxxxxxxxxxxx_case_0TesterCase2
128 : public Arm32DecoderTester {
129 public:
Unnamed_111101010011xxxxxxxxxxxxxxxxxxxx_case_0TesterCase2(const NamedClassDecoder & decoder)130 Unnamed_111101010011xxxxxxxxxxxxxxxxxxxx_case_0TesterCase2(const NamedClassDecoder& decoder)
131 : Arm32DecoderTester(decoder) {}
132 virtual bool PassesParsePreconditions(
133 nacl_arm_dec::Instruction inst,
134 const NamedClassDecoder& decoder);
135 };
136
137 bool Unnamed_111101010011xxxxxxxxxxxxxxxxxxxx_case_0TesterCase2
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)138 ::PassesParsePreconditions(
139 nacl_arm_dec::Instruction inst,
140 const NamedClassDecoder& decoder) {
141
142 // Check that row patterns apply to pattern being checked.'
143 // op1(26:20)=~1010011
144 if ((inst.Bits() & 0x07F00000) !=
145 0x05300000) return false;
146
147 // Check other preconditions defined for the base decoder.
148 return Arm32DecoderTester::
149 PassesParsePreconditions(inst, decoder);
150 }
151
152 // op1(26:20)=1010111 & op2(7:4)=0000
153 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
154 // baseline: Unnamed_111101010111xxxxxxxxxxxx0000xxxx_case_0,
155 // defs: {},
156 // pattern: 111101010111xxxxxxxxxxxx0000xxxx,
157 // safety: [true => UNPREDICTABLE],
158 // true: true,
159 // uses: {}}
160 class Unnamed_111101010111xxxxxxxxxxxx0000xxxx_case_0TesterCase3
161 : public Arm32DecoderTester {
162 public:
Unnamed_111101010111xxxxxxxxxxxx0000xxxx_case_0TesterCase3(const NamedClassDecoder & decoder)163 Unnamed_111101010111xxxxxxxxxxxx0000xxxx_case_0TesterCase3(const NamedClassDecoder& decoder)
164 : Arm32DecoderTester(decoder) {}
165 virtual bool PassesParsePreconditions(
166 nacl_arm_dec::Instruction inst,
167 const NamedClassDecoder& decoder);
168 };
169
170 bool Unnamed_111101010111xxxxxxxxxxxx0000xxxx_case_0TesterCase3
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)171 ::PassesParsePreconditions(
172 nacl_arm_dec::Instruction inst,
173 const NamedClassDecoder& decoder) {
174
175 // Check that row patterns apply to pattern being checked.'
176 // op1(26:20)=~1010111
177 if ((inst.Bits() & 0x07F00000) !=
178 0x05700000) return false;
179 // op2(7:4)=~0000
180 if ((inst.Bits() & 0x000000F0) !=
181 0x00000000) return false;
182
183 // Check other preconditions defined for the base decoder.
184 return Arm32DecoderTester::
185 PassesParsePreconditions(inst, decoder);
186 }
187
188 // op1(26:20)=1010111 & op2(7:4)=0001 & $pattern(31:0)=xxxxxxxxxxxx111111110000xxxx1111
189 // = {actual: Actual_BLX_immediate_1111101hiiiiiiiiiiiiiiiiiiiiiiii_case_1,
190 // baseline: CLREX_11110101011111111111000000011111_case_0,
191 // defs: {},
192 // pattern: 11110101011111111111000000011111,
193 // rule: CLREX,
194 // safety: [true => FORBIDDEN],
195 // true: true,
196 // uses: {}}
197 class CLREX_11110101011111111111000000011111_case_0TesterCase4
198 : public Arm32DecoderTester {
199 public:
CLREX_11110101011111111111000000011111_case_0TesterCase4(const NamedClassDecoder & decoder)200 CLREX_11110101011111111111000000011111_case_0TesterCase4(const NamedClassDecoder& decoder)
201 : Arm32DecoderTester(decoder) {}
202 virtual bool PassesParsePreconditions(
203 nacl_arm_dec::Instruction inst,
204 const NamedClassDecoder& decoder);
205 };
206
207 bool CLREX_11110101011111111111000000011111_case_0TesterCase4
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)208 ::PassesParsePreconditions(
209 nacl_arm_dec::Instruction inst,
210 const NamedClassDecoder& decoder) {
211
212 // Check that row patterns apply to pattern being checked.'
213 // op1(26:20)=~1010111
214 if ((inst.Bits() & 0x07F00000) !=
215 0x05700000) return false;
216 // op2(7:4)=~0001
217 if ((inst.Bits() & 0x000000F0) !=
218 0x00000010) return false;
219 // $pattern(31:0)=~xxxxxxxxxxxx111111110000xxxx1111
220 if ((inst.Bits() & 0x000FFF0F) !=
221 0x000FF00F) return false;
222
223 // Check other preconditions defined for the base decoder.
224 return Arm32DecoderTester::
225 PassesParsePreconditions(inst, decoder);
226 }
227
228 // op1(26:20)=1010111 & op2(7:4)=0100 & $pattern(31:0)=xxxxxxxxxxxx111111110000xxxxxxxx
229 // = {actual: Actual_DMB_1111010101111111111100000101xxxx_case_1,
230 // baseline: DSB_1111010101111111111100000100xxxx_case_0,
231 // defs: {},
232 // fields: [option(3:0)],
233 // option: option(3:0),
234 // pattern: 1111010101111111111100000100xxxx,
235 // rule: DSB,
236 // safety: [not option in {'1111'(3:0), '1110'(3:0), '1011'(3:0), '1010'(3:0), '0111'(3:0), '0110'(3:0), '0011'(3:0), '0010'(3:0)} => FORBIDDEN_OPERANDS],
237 // uses: {}}
238 class DSB_1111010101111111111100000100xxxx_case_0TesterCase5
239 : public Arm32DecoderTester {
240 public:
DSB_1111010101111111111100000100xxxx_case_0TesterCase5(const NamedClassDecoder & decoder)241 DSB_1111010101111111111100000100xxxx_case_0TesterCase5(const NamedClassDecoder& decoder)
242 : Arm32DecoderTester(decoder) {}
243 virtual bool PassesParsePreconditions(
244 nacl_arm_dec::Instruction inst,
245 const NamedClassDecoder& decoder);
246 };
247
248 bool DSB_1111010101111111111100000100xxxx_case_0TesterCase5
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)249 ::PassesParsePreconditions(
250 nacl_arm_dec::Instruction inst,
251 const NamedClassDecoder& decoder) {
252
253 // Check that row patterns apply to pattern being checked.'
254 // op1(26:20)=~1010111
255 if ((inst.Bits() & 0x07F00000) !=
256 0x05700000) return false;
257 // op2(7:4)=~0100
258 if ((inst.Bits() & 0x000000F0) !=
259 0x00000040) return false;
260 // $pattern(31:0)=~xxxxxxxxxxxx111111110000xxxxxxxx
261 if ((inst.Bits() & 0x000FFF00) !=
262 0x000FF000) return false;
263
264 // Check other preconditions defined for the base decoder.
265 return Arm32DecoderTester::
266 PassesParsePreconditions(inst, decoder);
267 }
268
269 // op1(26:20)=1010111 & op2(7:4)=0101 & $pattern(31:0)=xxxxxxxxxxxx111111110000xxxxxxxx
270 // = {actual: Actual_DMB_1111010101111111111100000101xxxx_case_1,
271 // baseline: DMB_1111010101111111111100000101xxxx_case_0,
272 // defs: {},
273 // fields: [option(3:0)],
274 // option: option(3:0),
275 // pattern: 1111010101111111111100000101xxxx,
276 // rule: DMB,
277 // safety: [not option in {'1111'(3:0), '1110'(3:0), '1011'(3:0), '1010'(3:0), '0111'(3:0), '0110'(3:0), '0011'(3:0), '0010'(3:0)} => FORBIDDEN_OPERANDS],
278 // uses: {}}
279 class DMB_1111010101111111111100000101xxxx_case_0TesterCase6
280 : public Arm32DecoderTester {
281 public:
DMB_1111010101111111111100000101xxxx_case_0TesterCase6(const NamedClassDecoder & decoder)282 DMB_1111010101111111111100000101xxxx_case_0TesterCase6(const NamedClassDecoder& decoder)
283 : Arm32DecoderTester(decoder) {}
284 virtual bool PassesParsePreconditions(
285 nacl_arm_dec::Instruction inst,
286 const NamedClassDecoder& decoder);
287 };
288
289 bool DMB_1111010101111111111100000101xxxx_case_0TesterCase6
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)290 ::PassesParsePreconditions(
291 nacl_arm_dec::Instruction inst,
292 const NamedClassDecoder& decoder) {
293
294 // Check that row patterns apply to pattern being checked.'
295 // op1(26:20)=~1010111
296 if ((inst.Bits() & 0x07F00000) !=
297 0x05700000) return false;
298 // op2(7:4)=~0101
299 if ((inst.Bits() & 0x000000F0) !=
300 0x00000050) return false;
301 // $pattern(31:0)=~xxxxxxxxxxxx111111110000xxxxxxxx
302 if ((inst.Bits() & 0x000FFF00) !=
303 0x000FF000) return false;
304
305 // Check other preconditions defined for the base decoder.
306 return Arm32DecoderTester::
307 PassesParsePreconditions(inst, decoder);
308 }
309
310 // op1(26:20)=1010111 & op2(7:4)=0110 & $pattern(31:0)=xxxxxxxxxxxx111111110000xxxxxxxx
311 // = {actual: Actual_ISB_1111010101111111111100000110xxxx_case_1,
312 // baseline: ISB_1111010101111111111100000110xxxx_case_0,
313 // defs: {},
314 // fields: [option(3:0)],
315 // option: option(3:0),
316 // pattern: 1111010101111111111100000110xxxx,
317 // rule: ISB,
318 // safety: [option(3:0)=~1111 => FORBIDDEN_OPERANDS],
319 // uses: {}}
320 class ISB_1111010101111111111100000110xxxx_case_0TesterCase7
321 : public Arm32DecoderTester {
322 public:
ISB_1111010101111111111100000110xxxx_case_0TesterCase7(const NamedClassDecoder & decoder)323 ISB_1111010101111111111100000110xxxx_case_0TesterCase7(const NamedClassDecoder& decoder)
324 : Arm32DecoderTester(decoder) {}
325 virtual bool PassesParsePreconditions(
326 nacl_arm_dec::Instruction inst,
327 const NamedClassDecoder& decoder);
328 };
329
330 bool ISB_1111010101111111111100000110xxxx_case_0TesterCase7
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)331 ::PassesParsePreconditions(
332 nacl_arm_dec::Instruction inst,
333 const NamedClassDecoder& decoder) {
334
335 // Check that row patterns apply to pattern being checked.'
336 // op1(26:20)=~1010111
337 if ((inst.Bits() & 0x07F00000) !=
338 0x05700000) return false;
339 // op2(7:4)=~0110
340 if ((inst.Bits() & 0x000000F0) !=
341 0x00000060) return false;
342 // $pattern(31:0)=~xxxxxxxxxxxx111111110000xxxxxxxx
343 if ((inst.Bits() & 0x000FFF00) !=
344 0x000FF000) return false;
345
346 // Check other preconditions defined for the base decoder.
347 return Arm32DecoderTester::
348 PassesParsePreconditions(inst, decoder);
349 }
350
351 // op1(26:20)=1010111 & op2(7:4)=0111
352 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
353 // baseline: Unnamed_111101010111xxxxxxxxxxxx0111xxxx_case_0,
354 // defs: {},
355 // pattern: 111101010111xxxxxxxxxxxx0111xxxx,
356 // safety: [true => UNPREDICTABLE],
357 // true: true,
358 // uses: {}}
359 class Unnamed_111101010111xxxxxxxxxxxx0111xxxx_case_0TesterCase8
360 : public Arm32DecoderTester {
361 public:
Unnamed_111101010111xxxxxxxxxxxx0111xxxx_case_0TesterCase8(const NamedClassDecoder & decoder)362 Unnamed_111101010111xxxxxxxxxxxx0111xxxx_case_0TesterCase8(const NamedClassDecoder& decoder)
363 : Arm32DecoderTester(decoder) {}
364 virtual bool PassesParsePreconditions(
365 nacl_arm_dec::Instruction inst,
366 const NamedClassDecoder& decoder);
367 };
368
369 bool Unnamed_111101010111xxxxxxxxxxxx0111xxxx_case_0TesterCase8
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)370 ::PassesParsePreconditions(
371 nacl_arm_dec::Instruction inst,
372 const NamedClassDecoder& decoder) {
373
374 // Check that row patterns apply to pattern being checked.'
375 // op1(26:20)=~1010111
376 if ((inst.Bits() & 0x07F00000) !=
377 0x05700000) return false;
378 // op2(7:4)=~0111
379 if ((inst.Bits() & 0x000000F0) !=
380 0x00000070) return false;
381
382 // Check other preconditions defined for the base decoder.
383 return Arm32DecoderTester::
384 PassesParsePreconditions(inst, decoder);
385 }
386
387 // op1(26:20)=1010111 & op2(7:4)=001x
388 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
389 // baseline: Unnamed_111101010111xxxxxxxxxxxx001xxxxx_case_0,
390 // defs: {},
391 // pattern: 111101010111xxxxxxxxxxxx001xxxxx,
392 // safety: [true => UNPREDICTABLE],
393 // true: true,
394 // uses: {}}
395 class Unnamed_111101010111xxxxxxxxxxxx001xxxxx_case_0TesterCase9
396 : public Arm32DecoderTester {
397 public:
Unnamed_111101010111xxxxxxxxxxxx001xxxxx_case_0TesterCase9(const NamedClassDecoder & decoder)398 Unnamed_111101010111xxxxxxxxxxxx001xxxxx_case_0TesterCase9(const NamedClassDecoder& decoder)
399 : Arm32DecoderTester(decoder) {}
400 virtual bool PassesParsePreconditions(
401 nacl_arm_dec::Instruction inst,
402 const NamedClassDecoder& decoder);
403 };
404
405 bool Unnamed_111101010111xxxxxxxxxxxx001xxxxx_case_0TesterCase9
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)406 ::PassesParsePreconditions(
407 nacl_arm_dec::Instruction inst,
408 const NamedClassDecoder& decoder) {
409
410 // Check that row patterns apply to pattern being checked.'
411 // op1(26:20)=~1010111
412 if ((inst.Bits() & 0x07F00000) !=
413 0x05700000) return false;
414 // op2(7:4)=~001x
415 if ((inst.Bits() & 0x000000E0) !=
416 0x00000020) return false;
417
418 // Check other preconditions defined for the base decoder.
419 return Arm32DecoderTester::
420 PassesParsePreconditions(inst, decoder);
421 }
422
423 // op1(26:20)=1010111 & op2(7:4)=1xxx
424 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
425 // baseline: Unnamed_111101010111xxxxxxxxxxxx1xxxxxxx_case_0,
426 // defs: {},
427 // pattern: 111101010111xxxxxxxxxxxx1xxxxxxx,
428 // safety: [true => UNPREDICTABLE],
429 // true: true,
430 // uses: {}}
431 class Unnamed_111101010111xxxxxxxxxxxx1xxxxxxx_case_0TesterCase10
432 : public Arm32DecoderTester {
433 public:
Unnamed_111101010111xxxxxxxxxxxx1xxxxxxx_case_0TesterCase10(const NamedClassDecoder & decoder)434 Unnamed_111101010111xxxxxxxxxxxx1xxxxxxx_case_0TesterCase10(const NamedClassDecoder& decoder)
435 : Arm32DecoderTester(decoder) {}
436 virtual bool PassesParsePreconditions(
437 nacl_arm_dec::Instruction inst,
438 const NamedClassDecoder& decoder);
439 };
440
441 bool Unnamed_111101010111xxxxxxxxxxxx1xxxxxxx_case_0TesterCase10
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)442 ::PassesParsePreconditions(
443 nacl_arm_dec::Instruction inst,
444 const NamedClassDecoder& decoder) {
445
446 // Check that row patterns apply to pattern being checked.'
447 // op1(26:20)=~1010111
448 if ((inst.Bits() & 0x07F00000) !=
449 0x05700000) return false;
450 // op2(7:4)=~1xxx
451 if ((inst.Bits() & 0x00000080) !=
452 0x00000080) return false;
453
454 // Check other preconditions defined for the base decoder.
455 return Arm32DecoderTester::
456 PassesParsePreconditions(inst, decoder);
457 }
458
459 // op1(26:20)=100x001
460 // = {actual: Actual_BLX_immediate_1111101hiiiiiiiiiiiiiiiiiiiiiiii_case_1,
461 // baseline: Unnamed_11110100x001xxxxxxxxxxxxxxxxxxxx_case_0,
462 // defs: {},
463 // pattern: 11110100x001xxxxxxxxxxxxxxxxxxxx,
464 // safety: [true => FORBIDDEN],
465 // true: true,
466 // uses: {}}
467 class Unnamed_11110100x001xxxxxxxxxxxxxxxxxxxx_case_0TesterCase11
468 : public Arm32DecoderTester {
469 public:
Unnamed_11110100x001xxxxxxxxxxxxxxxxxxxx_case_0TesterCase11(const NamedClassDecoder & decoder)470 Unnamed_11110100x001xxxxxxxxxxxxxxxxxxxx_case_0TesterCase11(const NamedClassDecoder& decoder)
471 : Arm32DecoderTester(decoder) {}
472 virtual bool PassesParsePreconditions(
473 nacl_arm_dec::Instruction inst,
474 const NamedClassDecoder& decoder);
475 };
476
477 bool Unnamed_11110100x001xxxxxxxxxxxxxxxxxxxx_case_0TesterCase11
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)478 ::PassesParsePreconditions(
479 nacl_arm_dec::Instruction inst,
480 const NamedClassDecoder& decoder) {
481
482 // Check that row patterns apply to pattern being checked.'
483 // op1(26:20)=~100x001
484 if ((inst.Bits() & 0x07700000) !=
485 0x04100000) return false;
486
487 // Check other preconditions defined for the base decoder.
488 return Arm32DecoderTester::
489 PassesParsePreconditions(inst, decoder);
490 }
491
492 // op1(26:20)=100x101 & $pattern(31:0)=xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
493 // = {Pc: 15,
494 // Rn: Rn(19:16),
495 // actual: Actual_PLI_immediate_literal_11110100u101nnnn1111iiiiiiiiiiii_case_1,
496 // base: Rn,
497 // baseline: PLI_immediate_literal_11110100u101nnnn1111iiiiiiiiiiii_case_0,
498 // defs: {},
499 // fields: [Rn(19:16)],
500 // is_literal_load: Rn ==
501 // Pc,
502 // pattern: 11110100u101nnnn1111iiiiiiiiiiii,
503 // rule: PLI_immediate_literal,
504 // safety: [true => MAY_BE_SAFE],
505 // true: true,
506 // uses: {Rn},
507 // violations: [implied by 'base']}
508 class PLI_immediate_literal_11110100u101nnnn1111iiiiiiiiiiii_case_0TesterCase12
509 : public Arm32DecoderTester {
510 public:
PLI_immediate_literal_11110100u101nnnn1111iiiiiiiiiiii_case_0TesterCase12(const NamedClassDecoder & decoder)511 PLI_immediate_literal_11110100u101nnnn1111iiiiiiiiiiii_case_0TesterCase12(const NamedClassDecoder& decoder)
512 : Arm32DecoderTester(decoder) {}
513 virtual bool PassesParsePreconditions(
514 nacl_arm_dec::Instruction inst,
515 const NamedClassDecoder& decoder);
516 };
517
518 bool PLI_immediate_literal_11110100u101nnnn1111iiiiiiiiiiii_case_0TesterCase12
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)519 ::PassesParsePreconditions(
520 nacl_arm_dec::Instruction inst,
521 const NamedClassDecoder& decoder) {
522
523 // Check that row patterns apply to pattern being checked.'
524 // op1(26:20)=~100x101
525 if ((inst.Bits() & 0x07700000) !=
526 0x04500000) return false;
527 // $pattern(31:0)=~xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
528 if ((inst.Bits() & 0x0000F000) !=
529 0x0000F000) return false;
530
531 // Check other preconditions defined for the base decoder.
532 return Arm32DecoderTester::
533 PassesParsePreconditions(inst, decoder);
534 }
535
536 // op1(26:20)=101x001 & Rn(19:16)=~1111 & $pattern(31:0)=xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
537 // = {Pc: 15,
538 // Rn: Rn(19:16),
539 // actual: Actual_PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1,
540 // base: Rn,
541 // baseline: PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_0,
542 // defs: {},
543 // fields: [Rn(19:16)],
544 // is_literal_load: base ==
545 // Pc,
546 // pattern: 11110101ur01nnnn1111iiiiiiiiiiii,
547 // rule: PLD_PLDW_immediate,
548 // safety: [Rn(19:16)=1111 => DECODER_ERROR],
549 // uses: {Rn},
550 // violations: [implied by 'base']}
551 class PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_0TesterCase13
552 : public Arm32DecoderTester {
553 public:
PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_0TesterCase13(const NamedClassDecoder & decoder)554 PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_0TesterCase13(const NamedClassDecoder& decoder)
555 : Arm32DecoderTester(decoder) {}
556 virtual bool PassesParsePreconditions(
557 nacl_arm_dec::Instruction inst,
558 const NamedClassDecoder& decoder);
559 };
560
561 bool PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_0TesterCase13
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)562 ::PassesParsePreconditions(
563 nacl_arm_dec::Instruction inst,
564 const NamedClassDecoder& decoder) {
565
566 // Check that row patterns apply to pattern being checked.'
567 // op1(26:20)=~101x001
568 if ((inst.Bits() & 0x07700000) !=
569 0x05100000) return false;
570 // Rn(19:16)=1111
571 if ((inst.Bits() & 0x000F0000) ==
572 0x000F0000) return false;
573 // $pattern(31:0)=~xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
574 if ((inst.Bits() & 0x0000F000) !=
575 0x0000F000) return false;
576
577 // Check other preconditions defined for the base decoder.
578 return Arm32DecoderTester::
579 PassesParsePreconditions(inst, decoder);
580 }
581
582 // op1(26:20)=101x001 & Rn(19:16)=1111
583 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
584 // baseline: Unnamed_11110101x001xxxxxxxxxxxxxxxxxxxx_case_0,
585 // defs: {},
586 // pattern: 11110101x001xxxxxxxxxxxxxxxxxxxx,
587 // safety: [true => UNPREDICTABLE],
588 // true: true,
589 // uses: {}}
590 class Unnamed_11110101x001xxxxxxxxxxxxxxxxxxxx_case_0TesterCase14
591 : public Arm32DecoderTester {
592 public:
Unnamed_11110101x001xxxxxxxxxxxxxxxxxxxx_case_0TesterCase14(const NamedClassDecoder & decoder)593 Unnamed_11110101x001xxxxxxxxxxxxxxxxxxxx_case_0TesterCase14(const NamedClassDecoder& decoder)
594 : Arm32DecoderTester(decoder) {}
595 virtual bool PassesParsePreconditions(
596 nacl_arm_dec::Instruction inst,
597 const NamedClassDecoder& decoder);
598 };
599
600 bool Unnamed_11110101x001xxxxxxxxxxxxxxxxxxxx_case_0TesterCase14
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)601 ::PassesParsePreconditions(
602 nacl_arm_dec::Instruction inst,
603 const NamedClassDecoder& decoder) {
604
605 // Check that row patterns apply to pattern being checked.'
606 // op1(26:20)=~101x001
607 if ((inst.Bits() & 0x07700000) !=
608 0x05100000) return false;
609 // Rn(19:16)=~1111
610 if ((inst.Bits() & 0x000F0000) !=
611 0x000F0000) return false;
612
613 // Check other preconditions defined for the base decoder.
614 return Arm32DecoderTester::
615 PassesParsePreconditions(inst, decoder);
616 }
617
618 // op1(26:20)=101x101 & Rn(19:16)=~1111 & $pattern(31:0)=xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
619 // = {Pc: 15,
620 // Rn: Rn(19:16),
621 // actual: Actual_PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1,
622 // base: Rn,
623 // baseline: PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1,
624 // defs: {},
625 // fields: [Rn(19:16)],
626 // is_literal_load: base ==
627 // Pc,
628 // pattern: 11110101ur01nnnn1111iiiiiiiiiiii,
629 // rule: PLD_PLDW_immediate,
630 // safety: [Rn(19:16)=1111 => DECODER_ERROR],
631 // uses: {Rn},
632 // violations: [implied by 'base']}
633 class PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1TesterCase15
634 : public Arm32DecoderTester {
635 public:
PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1TesterCase15(const NamedClassDecoder & decoder)636 PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1TesterCase15(const NamedClassDecoder& decoder)
637 : Arm32DecoderTester(decoder) {}
638 virtual bool PassesParsePreconditions(
639 nacl_arm_dec::Instruction inst,
640 const NamedClassDecoder& decoder);
641 };
642
643 bool PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1TesterCase15
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)644 ::PassesParsePreconditions(
645 nacl_arm_dec::Instruction inst,
646 const NamedClassDecoder& decoder) {
647
648 // Check that row patterns apply to pattern being checked.'
649 // op1(26:20)=~101x101
650 if ((inst.Bits() & 0x07700000) !=
651 0x05500000) return false;
652 // Rn(19:16)=1111
653 if ((inst.Bits() & 0x000F0000) ==
654 0x000F0000) return false;
655 // $pattern(31:0)=~xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
656 if ((inst.Bits() & 0x0000F000) !=
657 0x0000F000) return false;
658
659 // Check other preconditions defined for the base decoder.
660 return Arm32DecoderTester::
661 PassesParsePreconditions(inst, decoder);
662 }
663
664 // op1(26:20)=101x101 & Rn(19:16)=1111 & $pattern(31:0)=xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
665 // = {Pc: 15,
666 // actual: Actual_PLD_literal_11110101u10111111111iiiiiiiiiiii_case_1,
667 // base: Pc,
668 // baseline: PLD_literal_11110101u10111111111iiiiiiiiiiii_case_0,
669 // defs: {},
670 // is_literal_load: true,
671 // pattern: 11110101u10111111111iiiiiiiiiiii,
672 // rule: PLD_literal,
673 // safety: [true => MAY_BE_SAFE],
674 // true: true,
675 // uses: {Pc},
676 // violations: [implied by 'base']}
677 class PLD_literal_11110101u10111111111iiiiiiiiiiii_case_0TesterCase16
678 : public Arm32DecoderTester {
679 public:
PLD_literal_11110101u10111111111iiiiiiiiiiii_case_0TesterCase16(const NamedClassDecoder & decoder)680 PLD_literal_11110101u10111111111iiiiiiiiiiii_case_0TesterCase16(const NamedClassDecoder& decoder)
681 : Arm32DecoderTester(decoder) {}
682 virtual bool PassesParsePreconditions(
683 nacl_arm_dec::Instruction inst,
684 const NamedClassDecoder& decoder);
685 };
686
687 bool PLD_literal_11110101u10111111111iiiiiiiiiiii_case_0TesterCase16
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)688 ::PassesParsePreconditions(
689 nacl_arm_dec::Instruction inst,
690 const NamedClassDecoder& decoder) {
691
692 // Check that row patterns apply to pattern being checked.'
693 // op1(26:20)=~101x101
694 if ((inst.Bits() & 0x07700000) !=
695 0x05500000) return false;
696 // Rn(19:16)=~1111
697 if ((inst.Bits() & 0x000F0000) !=
698 0x000F0000) return false;
699 // $pattern(31:0)=~xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
700 if ((inst.Bits() & 0x0000F000) !=
701 0x0000F000) return false;
702
703 // Check other preconditions defined for the base decoder.
704 return Arm32DecoderTester::
705 PassesParsePreconditions(inst, decoder);
706 }
707
708 // op1(26:20)=110x001 & op2(7:4)=xxx0
709 // = {actual: Actual_BLX_immediate_1111101hiiiiiiiiiiiiiiiiiiiiiiii_case_1,
710 // baseline: Unnamed_11110110x001xxxxxxxxxxxxxxx0xxxx_case_0,
711 // defs: {},
712 // pattern: 11110110x001xxxxxxxxxxxxxxx0xxxx,
713 // safety: [true => FORBIDDEN],
714 // true: true,
715 // uses: {}}
716 class Unnamed_11110110x001xxxxxxxxxxxxxxx0xxxx_case_0TesterCase17
717 : public Arm32DecoderTester {
718 public:
Unnamed_11110110x001xxxxxxxxxxxxxxx0xxxx_case_0TesterCase17(const NamedClassDecoder & decoder)719 Unnamed_11110110x001xxxxxxxxxxxxxxx0xxxx_case_0TesterCase17(const NamedClassDecoder& decoder)
720 : Arm32DecoderTester(decoder) {}
721 virtual bool PassesParsePreconditions(
722 nacl_arm_dec::Instruction inst,
723 const NamedClassDecoder& decoder);
724 };
725
726 bool Unnamed_11110110x001xxxxxxxxxxxxxxx0xxxx_case_0TesterCase17
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)727 ::PassesParsePreconditions(
728 nacl_arm_dec::Instruction inst,
729 const NamedClassDecoder& decoder) {
730
731 // Check that row patterns apply to pattern being checked.'
732 // op1(26:20)=~110x001
733 if ((inst.Bits() & 0x07700000) !=
734 0x06100000) return false;
735 // op2(7:4)=~xxx0
736 if ((inst.Bits() & 0x00000010) !=
737 0x00000000) return false;
738
739 // Check other preconditions defined for the base decoder.
740 return Arm32DecoderTester::
741 PassesParsePreconditions(inst, decoder);
742 }
743
744 // op1(26:20)=110x101 & op2(7:4)=xxx0 & $pattern(31:0)=xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
745 // = {Pc: 15,
746 // Rm: Rm(3:0),
747 // Rn: Rn(19:16),
748 // actual: Actual_PLI_register_11110110u101nnnn1111iiiiitt0mmmm_case_1,
749 // base: Rn,
750 // baseline: PLI_register_11110110u101nnnn1111iiiiitt0mmmm_case_0,
751 // defs: {},
752 // fields: [Rn(19:16), Rm(3:0)],
753 // pattern: 11110110u101nnnn1111iiiiitt0mmmm,
754 // rule: PLI_register,
755 // safety: [Rm ==
756 // Pc => UNPREDICTABLE,
757 // true => FORBIDDEN_OPERANDS],
758 // true: true,
759 // uses: {Rm, Rn},
760 // violations: [implied by 'base']}
761 class PLI_register_11110110u101nnnn1111iiiiitt0mmmm_case_0TesterCase18
762 : public Arm32DecoderTester {
763 public:
PLI_register_11110110u101nnnn1111iiiiitt0mmmm_case_0TesterCase18(const NamedClassDecoder & decoder)764 PLI_register_11110110u101nnnn1111iiiiitt0mmmm_case_0TesterCase18(const NamedClassDecoder& decoder)
765 : Arm32DecoderTester(decoder) {}
766 virtual bool PassesParsePreconditions(
767 nacl_arm_dec::Instruction inst,
768 const NamedClassDecoder& decoder);
769 };
770
771 bool PLI_register_11110110u101nnnn1111iiiiitt0mmmm_case_0TesterCase18
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)772 ::PassesParsePreconditions(
773 nacl_arm_dec::Instruction inst,
774 const NamedClassDecoder& decoder) {
775
776 // Check that row patterns apply to pattern being checked.'
777 // op1(26:20)=~110x101
778 if ((inst.Bits() & 0x07700000) !=
779 0x06500000) return false;
780 // op2(7:4)=~xxx0
781 if ((inst.Bits() & 0x00000010) !=
782 0x00000000) return false;
783 // $pattern(31:0)=~xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
784 if ((inst.Bits() & 0x0000F000) !=
785 0x0000F000) return false;
786
787 // Check other preconditions defined for the base decoder.
788 return Arm32DecoderTester::
789 PassesParsePreconditions(inst, decoder);
790 }
791
792 // op1(26:20)=111x001 & op2(7:4)=xxx0 & $pattern(31:0)=xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
793 // = {Pc: 15,
794 // R: R(22),
795 // Rm: Rm(3:0),
796 // Rn: Rn(19:16),
797 // actual: Actual_PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_1,
798 // base: Rn,
799 // baseline: PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_0,
800 // defs: {},
801 // fields: [R(22), Rn(19:16), Rm(3:0)],
802 // is_pldw: R(22)=1,
803 // pattern: 11110111u001nnnn1111iiiiitt0mmmm,
804 // rule: PLD_PLDW_register,
805 // safety: [Rm ==
806 // Pc ||
807 // (Rn ==
808 // Pc &&
809 // is_pldw) => UNPREDICTABLE,
810 // true => FORBIDDEN_OPERANDS],
811 // true: true,
812 // uses: {Rm, Rn},
813 // violations: [implied by 'base']}
814 class PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_0TesterCase19
815 : public Arm32DecoderTester {
816 public:
PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_0TesterCase19(const NamedClassDecoder & decoder)817 PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_0TesterCase19(const NamedClassDecoder& decoder)
818 : Arm32DecoderTester(decoder) {}
819 virtual bool PassesParsePreconditions(
820 nacl_arm_dec::Instruction inst,
821 const NamedClassDecoder& decoder);
822 };
823
824 bool PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_0TesterCase19
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)825 ::PassesParsePreconditions(
826 nacl_arm_dec::Instruction inst,
827 const NamedClassDecoder& decoder) {
828
829 // Check that row patterns apply to pattern being checked.'
830 // op1(26:20)=~111x001
831 if ((inst.Bits() & 0x07700000) !=
832 0x07100000) return false;
833 // op2(7:4)=~xxx0
834 if ((inst.Bits() & 0x00000010) !=
835 0x00000000) return false;
836 // $pattern(31:0)=~xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
837 if ((inst.Bits() & 0x0000F000) !=
838 0x0000F000) return false;
839
840 // Check other preconditions defined for the base decoder.
841 return Arm32DecoderTester::
842 PassesParsePreconditions(inst, decoder);
843 }
844
845 // op1(26:20)=111x101 & op2(7:4)=xxx0 & $pattern(31:0)=xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
846 // = {Pc: 15,
847 // R: R(22),
848 // Rm: Rm(3:0),
849 // Rn: Rn(19:16),
850 // actual: Actual_PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_1,
851 // base: Rn,
852 // baseline: PLD_PLDW_register_11110111u101nnnn1111iiiiitt0mmmm_case_0,
853 // defs: {},
854 // fields: [R(22), Rn(19:16), Rm(3:0)],
855 // is_pldw: R(22)=1,
856 // pattern: 11110111u101nnnn1111iiiiitt0mmmm,
857 // rule: PLD_PLDW_register,
858 // safety: [Rm ==
859 // Pc ||
860 // (Rn ==
861 // Pc &&
862 // is_pldw) => UNPREDICTABLE,
863 // true => FORBIDDEN_OPERANDS],
864 // true: true,
865 // uses: {Rm, Rn},
866 // violations: [implied by 'base']}
867 class PLD_PLDW_register_11110111u101nnnn1111iiiiitt0mmmm_case_0TesterCase20
868 : public Arm32DecoderTester {
869 public:
PLD_PLDW_register_11110111u101nnnn1111iiiiitt0mmmm_case_0TesterCase20(const NamedClassDecoder & decoder)870 PLD_PLDW_register_11110111u101nnnn1111iiiiitt0mmmm_case_0TesterCase20(const NamedClassDecoder& decoder)
871 : Arm32DecoderTester(decoder) {}
872 virtual bool PassesParsePreconditions(
873 nacl_arm_dec::Instruction inst,
874 const NamedClassDecoder& decoder);
875 };
876
877 bool PLD_PLDW_register_11110111u101nnnn1111iiiiitt0mmmm_case_0TesterCase20
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)878 ::PassesParsePreconditions(
879 nacl_arm_dec::Instruction inst,
880 const NamedClassDecoder& decoder) {
881
882 // Check that row patterns apply to pattern being checked.'
883 // op1(26:20)=~111x101
884 if ((inst.Bits() & 0x07700000) !=
885 0x07500000) return false;
886 // op2(7:4)=~xxx0
887 if ((inst.Bits() & 0x00000010) !=
888 0x00000000) return false;
889 // $pattern(31:0)=~xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
890 if ((inst.Bits() & 0x0000F000) !=
891 0x0000F000) return false;
892
893 // Check other preconditions defined for the base decoder.
894 return Arm32DecoderTester::
895 PassesParsePreconditions(inst, decoder);
896 }
897
898 // op1(26:20)=1011x11
899 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
900 // baseline: Unnamed_111101011x11xxxxxxxxxxxxxxxxxxxx_case_0,
901 // defs: {},
902 // pattern: 111101011x11xxxxxxxxxxxxxxxxxxxx,
903 // safety: [true => UNPREDICTABLE],
904 // true: true,
905 // uses: {}}
906 class Unnamed_111101011x11xxxxxxxxxxxxxxxxxxxx_case_0TesterCase21
907 : public Arm32DecoderTester {
908 public:
Unnamed_111101011x11xxxxxxxxxxxxxxxxxxxx_case_0TesterCase21(const NamedClassDecoder & decoder)909 Unnamed_111101011x11xxxxxxxxxxxxxxxxxxxx_case_0TesterCase21(const NamedClassDecoder& decoder)
910 : Arm32DecoderTester(decoder) {}
911 virtual bool PassesParsePreconditions(
912 nacl_arm_dec::Instruction inst,
913 const NamedClassDecoder& decoder);
914 };
915
916 bool Unnamed_111101011x11xxxxxxxxxxxxxxxxxxxx_case_0TesterCase21
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)917 ::PassesParsePreconditions(
918 nacl_arm_dec::Instruction inst,
919 const NamedClassDecoder& decoder) {
920
921 // Check that row patterns apply to pattern being checked.'
922 // op1(26:20)=~1011x11
923 if ((inst.Bits() & 0x07B00000) !=
924 0x05B00000) return false;
925
926 // Check other preconditions defined for the base decoder.
927 return Arm32DecoderTester::
928 PassesParsePreconditions(inst, decoder);
929 }
930
931 // op1(26:20)=100xx11
932 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
933 // baseline: Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_0,
934 // defs: {},
935 // pattern: 11110100xx11xxxxxxxxxxxxxxxxxxxx,
936 // safety: [true => UNPREDICTABLE],
937 // true: true,
938 // uses: {}}
939 class Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_0TesterCase22
940 : public Arm32DecoderTester {
941 public:
Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_0TesterCase22(const NamedClassDecoder & decoder)942 Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_0TesterCase22(const NamedClassDecoder& decoder)
943 : Arm32DecoderTester(decoder) {}
944 virtual bool PassesParsePreconditions(
945 nacl_arm_dec::Instruction inst,
946 const NamedClassDecoder& decoder);
947 };
948
949 bool Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_0TesterCase22
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)950 ::PassesParsePreconditions(
951 nacl_arm_dec::Instruction inst,
952 const NamedClassDecoder& decoder) {
953
954 // Check that row patterns apply to pattern being checked.'
955 // op1(26:20)=~100xx11
956 if ((inst.Bits() & 0x07300000) !=
957 0x04300000) return false;
958
959 // Check other preconditions defined for the base decoder.
960 return Arm32DecoderTester::
961 PassesParsePreconditions(inst, decoder);
962 }
963
964 // op1(26:20)=11xxx11 & op2(7:4)=xxx0
965 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
966 // baseline: Unnamed_1111011xxx11xxxxxxxxxxxxxxx0xxxx_case_0,
967 // defs: {},
968 // pattern: 1111011xxx11xxxxxxxxxxxxxxx0xxxx,
969 // safety: [true => UNPREDICTABLE],
970 // true: true,
971 // uses: {}}
972 class Unnamed_1111011xxx11xxxxxxxxxxxxxxx0xxxx_case_0TesterCase23
973 : public Arm32DecoderTester {
974 public:
Unnamed_1111011xxx11xxxxxxxxxxxxxxx0xxxx_case_0TesterCase23(const NamedClassDecoder & decoder)975 Unnamed_1111011xxx11xxxxxxxxxxxxxxx0xxxx_case_0TesterCase23(const NamedClassDecoder& decoder)
976 : Arm32DecoderTester(decoder) {}
977 virtual bool PassesParsePreconditions(
978 nacl_arm_dec::Instruction inst,
979 const NamedClassDecoder& decoder);
980 };
981
982 bool Unnamed_1111011xxx11xxxxxxxxxxxxxxx0xxxx_case_0TesterCase23
PassesParsePreconditions(nacl_arm_dec::Instruction inst,const NamedClassDecoder & decoder)983 ::PassesParsePreconditions(
984 nacl_arm_dec::Instruction inst,
985 const NamedClassDecoder& decoder) {
986
987 // Check that row patterns apply to pattern being checked.'
988 // op1(26:20)=~11xxx11
989 if ((inst.Bits() & 0x06300000) !=
990 0x06300000) return false;
991 // op2(7:4)=~xxx0
992 if ((inst.Bits() & 0x00000010) !=
993 0x00000000) return false;
994
995 // Check other preconditions defined for the base decoder.
996 return Arm32DecoderTester::
997 PassesParsePreconditions(inst, decoder);
998 }
999
1000 // The following are derived class decoder testers for decoder actions
1001 // associated with a pattern of an action. These derived classes introduce
1002 // a default constructor that automatically initializes the expected decoder
1003 // to the corresponding instance in the generated DecoderState.
1004
1005 // op1(26:20)=0010000 & op2(7:4)=0000 & Rn(19:16)=xxx1 & $pattern(31:0)=xxxxxxxxxxxx000x000000x0xxxx0000
1006 // = {actual: Actual_BLX_immediate_1111101hiiiiiiiiiiiiiiiiiiiiiiii_case_1,
1007 // baseline: SETEND_1111000100000001000000i000000000_case_0,
1008 // defs: {},
1009 // pattern: 1111000100000001000000i000000000,
1010 // rule: SETEND,
1011 // safety: [true => FORBIDDEN],
1012 // true: true,
1013 // uses: {}}
1014 class SETEND_1111000100000001000000i000000000_case_0Tester_Case0
1015 : public SETEND_1111000100000001000000i000000000_case_0TesterCase0 {
1016 public:
SETEND_1111000100000001000000i000000000_case_0Tester_Case0()1017 SETEND_1111000100000001000000i000000000_case_0Tester_Case0()
1018 : SETEND_1111000100000001000000i000000000_case_0TesterCase0(
1019 state_.SETEND_1111000100000001000000i000000000_case_0_SETEND_instance_)
1020 {}
1021 };
1022
1023 // op1(26:20)=0010000 & op2(7:4)=xx0x & Rn(19:16)=xxx0 & $pattern(31:0)=xxxxxxxxxxxxxxxx0000000xxxxxxxxx
1024 // = {actual: Actual_BLX_immediate_1111101hiiiiiiiiiiiiiiiiiiiiiiii_case_1,
1025 // baseline: CPS_111100010000iii00000000iii0iiiii_case_0,
1026 // defs: {},
1027 // pattern: 111100010000iii00000000iii0iiiii,
1028 // rule: CPS,
1029 // safety: [true => FORBIDDEN],
1030 // true: true,
1031 // uses: {}}
1032 class CPS_111100010000iii00000000iii0iiiii_case_0Tester_Case1
1033 : public CPS_111100010000iii00000000iii0iiiii_case_0TesterCase1 {
1034 public:
CPS_111100010000iii00000000iii0iiiii_case_0Tester_Case1()1035 CPS_111100010000iii00000000iii0iiiii_case_0Tester_Case1()
1036 : CPS_111100010000iii00000000iii0iiiii_case_0TesterCase1(
1037 state_.CPS_111100010000iii00000000iii0iiiii_case_0_CPS_instance_)
1038 {}
1039 };
1040
1041 // op1(26:20)=1010011
1042 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
1043 // baseline: Unnamed_111101010011xxxxxxxxxxxxxxxxxxxx_case_0,
1044 // defs: {},
1045 // pattern: 111101010011xxxxxxxxxxxxxxxxxxxx,
1046 // safety: [true => UNPREDICTABLE],
1047 // true: true,
1048 // uses: {}}
1049 class Unnamed_111101010011xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case2
1050 : public Unnamed_111101010011xxxxxxxxxxxxxxxxxxxx_case_0TesterCase2 {
1051 public:
Unnamed_111101010011xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case2()1052 Unnamed_111101010011xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case2()
1053 : Unnamed_111101010011xxxxxxxxxxxxxxxxxxxx_case_0TesterCase2(
1054 state_.Unnamed_111101010011xxxxxxxxxxxxxxxxxxxx_case_0_None_instance_)
1055 {}
1056 };
1057
1058 // op1(26:20)=1010111 & op2(7:4)=0000
1059 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
1060 // baseline: Unnamed_111101010111xxxxxxxxxxxx0000xxxx_case_0,
1061 // defs: {},
1062 // pattern: 111101010111xxxxxxxxxxxx0000xxxx,
1063 // safety: [true => UNPREDICTABLE],
1064 // true: true,
1065 // uses: {}}
1066 class Unnamed_111101010111xxxxxxxxxxxx0000xxxx_case_0Tester_Case3
1067 : public Unnamed_111101010111xxxxxxxxxxxx0000xxxx_case_0TesterCase3 {
1068 public:
Unnamed_111101010111xxxxxxxxxxxx0000xxxx_case_0Tester_Case3()1069 Unnamed_111101010111xxxxxxxxxxxx0000xxxx_case_0Tester_Case3()
1070 : Unnamed_111101010111xxxxxxxxxxxx0000xxxx_case_0TesterCase3(
1071 state_.Unnamed_111101010111xxxxxxxxxxxx0000xxxx_case_0_None_instance_)
1072 {}
1073 };
1074
1075 // op1(26:20)=1010111 & op2(7:4)=0001 & $pattern(31:0)=xxxxxxxxxxxx111111110000xxxx1111
1076 // = {actual: Actual_BLX_immediate_1111101hiiiiiiiiiiiiiiiiiiiiiiii_case_1,
1077 // baseline: CLREX_11110101011111111111000000011111_case_0,
1078 // defs: {},
1079 // pattern: 11110101011111111111000000011111,
1080 // rule: CLREX,
1081 // safety: [true => FORBIDDEN],
1082 // true: true,
1083 // uses: {}}
1084 class CLREX_11110101011111111111000000011111_case_0Tester_Case4
1085 : public CLREX_11110101011111111111000000011111_case_0TesterCase4 {
1086 public:
CLREX_11110101011111111111000000011111_case_0Tester_Case4()1087 CLREX_11110101011111111111000000011111_case_0Tester_Case4()
1088 : CLREX_11110101011111111111000000011111_case_0TesterCase4(
1089 state_.CLREX_11110101011111111111000000011111_case_0_CLREX_instance_)
1090 {}
1091 };
1092
1093 // op1(26:20)=1010111 & op2(7:4)=0100 & $pattern(31:0)=xxxxxxxxxxxx111111110000xxxxxxxx
1094 // = {actual: Actual_DMB_1111010101111111111100000101xxxx_case_1,
1095 // baseline: DSB_1111010101111111111100000100xxxx_case_0,
1096 // defs: {},
1097 // fields: [option(3:0)],
1098 // option: option(3:0),
1099 // pattern: 1111010101111111111100000100xxxx,
1100 // rule: DSB,
1101 // safety: [not option in {'1111'(3:0), '1110'(3:0), '1011'(3:0), '1010'(3:0), '0111'(3:0), '0110'(3:0), '0011'(3:0), '0010'(3:0)} => FORBIDDEN_OPERANDS],
1102 // uses: {}}
1103 class DSB_1111010101111111111100000100xxxx_case_0Tester_Case5
1104 : public DSB_1111010101111111111100000100xxxx_case_0TesterCase5 {
1105 public:
DSB_1111010101111111111100000100xxxx_case_0Tester_Case5()1106 DSB_1111010101111111111100000100xxxx_case_0Tester_Case5()
1107 : DSB_1111010101111111111100000100xxxx_case_0TesterCase5(
1108 state_.DSB_1111010101111111111100000100xxxx_case_0_DSB_instance_)
1109 {}
1110 };
1111
1112 // op1(26:20)=1010111 & op2(7:4)=0101 & $pattern(31:0)=xxxxxxxxxxxx111111110000xxxxxxxx
1113 // = {actual: Actual_DMB_1111010101111111111100000101xxxx_case_1,
1114 // baseline: DMB_1111010101111111111100000101xxxx_case_0,
1115 // defs: {},
1116 // fields: [option(3:0)],
1117 // option: option(3:0),
1118 // pattern: 1111010101111111111100000101xxxx,
1119 // rule: DMB,
1120 // safety: [not option in {'1111'(3:0), '1110'(3:0), '1011'(3:0), '1010'(3:0), '0111'(3:0), '0110'(3:0), '0011'(3:0), '0010'(3:0)} => FORBIDDEN_OPERANDS],
1121 // uses: {}}
1122 class DMB_1111010101111111111100000101xxxx_case_0Tester_Case6
1123 : public DMB_1111010101111111111100000101xxxx_case_0TesterCase6 {
1124 public:
DMB_1111010101111111111100000101xxxx_case_0Tester_Case6()1125 DMB_1111010101111111111100000101xxxx_case_0Tester_Case6()
1126 : DMB_1111010101111111111100000101xxxx_case_0TesterCase6(
1127 state_.DMB_1111010101111111111100000101xxxx_case_0_DMB_instance_)
1128 {}
1129 };
1130
1131 // op1(26:20)=1010111 & op2(7:4)=0110 & $pattern(31:0)=xxxxxxxxxxxx111111110000xxxxxxxx
1132 // = {actual: Actual_ISB_1111010101111111111100000110xxxx_case_1,
1133 // baseline: ISB_1111010101111111111100000110xxxx_case_0,
1134 // defs: {},
1135 // fields: [option(3:0)],
1136 // option: option(3:0),
1137 // pattern: 1111010101111111111100000110xxxx,
1138 // rule: ISB,
1139 // safety: [option(3:0)=~1111 => FORBIDDEN_OPERANDS],
1140 // uses: {}}
1141 class ISB_1111010101111111111100000110xxxx_case_0Tester_Case7
1142 : public ISB_1111010101111111111100000110xxxx_case_0TesterCase7 {
1143 public:
ISB_1111010101111111111100000110xxxx_case_0Tester_Case7()1144 ISB_1111010101111111111100000110xxxx_case_0Tester_Case7()
1145 : ISB_1111010101111111111100000110xxxx_case_0TesterCase7(
1146 state_.ISB_1111010101111111111100000110xxxx_case_0_ISB_instance_)
1147 {}
1148 };
1149
1150 // op1(26:20)=1010111 & op2(7:4)=0111
1151 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
1152 // baseline: Unnamed_111101010111xxxxxxxxxxxx0111xxxx_case_0,
1153 // defs: {},
1154 // pattern: 111101010111xxxxxxxxxxxx0111xxxx,
1155 // safety: [true => UNPREDICTABLE],
1156 // true: true,
1157 // uses: {}}
1158 class Unnamed_111101010111xxxxxxxxxxxx0111xxxx_case_0Tester_Case8
1159 : public Unnamed_111101010111xxxxxxxxxxxx0111xxxx_case_0TesterCase8 {
1160 public:
Unnamed_111101010111xxxxxxxxxxxx0111xxxx_case_0Tester_Case8()1161 Unnamed_111101010111xxxxxxxxxxxx0111xxxx_case_0Tester_Case8()
1162 : Unnamed_111101010111xxxxxxxxxxxx0111xxxx_case_0TesterCase8(
1163 state_.Unnamed_111101010111xxxxxxxxxxxx0111xxxx_case_0_None_instance_)
1164 {}
1165 };
1166
1167 // op1(26:20)=1010111 & op2(7:4)=001x
1168 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
1169 // baseline: Unnamed_111101010111xxxxxxxxxxxx001xxxxx_case_0,
1170 // defs: {},
1171 // pattern: 111101010111xxxxxxxxxxxx001xxxxx,
1172 // safety: [true => UNPREDICTABLE],
1173 // true: true,
1174 // uses: {}}
1175 class Unnamed_111101010111xxxxxxxxxxxx001xxxxx_case_0Tester_Case9
1176 : public Unnamed_111101010111xxxxxxxxxxxx001xxxxx_case_0TesterCase9 {
1177 public:
Unnamed_111101010111xxxxxxxxxxxx001xxxxx_case_0Tester_Case9()1178 Unnamed_111101010111xxxxxxxxxxxx001xxxxx_case_0Tester_Case9()
1179 : Unnamed_111101010111xxxxxxxxxxxx001xxxxx_case_0TesterCase9(
1180 state_.Unnamed_111101010111xxxxxxxxxxxx001xxxxx_case_0_None_instance_)
1181 {}
1182 };
1183
1184 // op1(26:20)=1010111 & op2(7:4)=1xxx
1185 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
1186 // baseline: Unnamed_111101010111xxxxxxxxxxxx1xxxxxxx_case_0,
1187 // defs: {},
1188 // pattern: 111101010111xxxxxxxxxxxx1xxxxxxx,
1189 // safety: [true => UNPREDICTABLE],
1190 // true: true,
1191 // uses: {}}
1192 class Unnamed_111101010111xxxxxxxxxxxx1xxxxxxx_case_0Tester_Case10
1193 : public Unnamed_111101010111xxxxxxxxxxxx1xxxxxxx_case_0TesterCase10 {
1194 public:
Unnamed_111101010111xxxxxxxxxxxx1xxxxxxx_case_0Tester_Case10()1195 Unnamed_111101010111xxxxxxxxxxxx1xxxxxxx_case_0Tester_Case10()
1196 : Unnamed_111101010111xxxxxxxxxxxx1xxxxxxx_case_0TesterCase10(
1197 state_.Unnamed_111101010111xxxxxxxxxxxx1xxxxxxx_case_0_None_instance_)
1198 {}
1199 };
1200
1201 // op1(26:20)=100x001
1202 // = {actual: Actual_BLX_immediate_1111101hiiiiiiiiiiiiiiiiiiiiiiii_case_1,
1203 // baseline: Unnamed_11110100x001xxxxxxxxxxxxxxxxxxxx_case_0,
1204 // defs: {},
1205 // pattern: 11110100x001xxxxxxxxxxxxxxxxxxxx,
1206 // safety: [true => FORBIDDEN],
1207 // true: true,
1208 // uses: {}}
1209 class Unnamed_11110100x001xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case11
1210 : public Unnamed_11110100x001xxxxxxxxxxxxxxxxxxxx_case_0TesterCase11 {
1211 public:
Unnamed_11110100x001xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case11()1212 Unnamed_11110100x001xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case11()
1213 : Unnamed_11110100x001xxxxxxxxxxxxxxxxxxxx_case_0TesterCase11(
1214 state_.Unnamed_11110100x001xxxxxxxxxxxxxxxxxxxx_case_0_None_instance_)
1215 {}
1216 };
1217
1218 // op1(26:20)=100x101 & $pattern(31:0)=xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
1219 // = {Pc: 15,
1220 // Rn: Rn(19:16),
1221 // actual: Actual_PLI_immediate_literal_11110100u101nnnn1111iiiiiiiiiiii_case_1,
1222 // base: Rn,
1223 // baseline: PLI_immediate_literal_11110100u101nnnn1111iiiiiiiiiiii_case_0,
1224 // defs: {},
1225 // fields: [Rn(19:16)],
1226 // is_literal_load: Rn ==
1227 // Pc,
1228 // pattern: 11110100u101nnnn1111iiiiiiiiiiii,
1229 // rule: PLI_immediate_literal,
1230 // safety: [true => MAY_BE_SAFE],
1231 // true: true,
1232 // uses: {Rn},
1233 // violations: [implied by 'base']}
1234 class PLI_immediate_literal_11110100u101nnnn1111iiiiiiiiiiii_case_0Tester_Case12
1235 : public PLI_immediate_literal_11110100u101nnnn1111iiiiiiiiiiii_case_0TesterCase12 {
1236 public:
PLI_immediate_literal_11110100u101nnnn1111iiiiiiiiiiii_case_0Tester_Case12()1237 PLI_immediate_literal_11110100u101nnnn1111iiiiiiiiiiii_case_0Tester_Case12()
1238 : PLI_immediate_literal_11110100u101nnnn1111iiiiiiiiiiii_case_0TesterCase12(
1239 state_.PLI_immediate_literal_11110100u101nnnn1111iiiiiiiiiiii_case_0_PLI_immediate_literal_instance_)
1240 {}
1241 };
1242
1243 // op1(26:20)=101x001 & Rn(19:16)=~1111 & $pattern(31:0)=xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
1244 // = {Pc: 15,
1245 // Rn: Rn(19:16),
1246 // actual: Actual_PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1,
1247 // base: Rn,
1248 // baseline: PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_0,
1249 // defs: {},
1250 // fields: [Rn(19:16)],
1251 // is_literal_load: base ==
1252 // Pc,
1253 // pattern: 11110101ur01nnnn1111iiiiiiiiiiii,
1254 // rule: PLD_PLDW_immediate,
1255 // safety: [Rn(19:16)=1111 => DECODER_ERROR],
1256 // uses: {Rn},
1257 // violations: [implied by 'base']}
1258 class PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_0Tester_Case13
1259 : public PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_0TesterCase13 {
1260 public:
PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_0Tester_Case13()1261 PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_0Tester_Case13()
1262 : PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_0TesterCase13(
1263 state_.PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_0_PLD_PLDW_immediate_instance_)
1264 {}
1265 };
1266
1267 // op1(26:20)=101x001 & Rn(19:16)=1111
1268 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
1269 // baseline: Unnamed_11110101x001xxxxxxxxxxxxxxxxxxxx_case_0,
1270 // defs: {},
1271 // pattern: 11110101x001xxxxxxxxxxxxxxxxxxxx,
1272 // safety: [true => UNPREDICTABLE],
1273 // true: true,
1274 // uses: {}}
1275 class Unnamed_11110101x001xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case14
1276 : public Unnamed_11110101x001xxxxxxxxxxxxxxxxxxxx_case_0TesterCase14 {
1277 public:
Unnamed_11110101x001xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case14()1278 Unnamed_11110101x001xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case14()
1279 : Unnamed_11110101x001xxxxxxxxxxxxxxxxxxxx_case_0TesterCase14(
1280 state_.Unnamed_11110101x001xxxxxxxxxxxxxxxxxxxx_case_0_None_instance_)
1281 {}
1282 };
1283
1284 // op1(26:20)=101x101 & Rn(19:16)=~1111 & $pattern(31:0)=xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
1285 // = {Pc: 15,
1286 // Rn: Rn(19:16),
1287 // actual: Actual_PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1,
1288 // base: Rn,
1289 // baseline: PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1,
1290 // defs: {},
1291 // fields: [Rn(19:16)],
1292 // is_literal_load: base ==
1293 // Pc,
1294 // pattern: 11110101ur01nnnn1111iiiiiiiiiiii,
1295 // rule: PLD_PLDW_immediate,
1296 // safety: [Rn(19:16)=1111 => DECODER_ERROR],
1297 // uses: {Rn},
1298 // violations: [implied by 'base']}
1299 class PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1Tester_Case15
1300 : public PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1TesterCase15 {
1301 public:
PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1Tester_Case15()1302 PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1Tester_Case15()
1303 : PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1TesterCase15(
1304 state_.PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1_PLD_PLDW_immediate_instance_)
1305 {}
1306 };
1307
1308 // op1(26:20)=101x101 & Rn(19:16)=1111 & $pattern(31:0)=xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
1309 // = {Pc: 15,
1310 // actual: Actual_PLD_literal_11110101u10111111111iiiiiiiiiiii_case_1,
1311 // base: Pc,
1312 // baseline: PLD_literal_11110101u10111111111iiiiiiiiiiii_case_0,
1313 // defs: {},
1314 // is_literal_load: true,
1315 // pattern: 11110101u10111111111iiiiiiiiiiii,
1316 // rule: PLD_literal,
1317 // safety: [true => MAY_BE_SAFE],
1318 // true: true,
1319 // uses: {Pc},
1320 // violations: [implied by 'base']}
1321 class PLD_literal_11110101u10111111111iiiiiiiiiiii_case_0Tester_Case16
1322 : public PLD_literal_11110101u10111111111iiiiiiiiiiii_case_0TesterCase16 {
1323 public:
PLD_literal_11110101u10111111111iiiiiiiiiiii_case_0Tester_Case16()1324 PLD_literal_11110101u10111111111iiiiiiiiiiii_case_0Tester_Case16()
1325 : PLD_literal_11110101u10111111111iiiiiiiiiiii_case_0TesterCase16(
1326 state_.PLD_literal_11110101u10111111111iiiiiiiiiiii_case_0_PLD_literal_instance_)
1327 {}
1328 };
1329
1330 // op1(26:20)=110x001 & op2(7:4)=xxx0
1331 // = {actual: Actual_BLX_immediate_1111101hiiiiiiiiiiiiiiiiiiiiiiii_case_1,
1332 // baseline: Unnamed_11110110x001xxxxxxxxxxxxxxx0xxxx_case_0,
1333 // defs: {},
1334 // pattern: 11110110x001xxxxxxxxxxxxxxx0xxxx,
1335 // safety: [true => FORBIDDEN],
1336 // true: true,
1337 // uses: {}}
1338 class Unnamed_11110110x001xxxxxxxxxxxxxxx0xxxx_case_0Tester_Case17
1339 : public Unnamed_11110110x001xxxxxxxxxxxxxxx0xxxx_case_0TesterCase17 {
1340 public:
Unnamed_11110110x001xxxxxxxxxxxxxxx0xxxx_case_0Tester_Case17()1341 Unnamed_11110110x001xxxxxxxxxxxxxxx0xxxx_case_0Tester_Case17()
1342 : Unnamed_11110110x001xxxxxxxxxxxxxxx0xxxx_case_0TesterCase17(
1343 state_.Unnamed_11110110x001xxxxxxxxxxxxxxx0xxxx_case_0_None_instance_)
1344 {}
1345 };
1346
1347 // op1(26:20)=110x101 & op2(7:4)=xxx0 & $pattern(31:0)=xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
1348 // = {Pc: 15,
1349 // Rm: Rm(3:0),
1350 // Rn: Rn(19:16),
1351 // actual: Actual_PLI_register_11110110u101nnnn1111iiiiitt0mmmm_case_1,
1352 // base: Rn,
1353 // baseline: PLI_register_11110110u101nnnn1111iiiiitt0mmmm_case_0,
1354 // defs: {},
1355 // fields: [Rn(19:16), Rm(3:0)],
1356 // pattern: 11110110u101nnnn1111iiiiitt0mmmm,
1357 // rule: PLI_register,
1358 // safety: [Rm ==
1359 // Pc => UNPREDICTABLE,
1360 // true => FORBIDDEN_OPERANDS],
1361 // true: true,
1362 // uses: {Rm, Rn},
1363 // violations: [implied by 'base']}
1364 class PLI_register_11110110u101nnnn1111iiiiitt0mmmm_case_0Tester_Case18
1365 : public PLI_register_11110110u101nnnn1111iiiiitt0mmmm_case_0TesterCase18 {
1366 public:
PLI_register_11110110u101nnnn1111iiiiitt0mmmm_case_0Tester_Case18()1367 PLI_register_11110110u101nnnn1111iiiiitt0mmmm_case_0Tester_Case18()
1368 : PLI_register_11110110u101nnnn1111iiiiitt0mmmm_case_0TesterCase18(
1369 state_.PLI_register_11110110u101nnnn1111iiiiitt0mmmm_case_0_PLI_register_instance_)
1370 {}
1371 };
1372
1373 // op1(26:20)=111x001 & op2(7:4)=xxx0 & $pattern(31:0)=xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
1374 // = {Pc: 15,
1375 // R: R(22),
1376 // Rm: Rm(3:0),
1377 // Rn: Rn(19:16),
1378 // actual: Actual_PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_1,
1379 // base: Rn,
1380 // baseline: PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_0,
1381 // defs: {},
1382 // fields: [R(22), Rn(19:16), Rm(3:0)],
1383 // is_pldw: R(22)=1,
1384 // pattern: 11110111u001nnnn1111iiiiitt0mmmm,
1385 // rule: PLD_PLDW_register,
1386 // safety: [Rm ==
1387 // Pc ||
1388 // (Rn ==
1389 // Pc &&
1390 // is_pldw) => UNPREDICTABLE,
1391 // true => FORBIDDEN_OPERANDS],
1392 // true: true,
1393 // uses: {Rm, Rn},
1394 // violations: [implied by 'base']}
1395 class PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_0Tester_Case19
1396 : public PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_0TesterCase19 {
1397 public:
PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_0Tester_Case19()1398 PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_0Tester_Case19()
1399 : PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_0TesterCase19(
1400 state_.PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_0_PLD_PLDW_register_instance_)
1401 {}
1402 };
1403
1404 // op1(26:20)=111x101 & op2(7:4)=xxx0 & $pattern(31:0)=xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
1405 // = {Pc: 15,
1406 // R: R(22),
1407 // Rm: Rm(3:0),
1408 // Rn: Rn(19:16),
1409 // actual: Actual_PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_1,
1410 // base: Rn,
1411 // baseline: PLD_PLDW_register_11110111u101nnnn1111iiiiitt0mmmm_case_0,
1412 // defs: {},
1413 // fields: [R(22), Rn(19:16), Rm(3:0)],
1414 // is_pldw: R(22)=1,
1415 // pattern: 11110111u101nnnn1111iiiiitt0mmmm,
1416 // rule: PLD_PLDW_register,
1417 // safety: [Rm ==
1418 // Pc ||
1419 // (Rn ==
1420 // Pc &&
1421 // is_pldw) => UNPREDICTABLE,
1422 // true => FORBIDDEN_OPERANDS],
1423 // true: true,
1424 // uses: {Rm, Rn},
1425 // violations: [implied by 'base']}
1426 class PLD_PLDW_register_11110111u101nnnn1111iiiiitt0mmmm_case_0Tester_Case20
1427 : public PLD_PLDW_register_11110111u101nnnn1111iiiiitt0mmmm_case_0TesterCase20 {
1428 public:
PLD_PLDW_register_11110111u101nnnn1111iiiiitt0mmmm_case_0Tester_Case20()1429 PLD_PLDW_register_11110111u101nnnn1111iiiiitt0mmmm_case_0Tester_Case20()
1430 : PLD_PLDW_register_11110111u101nnnn1111iiiiitt0mmmm_case_0TesterCase20(
1431 state_.PLD_PLDW_register_11110111u101nnnn1111iiiiitt0mmmm_case_0_PLD_PLDW_register_instance_)
1432 {}
1433 };
1434
1435 // op1(26:20)=1011x11
1436 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
1437 // baseline: Unnamed_111101011x11xxxxxxxxxxxxxxxxxxxx_case_0,
1438 // defs: {},
1439 // pattern: 111101011x11xxxxxxxxxxxxxxxxxxxx,
1440 // safety: [true => UNPREDICTABLE],
1441 // true: true,
1442 // uses: {}}
1443 class Unnamed_111101011x11xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case21
1444 : public Unnamed_111101011x11xxxxxxxxxxxxxxxxxxxx_case_0TesterCase21 {
1445 public:
Unnamed_111101011x11xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case21()1446 Unnamed_111101011x11xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case21()
1447 : Unnamed_111101011x11xxxxxxxxxxxxxxxxxxxx_case_0TesterCase21(
1448 state_.Unnamed_111101011x11xxxxxxxxxxxxxxxxxxxx_case_0_None_instance_)
1449 {}
1450 };
1451
1452 // op1(26:20)=100xx11
1453 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
1454 // baseline: Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_0,
1455 // defs: {},
1456 // pattern: 11110100xx11xxxxxxxxxxxxxxxxxxxx,
1457 // safety: [true => UNPREDICTABLE],
1458 // true: true,
1459 // uses: {}}
1460 class Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case22
1461 : public Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_0TesterCase22 {
1462 public:
Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case22()1463 Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case22()
1464 : Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_0TesterCase22(
1465 state_.Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_0_None_instance_)
1466 {}
1467 };
1468
1469 // op1(26:20)=11xxx11 & op2(7:4)=xxx0
1470 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
1471 // baseline: Unnamed_1111011xxx11xxxxxxxxxxxxxxx0xxxx_case_0,
1472 // defs: {},
1473 // pattern: 1111011xxx11xxxxxxxxxxxxxxx0xxxx,
1474 // safety: [true => UNPREDICTABLE],
1475 // true: true,
1476 // uses: {}}
1477 class Unnamed_1111011xxx11xxxxxxxxxxxxxxx0xxxx_case_0Tester_Case23
1478 : public Unnamed_1111011xxx11xxxxxxxxxxxxxxx0xxxx_case_0TesterCase23 {
1479 public:
Unnamed_1111011xxx11xxxxxxxxxxxxxxx0xxxx_case_0Tester_Case23()1480 Unnamed_1111011xxx11xxxxxxxxxxxxxxx0xxxx_case_0Tester_Case23()
1481 : Unnamed_1111011xxx11xxxxxxxxxxxxxxx0xxxx_case_0TesterCase23(
1482 state_.Unnamed_1111011xxx11xxxxxxxxxxxxxxx0xxxx_case_0_None_instance_)
1483 {}
1484 };
1485
1486 // Defines a gtest testing harness for tests.
1487 class Arm32DecoderStateTests : public ::testing::Test {
1488 protected:
Arm32DecoderStateTests()1489 Arm32DecoderStateTests() {}
1490 };
1491
1492 // The following functions test each pattern specified in parse
1493 // decoder tables.
1494
1495 // op1(26:20)=0010000 & op2(7:4)=0000 & Rn(19:16)=xxx1 & $pattern(31:0)=xxxxxxxxxxxx000x000000x0xxxx0000
1496 // = {actual: Actual_BLX_immediate_1111101hiiiiiiiiiiiiiiiiiiiiiiii_case_1,
1497 // baseline: SETEND_1111000100000001000000i000000000_case_0,
1498 // defs: {},
1499 // pattern: 1111000100000001000000i000000000,
1500 // rule: SETEND,
1501 // safety: [true => FORBIDDEN],
1502 // true: true,
1503 // uses: {}}
TEST_F(Arm32DecoderStateTests,SETEND_1111000100000001000000i000000000_case_0Tester_Case0_TestCase0)1504 TEST_F(Arm32DecoderStateTests,
1505 SETEND_1111000100000001000000i000000000_case_0Tester_Case0_TestCase0) {
1506 SETEND_1111000100000001000000i000000000_case_0Tester_Case0 baseline_tester;
1507 NamedActual_BLX_immediate_1111101hiiiiiiiiiiiiiiiiiiiiiiii_case_1_SETEND actual;
1508 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1509 a_vs_b_tester.Test("1111000100000001000000i000000000");
1510 }
1511
1512 // op1(26:20)=0010000 & op2(7:4)=xx0x & Rn(19:16)=xxx0 & $pattern(31:0)=xxxxxxxxxxxxxxxx0000000xxxxxxxxx
1513 // = {actual: Actual_BLX_immediate_1111101hiiiiiiiiiiiiiiiiiiiiiiii_case_1,
1514 // baseline: CPS_111100010000iii00000000iii0iiiii_case_0,
1515 // defs: {},
1516 // pattern: 111100010000iii00000000iii0iiiii,
1517 // rule: CPS,
1518 // safety: [true => FORBIDDEN],
1519 // true: true,
1520 // uses: {}}
TEST_F(Arm32DecoderStateTests,CPS_111100010000iii00000000iii0iiiii_case_0Tester_Case1_TestCase1)1521 TEST_F(Arm32DecoderStateTests,
1522 CPS_111100010000iii00000000iii0iiiii_case_0Tester_Case1_TestCase1) {
1523 CPS_111100010000iii00000000iii0iiiii_case_0Tester_Case1 baseline_tester;
1524 NamedActual_BLX_immediate_1111101hiiiiiiiiiiiiiiiiiiiiiiii_case_1_CPS actual;
1525 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1526 a_vs_b_tester.Test("111100010000iii00000000iii0iiiii");
1527 }
1528
1529 // op1(26:20)=1010011
1530 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
1531 // baseline: Unnamed_111101010011xxxxxxxxxxxxxxxxxxxx_case_0,
1532 // defs: {},
1533 // pattern: 111101010011xxxxxxxxxxxxxxxxxxxx,
1534 // safety: [true => UNPREDICTABLE],
1535 // true: true,
1536 // uses: {}}
TEST_F(Arm32DecoderStateTests,Unnamed_111101010011xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case2_TestCase2)1537 TEST_F(Arm32DecoderStateTests,
1538 Unnamed_111101010011xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case2_TestCase2) {
1539 Unnamed_111101010011xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case2 baseline_tester;
1540 NamedActual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1_None actual;
1541 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1542 a_vs_b_tester.Test("111101010011xxxxxxxxxxxxxxxxxxxx");
1543 }
1544
1545 // op1(26:20)=1010111 & op2(7:4)=0000
1546 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
1547 // baseline: Unnamed_111101010111xxxxxxxxxxxx0000xxxx_case_0,
1548 // defs: {},
1549 // pattern: 111101010111xxxxxxxxxxxx0000xxxx,
1550 // safety: [true => UNPREDICTABLE],
1551 // true: true,
1552 // uses: {}}
TEST_F(Arm32DecoderStateTests,Unnamed_111101010111xxxxxxxxxxxx0000xxxx_case_0Tester_Case3_TestCase3)1553 TEST_F(Arm32DecoderStateTests,
1554 Unnamed_111101010111xxxxxxxxxxxx0000xxxx_case_0Tester_Case3_TestCase3) {
1555 Unnamed_111101010111xxxxxxxxxxxx0000xxxx_case_0Tester_Case3 baseline_tester;
1556 NamedActual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1_None actual;
1557 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1558 a_vs_b_tester.Test("111101010111xxxxxxxxxxxx0000xxxx");
1559 }
1560
1561 // op1(26:20)=1010111 & op2(7:4)=0001 & $pattern(31:0)=xxxxxxxxxxxx111111110000xxxx1111
1562 // = {actual: Actual_BLX_immediate_1111101hiiiiiiiiiiiiiiiiiiiiiiii_case_1,
1563 // baseline: CLREX_11110101011111111111000000011111_case_0,
1564 // defs: {},
1565 // pattern: 11110101011111111111000000011111,
1566 // rule: CLREX,
1567 // safety: [true => FORBIDDEN],
1568 // true: true,
1569 // uses: {}}
TEST_F(Arm32DecoderStateTests,CLREX_11110101011111111111000000011111_case_0Tester_Case4_TestCase4)1570 TEST_F(Arm32DecoderStateTests,
1571 CLREX_11110101011111111111000000011111_case_0Tester_Case4_TestCase4) {
1572 CLREX_11110101011111111111000000011111_case_0Tester_Case4 baseline_tester;
1573 NamedActual_BLX_immediate_1111101hiiiiiiiiiiiiiiiiiiiiiiii_case_1_CLREX actual;
1574 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1575 a_vs_b_tester.Test("11110101011111111111000000011111");
1576 }
1577
1578 // op1(26:20)=1010111 & op2(7:4)=0100 & $pattern(31:0)=xxxxxxxxxxxx111111110000xxxxxxxx
1579 // = {actual: Actual_DMB_1111010101111111111100000101xxxx_case_1,
1580 // baseline: DSB_1111010101111111111100000100xxxx_case_0,
1581 // defs: {},
1582 // fields: [option(3:0)],
1583 // option: option(3:0),
1584 // pattern: 1111010101111111111100000100xxxx,
1585 // rule: DSB,
1586 // safety: [not option in {'1111'(3:0), '1110'(3:0), '1011'(3:0), '1010'(3:0), '0111'(3:0), '0110'(3:0), '0011'(3:0), '0010'(3:0)} => FORBIDDEN_OPERANDS],
1587 // uses: {}}
TEST_F(Arm32DecoderStateTests,DSB_1111010101111111111100000100xxxx_case_0Tester_Case5_TestCase5)1588 TEST_F(Arm32DecoderStateTests,
1589 DSB_1111010101111111111100000100xxxx_case_0Tester_Case5_TestCase5) {
1590 DSB_1111010101111111111100000100xxxx_case_0Tester_Case5 baseline_tester;
1591 NamedActual_DMB_1111010101111111111100000101xxxx_case_1_DSB actual;
1592 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1593 a_vs_b_tester.Test("1111010101111111111100000100xxxx");
1594 }
1595
1596 // op1(26:20)=1010111 & op2(7:4)=0101 & $pattern(31:0)=xxxxxxxxxxxx111111110000xxxxxxxx
1597 // = {actual: Actual_DMB_1111010101111111111100000101xxxx_case_1,
1598 // baseline: DMB_1111010101111111111100000101xxxx_case_0,
1599 // defs: {},
1600 // fields: [option(3:0)],
1601 // option: option(3:0),
1602 // pattern: 1111010101111111111100000101xxxx,
1603 // rule: DMB,
1604 // safety: [not option in {'1111'(3:0), '1110'(3:0), '1011'(3:0), '1010'(3:0), '0111'(3:0), '0110'(3:0), '0011'(3:0), '0010'(3:0)} => FORBIDDEN_OPERANDS],
1605 // uses: {}}
TEST_F(Arm32DecoderStateTests,DMB_1111010101111111111100000101xxxx_case_0Tester_Case6_TestCase6)1606 TEST_F(Arm32DecoderStateTests,
1607 DMB_1111010101111111111100000101xxxx_case_0Tester_Case6_TestCase6) {
1608 DMB_1111010101111111111100000101xxxx_case_0Tester_Case6 baseline_tester;
1609 NamedActual_DMB_1111010101111111111100000101xxxx_case_1_DMB actual;
1610 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1611 a_vs_b_tester.Test("1111010101111111111100000101xxxx");
1612 }
1613
1614 // op1(26:20)=1010111 & op2(7:4)=0110 & $pattern(31:0)=xxxxxxxxxxxx111111110000xxxxxxxx
1615 // = {actual: Actual_ISB_1111010101111111111100000110xxxx_case_1,
1616 // baseline: ISB_1111010101111111111100000110xxxx_case_0,
1617 // defs: {},
1618 // fields: [option(3:0)],
1619 // option: option(3:0),
1620 // pattern: 1111010101111111111100000110xxxx,
1621 // rule: ISB,
1622 // safety: [option(3:0)=~1111 => FORBIDDEN_OPERANDS],
1623 // uses: {}}
TEST_F(Arm32DecoderStateTests,ISB_1111010101111111111100000110xxxx_case_0Tester_Case7_TestCase7)1624 TEST_F(Arm32DecoderStateTests,
1625 ISB_1111010101111111111100000110xxxx_case_0Tester_Case7_TestCase7) {
1626 ISB_1111010101111111111100000110xxxx_case_0Tester_Case7 baseline_tester;
1627 NamedActual_ISB_1111010101111111111100000110xxxx_case_1_ISB actual;
1628 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1629 a_vs_b_tester.Test("1111010101111111111100000110xxxx");
1630 }
1631
1632 // op1(26:20)=1010111 & op2(7:4)=0111
1633 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
1634 // baseline: Unnamed_111101010111xxxxxxxxxxxx0111xxxx_case_0,
1635 // defs: {},
1636 // pattern: 111101010111xxxxxxxxxxxx0111xxxx,
1637 // safety: [true => UNPREDICTABLE],
1638 // true: true,
1639 // uses: {}}
TEST_F(Arm32DecoderStateTests,Unnamed_111101010111xxxxxxxxxxxx0111xxxx_case_0Tester_Case8_TestCase8)1640 TEST_F(Arm32DecoderStateTests,
1641 Unnamed_111101010111xxxxxxxxxxxx0111xxxx_case_0Tester_Case8_TestCase8) {
1642 Unnamed_111101010111xxxxxxxxxxxx0111xxxx_case_0Tester_Case8 baseline_tester;
1643 NamedActual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1_None actual;
1644 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1645 a_vs_b_tester.Test("111101010111xxxxxxxxxxxx0111xxxx");
1646 }
1647
1648 // op1(26:20)=1010111 & op2(7:4)=001x
1649 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
1650 // baseline: Unnamed_111101010111xxxxxxxxxxxx001xxxxx_case_0,
1651 // defs: {},
1652 // pattern: 111101010111xxxxxxxxxxxx001xxxxx,
1653 // safety: [true => UNPREDICTABLE],
1654 // true: true,
1655 // uses: {}}
TEST_F(Arm32DecoderStateTests,Unnamed_111101010111xxxxxxxxxxxx001xxxxx_case_0Tester_Case9_TestCase9)1656 TEST_F(Arm32DecoderStateTests,
1657 Unnamed_111101010111xxxxxxxxxxxx001xxxxx_case_0Tester_Case9_TestCase9) {
1658 Unnamed_111101010111xxxxxxxxxxxx001xxxxx_case_0Tester_Case9 baseline_tester;
1659 NamedActual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1_None actual;
1660 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1661 a_vs_b_tester.Test("111101010111xxxxxxxxxxxx001xxxxx");
1662 }
1663
1664 // op1(26:20)=1010111 & op2(7:4)=1xxx
1665 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
1666 // baseline: Unnamed_111101010111xxxxxxxxxxxx1xxxxxxx_case_0,
1667 // defs: {},
1668 // pattern: 111101010111xxxxxxxxxxxx1xxxxxxx,
1669 // safety: [true => UNPREDICTABLE],
1670 // true: true,
1671 // uses: {}}
TEST_F(Arm32DecoderStateTests,Unnamed_111101010111xxxxxxxxxxxx1xxxxxxx_case_0Tester_Case10_TestCase10)1672 TEST_F(Arm32DecoderStateTests,
1673 Unnamed_111101010111xxxxxxxxxxxx1xxxxxxx_case_0Tester_Case10_TestCase10) {
1674 Unnamed_111101010111xxxxxxxxxxxx1xxxxxxx_case_0Tester_Case10 baseline_tester;
1675 NamedActual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1_None actual;
1676 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1677 a_vs_b_tester.Test("111101010111xxxxxxxxxxxx1xxxxxxx");
1678 }
1679
1680 // op1(26:20)=100x001
1681 // = {actual: Actual_BLX_immediate_1111101hiiiiiiiiiiiiiiiiiiiiiiii_case_1,
1682 // baseline: Unnamed_11110100x001xxxxxxxxxxxxxxxxxxxx_case_0,
1683 // defs: {},
1684 // pattern: 11110100x001xxxxxxxxxxxxxxxxxxxx,
1685 // safety: [true => FORBIDDEN],
1686 // true: true,
1687 // uses: {}}
TEST_F(Arm32DecoderStateTests,Unnamed_11110100x001xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case11_TestCase11)1688 TEST_F(Arm32DecoderStateTests,
1689 Unnamed_11110100x001xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case11_TestCase11) {
1690 Unnamed_11110100x001xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case11 baseline_tester;
1691 NamedActual_BLX_immediate_1111101hiiiiiiiiiiiiiiiiiiiiiiii_case_1_None actual;
1692 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1693 a_vs_b_tester.Test("11110100x001xxxxxxxxxxxxxxxxxxxx");
1694 }
1695
1696 // op1(26:20)=100x101 & $pattern(31:0)=xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
1697 // = {Pc: 15,
1698 // Rn: Rn(19:16),
1699 // actual: Actual_PLI_immediate_literal_11110100u101nnnn1111iiiiiiiiiiii_case_1,
1700 // base: Rn,
1701 // baseline: PLI_immediate_literal_11110100u101nnnn1111iiiiiiiiiiii_case_0,
1702 // defs: {},
1703 // fields: [Rn(19:16)],
1704 // is_literal_load: Rn ==
1705 // Pc,
1706 // pattern: 11110100u101nnnn1111iiiiiiiiiiii,
1707 // rule: PLI_immediate_literal,
1708 // safety: [true => MAY_BE_SAFE],
1709 // true: true,
1710 // uses: {Rn},
1711 // violations: [implied by 'base']}
TEST_F(Arm32DecoderStateTests,PLI_immediate_literal_11110100u101nnnn1111iiiiiiiiiiii_case_0Tester_Case12_TestCase12)1712 TEST_F(Arm32DecoderStateTests,
1713 PLI_immediate_literal_11110100u101nnnn1111iiiiiiiiiiii_case_0Tester_Case12_TestCase12) {
1714 PLI_immediate_literal_11110100u101nnnn1111iiiiiiiiiiii_case_0Tester_Case12 baseline_tester;
1715 NamedActual_PLI_immediate_literal_11110100u101nnnn1111iiiiiiiiiiii_case_1_PLI_immediate_literal actual;
1716 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1717 a_vs_b_tester.Test("11110100u101nnnn1111iiiiiiiiiiii");
1718 }
1719
1720 // op1(26:20)=101x001 & Rn(19:16)=~1111 & $pattern(31:0)=xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
1721 // = {Pc: 15,
1722 // Rn: Rn(19:16),
1723 // actual: Actual_PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1,
1724 // base: Rn,
1725 // baseline: PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_0,
1726 // defs: {},
1727 // fields: [Rn(19:16)],
1728 // is_literal_load: base ==
1729 // Pc,
1730 // pattern: 11110101ur01nnnn1111iiiiiiiiiiii,
1731 // rule: PLD_PLDW_immediate,
1732 // safety: [Rn(19:16)=1111 => DECODER_ERROR],
1733 // uses: {Rn},
1734 // violations: [implied by 'base']}
TEST_F(Arm32DecoderStateTests,PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_0Tester_Case13_TestCase13)1735 TEST_F(Arm32DecoderStateTests,
1736 PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_0Tester_Case13_TestCase13) {
1737 PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_0Tester_Case13 baseline_tester;
1738 NamedActual_PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1_PLD_PLDW_immediate actual;
1739 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1740 a_vs_b_tester.Test("11110101ur01nnnn1111iiiiiiiiiiii");
1741 }
1742
1743 // op1(26:20)=101x001 & Rn(19:16)=1111
1744 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
1745 // baseline: Unnamed_11110101x001xxxxxxxxxxxxxxxxxxxx_case_0,
1746 // defs: {},
1747 // pattern: 11110101x001xxxxxxxxxxxxxxxxxxxx,
1748 // safety: [true => UNPREDICTABLE],
1749 // true: true,
1750 // uses: {}}
TEST_F(Arm32DecoderStateTests,Unnamed_11110101x001xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case14_TestCase14)1751 TEST_F(Arm32DecoderStateTests,
1752 Unnamed_11110101x001xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case14_TestCase14) {
1753 Unnamed_11110101x001xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case14 baseline_tester;
1754 NamedActual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1_None actual;
1755 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1756 a_vs_b_tester.Test("11110101x001xxxxxxxxxxxxxxxxxxxx");
1757 }
1758
1759 // op1(26:20)=101x101 & Rn(19:16)=~1111 & $pattern(31:0)=xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
1760 // = {Pc: 15,
1761 // Rn: Rn(19:16),
1762 // actual: Actual_PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1,
1763 // base: Rn,
1764 // baseline: PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1,
1765 // defs: {},
1766 // fields: [Rn(19:16)],
1767 // is_literal_load: base ==
1768 // Pc,
1769 // pattern: 11110101ur01nnnn1111iiiiiiiiiiii,
1770 // rule: PLD_PLDW_immediate,
1771 // safety: [Rn(19:16)=1111 => DECODER_ERROR],
1772 // uses: {Rn},
1773 // violations: [implied by 'base']}
TEST_F(Arm32DecoderStateTests,PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1Tester_Case15_TestCase15)1774 TEST_F(Arm32DecoderStateTests,
1775 PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1Tester_Case15_TestCase15) {
1776 PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1Tester_Case15 baseline_tester;
1777 NamedActual_PLD_PLDW_immediate_11110101ur01nnnn1111iiiiiiiiiiii_case_1_PLD_PLDW_immediate actual;
1778 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1779 a_vs_b_tester.Test("11110101ur01nnnn1111iiiiiiiiiiii");
1780 }
1781
1782 // op1(26:20)=101x101 & Rn(19:16)=1111 & $pattern(31:0)=xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
1783 // = {Pc: 15,
1784 // actual: Actual_PLD_literal_11110101u10111111111iiiiiiiiiiii_case_1,
1785 // base: Pc,
1786 // baseline: PLD_literal_11110101u10111111111iiiiiiiiiiii_case_0,
1787 // defs: {},
1788 // is_literal_load: true,
1789 // pattern: 11110101u10111111111iiiiiiiiiiii,
1790 // rule: PLD_literal,
1791 // safety: [true => MAY_BE_SAFE],
1792 // true: true,
1793 // uses: {Pc},
1794 // violations: [implied by 'base']}
TEST_F(Arm32DecoderStateTests,PLD_literal_11110101u10111111111iiiiiiiiiiii_case_0Tester_Case16_TestCase16)1795 TEST_F(Arm32DecoderStateTests,
1796 PLD_literal_11110101u10111111111iiiiiiiiiiii_case_0Tester_Case16_TestCase16) {
1797 PLD_literal_11110101u10111111111iiiiiiiiiiii_case_0Tester_Case16 baseline_tester;
1798 NamedActual_PLD_literal_11110101u10111111111iiiiiiiiiiii_case_1_PLD_literal actual;
1799 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1800 a_vs_b_tester.Test("11110101u10111111111iiiiiiiiiiii");
1801 }
1802
1803 // op1(26:20)=110x001 & op2(7:4)=xxx0
1804 // = {actual: Actual_BLX_immediate_1111101hiiiiiiiiiiiiiiiiiiiiiiii_case_1,
1805 // baseline: Unnamed_11110110x001xxxxxxxxxxxxxxx0xxxx_case_0,
1806 // defs: {},
1807 // pattern: 11110110x001xxxxxxxxxxxxxxx0xxxx,
1808 // safety: [true => FORBIDDEN],
1809 // true: true,
1810 // uses: {}}
TEST_F(Arm32DecoderStateTests,Unnamed_11110110x001xxxxxxxxxxxxxxx0xxxx_case_0Tester_Case17_TestCase17)1811 TEST_F(Arm32DecoderStateTests,
1812 Unnamed_11110110x001xxxxxxxxxxxxxxx0xxxx_case_0Tester_Case17_TestCase17) {
1813 Unnamed_11110110x001xxxxxxxxxxxxxxx0xxxx_case_0Tester_Case17 baseline_tester;
1814 NamedActual_BLX_immediate_1111101hiiiiiiiiiiiiiiiiiiiiiiii_case_1_None actual;
1815 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1816 a_vs_b_tester.Test("11110110x001xxxxxxxxxxxxxxx0xxxx");
1817 }
1818
1819 // op1(26:20)=110x101 & op2(7:4)=xxx0 & $pattern(31:0)=xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
1820 // = {Pc: 15,
1821 // Rm: Rm(3:0),
1822 // Rn: Rn(19:16),
1823 // actual: Actual_PLI_register_11110110u101nnnn1111iiiiitt0mmmm_case_1,
1824 // base: Rn,
1825 // baseline: PLI_register_11110110u101nnnn1111iiiiitt0mmmm_case_0,
1826 // defs: {},
1827 // fields: [Rn(19:16), Rm(3:0)],
1828 // pattern: 11110110u101nnnn1111iiiiitt0mmmm,
1829 // rule: PLI_register,
1830 // safety: [Rm ==
1831 // Pc => UNPREDICTABLE,
1832 // true => FORBIDDEN_OPERANDS],
1833 // true: true,
1834 // uses: {Rm, Rn},
1835 // violations: [implied by 'base']}
TEST_F(Arm32DecoderStateTests,PLI_register_11110110u101nnnn1111iiiiitt0mmmm_case_0Tester_Case18_TestCase18)1836 TEST_F(Arm32DecoderStateTests,
1837 PLI_register_11110110u101nnnn1111iiiiitt0mmmm_case_0Tester_Case18_TestCase18) {
1838 PLI_register_11110110u101nnnn1111iiiiitt0mmmm_case_0Tester_Case18 baseline_tester;
1839 NamedActual_PLI_register_11110110u101nnnn1111iiiiitt0mmmm_case_1_PLI_register actual;
1840 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1841 a_vs_b_tester.Test("11110110u101nnnn1111iiiiitt0mmmm");
1842 }
1843
1844 // op1(26:20)=111x001 & op2(7:4)=xxx0 & $pattern(31:0)=xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
1845 // = {Pc: 15,
1846 // R: R(22),
1847 // Rm: Rm(3:0),
1848 // Rn: Rn(19:16),
1849 // actual: Actual_PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_1,
1850 // base: Rn,
1851 // baseline: PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_0,
1852 // defs: {},
1853 // fields: [R(22), Rn(19:16), Rm(3:0)],
1854 // is_pldw: R(22)=1,
1855 // pattern: 11110111u001nnnn1111iiiiitt0mmmm,
1856 // rule: PLD_PLDW_register,
1857 // safety: [Rm ==
1858 // Pc ||
1859 // (Rn ==
1860 // Pc &&
1861 // is_pldw) => UNPREDICTABLE,
1862 // true => FORBIDDEN_OPERANDS],
1863 // true: true,
1864 // uses: {Rm, Rn},
1865 // violations: [implied by 'base']}
TEST_F(Arm32DecoderStateTests,PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_0Tester_Case19_TestCase19)1866 TEST_F(Arm32DecoderStateTests,
1867 PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_0Tester_Case19_TestCase19) {
1868 PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_0Tester_Case19 baseline_tester;
1869 NamedActual_PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_1_PLD_PLDW_register actual;
1870 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1871 a_vs_b_tester.Test("11110111u001nnnn1111iiiiitt0mmmm");
1872 }
1873
1874 // op1(26:20)=111x101 & op2(7:4)=xxx0 & $pattern(31:0)=xxxxxxxxxxxxxxxx1111xxxxxxxxxxxx
1875 // = {Pc: 15,
1876 // R: R(22),
1877 // Rm: Rm(3:0),
1878 // Rn: Rn(19:16),
1879 // actual: Actual_PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_1,
1880 // base: Rn,
1881 // baseline: PLD_PLDW_register_11110111u101nnnn1111iiiiitt0mmmm_case_0,
1882 // defs: {},
1883 // fields: [R(22), Rn(19:16), Rm(3:0)],
1884 // is_pldw: R(22)=1,
1885 // pattern: 11110111u101nnnn1111iiiiitt0mmmm,
1886 // rule: PLD_PLDW_register,
1887 // safety: [Rm ==
1888 // Pc ||
1889 // (Rn ==
1890 // Pc &&
1891 // is_pldw) => UNPREDICTABLE,
1892 // true => FORBIDDEN_OPERANDS],
1893 // true: true,
1894 // uses: {Rm, Rn},
1895 // violations: [implied by 'base']}
TEST_F(Arm32DecoderStateTests,PLD_PLDW_register_11110111u101nnnn1111iiiiitt0mmmm_case_0Tester_Case20_TestCase20)1896 TEST_F(Arm32DecoderStateTests,
1897 PLD_PLDW_register_11110111u101nnnn1111iiiiitt0mmmm_case_0Tester_Case20_TestCase20) {
1898 PLD_PLDW_register_11110111u101nnnn1111iiiiitt0mmmm_case_0Tester_Case20 baseline_tester;
1899 NamedActual_PLD_PLDW_register_11110111u001nnnn1111iiiiitt0mmmm_case_1_PLD_PLDW_register actual;
1900 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1901 a_vs_b_tester.Test("11110111u101nnnn1111iiiiitt0mmmm");
1902 }
1903
1904 // op1(26:20)=1011x11
1905 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
1906 // baseline: Unnamed_111101011x11xxxxxxxxxxxxxxxxxxxx_case_0,
1907 // defs: {},
1908 // pattern: 111101011x11xxxxxxxxxxxxxxxxxxxx,
1909 // safety: [true => UNPREDICTABLE],
1910 // true: true,
1911 // uses: {}}
TEST_F(Arm32DecoderStateTests,Unnamed_111101011x11xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case21_TestCase21)1912 TEST_F(Arm32DecoderStateTests,
1913 Unnamed_111101011x11xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case21_TestCase21) {
1914 Unnamed_111101011x11xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case21 baseline_tester;
1915 NamedActual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1_None actual;
1916 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1917 a_vs_b_tester.Test("111101011x11xxxxxxxxxxxxxxxxxxxx");
1918 }
1919
1920 // op1(26:20)=100xx11
1921 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
1922 // baseline: Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_0,
1923 // defs: {},
1924 // pattern: 11110100xx11xxxxxxxxxxxxxxxxxxxx,
1925 // safety: [true => UNPREDICTABLE],
1926 // true: true,
1927 // uses: {}}
TEST_F(Arm32DecoderStateTests,Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case22_TestCase22)1928 TEST_F(Arm32DecoderStateTests,
1929 Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case22_TestCase22) {
1930 Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_0Tester_Case22 baseline_tester;
1931 NamedActual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1_None actual;
1932 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1933 a_vs_b_tester.Test("11110100xx11xxxxxxxxxxxxxxxxxxxx");
1934 }
1935
1936 // op1(26:20)=11xxx11 & op2(7:4)=xxx0
1937 // = {actual: Actual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1,
1938 // baseline: Unnamed_1111011xxx11xxxxxxxxxxxxxxx0xxxx_case_0,
1939 // defs: {},
1940 // pattern: 1111011xxx11xxxxxxxxxxxxxxx0xxxx,
1941 // safety: [true => UNPREDICTABLE],
1942 // true: true,
1943 // uses: {}}
TEST_F(Arm32DecoderStateTests,Unnamed_1111011xxx11xxxxxxxxxxxxxxx0xxxx_case_0Tester_Case23_TestCase23)1944 TEST_F(Arm32DecoderStateTests,
1945 Unnamed_1111011xxx11xxxxxxxxxxxxxxx0xxxx_case_0Tester_Case23_TestCase23) {
1946 Unnamed_1111011xxx11xxxxxxxxxxxxxxx0xxxx_case_0Tester_Case23 baseline_tester;
1947 NamedActual_Unnamed_11110100xx11xxxxxxxxxxxxxxxxxxxx_case_1_None actual;
1948 ActualVsBaselineTester a_vs_b_tester(actual, baseline_tester);
1949 a_vs_b_tester.Test("1111011xxx11xxxxxxxxxxxxxxx0xxxx");
1950 }
1951
1952 } // namespace nacl_arm_test
1953
main(int argc,char * argv[])1954 int main(int argc, char* argv[]) {
1955 testing::InitGoogleTest(&argc, argv);
1956 return RUN_ALL_TESTS();
1957 }
1958