1#![cfg_attr(rustfmt, rustfmt_skip)]
2#![allow(clippy::eq_op)]
3#![allow(clippy::double_parens)]
4#![allow(clippy::unnecessary_cast)]
5#![allow(clippy::derivable_impls)]
6#![allow(clippy::needless_else)]
7#![allow(clippy::manual_range_patterns)]
8#![allow(unused_parens)]
9#![allow(unused_variables)]
10use crate::*;
11impl BranchTarget {
12 #[inline(always)]
13 pub(crate) fn parse(value: u32, pc: u32) -> Self {
14 Self {
15 addr: pc.wrapping_add((value)),
16 }
17 }
18}
19impl Cond {
20 #[inline(always)]
21 pub(crate) fn parse(value: u32, pc: u32) -> Self {
22 debug_assert!(value < 15, "Invalid enum value {:#x} for Cond", value);
23 unsafe { core::mem::transmute::<u8, Self>(value as u8) }
24 }
25}
26impl Reg {
27 #[inline(always)]
28 pub(crate) fn parse(value: u32, pc: u32) -> Self {
29 debug_assert!(value < 16, "Invalid enum value {:#x} for Reg", value);
30 unsafe { core::mem::transmute::<u8, Self>(value as u8) }
31 }
32}
33#[cfg(feature = "arm")]
34impl StatusReg {
35 #[inline(always)]
36 pub(crate) fn parse(value: u32, pc: u32) -> Self {
37 debug_assert!(value < 2, "Invalid enum value {:#x} for StatusReg", value);
38 unsafe { core::mem::transmute::<u8, Self>(value as u8) }
39 }
40}
41#[cfg(feature = "arm")]
42impl StatusFields {
43 #[inline(always)]
44 pub(crate) fn parse(value: u32, pc: u32) -> Self {
45 Self {
46 reg: StatusReg::parse((((value) >> 22) & 0x1), pc),
47 c: (((value) >> 16) & 0x1) != 0,
48 x: (((value) >> 17) & 0x1) != 0,
49 s: (((value) >> 18) & 0x1) != 0,
50 f: (((value) >> 19) & 0x1) != 0,
51 }
52 }
53}
54#[cfg(feature = "arm")]
55impl MsrOp2 {
56 #[inline(always)]
57 pub(crate) fn parse(value: u32, pc: u32) -> Option<Self> {
58 if (value & 0x2000000) == 0x2000000 {
59 Some(Self::Imm(((value) & 0xff).rotate_right((((value) >> 8) & 0xf))))
60 } else if (value & 0x20000f0) == 0x0 {
61 if value & 0xf00 != 0 {
62 return None;
63 }
64 Some(Self::Reg(Reg::parse(((value) & 0xf), pc)))
65 } else {
66 None
67 }
68 }
69}
70impl ShiftOp {
71 #[inline(always)]
72 pub(crate) fn parse(value: u32, pc: u32) -> Self {
73 debug_assert!(value < 4, "Invalid enum value {:#x} for ShiftOp", value);
74 unsafe { core::mem::transmute::<u8, Self>(value as u8) }
75 }
76}
77#[cfg(feature = "arm")]
78impl Coproc {
79 #[inline(always)]
80 pub(crate) fn parse(value: u32, pc: u32) -> Self {
81 debug_assert!(value < 16, "Invalid enum value {:#x} for Coproc", value);
82 unsafe { core::mem::transmute::<u8, Self>(value as u8) }
83 }
84}
85#[cfg(feature = "arm")]
86impl CoReg {
87 #[inline(always)]
88 pub(crate) fn parse(value: u32, pc: u32) -> Self {
89 debug_assert!(value < 16, "Invalid enum value {:#x} for CoReg", value);
90 unsafe { core::mem::transmute::<u8, Self>(value as u8) }
91 }
92}
93impl Op2 {
94 #[inline(always)]
95 pub(crate) fn parse(value: u32, pc: u32) -> Option<Self> {
96 if (value & 0x2000000) == 0x2000000 {
97 Some(Self::Imm(((value) & 0xff).rotate_right((((value) >> 8) & 0xf) << 1)))
98 } else if (value & 0x2000090) == 0x10 {
99 Some(Self::ShiftReg(ShiftReg::parse((value), pc)?))
100 } else if (value & 0x2000010) == 0x0 {
101 Some(Self::ShiftImm(ShiftImm::parse((value), pc)))
102 } else {
103 None
104 }
105 }
106}
107impl ShiftReg {
108 #[inline(always)]
109 pub(crate) fn parse(value: u32, pc: u32) -> Option<Self> {
110 if value & 0xf == 0xf {
111 return None;
112 }
113 if value & 0xf00 == 0xf00 {
114 return None;
115 }
116 if value & 0xf000 == 0xf000 {
117 return None;
118 }
119 if value & 0xf0000 == 0xf0000 {
120 return None;
121 }
122 Some(Self {
123 rm: Reg::parse(((value) & 0xf), pc),
124 shift_op: ShiftOp::parse((((value) >> 5) & 0x3), pc),
125 rs: Reg::parse((((value) >> 8) & 0xf), pc),
126 })
127 }
128}
129impl ShiftImm {
130 #[inline(always)]
131 pub(crate) fn parse(value: u32, pc: u32) -> Self {
132 Self {
133 rm: Reg::parse(((value) & 0xf), pc),
134 shift_op: ShiftOp::parse((((value) >> 5) & 0x3), pc),
135 imm: (((value) >> 7) & 0x1f),
136 }
137 }
138}
139impl Op2Shift {
140 #[inline(always)]
141 pub(crate) fn parse(value: u32, pc: u32) -> Option<Self> {
142 if (value & 0x10) == 0x0 {
143 Some(
144 Self::Imm(
145 if (((value) >> 7) & 0x1f) != 0 {
146 (((value) >> 7) & 0x1f)
147 } else {
148 32
149 },
150 ),
151 )
152 } else if (value & 0x90) == 0x10 {
153 Some(Self::Reg(Reg::parse((((value) >> 8) & 0xf), pc)))
154 } else {
155 None
156 }
157 }
158}
159#[cfg(any(feature = "v6", feature = "v6k"))]
160impl CpsEffect {
161 #[inline(always)]
162 pub(crate) fn parse(value: u32, pc: u32) -> Option<Self> {
163 match value {
164 0x0 => Some(Self::SetMode),
165 0x2 => Some(Self::Ie),
166 0x3 => Some(Self::Id),
167 _ => None,
168 }
169 }
170}
171#[cfg(any(feature = "v6", feature = "v6k"))]
172impl AifFlags {
173 #[inline(always)]
174 pub(crate) fn parse(value: u32, pc: u32) -> Self {
175 Self {
176 a: (((value) >> 2) & 0x1) != 0,
177 i: (((value) >> 1) & 0x1) != 0,
178 f: ((value) & 0x1) != 0,
179 }
180 }
181}
182#[cfg(feature = "arm")]
183impl AddrLdcStc {
184 #[inline(always)]
185 pub(crate) fn parse(value: u32, pc: u32) -> Option<Self> {
186 if (value & 0x1000000) == 0x1000000 {
187 Some(Self::Pre {
188 rn: Reg::parse((((value) >> 16) & 0xf), pc),
189 offset: ((if (((value) >> 23) & 0x1) == 0 {
190 -((((value) & 0xff) << 2) as i32)
191 } else {
192 (((value) & 0xff) << 2) as i32
193 })) as i32,
194 writeback: ((((value) >> 21) & 0x1)) != 0,
195 })
196 } else if (value & 0x1200000) == 0x200000 {
197 Some(Self::Post {
198 rn: Reg::parse((((value) >> 16) & 0xf), pc),
199 offset: ((if (((value) >> 23) & 0x1) == 0 {
200 -((((value) & 0xff) << 2) as i32)
201 } else {
202 (((value) & 0xff) << 2) as i32
203 })) as i32,
204 })
205 } else if (value & 0x1a00000) == 0x800000 {
206 Some(Self::Unidx {
207 rn: Reg::parse((((value) >> 16) & 0xf), pc),
208 option: ((value) & 0xff),
209 })
210 } else {
211 None
212 }
213 }
214}
215impl LdmStmMode {
216 #[inline(always)]
217 pub(crate) fn parse(value: u32, pc: u32) -> Self {
218 debug_assert!(value < 4, "Invalid enum value {:#x} for LdmStmMode", value);
219 unsafe { core::mem::transmute::<u8, Self>(value as u8) }
220 }
221}
222impl AddrLdrStr {
223 #[inline(always)]
224 pub(crate) fn parse(value: u32, pc: u32) -> Option<Self> {
225 if (value & 0x1000000) == 0x1000000 {
226 Some(Self::Pre {
227 rn: Reg::parse((((value) >> 16) & 0xf), pc),
228 offset: LdrStrOffset::parse((value), pc)?,
229 writeback: ((((value) >> 21) & 0x1)) != 0,
230 })
231 } else if (value & 0x1200000) == 0x0 {
232 Some(Self::Post(AddrLdrStrPost::parse((value), pc)?))
233 } else {
234 None
235 }
236 }
237}
238impl AddrLdrStrPost {
239 #[inline(always)]
240 pub(crate) fn parse(value: u32, pc: u32) -> Option<Self> {
241 Some(Self {
242 rn: Reg::parse((((value) >> 16) & 0xf), pc),
243 offset: LdrStrOffset::parse((value), pc)?,
244 })
245 }
246}
247impl LdrStrOffset {
248 #[inline(always)]
249 pub(crate) fn parse(value: u32, pc: u32) -> Option<Self> {
250 if (value & 0x2000000) == 0x0 {
251 Some(
252 Self::Imm(
253 ((if (((value) >> 23) & 0x1) == 0 {
254 -(((value) & 0xfff) as i32)
255 } else {
256 ((value) & 0xfff) as i32
257 })) as i32,
258 ),
259 )
260 } else if (value & 0x2000010) == 0x2000000 {
261 Some(Self::Reg {
262 subtract: ((((value) >> 23) & 0x1) ^ 1) != 0,
263 rm: Reg::parse(((value) & 0xf), pc),
264 shift_op: ShiftOp::parse((((value) >> 5) & 0x3), pc),
265 imm: if (((value) >> 5) & 0x3) == 1 && (((value) >> 7) & 0x1f) == 0 {
266 0x20
267 } else {
268 (((value) >> 7) & 0x1f)
269 },
270 })
271 } else {
272 None
273 }
274 }
275}
276impl AddrMiscLoad {
277 #[inline(always)]
278 pub(crate) fn parse(value: u32, pc: u32) -> Option<Self> {
279 if (value & 0x1000000) == 0x1000000 {
280 Some(Self::Pre {
281 rn: Reg::parse((((value) >> 16) & 0xf), pc),
282 offset: MiscLoadOffset::parse((value), pc)?,
283 writeback: ((((value) >> 21) & 0x1)) != 0,
284 })
285 } else if (value & 0x1200000) == 0x0 {
286 Some(Self::Post {
287 rn: Reg::parse((((value) >> 16) & 0xf), pc),
288 offset: MiscLoadOffset::parse((value), pc)?,
289 })
290 } else {
291 None
292 }
293 }
294}
295impl MiscLoadOffset {
296 #[inline(always)]
297 pub(crate) fn parse(value: u32, pc: u32) -> Option<Self> {
298 if (value & 0xe400090) == 0x400090 {
299 Some(
300 Self::Imm(
301 ((if (((value) >> 23) & 0x1) == 0 {
302 -((((((value) >> 8) & 0xf) << 4) | ((value) & 0xf)) as i32)
303 } else {
304 (((((value) >> 8) & 0xf) << 4) | ((value) & 0xf)) as i32
305 })) as i32,
306 ),
307 )
308 } else if (value & 0xe400090) == 0x90 {
309 if value & 0xf00 != 0 {
310 return None;
311 }
312 Some(Self::Reg {
313 subtract: ((((value) >> 23) & 0x1) ^ 1) != 0,
314 rm: Reg::parse(((value) & 0xf), pc),
315 })
316 } else {
317 None
318 }
319 }
320}
321#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
322impl SrsRfeMode {
323 #[inline(always)]
324 pub(crate) fn parse(value: u32, pc: u32) -> Self {
325 debug_assert!(value < 4, "Invalid enum value {:#x} for SrsRfeMode", value);
326 unsafe { core::mem::transmute::<u8, Self>(value as u8) }
327 }
328}
329#[cfg(any(feature = "v6", feature = "v6k"))]
330impl Endianness {
331 #[inline(always)]
332 pub(crate) fn parse(value: u32, pc: u32) -> Self {
333 debug_assert!(value < 2, "Invalid enum value {:#x} for Endianness", value);
334 unsafe { core::mem::transmute::<u8, Self>(value as u8) }
335 }
336}
337#[cfg(
338 all(
339 feature = "arm",
340 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
341 )
342)]
343impl RegSide {
344 #[inline(always)]
345 pub(crate) fn parse(value: u32, pc: u32) -> Self {
346 debug_assert!(value < 2, "Invalid enum value {:#x} for RegSide", value);
347 unsafe { core::mem::transmute::<u8, Self>(value as u8) }
348 }
349}
350#[cfg(
351 all(
352 feature = "arm",
353 feature = "vfp_v2",
354 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
355 )
356)]
357impl Sreg {
358 #[inline(always)]
359 pub(crate) fn parse(value: u32, pc: u32) -> Self {
360 debug_assert!(value < 32, "Invalid enum value {:#x} for Sreg", value);
361 unsafe { core::mem::transmute::<u8, Self>(value as u8) }
362 }
363}
364#[cfg(
365 all(
366 feature = "arm",
367 feature = "vfp_v2",
368 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
369 )
370)]
371impl Dreg {
372 #[inline(always)]
373 pub(crate) fn parse(value: u32, pc: u32) -> Self {
374 debug_assert!(value < 32, "Invalid enum value {:#x} for Dreg", value);
375 unsafe { core::mem::transmute::<u8, Self>(value as u8) }
376 }
377}
378#[cfg(
379 all(
380 feature = "arm",
381 feature = "vfp_v2",
382 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
383 )
384)]
385impl VcmpF32Op2 {
386 #[inline(always)]
387 pub(crate) fn parse(value: u32, pc: u32) -> Option<Self> {
388 if (value & 0x1003f) == 0x10000 {
389 Some(Self::Zero)
390 } else if (value & 0x10010) == 0x0 {
391 Some(
392 Self::Reg(
393 Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc),
394 ),
395 )
396 } else {
397 None
398 }
399 }
400}
401#[cfg(
402 all(
403 feature = "arm",
404 feature = "vfp_v2",
405 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
406 )
407)]
408impl VcmpF64Op2 {
409 #[inline(always)]
410 pub(crate) fn parse(value: u32, pc: u32) -> Option<Self> {
411 if (value & 0x1003f) == 0x10000 {
412 Some(Self::Zero)
413 } else if (value & 0x10010) == 0x0 {
414 Some(
415 Self::Reg(
416 Dreg::parse(((((value) >> 5) & 0x1) << 4) | ((value) & 0xf), pc),
417 ),
418 )
419 } else {
420 None
421 }
422 }
423}
424#[cfg(
425 all(
426 feature = "arm",
427 feature = "vfp_v2",
428 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
429 )
430)]
431impl DregIndex {
432 #[inline(always)]
433 pub(crate) fn parse(value: u32, pc: u32) -> Self {
434 Self {
435 dreg: Dreg::parse(
436 ((((value) >> 7) & 0x1) << 4) | (((value) >> 16) & 0xf),
437 pc,
438 ),
439 index: (((value) >> 21) & 0x1),
440 }
441 }
442}
443#[cfg(
444 all(
445 feature = "arm",
446 feature = "vfp_v2",
447 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
448 )
449)]
450impl VldmVstmMode {
451 #[inline(always)]
452 pub(crate) fn parse(value: u32, pc: u32) -> Option<Self> {
453 match value {
454 0x1 => Some(Self::Ia),
455 0x2 => Some(Self::Db),
456 _ => None,
457 }
458 }
459}
460impl Default for BranchTarget {
461 fn default() -> Self {
462 Self { addr: 0 }
463 }
464}
465impl Default for Cond {
466 fn default() -> Self {
467 Self::Al
468 }
469}
470impl Default for ShiftOp {
471 fn default() -> Self {
472 Self::Lsl
473 }
474}
475#[cfg(any(feature = "v6", feature = "v6k"))]
476impl Default for AifFlags {
477 fn default() -> Self {
478 Self {
479 a: false,
480 i: false,
481 f: false,
482 }
483 }
484}
485impl Default for LdmStmMode {
486 fn default() -> Self {
487 Self::Ia
488 }
489}
490#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
491impl Default for SrsRfeMode {
492 fn default() -> Self {
493 Self::Ia
494 }
495}
496#[cfg(
497 all(
498 feature = "arm",
499 feature = "vfp_v2",
500 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
501 )
502)]
503impl Default for Fpscr {
504 fn default() -> Self {
505 Self {}
506 }
507}
508#[cfg(feature = "arm")]
509pub fn parse_arm(ins: u32, pc: u32, options: &Options) -> Ins {
510 match (((ins) & 0x1f0) >> 4) | (((ins) & 0xff80000) >> 14) {
511 0x0 | 0x1 | 0x2 | 0x3 | 0x4 | 0x5 | 0x6 | 0x7 | 0x8 | 0xa | 0xc | 0xe | 0x10
512 | 0x11 | 0x12 | 0x13 | 0x14 | 0x15 | 0x16 | 0x17 | 0x18 | 0x1a | 0x1c | 0x1e
513 | 0x20 | 0x21 | 0x22 | 0x23 | 0x24 | 0x25 | 0x26 | 0x27 | 0x28 | 0x2a | 0x2c
514 | 0x2e | 0x30 | 0x31 | 0x32 | 0x33 | 0x34 | 0x35 | 0x36 | 0x37 | 0x38 | 0x3a
515 | 0x3c | 0x3e | 0x40 | 0x41 | 0x42 | 0x43 | 0x44 | 0x45 | 0x46 | 0x47 | 0x48
516 | 0x4a | 0x4c | 0x4e | 0x50 | 0x51 | 0x52 | 0x53 | 0x54 | 0x55 | 0x56 | 0x57
517 | 0x58 | 0x5a | 0x5c | 0x5e | 0x60 | 0x61 | 0x62 | 0x63 | 0x64 | 0x65 | 0x66
518 | 0x67 | 0x68 | 0x6a | 0x6c | 0x6e | 0x70 | 0x71 | 0x72 | 0x73 | 0x74 | 0x75
519 | 0x76 | 0x77 | 0x78 | 0x7a | 0x7c | 0x7e | 0x800 | 0x801 | 0x802 | 0x803 | 0x804
520 | 0x805 | 0x806 | 0x807 | 0x808 | 0x809 | 0x80a | 0x80b | 0x80c | 0x80d | 0x80e
521 | 0x80f | 0x810 | 0x811 | 0x812 | 0x813 | 0x814 | 0x815 | 0x816 | 0x817 | 0x818
522 | 0x819 | 0x81a | 0x81b | 0x81c | 0x81d | 0x81e | 0x81f | 0x820 | 0x821 | 0x822
523 | 0x823 | 0x824 | 0x825 | 0x826 | 0x827 | 0x828 | 0x829 | 0x82a | 0x82b | 0x82c
524 | 0x82d | 0x82e | 0x82f | 0x830 | 0x831 | 0x832 | 0x833 | 0x834 | 0x835 | 0x836
525 | 0x837 | 0x838 | 0x839 | 0x83a | 0x83b | 0x83c | 0x83d | 0x83e | 0x83f | 0x840
526 | 0x841 | 0x842 | 0x843 | 0x844 | 0x845 | 0x846 | 0x847 | 0x848 | 0x849 | 0x84a
527 | 0x84b | 0x84c | 0x84d | 0x84e | 0x84f | 0x850 | 0x851 | 0x852 | 0x853 | 0x854
528 | 0x855 | 0x856 | 0x857 | 0x858 | 0x859 | 0x85a | 0x85b | 0x85c | 0x85d | 0x85e
529 | 0x85f | 0x860 | 0x861 | 0x862 | 0x863 | 0x864 | 0x865 | 0x866 | 0x867 | 0x868
530 | 0x869 | 0x86a | 0x86b | 0x86c | 0x86d | 0x86e | 0x86f | 0x870 | 0x871 | 0x872
531 | 0x873 | 0x874 | 0x875 | 0x876 | 0x877 | 0x878 | 0x879 | 0x87a | 0x87b | 0x87c
532 | 0x87d | 0x87e | 0x87f => {
533 #[cfg(feature = "arm")]
534 if let Some(ins) = parse_arm_and_0(ins, pc, options) {
535 return ins;
536 }
537 }
538 0x9 | 0x19 | 0x29 | 0x39 | 0x49 | 0x59 | 0x69 | 0x79 => {
539 #[cfg(feature = "arm")]
540 if (ins & 0xfe000f0) == 0x90
541 && let Some(ins) = parse_arm_mul_0(ins, pc, options)
542 {
543 return ins;
544 }
545 #[cfg(feature = "arm")]
546 if (ins & 0xde00000) == 0x0
547 && let Some(ins) = parse_arm_and_0(ins, pc, options)
548 {
549 return ins;
550 }
551 }
552 0xb | 0x1b | 0x2b | 0x3b => {
553 #[cfg(feature = "arm")]
554 if (ins & 0xe1000f0) == 0xb0
555 && let Some(ins) = parse_arm_strh_0(ins, pc, options)
556 {
557 return ins;
558 }
559 #[cfg(feature = "arm")]
560 if (ins & 0xde00000) == 0x0
561 && let Some(ins) = parse_arm_and_0(ins, pc, options)
562 {
563 return ins;
564 }
565 }
566 0xd | 0x1d | 0x2d | 0x3d => {
567 #[cfg(
568 all(
569 feature = "arm",
570 any(
571 feature = "v5te",
572 feature = "v5tej",
573 feature = "v6",
574 feature = "v6k"
575 )
576 )
577 )]
578 if (ins & 0xe1000f0) == 0xd0
579 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
580 {
581 return ins;
582 }
583 #[cfg(feature = "arm")]
584 if (ins & 0xde00000) == 0x0
585 && let Some(ins) = parse_arm_and_0(ins, pc, options)
586 {
587 return ins;
588 }
589 }
590 0xf | 0x1f | 0x2f | 0x3f => {
591 #[cfg(
592 all(
593 feature = "arm",
594 any(
595 feature = "v5te",
596 feature = "v5tej",
597 feature = "v6",
598 feature = "v6k"
599 )
600 )
601 )]
602 if (ins & 0xe1000f0) == 0xf0
603 && let Some(ins) = parse_arm_strd_0(ins, pc, options)
604 {
605 return ins;
606 }
607 #[cfg(feature = "arm")]
608 if (ins & 0xde00000) == 0x0
609 && let Some(ins) = parse_arm_and_0(ins, pc, options)
610 {
611 return ins;
612 }
613 }
614 0x4b | 0x5b | 0x6b | 0x7b => {
615 #[cfg(feature = "arm")]
616 if (ins & 0xe1000f0) == 0x1000b0
617 && let Some(ins) = parse_arm_ldrh_0(ins, pc, options)
618 {
619 return ins;
620 }
621 #[cfg(feature = "arm")]
622 if (ins & 0xde00000) == 0x0
623 && let Some(ins) = parse_arm_and_0(ins, pc, options)
624 {
625 return ins;
626 }
627 }
628 0x4d | 0x5d | 0x6d | 0x7d => {
629 #[cfg(feature = "arm")]
630 if (ins & 0xe1000f0) == 0x1000d0
631 && let Some(ins) = parse_arm_ldrsb_0(ins, pc, options)
632 {
633 return ins;
634 }
635 #[cfg(feature = "arm")]
636 if (ins & 0xde00000) == 0x0
637 && let Some(ins) = parse_arm_and_0(ins, pc, options)
638 {
639 return ins;
640 }
641 }
642 0x4f | 0x5f | 0x6f | 0x7f => {
643 #[cfg(feature = "arm")]
644 if (ins & 0xe1000f0) == 0x1000f0
645 && let Some(ins) = parse_arm_ldrsh_0(ins, pc, options)
646 {
647 return ins;
648 }
649 #[cfg(feature = "arm")]
650 if (ins & 0xde00000) == 0x0
651 && let Some(ins) = parse_arm_and_0(ins, pc, options)
652 {
653 return ins;
654 }
655 }
656 0x80 | 0x81 | 0x82 | 0x83 | 0x84 | 0x85 | 0x86 | 0x87 | 0x88 | 0x8a | 0x8c | 0x8e
657 | 0x90 | 0x91 | 0x92 | 0x93 | 0x94 | 0x95 | 0x96 | 0x97 | 0x98 | 0x9a | 0x9c
658 | 0x9e | 0xa0 | 0xa1 | 0xa2 | 0xa3 | 0xa4 | 0xa5 | 0xa6 | 0xa7 | 0xa8 | 0xaa
659 | 0xac | 0xae | 0xb0 | 0xb1 | 0xb2 | 0xb3 | 0xb4 | 0xb5 | 0xb6 | 0xb7 | 0xb8
660 | 0xba | 0xbc | 0xbe | 0xc0 | 0xc1 | 0xc2 | 0xc3 | 0xc4 | 0xc5 | 0xc6 | 0xc7
661 | 0xc8 | 0xca | 0xcc | 0xce | 0xd0 | 0xd1 | 0xd2 | 0xd3 | 0xd4 | 0xd5 | 0xd6
662 | 0xd7 | 0xd8 | 0xda | 0xdc | 0xde | 0xe0 | 0xe1 | 0xe2 | 0xe3 | 0xe4 | 0xe5
663 | 0xe6 | 0xe7 | 0xe8 | 0xea | 0xec | 0xee | 0xf0 | 0xf1 | 0xf2 | 0xf3 | 0xf4
664 | 0xf5 | 0xf6 | 0xf7 | 0xf8 | 0xfa | 0xfc | 0xfe | 0x880 | 0x881 | 0x882 | 0x883
665 | 0x884 | 0x885 | 0x886 | 0x887 | 0x888 | 0x889 | 0x88a | 0x88b | 0x88c | 0x88d
666 | 0x88e | 0x88f | 0x890 | 0x891 | 0x892 | 0x893 | 0x894 | 0x895 | 0x896 | 0x897
667 | 0x898 | 0x899 | 0x89a | 0x89b | 0x89c | 0x89d | 0x89e | 0x89f | 0x8a0 | 0x8a1
668 | 0x8a2 | 0x8a3 | 0x8a4 | 0x8a5 | 0x8a6 | 0x8a7 | 0x8a8 | 0x8a9 | 0x8aa | 0x8ab
669 | 0x8ac | 0x8ad | 0x8ae | 0x8af | 0x8b0 | 0x8b1 | 0x8b2 | 0x8b3 | 0x8b4 | 0x8b5
670 | 0x8b6 | 0x8b7 | 0x8b8 | 0x8b9 | 0x8ba | 0x8bb | 0x8bc | 0x8bd | 0x8be | 0x8bf
671 | 0x8c0 | 0x8c1 | 0x8c2 | 0x8c3 | 0x8c4 | 0x8c5 | 0x8c6 | 0x8c7 | 0x8c8 | 0x8c9
672 | 0x8ca | 0x8cb | 0x8cc | 0x8cd | 0x8ce | 0x8cf | 0x8d0 | 0x8d1 | 0x8d2 | 0x8d3
673 | 0x8d4 | 0x8d5 | 0x8d6 | 0x8d7 | 0x8d8 | 0x8d9 | 0x8da | 0x8db | 0x8dc | 0x8dd
674 | 0x8de | 0x8df | 0x8e0 | 0x8e1 | 0x8e2 | 0x8e3 | 0x8e4 | 0x8e5 | 0x8e6 | 0x8e7
675 | 0x8e8 | 0x8e9 | 0x8ea | 0x8eb | 0x8ec | 0x8ed | 0x8ee | 0x8ef | 0x8f0 | 0x8f1
676 | 0x8f2 | 0x8f3 | 0x8f4 | 0x8f5 | 0x8f6 | 0x8f7 | 0x8f8 | 0x8f9 | 0x8fa | 0x8fb
677 | 0x8fc | 0x8fd | 0x8fe | 0x8ff => {
678 #[cfg(feature = "arm")]
679 if let Some(ins) = parse_arm_eor_0(ins, pc, options) {
680 return ins;
681 }
682 }
683 0x89 | 0x99 | 0xa9 | 0xb9 | 0xc9 | 0xd9 | 0xe9 | 0xf9 => {
684 #[cfg(feature = "arm")]
685 if (ins & 0xfe000f0) == 0x200090
686 && let Some(ins) = parse_arm_mla_0(ins, pc, options)
687 {
688 return ins;
689 }
690 #[cfg(feature = "arm")]
691 if (ins & 0xde00000) == 0x200000
692 && let Some(ins) = parse_arm_eor_0(ins, pc, options)
693 {
694 return ins;
695 }
696 }
697 0x8b | 0x9b | 0xab | 0xbb => {
698 #[cfg(feature = "arm")]
699 if (ins & 0xe1000f0) == 0xb0
700 && let Some(ins) = parse_arm_strh_0(ins, pc, options)
701 {
702 return ins;
703 }
704 #[cfg(feature = "arm")]
705 if (ins & 0xde00000) == 0x200000
706 && let Some(ins) = parse_arm_eor_0(ins, pc, options)
707 {
708 return ins;
709 }
710 }
711 0x8d | 0x9d | 0xad | 0xbd => {
712 #[cfg(
713 all(
714 feature = "arm",
715 any(
716 feature = "v5te",
717 feature = "v5tej",
718 feature = "v6",
719 feature = "v6k"
720 )
721 )
722 )]
723 if (ins & 0xe1000f0) == 0xd0
724 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
725 {
726 return ins;
727 }
728 #[cfg(feature = "arm")]
729 if (ins & 0xde00000) == 0x200000
730 && let Some(ins) = parse_arm_eor_0(ins, pc, options)
731 {
732 return ins;
733 }
734 }
735 0x8f | 0x9f | 0xaf | 0xbf => {
736 #[cfg(
737 all(
738 feature = "arm",
739 any(
740 feature = "v5te",
741 feature = "v5tej",
742 feature = "v6",
743 feature = "v6k"
744 )
745 )
746 )]
747 if (ins & 0xe1000f0) == 0xf0
748 && let Some(ins) = parse_arm_strd_0(ins, pc, options)
749 {
750 return ins;
751 }
752 #[cfg(feature = "arm")]
753 if (ins & 0xde00000) == 0x200000
754 && let Some(ins) = parse_arm_eor_0(ins, pc, options)
755 {
756 return ins;
757 }
758 }
759 0xcb | 0xdb | 0xeb | 0xfb => {
760 #[cfg(feature = "arm")]
761 if (ins & 0xe1000f0) == 0x1000b0
762 && let Some(ins) = parse_arm_ldrh_0(ins, pc, options)
763 {
764 return ins;
765 }
766 #[cfg(feature = "arm")]
767 if (ins & 0xde00000) == 0x200000
768 && let Some(ins) = parse_arm_eor_0(ins, pc, options)
769 {
770 return ins;
771 }
772 }
773 0xcd | 0xdd | 0xed | 0xfd => {
774 #[cfg(feature = "arm")]
775 if (ins & 0xe1000f0) == 0x1000d0
776 && let Some(ins) = parse_arm_ldrsb_0(ins, pc, options)
777 {
778 return ins;
779 }
780 #[cfg(feature = "arm")]
781 if (ins & 0xde00000) == 0x200000
782 && let Some(ins) = parse_arm_eor_0(ins, pc, options)
783 {
784 return ins;
785 }
786 }
787 0xcf | 0xdf | 0xef | 0xff => {
788 #[cfg(feature = "arm")]
789 if (ins & 0xe1000f0) == 0x1000f0
790 && let Some(ins) = parse_arm_ldrsh_0(ins, pc, options)
791 {
792 return ins;
793 }
794 #[cfg(feature = "arm")]
795 if (ins & 0xde00000) == 0x200000
796 && let Some(ins) = parse_arm_eor_0(ins, pc, options)
797 {
798 return ins;
799 }
800 }
801 0x100 | 0x101 | 0x102 | 0x103 | 0x104 | 0x105 | 0x106 | 0x107 | 0x108 | 0x10a
802 | 0x10c | 0x10e | 0x110 | 0x111 | 0x112 | 0x113 | 0x114 | 0x115 | 0x116 | 0x117
803 | 0x118 | 0x11a | 0x11c | 0x11e | 0x120 | 0x121 | 0x122 | 0x123 | 0x124 | 0x125
804 | 0x126 | 0x127 | 0x128 | 0x12a | 0x12c | 0x12e | 0x130 | 0x131 | 0x132 | 0x133
805 | 0x134 | 0x135 | 0x136 | 0x137 | 0x138 | 0x13a | 0x13c | 0x13e | 0x140 | 0x141
806 | 0x142 | 0x143 | 0x144 | 0x145 | 0x146 | 0x147 | 0x148 | 0x149 | 0x14a | 0x14c
807 | 0x14e | 0x150 | 0x151 | 0x152 | 0x153 | 0x154 | 0x155 | 0x156 | 0x157 | 0x158
808 | 0x159 | 0x15a | 0x15c | 0x15e | 0x160 | 0x161 | 0x162 | 0x163 | 0x164 | 0x165
809 | 0x166 | 0x167 | 0x168 | 0x169 | 0x16a | 0x16c | 0x16e | 0x170 | 0x171 | 0x172
810 | 0x173 | 0x174 | 0x175 | 0x176 | 0x177 | 0x178 | 0x179 | 0x17a | 0x17c | 0x17e
811 | 0x900 | 0x901 | 0x902 | 0x903 | 0x904 | 0x905 | 0x906 | 0x907 | 0x908 | 0x909
812 | 0x90a | 0x90b | 0x90c | 0x90d | 0x90e | 0x90f | 0x910 | 0x911 | 0x912 | 0x913
813 | 0x914 | 0x915 | 0x916 | 0x917 | 0x918 | 0x919 | 0x91a | 0x91b | 0x91c | 0x91d
814 | 0x91e | 0x91f | 0x920 | 0x921 | 0x922 | 0x923 | 0x924 | 0x925 | 0x926 | 0x927
815 | 0x928 | 0x929 | 0x92a | 0x92b | 0x92c | 0x92d | 0x92e | 0x92f | 0x930 | 0x931
816 | 0x932 | 0x933 | 0x934 | 0x935 | 0x936 | 0x937 | 0x938 | 0x939 | 0x93a | 0x93b
817 | 0x93c | 0x93d | 0x93e | 0x93f | 0x940 | 0x941 | 0x942 | 0x943 | 0x944 | 0x945
818 | 0x946 | 0x947 | 0x948 | 0x949 | 0x94a | 0x94b | 0x94c | 0x94d | 0x94e | 0x94f
819 | 0x950 | 0x951 | 0x952 | 0x953 | 0x954 | 0x955 | 0x956 | 0x957 | 0x958 | 0x959
820 | 0x95a | 0x95b | 0x95c | 0x95d | 0x95e | 0x95f | 0x960 | 0x961 | 0x962 | 0x963
821 | 0x964 | 0x965 | 0x966 | 0x967 | 0x968 | 0x969 | 0x96a | 0x96b | 0x96c | 0x96d
822 | 0x96e | 0x96f | 0x970 | 0x971 | 0x972 | 0x973 | 0x974 | 0x975 | 0x976 | 0x977
823 | 0x978 | 0x979 | 0x97a | 0x97b | 0x97c | 0x97d | 0x97e | 0x97f => {
824 #[cfg(feature = "arm")]
825 if let Some(ins) = parse_arm_sub_0(ins, pc, options) {
826 return ins;
827 }
828 }
829 0x109 | 0x119 | 0x129 | 0x139 => {
830 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
831 if (ins & 0xff000f0) == 0x400090
832 && let Some(ins) = parse_arm_umaal_0(ins, pc, options)
833 {
834 return ins;
835 }
836 #[cfg(feature = "arm")]
837 if (ins & 0xde00000) == 0x400000
838 && let Some(ins) = parse_arm_sub_0(ins, pc, options)
839 {
840 return ins;
841 }
842 }
843 0x10b | 0x11b | 0x12b | 0x13b => {
844 #[cfg(feature = "arm")]
845 if (ins & 0xe1000f0) == 0xb0
846 && let Some(ins) = parse_arm_strh_0(ins, pc, options)
847 {
848 return ins;
849 }
850 #[cfg(feature = "arm")]
851 if (ins & 0xde00000) == 0x400000
852 && let Some(ins) = parse_arm_sub_0(ins, pc, options)
853 {
854 return ins;
855 }
856 }
857 0x10d | 0x11d => {
858 #[cfg(
859 all(
860 feature = "arm",
861 any(
862 feature = "v5te",
863 feature = "v5tej",
864 feature = "v6",
865 feature = "v6k"
866 )
867 )
868 )]
869 if (ins & 0xe1000f0) == 0xd0
870 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
871 {
872 return ins;
873 }
874 #[cfg(feature = "arm")]
875 if (ins & 0xde00000) == 0x400000
876 && let Some(ins) = parse_arm_sub_0(ins, pc, options)
877 {
878 return ins;
879 }
880 }
881 0x10f | 0x11f | 0x12f | 0x13f => {
882 #[cfg(
883 all(
884 feature = "arm",
885 any(
886 feature = "v5te",
887 feature = "v5tej",
888 feature = "v6",
889 feature = "v6k"
890 )
891 )
892 )]
893 if (ins & 0xe1000f0) == 0xf0
894 && let Some(ins) = parse_arm_strd_0(ins, pc, options)
895 {
896 return ins;
897 }
898 #[cfg(feature = "arm")]
899 if (ins & 0xde00000) == 0x400000
900 && let Some(ins) = parse_arm_sub_0(ins, pc, options)
901 {
902 return ins;
903 }
904 }
905 0x12d | 0x13d => {
906 #[cfg(
907 all(
908 feature = "arm",
909 any(
910 feature = "v5te",
911 feature = "v5tej",
912 feature = "v6",
913 feature = "v6k"
914 )
915 )
916 )]
917 if (ins & 0xe5f00f0) == 0x4f00d0
918 && let Some(ins) = parse_arm_ldrd_1(ins, pc, options)
919 {
920 return ins;
921 }
922 #[cfg(
923 all(
924 feature = "arm",
925 any(
926 feature = "v5te",
927 feature = "v5tej",
928 feature = "v6",
929 feature = "v6k"
930 )
931 )
932 )]
933 if (ins & 0xe1000f0) == 0xd0
934 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
935 {
936 return ins;
937 }
938 #[cfg(feature = "arm")]
939 if (ins & 0xde00000) == 0x400000
940 && let Some(ins) = parse_arm_sub_0(ins, pc, options)
941 {
942 return ins;
943 }
944 }
945 0x14b | 0x15b | 0x16b | 0x17b => {
946 #[cfg(feature = "arm")]
947 if (ins & 0xe1000f0) == 0x1000b0
948 && let Some(ins) = parse_arm_ldrh_0(ins, pc, options)
949 {
950 return ins;
951 }
952 #[cfg(feature = "arm")]
953 if (ins & 0xde00000) == 0x400000
954 && let Some(ins) = parse_arm_sub_0(ins, pc, options)
955 {
956 return ins;
957 }
958 }
959 0x14d | 0x15d | 0x16d | 0x17d => {
960 #[cfg(feature = "arm")]
961 if (ins & 0xe1000f0) == 0x1000d0
962 && let Some(ins) = parse_arm_ldrsb_0(ins, pc, options)
963 {
964 return ins;
965 }
966 #[cfg(feature = "arm")]
967 if (ins & 0xde00000) == 0x400000
968 && let Some(ins) = parse_arm_sub_0(ins, pc, options)
969 {
970 return ins;
971 }
972 }
973 0x14f | 0x15f | 0x16f | 0x17f => {
974 #[cfg(feature = "arm")]
975 if (ins & 0xe1000f0) == 0x1000f0
976 && let Some(ins) = parse_arm_ldrsh_0(ins, pc, options)
977 {
978 return ins;
979 }
980 #[cfg(feature = "arm")]
981 if (ins & 0xde00000) == 0x400000
982 && let Some(ins) = parse_arm_sub_0(ins, pc, options)
983 {
984 return ins;
985 }
986 }
987 0x180 | 0x181 | 0x182 | 0x183 | 0x184 | 0x185 | 0x186 | 0x187 | 0x188 | 0x189
988 | 0x18a | 0x18c | 0x18e | 0x190 | 0x191 | 0x192 | 0x193 | 0x194 | 0x195 | 0x196
989 | 0x197 | 0x198 | 0x199 | 0x19a | 0x19c | 0x19e | 0x1a0 | 0x1a1 | 0x1a2 | 0x1a3
990 | 0x1a4 | 0x1a5 | 0x1a6 | 0x1a7 | 0x1a8 | 0x1a9 | 0x1aa | 0x1ac | 0x1ae | 0x1b0
991 | 0x1b1 | 0x1b2 | 0x1b3 | 0x1b4 | 0x1b5 | 0x1b6 | 0x1b7 | 0x1b8 | 0x1b9 | 0x1ba
992 | 0x1bc | 0x1be | 0x1c0 | 0x1c1 | 0x1c2 | 0x1c3 | 0x1c4 | 0x1c5 | 0x1c6 | 0x1c7
993 | 0x1c8 | 0x1c9 | 0x1ca | 0x1cc | 0x1ce | 0x1d0 | 0x1d1 | 0x1d2 | 0x1d3 | 0x1d4
994 | 0x1d5 | 0x1d6 | 0x1d7 | 0x1d8 | 0x1d9 | 0x1da | 0x1dc | 0x1de | 0x1e0 | 0x1e1
995 | 0x1e2 | 0x1e3 | 0x1e4 | 0x1e5 | 0x1e6 | 0x1e7 | 0x1e8 | 0x1e9 | 0x1ea | 0x1ec
996 | 0x1ee | 0x1f0 | 0x1f1 | 0x1f2 | 0x1f3 | 0x1f4 | 0x1f5 | 0x1f6 | 0x1f7 | 0x1f8
997 | 0x1f9 | 0x1fa | 0x1fc | 0x1fe | 0x980 | 0x981 | 0x982 | 0x983 | 0x984 | 0x985
998 | 0x986 | 0x987 | 0x988 | 0x989 | 0x98a | 0x98b | 0x98c | 0x98d | 0x98e | 0x98f
999 | 0x990 | 0x991 | 0x992 | 0x993 | 0x994 | 0x995 | 0x996 | 0x997 | 0x998 | 0x999
1000 | 0x99a | 0x99b | 0x99c | 0x99d | 0x99e | 0x99f | 0x9a0 | 0x9a1 | 0x9a2 | 0x9a3
1001 | 0x9a4 | 0x9a5 | 0x9a6 | 0x9a7 | 0x9a8 | 0x9a9 | 0x9aa | 0x9ab | 0x9ac | 0x9ad
1002 | 0x9ae | 0x9af | 0x9b0 | 0x9b1 | 0x9b2 | 0x9b3 | 0x9b4 | 0x9b5 | 0x9b6 | 0x9b7
1003 | 0x9b8 | 0x9b9 | 0x9ba | 0x9bb | 0x9bc | 0x9bd | 0x9be | 0x9bf | 0x9c0 | 0x9c1
1004 | 0x9c2 | 0x9c3 | 0x9c4 | 0x9c5 | 0x9c6 | 0x9c7 | 0x9c8 | 0x9c9 | 0x9ca | 0x9cb
1005 | 0x9cc | 0x9cd | 0x9ce | 0x9cf | 0x9d0 | 0x9d1 | 0x9d2 | 0x9d3 | 0x9d4 | 0x9d5
1006 | 0x9d6 | 0x9d7 | 0x9d8 | 0x9d9 | 0x9da | 0x9db | 0x9dc | 0x9dd | 0x9de | 0x9df
1007 | 0x9e0 | 0x9e1 | 0x9e2 | 0x9e3 | 0x9e4 | 0x9e5 | 0x9e6 | 0x9e7 | 0x9e8 | 0x9e9
1008 | 0x9ea | 0x9eb | 0x9ec | 0x9ed | 0x9ee | 0x9ef | 0x9f0 | 0x9f1 | 0x9f2 | 0x9f3
1009 | 0x9f4 | 0x9f5 | 0x9f6 | 0x9f7 | 0x9f8 | 0x9f9 | 0x9fa | 0x9fb | 0x9fc | 0x9fd
1010 | 0x9fe | 0x9ff => {
1011 #[cfg(feature = "arm")]
1012 if let Some(ins) = parse_arm_rsb_0(ins, pc, options) {
1013 return ins;
1014 }
1015 }
1016 0x18b | 0x19b | 0x1ab | 0x1bb => {
1017 #[cfg(feature = "arm")]
1018 if (ins & 0xe1000f0) == 0xb0
1019 && let Some(ins) = parse_arm_strh_0(ins, pc, options)
1020 {
1021 return ins;
1022 }
1023 #[cfg(feature = "arm")]
1024 if (ins & 0xde00000) == 0x600000
1025 && let Some(ins) = parse_arm_rsb_0(ins, pc, options)
1026 {
1027 return ins;
1028 }
1029 }
1030 0x18d | 0x19d => {
1031 #[cfg(
1032 all(
1033 feature = "arm",
1034 any(
1035 feature = "v5te",
1036 feature = "v5tej",
1037 feature = "v6",
1038 feature = "v6k"
1039 )
1040 )
1041 )]
1042 if (ins & 0xe1000f0) == 0xd0
1043 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
1044 {
1045 return ins;
1046 }
1047 #[cfg(feature = "arm")]
1048 if (ins & 0xde00000) == 0x600000
1049 && let Some(ins) = parse_arm_rsb_0(ins, pc, options)
1050 {
1051 return ins;
1052 }
1053 }
1054 0x18f | 0x19f | 0x1af | 0x1bf => {
1055 #[cfg(
1056 all(
1057 feature = "arm",
1058 any(
1059 feature = "v5te",
1060 feature = "v5tej",
1061 feature = "v6",
1062 feature = "v6k"
1063 )
1064 )
1065 )]
1066 if (ins & 0xe1000f0) == 0xf0
1067 && let Some(ins) = parse_arm_strd_0(ins, pc, options)
1068 {
1069 return ins;
1070 }
1071 #[cfg(feature = "arm")]
1072 if (ins & 0xde00000) == 0x600000
1073 && let Some(ins) = parse_arm_rsb_0(ins, pc, options)
1074 {
1075 return ins;
1076 }
1077 }
1078 0x1ad | 0x1bd => {
1079 #[cfg(
1080 all(
1081 feature = "arm",
1082 any(
1083 feature = "v5te",
1084 feature = "v5tej",
1085 feature = "v6",
1086 feature = "v6k"
1087 )
1088 )
1089 )]
1090 if (ins & 0xe5f00f0) == 0x4f00d0
1091 && let Some(ins) = parse_arm_ldrd_1(ins, pc, options)
1092 {
1093 return ins;
1094 }
1095 #[cfg(
1096 all(
1097 feature = "arm",
1098 any(
1099 feature = "v5te",
1100 feature = "v5tej",
1101 feature = "v6",
1102 feature = "v6k"
1103 )
1104 )
1105 )]
1106 if (ins & 0xe1000f0) == 0xd0
1107 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
1108 {
1109 return ins;
1110 }
1111 #[cfg(feature = "arm")]
1112 if (ins & 0xde00000) == 0x600000
1113 && let Some(ins) = parse_arm_rsb_0(ins, pc, options)
1114 {
1115 return ins;
1116 }
1117 }
1118 0x1cb | 0x1db | 0x1eb | 0x1fb => {
1119 #[cfg(feature = "arm")]
1120 if (ins & 0xe1000f0) == 0x1000b0
1121 && let Some(ins) = parse_arm_ldrh_0(ins, pc, options)
1122 {
1123 return ins;
1124 }
1125 #[cfg(feature = "arm")]
1126 if (ins & 0xde00000) == 0x600000
1127 && let Some(ins) = parse_arm_rsb_0(ins, pc, options)
1128 {
1129 return ins;
1130 }
1131 }
1132 0x1cd | 0x1dd | 0x1ed | 0x1fd => {
1133 #[cfg(feature = "arm")]
1134 if (ins & 0xe1000f0) == 0x1000d0
1135 && let Some(ins) = parse_arm_ldrsb_0(ins, pc, options)
1136 {
1137 return ins;
1138 }
1139 #[cfg(feature = "arm")]
1140 if (ins & 0xde00000) == 0x600000
1141 && let Some(ins) = parse_arm_rsb_0(ins, pc, options)
1142 {
1143 return ins;
1144 }
1145 }
1146 0x1cf | 0x1df | 0x1ef | 0x1ff => {
1147 #[cfg(feature = "arm")]
1148 if (ins & 0xe1000f0) == 0x1000f0
1149 && let Some(ins) = parse_arm_ldrsh_0(ins, pc, options)
1150 {
1151 return ins;
1152 }
1153 #[cfg(feature = "arm")]
1154 if (ins & 0xde00000) == 0x600000
1155 && let Some(ins) = parse_arm_rsb_0(ins, pc, options)
1156 {
1157 return ins;
1158 }
1159 }
1160 0x200 | 0x201 | 0x202 | 0x203 | 0x204 | 0x205 | 0x206 | 0x207 | 0x208 | 0x20a
1161 | 0x20c | 0x20e | 0x210 | 0x211 | 0x212 | 0x213 | 0x214 | 0x215 | 0x216 | 0x217
1162 | 0x218 | 0x21a | 0x21c | 0x21e | 0x220 | 0x221 | 0x222 | 0x223 | 0x224 | 0x225
1163 | 0x226 | 0x227 | 0x228 | 0x22a | 0x22c | 0x22e | 0x230 | 0x231 | 0x232 | 0x233
1164 | 0x234 | 0x235 | 0x236 | 0x237 | 0x238 | 0x23a | 0x23c | 0x23e | 0x240 | 0x241
1165 | 0x242 | 0x243 | 0x244 | 0x245 | 0x246 | 0x247 | 0x248 | 0x24a | 0x24c | 0x24e
1166 | 0x250 | 0x251 | 0x252 | 0x253 | 0x254 | 0x255 | 0x256 | 0x257 | 0x258 | 0x25a
1167 | 0x25c | 0x25e | 0x260 | 0x261 | 0x262 | 0x263 | 0x264 | 0x265 | 0x266 | 0x267
1168 | 0x268 | 0x26a | 0x26c | 0x26e | 0x270 | 0x271 | 0x272 | 0x273 | 0x274 | 0x275
1169 | 0x276 | 0x277 | 0x278 | 0x27a | 0x27c | 0x27e | 0xa00 | 0xa01 | 0xa02 | 0xa03
1170 | 0xa04 | 0xa05 | 0xa06 | 0xa07 | 0xa08 | 0xa09 | 0xa0a | 0xa0b | 0xa0c | 0xa0d
1171 | 0xa0e | 0xa0f | 0xa10 | 0xa11 | 0xa12 | 0xa13 | 0xa14 | 0xa15 | 0xa16 | 0xa17
1172 | 0xa18 | 0xa19 | 0xa1a | 0xa1b | 0xa1c | 0xa1d | 0xa1e | 0xa1f | 0xa20 | 0xa21
1173 | 0xa22 | 0xa23 | 0xa24 | 0xa25 | 0xa26 | 0xa27 | 0xa28 | 0xa29 | 0xa2a | 0xa2b
1174 | 0xa2c | 0xa2d | 0xa2e | 0xa2f | 0xa30 | 0xa31 | 0xa32 | 0xa33 | 0xa34 | 0xa35
1175 | 0xa36 | 0xa37 | 0xa38 | 0xa39 | 0xa3a | 0xa3b | 0xa3c | 0xa3d | 0xa3e | 0xa3f
1176 | 0xa40 | 0xa41 | 0xa42 | 0xa43 | 0xa44 | 0xa45 | 0xa46 | 0xa47 | 0xa48 | 0xa49
1177 | 0xa4a | 0xa4b | 0xa4c | 0xa4d | 0xa4e | 0xa4f | 0xa50 | 0xa51 | 0xa52 | 0xa53
1178 | 0xa54 | 0xa55 | 0xa56 | 0xa57 | 0xa58 | 0xa59 | 0xa5a | 0xa5b | 0xa5c | 0xa5d
1179 | 0xa5e | 0xa5f | 0xa60 | 0xa61 | 0xa62 | 0xa63 | 0xa64 | 0xa65 | 0xa66 | 0xa67
1180 | 0xa68 | 0xa69 | 0xa6a | 0xa6b | 0xa6c | 0xa6d | 0xa6e | 0xa6f | 0xa70 | 0xa71
1181 | 0xa72 | 0xa73 | 0xa74 | 0xa75 | 0xa76 | 0xa77 | 0xa78 | 0xa79 | 0xa7a | 0xa7b
1182 | 0xa7c | 0xa7d | 0xa7e | 0xa7f => {
1183 #[cfg(feature = "arm")]
1184 if let Some(ins) = parse_arm_add_0(ins, pc, options) {
1185 return ins;
1186 }
1187 }
1188 0x209 | 0x219 | 0x229 | 0x239 | 0x249 | 0x259 | 0x269 | 0x279 => {
1189 #[cfg(feature = "arm")]
1190 if (ins & 0xfe000f0) == 0x800090
1191 && let Some(ins) = parse_arm_umull_0(ins, pc, options)
1192 {
1193 return ins;
1194 }
1195 #[cfg(feature = "arm")]
1196 if (ins & 0xde00000) == 0x800000
1197 && let Some(ins) = parse_arm_add_0(ins, pc, options)
1198 {
1199 return ins;
1200 }
1201 }
1202 0x20b | 0x21b | 0x22b | 0x23b => {
1203 #[cfg(feature = "arm")]
1204 if (ins & 0xe1000f0) == 0xb0
1205 && let Some(ins) = parse_arm_strh_0(ins, pc, options)
1206 {
1207 return ins;
1208 }
1209 #[cfg(feature = "arm")]
1210 if (ins & 0xde00000) == 0x800000
1211 && let Some(ins) = parse_arm_add_0(ins, pc, options)
1212 {
1213 return ins;
1214 }
1215 }
1216 0x20d | 0x21d | 0x22d | 0x23d => {
1217 #[cfg(
1218 all(
1219 feature = "arm",
1220 any(
1221 feature = "v5te",
1222 feature = "v5tej",
1223 feature = "v6",
1224 feature = "v6k"
1225 )
1226 )
1227 )]
1228 if (ins & 0xe1000f0) == 0xd0
1229 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
1230 {
1231 return ins;
1232 }
1233 #[cfg(feature = "arm")]
1234 if (ins & 0xde00000) == 0x800000
1235 && let Some(ins) = parse_arm_add_0(ins, pc, options)
1236 {
1237 return ins;
1238 }
1239 }
1240 0x20f | 0x21f | 0x22f | 0x23f => {
1241 #[cfg(
1242 all(
1243 feature = "arm",
1244 any(
1245 feature = "v5te",
1246 feature = "v5tej",
1247 feature = "v6",
1248 feature = "v6k"
1249 )
1250 )
1251 )]
1252 if (ins & 0xe1000f0) == 0xf0
1253 && let Some(ins) = parse_arm_strd_0(ins, pc, options)
1254 {
1255 return ins;
1256 }
1257 #[cfg(feature = "arm")]
1258 if (ins & 0xde00000) == 0x800000
1259 && let Some(ins) = parse_arm_add_0(ins, pc, options)
1260 {
1261 return ins;
1262 }
1263 }
1264 0x24b | 0x25b | 0x26b | 0x27b => {
1265 #[cfg(feature = "arm")]
1266 if (ins & 0xe1000f0) == 0x1000b0
1267 && let Some(ins) = parse_arm_ldrh_0(ins, pc, options)
1268 {
1269 return ins;
1270 }
1271 #[cfg(feature = "arm")]
1272 if (ins & 0xde00000) == 0x800000
1273 && let Some(ins) = parse_arm_add_0(ins, pc, options)
1274 {
1275 return ins;
1276 }
1277 }
1278 0x24d | 0x25d | 0x26d | 0x27d => {
1279 #[cfg(feature = "arm")]
1280 if (ins & 0xe1000f0) == 0x1000d0
1281 && let Some(ins) = parse_arm_ldrsb_0(ins, pc, options)
1282 {
1283 return ins;
1284 }
1285 #[cfg(feature = "arm")]
1286 if (ins & 0xde00000) == 0x800000
1287 && let Some(ins) = parse_arm_add_0(ins, pc, options)
1288 {
1289 return ins;
1290 }
1291 }
1292 0x24f | 0x25f | 0x26f | 0x27f => {
1293 #[cfg(feature = "arm")]
1294 if (ins & 0xe1000f0) == 0x1000f0
1295 && let Some(ins) = parse_arm_ldrsh_0(ins, pc, options)
1296 {
1297 return ins;
1298 }
1299 #[cfg(feature = "arm")]
1300 if (ins & 0xde00000) == 0x800000
1301 && let Some(ins) = parse_arm_add_0(ins, pc, options)
1302 {
1303 return ins;
1304 }
1305 }
1306 0x280 | 0x281 | 0x282 | 0x283 | 0x284 | 0x285 | 0x286 | 0x287 | 0x288 | 0x28a
1307 | 0x28c | 0x28e | 0x290 | 0x291 | 0x292 | 0x293 | 0x294 | 0x295 | 0x296 | 0x297
1308 | 0x298 | 0x29a | 0x29c | 0x29e | 0x2a0 | 0x2a1 | 0x2a2 | 0x2a3 | 0x2a4 | 0x2a5
1309 | 0x2a6 | 0x2a7 | 0x2a8 | 0x2aa | 0x2ac | 0x2ae | 0x2b0 | 0x2b1 | 0x2b2 | 0x2b3
1310 | 0x2b4 | 0x2b5 | 0x2b6 | 0x2b7 | 0x2b8 | 0x2ba | 0x2bc | 0x2be | 0x2c0 | 0x2c1
1311 | 0x2c2 | 0x2c3 | 0x2c4 | 0x2c5 | 0x2c6 | 0x2c7 | 0x2c8 | 0x2ca | 0x2cc | 0x2ce
1312 | 0x2d0 | 0x2d1 | 0x2d2 | 0x2d3 | 0x2d4 | 0x2d5 | 0x2d6 | 0x2d7 | 0x2d8 | 0x2da
1313 | 0x2dc | 0x2de | 0x2e0 | 0x2e1 | 0x2e2 | 0x2e3 | 0x2e4 | 0x2e5 | 0x2e6 | 0x2e7
1314 | 0x2e8 | 0x2ea | 0x2ec | 0x2ee | 0x2f0 | 0x2f1 | 0x2f2 | 0x2f3 | 0x2f4 | 0x2f5
1315 | 0x2f6 | 0x2f7 | 0x2f8 | 0x2fa | 0x2fc | 0x2fe | 0xa80 | 0xa81 | 0xa82 | 0xa83
1316 | 0xa84 | 0xa85 | 0xa86 | 0xa87 | 0xa88 | 0xa89 | 0xa8a | 0xa8b | 0xa8c | 0xa8d
1317 | 0xa8e | 0xa8f | 0xa90 | 0xa91 | 0xa92 | 0xa93 | 0xa94 | 0xa95 | 0xa96 | 0xa97
1318 | 0xa98 | 0xa99 | 0xa9a | 0xa9b | 0xa9c | 0xa9d | 0xa9e | 0xa9f | 0xaa0 | 0xaa1
1319 | 0xaa2 | 0xaa3 | 0xaa4 | 0xaa5 | 0xaa6 | 0xaa7 | 0xaa8 | 0xaa9 | 0xaaa | 0xaab
1320 | 0xaac | 0xaad | 0xaae | 0xaaf | 0xab0 | 0xab1 | 0xab2 | 0xab3 | 0xab4 | 0xab5
1321 | 0xab6 | 0xab7 | 0xab8 | 0xab9 | 0xaba | 0xabb | 0xabc | 0xabd | 0xabe | 0xabf
1322 | 0xac0 | 0xac1 | 0xac2 | 0xac3 | 0xac4 | 0xac5 | 0xac6 | 0xac7 | 0xac8 | 0xac9
1323 | 0xaca | 0xacb | 0xacc | 0xacd | 0xace | 0xacf | 0xad0 | 0xad1 | 0xad2 | 0xad3
1324 | 0xad4 | 0xad5 | 0xad6 | 0xad7 | 0xad8 | 0xad9 | 0xada | 0xadb | 0xadc | 0xadd
1325 | 0xade | 0xadf | 0xae0 | 0xae1 | 0xae2 | 0xae3 | 0xae4 | 0xae5 | 0xae6 | 0xae7
1326 | 0xae8 | 0xae9 | 0xaea | 0xaeb | 0xaec | 0xaed | 0xaee | 0xaef | 0xaf0 | 0xaf1
1327 | 0xaf2 | 0xaf3 | 0xaf4 | 0xaf5 | 0xaf6 | 0xaf7 | 0xaf8 | 0xaf9 | 0xafa | 0xafb
1328 | 0xafc | 0xafd | 0xafe | 0xaff => {
1329 #[cfg(feature = "arm")]
1330 if let Some(ins) = parse_arm_adc_0(ins, pc, options) {
1331 return ins;
1332 }
1333 }
1334 0x289 | 0x299 | 0x2a9 | 0x2b9 | 0x2c9 | 0x2d9 | 0x2e9 | 0x2f9 => {
1335 #[cfg(feature = "arm")]
1336 if (ins & 0xfe000f0) == 0xa00090
1337 && let Some(ins) = parse_arm_umlal_0(ins, pc, options)
1338 {
1339 return ins;
1340 }
1341 #[cfg(feature = "arm")]
1342 if (ins & 0xde00000) == 0xa00000
1343 && let Some(ins) = parse_arm_adc_0(ins, pc, options)
1344 {
1345 return ins;
1346 }
1347 }
1348 0x28b | 0x29b | 0x2ab | 0x2bb => {
1349 #[cfg(feature = "arm")]
1350 if (ins & 0xe1000f0) == 0xb0
1351 && let Some(ins) = parse_arm_strh_0(ins, pc, options)
1352 {
1353 return ins;
1354 }
1355 #[cfg(feature = "arm")]
1356 if (ins & 0xde00000) == 0xa00000
1357 && let Some(ins) = parse_arm_adc_0(ins, pc, options)
1358 {
1359 return ins;
1360 }
1361 }
1362 0x28d | 0x29d | 0x2ad | 0x2bd => {
1363 #[cfg(
1364 all(
1365 feature = "arm",
1366 any(
1367 feature = "v5te",
1368 feature = "v5tej",
1369 feature = "v6",
1370 feature = "v6k"
1371 )
1372 )
1373 )]
1374 if (ins & 0xe1000f0) == 0xd0
1375 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
1376 {
1377 return ins;
1378 }
1379 #[cfg(feature = "arm")]
1380 if (ins & 0xde00000) == 0xa00000
1381 && let Some(ins) = parse_arm_adc_0(ins, pc, options)
1382 {
1383 return ins;
1384 }
1385 }
1386 0x28f | 0x29f | 0x2af | 0x2bf => {
1387 #[cfg(
1388 all(
1389 feature = "arm",
1390 any(
1391 feature = "v5te",
1392 feature = "v5tej",
1393 feature = "v6",
1394 feature = "v6k"
1395 )
1396 )
1397 )]
1398 if (ins & 0xe1000f0) == 0xf0
1399 && let Some(ins) = parse_arm_strd_0(ins, pc, options)
1400 {
1401 return ins;
1402 }
1403 #[cfg(feature = "arm")]
1404 if (ins & 0xde00000) == 0xa00000
1405 && let Some(ins) = parse_arm_adc_0(ins, pc, options)
1406 {
1407 return ins;
1408 }
1409 }
1410 0x2cb | 0x2db | 0x2eb | 0x2fb => {
1411 #[cfg(feature = "arm")]
1412 if (ins & 0xe1000f0) == 0x1000b0
1413 && let Some(ins) = parse_arm_ldrh_0(ins, pc, options)
1414 {
1415 return ins;
1416 }
1417 #[cfg(feature = "arm")]
1418 if (ins & 0xde00000) == 0xa00000
1419 && let Some(ins) = parse_arm_adc_0(ins, pc, options)
1420 {
1421 return ins;
1422 }
1423 }
1424 0x2cd | 0x2dd | 0x2ed | 0x2fd => {
1425 #[cfg(feature = "arm")]
1426 if (ins & 0xe1000f0) == 0x1000d0
1427 && let Some(ins) = parse_arm_ldrsb_0(ins, pc, options)
1428 {
1429 return ins;
1430 }
1431 #[cfg(feature = "arm")]
1432 if (ins & 0xde00000) == 0xa00000
1433 && let Some(ins) = parse_arm_adc_0(ins, pc, options)
1434 {
1435 return ins;
1436 }
1437 }
1438 0x2cf | 0x2df | 0x2ef | 0x2ff => {
1439 #[cfg(feature = "arm")]
1440 if (ins & 0xe1000f0) == 0x1000f0
1441 && let Some(ins) = parse_arm_ldrsh_0(ins, pc, options)
1442 {
1443 return ins;
1444 }
1445 #[cfg(feature = "arm")]
1446 if (ins & 0xde00000) == 0xa00000
1447 && let Some(ins) = parse_arm_adc_0(ins, pc, options)
1448 {
1449 return ins;
1450 }
1451 }
1452 0x300 | 0x301 | 0x302 | 0x303 | 0x304 | 0x305 | 0x306 | 0x307 | 0x308 | 0x30a
1453 | 0x30c | 0x30e | 0x310 | 0x311 | 0x312 | 0x313 | 0x314 | 0x315 | 0x316 | 0x317
1454 | 0x318 | 0x31a | 0x31c | 0x31e | 0x320 | 0x321 | 0x322 | 0x323 | 0x324 | 0x325
1455 | 0x326 | 0x327 | 0x328 | 0x32a | 0x32c | 0x32e | 0x330 | 0x331 | 0x332 | 0x333
1456 | 0x334 | 0x335 | 0x336 | 0x337 | 0x338 | 0x33a | 0x33c | 0x33e | 0x340 | 0x341
1457 | 0x342 | 0x343 | 0x344 | 0x345 | 0x346 | 0x347 | 0x348 | 0x34a | 0x34c | 0x34e
1458 | 0x350 | 0x351 | 0x352 | 0x353 | 0x354 | 0x355 | 0x356 | 0x357 | 0x358 | 0x35a
1459 | 0x35c | 0x35e | 0x360 | 0x361 | 0x362 | 0x363 | 0x364 | 0x365 | 0x366 | 0x367
1460 | 0x368 | 0x36a | 0x36c | 0x36e | 0x370 | 0x371 | 0x372 | 0x373 | 0x374 | 0x375
1461 | 0x376 | 0x377 | 0x378 | 0x37a | 0x37c | 0x37e | 0xb00 | 0xb01 | 0xb02 | 0xb03
1462 | 0xb04 | 0xb05 | 0xb06 | 0xb07 | 0xb08 | 0xb09 | 0xb0a | 0xb0b | 0xb0c | 0xb0d
1463 | 0xb0e | 0xb0f | 0xb10 | 0xb11 | 0xb12 | 0xb13 | 0xb14 | 0xb15 | 0xb16 | 0xb17
1464 | 0xb18 | 0xb19 | 0xb1a | 0xb1b | 0xb1c | 0xb1d | 0xb1e | 0xb1f | 0xb20 | 0xb21
1465 | 0xb22 | 0xb23 | 0xb24 | 0xb25 | 0xb26 | 0xb27 | 0xb28 | 0xb29 | 0xb2a | 0xb2b
1466 | 0xb2c | 0xb2d | 0xb2e | 0xb2f | 0xb30 | 0xb31 | 0xb32 | 0xb33 | 0xb34 | 0xb35
1467 | 0xb36 | 0xb37 | 0xb38 | 0xb39 | 0xb3a | 0xb3b | 0xb3c | 0xb3d | 0xb3e | 0xb3f
1468 | 0xb40 | 0xb41 | 0xb42 | 0xb43 | 0xb44 | 0xb45 | 0xb46 | 0xb47 | 0xb48 | 0xb49
1469 | 0xb4a | 0xb4b | 0xb4c | 0xb4d | 0xb4e | 0xb4f | 0xb50 | 0xb51 | 0xb52 | 0xb53
1470 | 0xb54 | 0xb55 | 0xb56 | 0xb57 | 0xb58 | 0xb59 | 0xb5a | 0xb5b | 0xb5c | 0xb5d
1471 | 0xb5e | 0xb5f | 0xb60 | 0xb61 | 0xb62 | 0xb63 | 0xb64 | 0xb65 | 0xb66 | 0xb67
1472 | 0xb68 | 0xb69 | 0xb6a | 0xb6b | 0xb6c | 0xb6d | 0xb6e | 0xb6f | 0xb70 | 0xb71
1473 | 0xb72 | 0xb73 | 0xb74 | 0xb75 | 0xb76 | 0xb77 | 0xb78 | 0xb79 | 0xb7a | 0xb7b
1474 | 0xb7c | 0xb7d | 0xb7e | 0xb7f => {
1475 #[cfg(feature = "arm")]
1476 if let Some(ins) = parse_arm_sbc_0(ins, pc, options) {
1477 return ins;
1478 }
1479 }
1480 0x309 | 0x319 | 0x329 | 0x339 | 0x349 | 0x359 | 0x369 | 0x379 => {
1481 #[cfg(feature = "arm")]
1482 if (ins & 0xfe000f0) == 0xc00090
1483 && let Some(ins) = parse_arm_smull_0(ins, pc, options)
1484 {
1485 return ins;
1486 }
1487 #[cfg(feature = "arm")]
1488 if (ins & 0xde00000) == 0xc00000
1489 && let Some(ins) = parse_arm_sbc_0(ins, pc, options)
1490 {
1491 return ins;
1492 }
1493 }
1494 0x30b | 0x31b | 0x32b | 0x33b => {
1495 #[cfg(feature = "arm")]
1496 if (ins & 0xe1000f0) == 0xb0
1497 && let Some(ins) = parse_arm_strh_0(ins, pc, options)
1498 {
1499 return ins;
1500 }
1501 #[cfg(feature = "arm")]
1502 if (ins & 0xde00000) == 0xc00000
1503 && let Some(ins) = parse_arm_sbc_0(ins, pc, options)
1504 {
1505 return ins;
1506 }
1507 }
1508 0x30d | 0x31d => {
1509 #[cfg(
1510 all(
1511 feature = "arm",
1512 any(
1513 feature = "v5te",
1514 feature = "v5tej",
1515 feature = "v6",
1516 feature = "v6k"
1517 )
1518 )
1519 )]
1520 if (ins & 0xe1000f0) == 0xd0
1521 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
1522 {
1523 return ins;
1524 }
1525 #[cfg(feature = "arm")]
1526 if (ins & 0xde00000) == 0xc00000
1527 && let Some(ins) = parse_arm_sbc_0(ins, pc, options)
1528 {
1529 return ins;
1530 }
1531 }
1532 0x30f | 0x31f | 0x32f | 0x33f => {
1533 #[cfg(
1534 all(
1535 feature = "arm",
1536 any(
1537 feature = "v5te",
1538 feature = "v5tej",
1539 feature = "v6",
1540 feature = "v6k"
1541 )
1542 )
1543 )]
1544 if (ins & 0xe1000f0) == 0xf0
1545 && let Some(ins) = parse_arm_strd_0(ins, pc, options)
1546 {
1547 return ins;
1548 }
1549 #[cfg(feature = "arm")]
1550 if (ins & 0xde00000) == 0xc00000
1551 && let Some(ins) = parse_arm_sbc_0(ins, pc, options)
1552 {
1553 return ins;
1554 }
1555 }
1556 0x32d | 0x33d => {
1557 #[cfg(
1558 all(
1559 feature = "arm",
1560 any(
1561 feature = "v5te",
1562 feature = "v5tej",
1563 feature = "v6",
1564 feature = "v6k"
1565 )
1566 )
1567 )]
1568 if (ins & 0xe5f00f0) == 0x4f00d0
1569 && let Some(ins) = parse_arm_ldrd_1(ins, pc, options)
1570 {
1571 return ins;
1572 }
1573 #[cfg(
1574 all(
1575 feature = "arm",
1576 any(
1577 feature = "v5te",
1578 feature = "v5tej",
1579 feature = "v6",
1580 feature = "v6k"
1581 )
1582 )
1583 )]
1584 if (ins & 0xe1000f0) == 0xd0
1585 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
1586 {
1587 return ins;
1588 }
1589 #[cfg(feature = "arm")]
1590 if (ins & 0xde00000) == 0xc00000
1591 && let Some(ins) = parse_arm_sbc_0(ins, pc, options)
1592 {
1593 return ins;
1594 }
1595 }
1596 0x34b | 0x35b | 0x36b | 0x37b => {
1597 #[cfg(feature = "arm")]
1598 if (ins & 0xe1000f0) == 0x1000b0
1599 && let Some(ins) = parse_arm_ldrh_0(ins, pc, options)
1600 {
1601 return ins;
1602 }
1603 #[cfg(feature = "arm")]
1604 if (ins & 0xde00000) == 0xc00000
1605 && let Some(ins) = parse_arm_sbc_0(ins, pc, options)
1606 {
1607 return ins;
1608 }
1609 }
1610 0x34d | 0x35d | 0x36d | 0x37d => {
1611 #[cfg(feature = "arm")]
1612 if (ins & 0xe1000f0) == 0x1000d0
1613 && let Some(ins) = parse_arm_ldrsb_0(ins, pc, options)
1614 {
1615 return ins;
1616 }
1617 #[cfg(feature = "arm")]
1618 if (ins & 0xde00000) == 0xc00000
1619 && let Some(ins) = parse_arm_sbc_0(ins, pc, options)
1620 {
1621 return ins;
1622 }
1623 }
1624 0x34f | 0x35f | 0x36f | 0x37f => {
1625 #[cfg(feature = "arm")]
1626 if (ins & 0xe1000f0) == 0x1000f0
1627 && let Some(ins) = parse_arm_ldrsh_0(ins, pc, options)
1628 {
1629 return ins;
1630 }
1631 #[cfg(feature = "arm")]
1632 if (ins & 0xde00000) == 0xc00000
1633 && let Some(ins) = parse_arm_sbc_0(ins, pc, options)
1634 {
1635 return ins;
1636 }
1637 }
1638 0x380 | 0x381 | 0x382 | 0x383 | 0x384 | 0x385 | 0x386 | 0x387 | 0x388 | 0x38a
1639 | 0x38c | 0x38e | 0x390 | 0x391 | 0x392 | 0x393 | 0x394 | 0x395 | 0x396 | 0x397
1640 | 0x398 | 0x39a | 0x39c | 0x39e | 0x3a0 | 0x3a1 | 0x3a2 | 0x3a3 | 0x3a4 | 0x3a5
1641 | 0x3a6 | 0x3a7 | 0x3a8 | 0x3aa | 0x3ac | 0x3ae | 0x3b0 | 0x3b1 | 0x3b2 | 0x3b3
1642 | 0x3b4 | 0x3b5 | 0x3b6 | 0x3b7 | 0x3b8 | 0x3ba | 0x3bc | 0x3be | 0x3c0 | 0x3c1
1643 | 0x3c2 | 0x3c3 | 0x3c4 | 0x3c5 | 0x3c6 | 0x3c7 | 0x3c8 | 0x3ca | 0x3cc | 0x3ce
1644 | 0x3d0 | 0x3d1 | 0x3d2 | 0x3d3 | 0x3d4 | 0x3d5 | 0x3d6 | 0x3d7 | 0x3d8 | 0x3da
1645 | 0x3dc | 0x3de | 0x3e0 | 0x3e1 | 0x3e2 | 0x3e3 | 0x3e4 | 0x3e5 | 0x3e6 | 0x3e7
1646 | 0x3e8 | 0x3ea | 0x3ec | 0x3ee | 0x3f0 | 0x3f1 | 0x3f2 | 0x3f3 | 0x3f4 | 0x3f5
1647 | 0x3f6 | 0x3f7 | 0x3f8 | 0x3fa | 0x3fc | 0x3fe | 0xb80 | 0xb81 | 0xb82 | 0xb83
1648 | 0xb84 | 0xb85 | 0xb86 | 0xb87 | 0xb88 | 0xb89 | 0xb8a | 0xb8b | 0xb8c | 0xb8d
1649 | 0xb8e | 0xb8f | 0xb90 | 0xb91 | 0xb92 | 0xb93 | 0xb94 | 0xb95 | 0xb96 | 0xb97
1650 | 0xb98 | 0xb99 | 0xb9a | 0xb9b | 0xb9c | 0xb9d | 0xb9e | 0xb9f | 0xba0 | 0xba1
1651 | 0xba2 | 0xba3 | 0xba4 | 0xba5 | 0xba6 | 0xba7 | 0xba8 | 0xba9 | 0xbaa | 0xbab
1652 | 0xbac | 0xbad | 0xbae | 0xbaf | 0xbb0 | 0xbb1 | 0xbb2 | 0xbb3 | 0xbb4 | 0xbb5
1653 | 0xbb6 | 0xbb7 | 0xbb8 | 0xbb9 | 0xbba | 0xbbb | 0xbbc | 0xbbd | 0xbbe | 0xbbf
1654 | 0xbc0 | 0xbc1 | 0xbc2 | 0xbc3 | 0xbc4 | 0xbc5 | 0xbc6 | 0xbc7 | 0xbc8 | 0xbc9
1655 | 0xbca | 0xbcb | 0xbcc | 0xbcd | 0xbce | 0xbcf | 0xbd0 | 0xbd1 | 0xbd2 | 0xbd3
1656 | 0xbd4 | 0xbd5 | 0xbd6 | 0xbd7 | 0xbd8 | 0xbd9 | 0xbda | 0xbdb | 0xbdc | 0xbdd
1657 | 0xbde | 0xbdf | 0xbe0 | 0xbe1 | 0xbe2 | 0xbe3 | 0xbe4 | 0xbe5 | 0xbe6 | 0xbe7
1658 | 0xbe8 | 0xbe9 | 0xbea | 0xbeb | 0xbec | 0xbed | 0xbee | 0xbef | 0xbf0 | 0xbf1
1659 | 0xbf2 | 0xbf3 | 0xbf4 | 0xbf5 | 0xbf6 | 0xbf7 | 0xbf8 | 0xbf9 | 0xbfa | 0xbfb
1660 | 0xbfc | 0xbfd | 0xbfe | 0xbff => {
1661 #[cfg(feature = "arm")]
1662 if let Some(ins) = parse_arm_rsc_0(ins, pc, options) {
1663 return ins;
1664 }
1665 }
1666 0x389 | 0x399 | 0x3a9 | 0x3b9 | 0x3c9 | 0x3d9 | 0x3e9 | 0x3f9 => {
1667 #[cfg(feature = "arm")]
1668 if (ins & 0xfe000f0) == 0xe00090
1669 && let Some(ins) = parse_arm_smlal_0(ins, pc, options)
1670 {
1671 return ins;
1672 }
1673 #[cfg(feature = "arm")]
1674 if (ins & 0xde00000) == 0xe00000
1675 && let Some(ins) = parse_arm_rsc_0(ins, pc, options)
1676 {
1677 return ins;
1678 }
1679 }
1680 0x38b | 0x39b | 0x3ab | 0x3bb => {
1681 #[cfg(feature = "arm")]
1682 if (ins & 0xe1000f0) == 0xb0
1683 && let Some(ins) = parse_arm_strh_0(ins, pc, options)
1684 {
1685 return ins;
1686 }
1687 #[cfg(feature = "arm")]
1688 if (ins & 0xde00000) == 0xe00000
1689 && let Some(ins) = parse_arm_rsc_0(ins, pc, options)
1690 {
1691 return ins;
1692 }
1693 }
1694 0x38d | 0x39d => {
1695 #[cfg(
1696 all(
1697 feature = "arm",
1698 any(
1699 feature = "v5te",
1700 feature = "v5tej",
1701 feature = "v6",
1702 feature = "v6k"
1703 )
1704 )
1705 )]
1706 if (ins & 0xe1000f0) == 0xd0
1707 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
1708 {
1709 return ins;
1710 }
1711 #[cfg(feature = "arm")]
1712 if (ins & 0xde00000) == 0xe00000
1713 && let Some(ins) = parse_arm_rsc_0(ins, pc, options)
1714 {
1715 return ins;
1716 }
1717 }
1718 0x38f | 0x39f | 0x3af | 0x3bf => {
1719 #[cfg(
1720 all(
1721 feature = "arm",
1722 any(
1723 feature = "v5te",
1724 feature = "v5tej",
1725 feature = "v6",
1726 feature = "v6k"
1727 )
1728 )
1729 )]
1730 if (ins & 0xe1000f0) == 0xf0
1731 && let Some(ins) = parse_arm_strd_0(ins, pc, options)
1732 {
1733 return ins;
1734 }
1735 #[cfg(feature = "arm")]
1736 if (ins & 0xde00000) == 0xe00000
1737 && let Some(ins) = parse_arm_rsc_0(ins, pc, options)
1738 {
1739 return ins;
1740 }
1741 }
1742 0x3ad | 0x3bd => {
1743 #[cfg(
1744 all(
1745 feature = "arm",
1746 any(
1747 feature = "v5te",
1748 feature = "v5tej",
1749 feature = "v6",
1750 feature = "v6k"
1751 )
1752 )
1753 )]
1754 if (ins & 0xe5f00f0) == 0x4f00d0
1755 && let Some(ins) = parse_arm_ldrd_1(ins, pc, options)
1756 {
1757 return ins;
1758 }
1759 #[cfg(
1760 all(
1761 feature = "arm",
1762 any(
1763 feature = "v5te",
1764 feature = "v5tej",
1765 feature = "v6",
1766 feature = "v6k"
1767 )
1768 )
1769 )]
1770 if (ins & 0xe1000f0) == 0xd0
1771 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
1772 {
1773 return ins;
1774 }
1775 #[cfg(feature = "arm")]
1776 if (ins & 0xde00000) == 0xe00000
1777 && let Some(ins) = parse_arm_rsc_0(ins, pc, options)
1778 {
1779 return ins;
1780 }
1781 }
1782 0x3cb | 0x3db | 0x3eb | 0x3fb => {
1783 #[cfg(feature = "arm")]
1784 if (ins & 0xe1000f0) == 0x1000b0
1785 && let Some(ins) = parse_arm_ldrh_0(ins, pc, options)
1786 {
1787 return ins;
1788 }
1789 #[cfg(feature = "arm")]
1790 if (ins & 0xde00000) == 0xe00000
1791 && let Some(ins) = parse_arm_rsc_0(ins, pc, options)
1792 {
1793 return ins;
1794 }
1795 }
1796 0x3cd | 0x3dd | 0x3ed | 0x3fd => {
1797 #[cfg(feature = "arm")]
1798 if (ins & 0xe1000f0) == 0x1000d0
1799 && let Some(ins) = parse_arm_ldrsb_0(ins, pc, options)
1800 {
1801 return ins;
1802 }
1803 #[cfg(feature = "arm")]
1804 if (ins & 0xde00000) == 0xe00000
1805 && let Some(ins) = parse_arm_rsc_0(ins, pc, options)
1806 {
1807 return ins;
1808 }
1809 }
1810 0x3cf | 0x3df | 0x3ef | 0x3ff => {
1811 #[cfg(feature = "arm")]
1812 if (ins & 0xe1000f0) == 0x1000f0
1813 && let Some(ins) = parse_arm_ldrsh_0(ins, pc, options)
1814 {
1815 return ins;
1816 }
1817 #[cfg(feature = "arm")]
1818 if (ins & 0xde00000) == 0xe00000
1819 && let Some(ins) = parse_arm_rsc_0(ins, pc, options)
1820 {
1821 return ins;
1822 }
1823 }
1824 0x400 | 0x410 | 0x420 | 0x430 => {
1825 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
1826 if (ins & 0xfff100f0) == 0xf1010000
1827 && let Some(ins) = parse_arm_setend_0(ins, pc, options)
1828 {
1829 return ins;
1830 }
1831 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
1832 if (ins & 0xfff10020) == 0xf1000000
1833 && let Some(ins) = parse_arm_cps_0(ins, pc, options)
1834 {
1835 return ins;
1836 }
1837 #[cfg(feature = "arm")]
1838 if (ins & 0xfb002f0) == 0x1000000
1839 && let Some(ins) = parse_arm_mrs_0(ins, pc, options)
1840 {
1841 return ins;
1842 }
1843 }
1844 0x401 | 0x404 | 0x411 | 0x414 | 0x421 | 0x424 | 0x431 | 0x434 => {
1845 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
1846 if let Some(ins) = parse_arm_cps_0(ins, pc, options) {
1847 return ins;
1848 }
1849 }
1850 0x402 | 0x403 | 0x406 | 0x407 | 0x412 | 0x413 | 0x416 | 0x417 | 0x422 | 0x423
1851 | 0x426 | 0x427 | 0x432 | 0x433 | 0x436 | 0x437 | 0x501 | 0x502 | 0x503 | 0x504
1852 | 0x506 | 0x507 | 0x511 | 0x512 | 0x513 | 0x514 | 0x516 | 0x517 | 0x521 | 0x522
1853 | 0x523 | 0x524 | 0x526 | 0x527 | 0x531 | 0x532 | 0x533 | 0x534 | 0x536 | 0x537
1854 | 0xc00 | 0xc01 | 0xc02 | 0xc03 | 0xc04 | 0xc05 | 0xc06 | 0xc07 | 0xc08 | 0xc09
1855 | 0xc0a | 0xc0b | 0xc0c | 0xc0d | 0xc0e | 0xc0f | 0xc10 | 0xc11 | 0xc12 | 0xc13
1856 | 0xc14 | 0xc15 | 0xc16 | 0xc17 | 0xc18 | 0xc19 | 0xc1a | 0xc1b | 0xc1c | 0xc1d
1857 | 0xc1e | 0xc1f | 0xc20 | 0xc21 | 0xc22 | 0xc23 | 0xc24 | 0xc25 | 0xc26 | 0xc27
1858 | 0xc28 | 0xc29 | 0xc2a | 0xc2b | 0xc2c | 0xc2d | 0xc2e | 0xc2f | 0xc30 | 0xc31
1859 | 0xc32 | 0xc33 | 0xc34 | 0xc35 | 0xc36 | 0xc37 | 0xc38 | 0xc39 | 0xc3a | 0xc3b
1860 | 0xc3c | 0xc3d | 0xc3e | 0xc3f | 0xd00 | 0xd01 | 0xd02 | 0xd03 | 0xd04 | 0xd05
1861 | 0xd06 | 0xd07 | 0xd08 | 0xd09 | 0xd0a | 0xd0b | 0xd0c | 0xd0d | 0xd0e | 0xd0f
1862 | 0xd10 | 0xd11 | 0xd12 | 0xd13 | 0xd14 | 0xd15 | 0xd16 | 0xd17 | 0xd18 | 0xd19
1863 | 0xd1a | 0xd1b | 0xd1c | 0xd1d | 0xd1e | 0xd1f | 0xd20 | 0xd21 | 0xd22 | 0xd23
1864 | 0xd24 | 0xd25 | 0xd26 | 0xd27 | 0xd28 | 0xd29 | 0xd2a | 0xd2b | 0xd2c | 0xd2d
1865 | 0xd2e | 0xd2f | 0xd30 | 0xd31 | 0xd32 | 0xd33 | 0xd34 | 0xd35 | 0xd36 | 0xd37
1866 | 0xd38 | 0xd39 | 0xd3a | 0xd3b | 0xd3c | 0xd3d | 0xd3e | 0xd3f => {}
1867 0x405 | 0x415 | 0x425 | 0x435 => {
1868 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
1869 if (ins & 0xfff10020) == 0xf1000000
1870 && let Some(ins) = parse_arm_cps_0(ins, pc, options)
1871 {
1872 return ins;
1873 }
1874 #[cfg(
1875 all(
1876 feature = "arm",
1877 any(
1878 feature = "v5te",
1879 feature = "v5tej",
1880 feature = "v6",
1881 feature = "v6k"
1882 )
1883 )
1884 )]
1885 if (ins & 0xff000f0) == 0x1000050
1886 && let Some(ins) = parse_arm_qadd_0(ins, pc, options)
1887 {
1888 return ins;
1889 }
1890 }
1891 0x408 | 0x40c | 0x418 | 0x41c | 0x428 | 0x42c | 0x438 | 0x43c => {
1892 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
1893 if (ins & 0xfff10020) == 0xf1000000
1894 && let Some(ins) = parse_arm_cps_0(ins, pc, options)
1895 {
1896 return ins;
1897 }
1898 #[cfg(
1899 all(
1900 feature = "arm",
1901 any(
1902 feature = "v5te",
1903 feature = "v5tej",
1904 feature = "v6",
1905 feature = "v6k"
1906 )
1907 )
1908 )]
1909 if (ins & 0xff00090) == 0x1000080
1910 && let Some(ins) = parse_arm_smla_0(ins, pc, options)
1911 {
1912 return ins;
1913 }
1914 }
1915 0x409 | 0x419 | 0x429 | 0x439 => {
1916 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
1917 if (ins & 0xfff10020) == 0xf1000000
1918 && let Some(ins) = parse_arm_cps_0(ins, pc, options)
1919 {
1920 return ins;
1921 }
1922 #[cfg(feature = "arm")]
1923 if (ins & 0xff000f0) == 0x1000090
1924 && let Some(ins) = parse_arm_swp_0(ins, pc, options)
1925 {
1926 return ins;
1927 }
1928 }
1929 0x40a | 0x40e | 0x41a | 0x41e | 0x42a | 0x42e | 0x43a | 0x43e => {
1930 #[cfg(
1931 all(
1932 feature = "arm",
1933 any(
1934 feature = "v5te",
1935 feature = "v5tej",
1936 feature = "v6",
1937 feature = "v6k"
1938 )
1939 )
1940 )]
1941 if let Some(ins) = parse_arm_smla_0(ins, pc, options) {
1942 return ins;
1943 }
1944 }
1945 0x40b | 0x41b | 0x42b | 0x43b | 0x50b | 0x51b | 0x52b | 0x53b => {
1946 #[cfg(feature = "arm")]
1947 if let Some(ins) = parse_arm_strh_0(ins, pc, options) {
1948 return ins;
1949 }
1950 }
1951 0x40d | 0x41d | 0x42d | 0x43d => {
1952 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
1953 if (ins & 0xfff10020) == 0xf1000000
1954 && let Some(ins) = parse_arm_cps_0(ins, pc, options)
1955 {
1956 return ins;
1957 }
1958 #[cfg(
1959 all(
1960 feature = "arm",
1961 any(
1962 feature = "v5te",
1963 feature = "v5tej",
1964 feature = "v6",
1965 feature = "v6k"
1966 )
1967 )
1968 )]
1969 if (ins & 0xe1000f0) == 0xd0
1970 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
1971 {
1972 return ins;
1973 }
1974 }
1975 0x40f | 0x41f | 0x42f | 0x43f | 0x50f | 0x51f | 0x52f | 0x53f => {
1976 #[cfg(
1977 all(
1978 feature = "arm",
1979 any(
1980 feature = "v5te",
1981 feature = "v5tej",
1982 feature = "v6",
1983 feature = "v6k"
1984 )
1985 )
1986 )]
1987 if let Some(ins) = parse_arm_strd_0(ins, pc, options) {
1988 return ins;
1989 }
1990 }
1991 0x440 | 0x441 | 0x442 | 0x443 | 0x444 | 0x445 | 0x446 | 0x447 | 0x448 | 0x449
1992 | 0x44a | 0x44c | 0x44e | 0x450 | 0x451 | 0x452 | 0x453 | 0x454 | 0x455 | 0x456
1993 | 0x457 | 0x458 | 0x459 | 0x45a | 0x45c | 0x45e | 0x460 | 0x461 | 0x462 | 0x463
1994 | 0x464 | 0x465 | 0x466 | 0x467 | 0x468 | 0x469 | 0x46a | 0x46c | 0x46e | 0x470
1995 | 0x471 | 0x472 | 0x473 | 0x474 | 0x475 | 0x476 | 0x477 | 0x478 | 0x479 | 0x47a
1996 | 0x47c | 0x47e | 0xc40 | 0xc41 | 0xc42 | 0xc43 | 0xc44 | 0xc45 | 0xc46 | 0xc47
1997 | 0xc48 | 0xc49 | 0xc4a | 0xc4b | 0xc4c | 0xc4d | 0xc4e | 0xc4f | 0xc50 | 0xc51
1998 | 0xc52 | 0xc53 | 0xc54 | 0xc55 | 0xc56 | 0xc57 | 0xc58 | 0xc59 | 0xc5a | 0xc5b
1999 | 0xc5c | 0xc5d | 0xc5e | 0xc5f | 0xc60 | 0xc61 | 0xc62 | 0xc63 | 0xc64 | 0xc65
2000 | 0xc66 | 0xc67 | 0xc68 | 0xc69 | 0xc6a | 0xc6b | 0xc6c | 0xc6d | 0xc6e | 0xc6f
2001 | 0xc70 | 0xc71 | 0xc72 | 0xc73 | 0xc74 | 0xc75 | 0xc76 | 0xc77 | 0xc78 | 0xc79
2002 | 0xc7a | 0xc7b | 0xc7c | 0xc7d | 0xc7e | 0xc7f => {
2003 #[cfg(feature = "arm")]
2004 if let Some(ins) = parse_arm_tst_0(ins, pc, options) {
2005 return ins;
2006 }
2007 }
2008 0x44b | 0x45b | 0x46b | 0x47b => {
2009 #[cfg(feature = "arm")]
2010 if (ins & 0xe1000f0) == 0x1000b0
2011 && let Some(ins) = parse_arm_ldrh_0(ins, pc, options)
2012 {
2013 return ins;
2014 }
2015 #[cfg(feature = "arm")]
2016 if (ins & 0xdf00000) == 0x1100000
2017 && let Some(ins) = parse_arm_tst_0(ins, pc, options)
2018 {
2019 return ins;
2020 }
2021 }
2022 0x44d | 0x45d | 0x46d | 0x47d => {
2023 #[cfg(feature = "arm")]
2024 if (ins & 0xe1000f0) == 0x1000d0
2025 && let Some(ins) = parse_arm_ldrsb_0(ins, pc, options)
2026 {
2027 return ins;
2028 }
2029 #[cfg(feature = "arm")]
2030 if (ins & 0xdf00000) == 0x1100000
2031 && let Some(ins) = parse_arm_tst_0(ins, pc, options)
2032 {
2033 return ins;
2034 }
2035 }
2036 0x44f | 0x45f | 0x46f | 0x47f => {
2037 #[cfg(feature = "arm")]
2038 if (ins & 0xe1000f0) == 0x1000f0
2039 && let Some(ins) = parse_arm_ldrsh_0(ins, pc, options)
2040 {
2041 return ins;
2042 }
2043 #[cfg(feature = "arm")]
2044 if (ins & 0xdf00000) == 0x1100000
2045 && let Some(ins) = parse_arm_tst_0(ins, pc, options)
2046 {
2047 return ins;
2048 }
2049 }
2050 0x480 | 0x484 | 0x486 | 0x489 | 0x490 | 0x494 | 0x496 | 0x499 | 0x4a0 | 0x4a4
2051 | 0x4a6 | 0x4a9 | 0x4b0 | 0x4b4 | 0x4b6 | 0x4b9 | 0x580 | 0x582 | 0x583 | 0x584
2052 | 0x586 | 0x587 | 0x589 | 0x590 | 0x592 | 0x593 | 0x594 | 0x596 | 0x597 | 0x599
2053 | 0x5a0 | 0x5a2 | 0x5a3 | 0x5a4 | 0x5a6 | 0x5a7 | 0x5a9 | 0x5b0 | 0x5b2 | 0x5b3
2054 | 0x5b4 | 0x5b6 | 0x5b7 | 0x5b9 | 0xc82 | 0xc83 | 0xc84 | 0xc85 | 0xc86 | 0xc87
2055 | 0xc88 | 0xc89 | 0xc8a | 0xc8b | 0xc8c | 0xc8d | 0xc8e | 0xc92 | 0xc93 | 0xc94
2056 | 0xc95 | 0xc96 | 0xc97 | 0xc98 | 0xc99 | 0xc9a | 0xc9b | 0xc9c | 0xc9d | 0xc9e
2057 | 0xca0 | 0xca1 | 0xca2 | 0xca3 | 0xca4 | 0xca5 | 0xca6 | 0xca7 | 0xca8 | 0xca9
2058 | 0xcaa | 0xcab | 0xcac | 0xcad | 0xcae | 0xcaf | 0xcb0 | 0xcb1 | 0xcb2 | 0xcb3
2059 | 0xcb4 | 0xcb5 | 0xcb6 | 0xcb7 | 0xcb8 | 0xcb9 | 0xcba | 0xcbb | 0xcbc | 0xcbd
2060 | 0xcbe | 0xcbf | 0xd80 | 0xd81 | 0xd82 | 0xd83 | 0xd84 | 0xd85 | 0xd86 | 0xd87
2061 | 0xd88 | 0xd89 | 0xd8a | 0xd8b | 0xd8c | 0xd8d | 0xd8e | 0xd8f | 0xd90 | 0xd91
2062 | 0xd92 | 0xd93 | 0xd94 | 0xd95 | 0xd96 | 0xd97 | 0xd98 | 0xd99 | 0xd9a | 0xd9b
2063 | 0xd9c | 0xd9d | 0xd9e | 0xd9f | 0xda0 | 0xda1 | 0xda2 | 0xda3 | 0xda4 | 0xda5
2064 | 0xda6 | 0xda7 | 0xda8 | 0xda9 | 0xdaa | 0xdab | 0xdac | 0xdad | 0xdae | 0xdaf
2065 | 0xdb0 | 0xdb1 | 0xdb2 | 0xdb3 | 0xdb4 | 0xdb5 | 0xdb6 | 0xdb7 | 0xdb8 | 0xdb9
2066 | 0xdba | 0xdbb | 0xdbc | 0xdbd | 0xdbe | 0xdbf => {
2067 #[cfg(feature = "arm")]
2068 if let Some(ins) = parse_arm_msr_0(ins, pc, options) {
2069 return ins;
2070 }
2071 }
2072 0x481 | 0x491 | 0x4a1 | 0x4b1 => {
2073 #[cfg(
2074 all(
2075 feature = "arm",
2076 any(
2077 feature = "v4t",
2078 feature = "v5t",
2079 feature = "v5te",
2080 feature = "v5tej",
2081 feature = "v6",
2082 feature = "v6k"
2083 )
2084 )
2085 )]
2086 if (ins & 0xff000f0) == 0x1200010
2087 && let Some(ins) = parse_arm_bx_0(ins, pc, options)
2088 {
2089 return ins;
2090 }
2091 #[cfg(feature = "arm")]
2092 if (ins & 0xdb00000) == 0x1200000
2093 && let Some(ins) = parse_arm_msr_0(ins, pc, options)
2094 {
2095 return ins;
2096 }
2097 }
2098 0x482 | 0x492 | 0x4a2 | 0x4b2 => {
2099 #[cfg(
2100 all(
2101 feature = "arm",
2102 any(feature = "v5tej", feature = "v6", feature = "v6k")
2103 )
2104 )]
2105 if (ins & 0xff000f0) == 0x1200020
2106 && let Some(ins) = parse_arm_bxj_0(ins, pc, options)
2107 {
2108 return ins;
2109 }
2110 #[cfg(feature = "arm")]
2111 if (ins & 0xdb00000) == 0x1200000
2112 && let Some(ins) = parse_arm_msr_0(ins, pc, options)
2113 {
2114 return ins;
2115 }
2116 }
2117 0x483 | 0x493 | 0x4a3 | 0x4b3 => {
2118 #[cfg(
2119 all(
2120 feature = "arm",
2121 any(
2122 feature = "v5t",
2123 feature = "v5te",
2124 feature = "v5tej",
2125 feature = "v6",
2126 feature = "v6k"
2127 )
2128 )
2129 )]
2130 if (ins & 0xff000f0) == 0x1200030
2131 && let Some(ins) = parse_arm_blx_1(ins, pc, options)
2132 {
2133 return ins;
2134 }
2135 #[cfg(feature = "arm")]
2136 if (ins & 0xdb00000) == 0x1200000
2137 && let Some(ins) = parse_arm_msr_0(ins, pc, options)
2138 {
2139 return ins;
2140 }
2141 }
2142 0x485 | 0x495 | 0x4a5 | 0x4b5 => {
2143 #[cfg(
2144 all(
2145 feature = "arm",
2146 any(
2147 feature = "v5te",
2148 feature = "v5tej",
2149 feature = "v6",
2150 feature = "v6k"
2151 )
2152 )
2153 )]
2154 if (ins & 0xff000f0) == 0x1200050
2155 && let Some(ins) = parse_arm_qsub_0(ins, pc, options)
2156 {
2157 return ins;
2158 }
2159 #[cfg(feature = "arm")]
2160 if (ins & 0xdb00000) == 0x1200000
2161 && let Some(ins) = parse_arm_msr_0(ins, pc, options)
2162 {
2163 return ins;
2164 }
2165 }
2166 0x487 | 0x497 | 0x4a7 | 0x4b7 => {
2167 #[cfg(
2168 all(
2169 feature = "arm",
2170 any(
2171 feature = "v5t",
2172 feature = "v5te",
2173 feature = "v5tej",
2174 feature = "v6",
2175 feature = "v6k"
2176 )
2177 )
2178 )]
2179 if (ins & 0xfff000f0) == 0xe1200070
2180 && let Some(ins) = parse_arm_bkpt_0(ins, pc, options)
2181 {
2182 return ins;
2183 }
2184 #[cfg(feature = "arm")]
2185 if (ins & 0xdb00000) == 0x1200000
2186 && let Some(ins) = parse_arm_msr_0(ins, pc, options)
2187 {
2188 return ins;
2189 }
2190 }
2191 0x488 | 0x48c | 0x498 | 0x49c | 0x4a8 | 0x4ac | 0x4b8 | 0x4bc => {
2192 #[cfg(
2193 all(
2194 feature = "arm",
2195 any(
2196 feature = "v5te",
2197 feature = "v5tej",
2198 feature = "v6",
2199 feature = "v6k"
2200 )
2201 )
2202 )]
2203 if (ins & 0xff000b0) == 0x1200080
2204 && let Some(ins) = parse_arm_smlaw_0(ins, pc, options)
2205 {
2206 return ins;
2207 }
2208 #[cfg(feature = "arm")]
2209 if (ins & 0xdb00000) == 0x1200000
2210 && let Some(ins) = parse_arm_msr_0(ins, pc, options)
2211 {
2212 return ins;
2213 }
2214 }
2215 0x48a | 0x48e | 0x49a | 0x49e | 0x4aa | 0x4ae | 0x4ba | 0x4be => {
2216 #[cfg(
2217 all(
2218 feature = "arm",
2219 any(
2220 feature = "v5te",
2221 feature = "v5tej",
2222 feature = "v6",
2223 feature = "v6k"
2224 )
2225 )
2226 )]
2227 if (ins & 0xff000b0) == 0x12000a0
2228 && let Some(ins) = parse_arm_smulw_0(ins, pc, options)
2229 {
2230 return ins;
2231 }
2232 #[cfg(feature = "arm")]
2233 if (ins & 0xdb00000) == 0x1200000
2234 && let Some(ins) = parse_arm_msr_0(ins, pc, options)
2235 {
2236 return ins;
2237 }
2238 }
2239 0x48b | 0x49b | 0x4ab | 0x4bb | 0x58b | 0x59b | 0x5ab | 0x5bb => {
2240 #[cfg(feature = "arm")]
2241 if (ins & 0xe1000f0) == 0xb0
2242 && let Some(ins) = parse_arm_strh_0(ins, pc, options)
2243 {
2244 return ins;
2245 }
2246 #[cfg(feature = "arm")]
2247 if (ins & 0xdb00000) == 0x1200000
2248 && let Some(ins) = parse_arm_msr_0(ins, pc, options)
2249 {
2250 return ins;
2251 }
2252 }
2253 0x48d | 0x49d | 0x4ad | 0x4bd | 0x58d | 0x59d => {
2254 #[cfg(
2255 all(
2256 feature = "arm",
2257 any(
2258 feature = "v5te",
2259 feature = "v5tej",
2260 feature = "v6",
2261 feature = "v6k"
2262 )
2263 )
2264 )]
2265 if (ins & 0xe1000f0) == 0xd0
2266 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
2267 {
2268 return ins;
2269 }
2270 #[cfg(feature = "arm")]
2271 if (ins & 0xdb00000) == 0x1200000
2272 && let Some(ins) = parse_arm_msr_0(ins, pc, options)
2273 {
2274 return ins;
2275 }
2276 }
2277 0x48f | 0x49f | 0x4af | 0x4bf | 0x58f | 0x59f | 0x5af | 0x5bf => {
2278 #[cfg(
2279 all(
2280 feature = "arm",
2281 any(
2282 feature = "v5te",
2283 feature = "v5tej",
2284 feature = "v6",
2285 feature = "v6k"
2286 )
2287 )
2288 )]
2289 if (ins & 0xe1000f0) == 0xf0
2290 && let Some(ins) = parse_arm_strd_0(ins, pc, options)
2291 {
2292 return ins;
2293 }
2294 #[cfg(feature = "arm")]
2295 if (ins & 0xdb00000) == 0x1200000
2296 && let Some(ins) = parse_arm_msr_0(ins, pc, options)
2297 {
2298 return ins;
2299 }
2300 }
2301 0x4c0 | 0x4c1 | 0x4c2 | 0x4c3 | 0x4c4 | 0x4c5 | 0x4c6 | 0x4c7 | 0x4c8 | 0x4c9
2302 | 0x4ca | 0x4cc | 0x4ce | 0x4d0 | 0x4d1 | 0x4d2 | 0x4d3 | 0x4d4 | 0x4d5 | 0x4d6
2303 | 0x4d7 | 0x4d8 | 0x4d9 | 0x4da | 0x4dc | 0x4de | 0x4e0 | 0x4e1 | 0x4e2 | 0x4e3
2304 | 0x4e4 | 0x4e5 | 0x4e6 | 0x4e7 | 0x4e8 | 0x4e9 | 0x4ea | 0x4ec | 0x4ee | 0x4f0
2305 | 0x4f1 | 0x4f2 | 0x4f3 | 0x4f4 | 0x4f5 | 0x4f6 | 0x4f7 | 0x4f8 | 0x4f9 | 0x4fa
2306 | 0x4fc | 0x4fe | 0xcc0 | 0xcc1 | 0xcc2 | 0xcc3 | 0xcc4 | 0xcc5 | 0xcc6 | 0xcc7
2307 | 0xcc8 | 0xcc9 | 0xcca | 0xccb | 0xccc | 0xccd | 0xcce | 0xccf | 0xcd0 | 0xcd1
2308 | 0xcd2 | 0xcd3 | 0xcd4 | 0xcd5 | 0xcd6 | 0xcd7 | 0xcd8 | 0xcd9 | 0xcda | 0xcdb
2309 | 0xcdc | 0xcdd | 0xcde | 0xcdf | 0xce0 | 0xce1 | 0xce2 | 0xce3 | 0xce4 | 0xce5
2310 | 0xce6 | 0xce7 | 0xce8 | 0xce9 | 0xcea | 0xceb | 0xcec | 0xced | 0xcee | 0xcef
2311 | 0xcf0 | 0xcf1 | 0xcf2 | 0xcf3 | 0xcf4 | 0xcf5 | 0xcf6 | 0xcf7 | 0xcf8 | 0xcf9
2312 | 0xcfa | 0xcfb | 0xcfc | 0xcfd | 0xcfe | 0xcff => {
2313 #[cfg(feature = "arm")]
2314 if let Some(ins) = parse_arm_teq_0(ins, pc, options) {
2315 return ins;
2316 }
2317 }
2318 0x4cb | 0x4db | 0x4eb | 0x4fb => {
2319 #[cfg(feature = "arm")]
2320 if (ins & 0xe1000f0) == 0x1000b0
2321 && let Some(ins) = parse_arm_ldrh_0(ins, pc, options)
2322 {
2323 return ins;
2324 }
2325 #[cfg(feature = "arm")]
2326 if (ins & 0xdf00000) == 0x1300000
2327 && let Some(ins) = parse_arm_teq_0(ins, pc, options)
2328 {
2329 return ins;
2330 }
2331 }
2332 0x4cd | 0x4dd | 0x4ed | 0x4fd => {
2333 #[cfg(feature = "arm")]
2334 if (ins & 0xe1000f0) == 0x1000d0
2335 && let Some(ins) = parse_arm_ldrsb_0(ins, pc, options)
2336 {
2337 return ins;
2338 }
2339 #[cfg(feature = "arm")]
2340 if (ins & 0xdf00000) == 0x1300000
2341 && let Some(ins) = parse_arm_teq_0(ins, pc, options)
2342 {
2343 return ins;
2344 }
2345 }
2346 0x4cf | 0x4df | 0x4ef | 0x4ff => {
2347 #[cfg(feature = "arm")]
2348 if (ins & 0xe1000f0) == 0x1000f0
2349 && let Some(ins) = parse_arm_ldrsh_0(ins, pc, options)
2350 {
2351 return ins;
2352 }
2353 #[cfg(feature = "arm")]
2354 if (ins & 0xdf00000) == 0x1300000
2355 && let Some(ins) = parse_arm_teq_0(ins, pc, options)
2356 {
2357 return ins;
2358 }
2359 }
2360 0x500 | 0x510 | 0x520 | 0x530 => {
2361 #[cfg(feature = "arm")]
2362 if let Some(ins) = parse_arm_mrs_0(ins, pc, options) {
2363 return ins;
2364 }
2365 }
2366 0x505 | 0x515 | 0x525 | 0x535 => {
2367 #[cfg(
2368 all(
2369 feature = "arm",
2370 any(
2371 feature = "v5te",
2372 feature = "v5tej",
2373 feature = "v6",
2374 feature = "v6k"
2375 )
2376 )
2377 )]
2378 if let Some(ins) = parse_arm_qdadd_0(ins, pc, options) {
2379 return ins;
2380 }
2381 }
2382 0x508 | 0x50a | 0x50c | 0x50e | 0x518 | 0x51a | 0x51c | 0x51e | 0x528 | 0x52a
2383 | 0x52c | 0x52e | 0x538 | 0x53a | 0x53c | 0x53e => {
2384 #[cfg(
2385 all(
2386 feature = "arm",
2387 any(
2388 feature = "v5te",
2389 feature = "v5tej",
2390 feature = "v6",
2391 feature = "v6k"
2392 )
2393 )
2394 )]
2395 if let Some(ins) = parse_arm_smlal_half_0(ins, pc, options) {
2396 return ins;
2397 }
2398 }
2399 0x509 | 0x519 | 0x529 | 0x539 => {
2400 #[cfg(feature = "arm")]
2401 if let Some(ins) = parse_arm_swpb_0(ins, pc, options) {
2402 return ins;
2403 }
2404 }
2405 0x50d | 0x51d => {
2406 #[cfg(
2407 all(
2408 feature = "arm",
2409 any(
2410 feature = "v5te",
2411 feature = "v5tej",
2412 feature = "v6",
2413 feature = "v6k"
2414 )
2415 )
2416 )]
2417 if let Some(ins) = parse_arm_ldrd_0(ins, pc, options) {
2418 return ins;
2419 }
2420 }
2421 0x52d | 0x53d => {
2422 #[cfg(
2423 all(
2424 feature = "arm",
2425 any(
2426 feature = "v5te",
2427 feature = "v5tej",
2428 feature = "v6",
2429 feature = "v6k"
2430 )
2431 )
2432 )]
2433 if (ins & 0xe5f00f0) == 0x4f00d0
2434 && let Some(ins) = parse_arm_ldrd_1(ins, pc, options)
2435 {
2436 return ins;
2437 }
2438 #[cfg(
2439 all(
2440 feature = "arm",
2441 any(
2442 feature = "v5te",
2443 feature = "v5tej",
2444 feature = "v6",
2445 feature = "v6k"
2446 )
2447 )
2448 )]
2449 if (ins & 0xe1000f0) == 0xd0
2450 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
2451 {
2452 return ins;
2453 }
2454 }
2455 0x540 | 0x541 | 0x542 | 0x543 | 0x544 | 0x545 | 0x546 | 0x547 | 0x548 | 0x549
2456 | 0x54a | 0x54c | 0x54e | 0x550 | 0x551 | 0x552 | 0x553 | 0x554 | 0x555 | 0x556
2457 | 0x557 | 0x558 | 0x559 | 0x55a | 0x55c | 0x55e | 0x560 | 0x561 | 0x562 | 0x563
2458 | 0x564 | 0x565 | 0x566 | 0x567 | 0x568 | 0x569 | 0x56a | 0x56c | 0x56e | 0x570
2459 | 0x571 | 0x572 | 0x573 | 0x574 | 0x575 | 0x576 | 0x577 | 0x578 | 0x579 | 0x57a
2460 | 0x57c | 0x57e | 0xd40 | 0xd41 | 0xd42 | 0xd43 | 0xd44 | 0xd45 | 0xd46 | 0xd47
2461 | 0xd48 | 0xd49 | 0xd4a | 0xd4b | 0xd4c | 0xd4d | 0xd4e | 0xd4f | 0xd50 | 0xd51
2462 | 0xd52 | 0xd53 | 0xd54 | 0xd55 | 0xd56 | 0xd57 | 0xd58 | 0xd59 | 0xd5a | 0xd5b
2463 | 0xd5c | 0xd5d | 0xd5e | 0xd5f | 0xd60 | 0xd61 | 0xd62 | 0xd63 | 0xd64 | 0xd65
2464 | 0xd66 | 0xd67 | 0xd68 | 0xd69 | 0xd6a | 0xd6b | 0xd6c | 0xd6d | 0xd6e | 0xd6f
2465 | 0xd70 | 0xd71 | 0xd72 | 0xd73 | 0xd74 | 0xd75 | 0xd76 | 0xd77 | 0xd78 | 0xd79
2466 | 0xd7a | 0xd7b | 0xd7c | 0xd7d | 0xd7e | 0xd7f => {
2467 #[cfg(feature = "arm")]
2468 if let Some(ins) = parse_arm_cmp_0(ins, pc, options) {
2469 return ins;
2470 }
2471 }
2472 0x54b | 0x55b | 0x56b | 0x57b => {
2473 #[cfg(feature = "arm")]
2474 if (ins & 0xe1000f0) == 0x1000b0
2475 && let Some(ins) = parse_arm_ldrh_0(ins, pc, options)
2476 {
2477 return ins;
2478 }
2479 #[cfg(feature = "arm")]
2480 if (ins & 0xdf00000) == 0x1500000
2481 && let Some(ins) = parse_arm_cmp_0(ins, pc, options)
2482 {
2483 return ins;
2484 }
2485 }
2486 0x54d | 0x55d | 0x56d | 0x57d => {
2487 #[cfg(feature = "arm")]
2488 if (ins & 0xe1000f0) == 0x1000d0
2489 && let Some(ins) = parse_arm_ldrsb_0(ins, pc, options)
2490 {
2491 return ins;
2492 }
2493 #[cfg(feature = "arm")]
2494 if (ins & 0xdf00000) == 0x1500000
2495 && let Some(ins) = parse_arm_cmp_0(ins, pc, options)
2496 {
2497 return ins;
2498 }
2499 }
2500 0x54f | 0x55f | 0x56f | 0x57f => {
2501 #[cfg(feature = "arm")]
2502 if (ins & 0xe1000f0) == 0x1000f0
2503 && let Some(ins) = parse_arm_ldrsh_0(ins, pc, options)
2504 {
2505 return ins;
2506 }
2507 #[cfg(feature = "arm")]
2508 if (ins & 0xdf00000) == 0x1500000
2509 && let Some(ins) = parse_arm_cmp_0(ins, pc, options)
2510 {
2511 return ins;
2512 }
2513 }
2514 0x581 | 0x591 | 0x5a1 | 0x5b1 => {
2515 #[cfg(
2516 all(
2517 feature = "arm",
2518 any(
2519 feature = "v5t",
2520 feature = "v5te",
2521 feature = "v5tej",
2522 feature = "v6",
2523 feature = "v6k"
2524 )
2525 )
2526 )]
2527 if (ins & 0xff000f0) == 0x1600010
2528 && let Some(ins) = parse_arm_clz_0(ins, pc, options)
2529 {
2530 return ins;
2531 }
2532 #[cfg(feature = "arm")]
2533 if (ins & 0xdb00000) == 0x1200000
2534 && let Some(ins) = parse_arm_msr_0(ins, pc, options)
2535 {
2536 return ins;
2537 }
2538 }
2539 0x585 | 0x595 | 0x5a5 | 0x5b5 => {
2540 #[cfg(
2541 all(
2542 feature = "arm",
2543 any(
2544 feature = "v5te",
2545 feature = "v5tej",
2546 feature = "v6",
2547 feature = "v6k"
2548 )
2549 )
2550 )]
2551 if (ins & 0xff000f0) == 0x1600050
2552 && let Some(ins) = parse_arm_qdsub_0(ins, pc, options)
2553 {
2554 return ins;
2555 }
2556 #[cfg(feature = "arm")]
2557 if (ins & 0xdb00000) == 0x1200000
2558 && let Some(ins) = parse_arm_msr_0(ins, pc, options)
2559 {
2560 return ins;
2561 }
2562 }
2563 0x588 | 0x58a | 0x58c | 0x58e | 0x598 | 0x59a | 0x59c | 0x59e | 0x5a8 | 0x5aa
2564 | 0x5ac | 0x5ae | 0x5b8 | 0x5ba | 0x5bc | 0x5be => {
2565 #[cfg(
2566 all(
2567 feature = "arm",
2568 any(
2569 feature = "v5te",
2570 feature = "v5tej",
2571 feature = "v6",
2572 feature = "v6k"
2573 )
2574 )
2575 )]
2576 if (ins & 0xff00090) == 0x1600080
2577 && let Some(ins) = parse_arm_smul_0(ins, pc, options)
2578 {
2579 return ins;
2580 }
2581 #[cfg(feature = "arm")]
2582 if (ins & 0xdb00000) == 0x1200000
2583 && let Some(ins) = parse_arm_msr_0(ins, pc, options)
2584 {
2585 return ins;
2586 }
2587 }
2588 0x5ad | 0x5bd => {
2589 #[cfg(
2590 all(
2591 feature = "arm",
2592 any(
2593 feature = "v5te",
2594 feature = "v5tej",
2595 feature = "v6",
2596 feature = "v6k"
2597 )
2598 )
2599 )]
2600 if (ins & 0xe5f00f0) == 0x4f00d0
2601 && let Some(ins) = parse_arm_ldrd_1(ins, pc, options)
2602 {
2603 return ins;
2604 }
2605 #[cfg(
2606 all(
2607 feature = "arm",
2608 any(
2609 feature = "v5te",
2610 feature = "v5tej",
2611 feature = "v6",
2612 feature = "v6k"
2613 )
2614 )
2615 )]
2616 if (ins & 0xe1000f0) == 0xd0
2617 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
2618 {
2619 return ins;
2620 }
2621 #[cfg(feature = "arm")]
2622 if (ins & 0xdb00000) == 0x1200000
2623 && let Some(ins) = parse_arm_msr_0(ins, pc, options)
2624 {
2625 return ins;
2626 }
2627 }
2628 0x5c0 | 0x5c1 | 0x5c2 | 0x5c3 | 0x5c4 | 0x5c5 | 0x5c6 | 0x5c7 | 0x5c8 | 0x5c9
2629 | 0x5ca | 0x5cc | 0x5ce | 0x5d0 | 0x5d1 | 0x5d2 | 0x5d3 | 0x5d4 | 0x5d5 | 0x5d6
2630 | 0x5d7 | 0x5d8 | 0x5d9 | 0x5da | 0x5dc | 0x5de | 0x5e0 | 0x5e1 | 0x5e2 | 0x5e3
2631 | 0x5e4 | 0x5e5 | 0x5e6 | 0x5e7 | 0x5e8 | 0x5e9 | 0x5ea | 0x5ec | 0x5ee | 0x5f0
2632 | 0x5f1 | 0x5f2 | 0x5f3 | 0x5f4 | 0x5f5 | 0x5f6 | 0x5f7 | 0x5f8 | 0x5f9 | 0x5fa
2633 | 0x5fc | 0x5fe | 0xdc0 | 0xdc1 | 0xdc2 | 0xdc3 | 0xdc4 | 0xdc5 | 0xdc6 | 0xdc7
2634 | 0xdc8 | 0xdc9 | 0xdca | 0xdcb | 0xdcc | 0xdcd | 0xdce | 0xdcf | 0xdd0 | 0xdd1
2635 | 0xdd2 | 0xdd3 | 0xdd4 | 0xdd5 | 0xdd6 | 0xdd7 | 0xdd8 | 0xdd9 | 0xdda | 0xddb
2636 | 0xddc | 0xddd | 0xdde | 0xddf | 0xde0 | 0xde1 | 0xde2 | 0xde3 | 0xde4 | 0xde5
2637 | 0xde6 | 0xde7 | 0xde8 | 0xde9 | 0xdea | 0xdeb | 0xdec | 0xded | 0xdee | 0xdef
2638 | 0xdf0 | 0xdf1 | 0xdf2 | 0xdf3 | 0xdf4 | 0xdf5 | 0xdf6 | 0xdf7 | 0xdf8 | 0xdf9
2639 | 0xdfa | 0xdfb | 0xdfc | 0xdfd | 0xdfe | 0xdff => {
2640 #[cfg(feature = "arm")]
2641 if let Some(ins) = parse_arm_cmn_0(ins, pc, options) {
2642 return ins;
2643 }
2644 }
2645 0x5cb | 0x5db | 0x5eb | 0x5fb => {
2646 #[cfg(feature = "arm")]
2647 if (ins & 0xe1000f0) == 0x1000b0
2648 && let Some(ins) = parse_arm_ldrh_0(ins, pc, options)
2649 {
2650 return ins;
2651 }
2652 #[cfg(feature = "arm")]
2653 if (ins & 0xdf00000) == 0x1700000
2654 && let Some(ins) = parse_arm_cmn_0(ins, pc, options)
2655 {
2656 return ins;
2657 }
2658 }
2659 0x5cd | 0x5dd | 0x5ed | 0x5fd => {
2660 #[cfg(feature = "arm")]
2661 if (ins & 0xe1000f0) == 0x1000d0
2662 && let Some(ins) = parse_arm_ldrsb_0(ins, pc, options)
2663 {
2664 return ins;
2665 }
2666 #[cfg(feature = "arm")]
2667 if (ins & 0xdf00000) == 0x1700000
2668 && let Some(ins) = parse_arm_cmn_0(ins, pc, options)
2669 {
2670 return ins;
2671 }
2672 }
2673 0x5cf | 0x5df | 0x5ef | 0x5ff => {
2674 #[cfg(feature = "arm")]
2675 if (ins & 0xe1000f0) == 0x1000f0
2676 && let Some(ins) = parse_arm_ldrsh_0(ins, pc, options)
2677 {
2678 return ins;
2679 }
2680 #[cfg(feature = "arm")]
2681 if (ins & 0xdf00000) == 0x1700000
2682 && let Some(ins) = parse_arm_cmn_0(ins, pc, options)
2683 {
2684 return ins;
2685 }
2686 }
2687 0x600 | 0x601 | 0x602 | 0x603 | 0x604 | 0x605 | 0x606 | 0x607 | 0x608 | 0x60a
2688 | 0x60c | 0x60e | 0x610 | 0x611 | 0x612 | 0x613 | 0x614 | 0x615 | 0x616 | 0x617
2689 | 0x618 | 0x61a | 0x61c | 0x61e | 0x620 | 0x621 | 0x622 | 0x623 | 0x624 | 0x625
2690 | 0x626 | 0x627 | 0x628 | 0x62a | 0x62c | 0x62e | 0x630 | 0x631 | 0x632 | 0x633
2691 | 0x634 | 0x635 | 0x636 | 0x637 | 0x638 | 0x63a | 0x63c | 0x63e | 0x640 | 0x641
2692 | 0x642 | 0x643 | 0x644 | 0x645 | 0x646 | 0x647 | 0x648 | 0x64a | 0x64c | 0x64e
2693 | 0x650 | 0x651 | 0x652 | 0x653 | 0x654 | 0x655 | 0x656 | 0x657 | 0x658 | 0x65a
2694 | 0x65c | 0x65e | 0x660 | 0x661 | 0x662 | 0x663 | 0x664 | 0x665 | 0x666 | 0x667
2695 | 0x668 | 0x66a | 0x66c | 0x66e | 0x670 | 0x671 | 0x672 | 0x673 | 0x674 | 0x675
2696 | 0x676 | 0x677 | 0x678 | 0x67a | 0x67c | 0x67e | 0xe00 | 0xe01 | 0xe02 | 0xe03
2697 | 0xe04 | 0xe05 | 0xe06 | 0xe07 | 0xe08 | 0xe09 | 0xe0a | 0xe0b | 0xe0c | 0xe0d
2698 | 0xe0e | 0xe0f | 0xe10 | 0xe11 | 0xe12 | 0xe13 | 0xe14 | 0xe15 | 0xe16 | 0xe17
2699 | 0xe18 | 0xe19 | 0xe1a | 0xe1b | 0xe1c | 0xe1d | 0xe1e | 0xe1f | 0xe20 | 0xe21
2700 | 0xe22 | 0xe23 | 0xe24 | 0xe25 | 0xe26 | 0xe27 | 0xe28 | 0xe29 | 0xe2a | 0xe2b
2701 | 0xe2c | 0xe2d | 0xe2e | 0xe2f | 0xe30 | 0xe31 | 0xe32 | 0xe33 | 0xe34 | 0xe35
2702 | 0xe36 | 0xe37 | 0xe38 | 0xe39 | 0xe3a | 0xe3b | 0xe3c | 0xe3d | 0xe3e | 0xe3f
2703 | 0xe40 | 0xe41 | 0xe42 | 0xe43 | 0xe44 | 0xe45 | 0xe46 | 0xe47 | 0xe48 | 0xe49
2704 | 0xe4a | 0xe4b | 0xe4c | 0xe4d | 0xe4e | 0xe4f | 0xe50 | 0xe51 | 0xe52 | 0xe53
2705 | 0xe54 | 0xe55 | 0xe56 | 0xe57 | 0xe58 | 0xe59 | 0xe5a | 0xe5b | 0xe5c | 0xe5d
2706 | 0xe5e | 0xe5f | 0xe60 | 0xe61 | 0xe62 | 0xe63 | 0xe64 | 0xe65 | 0xe66 | 0xe67
2707 | 0xe68 | 0xe69 | 0xe6a | 0xe6b | 0xe6c | 0xe6d | 0xe6e | 0xe6f | 0xe70 | 0xe71
2708 | 0xe72 | 0xe73 | 0xe74 | 0xe75 | 0xe76 | 0xe77 | 0xe78 | 0xe79 | 0xe7a | 0xe7b
2709 | 0xe7c | 0xe7d | 0xe7e | 0xe7f => {
2710 #[cfg(feature = "arm")]
2711 if let Some(ins) = parse_arm_orr_0(ins, pc, options) {
2712 return ins;
2713 }
2714 }
2715 0x609 | 0x619 | 0x629 | 0x639 => {
2716 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
2717 if (ins & 0xff000f0) == 0x1800090
2718 && let Some(ins) = parse_arm_strex_0(ins, pc, options)
2719 {
2720 return ins;
2721 }
2722 #[cfg(feature = "arm")]
2723 if (ins & 0xde00000) == 0x1800000
2724 && let Some(ins) = parse_arm_orr_0(ins, pc, options)
2725 {
2726 return ins;
2727 }
2728 }
2729 0x60b | 0x61b | 0x62b | 0x63b => {
2730 #[cfg(feature = "arm")]
2731 if (ins & 0xe1000f0) == 0xb0
2732 && let Some(ins) = parse_arm_strh_0(ins, pc, options)
2733 {
2734 return ins;
2735 }
2736 #[cfg(feature = "arm")]
2737 if (ins & 0xde00000) == 0x1800000
2738 && let Some(ins) = parse_arm_orr_0(ins, pc, options)
2739 {
2740 return ins;
2741 }
2742 }
2743 0x60d | 0x61d | 0x62d | 0x63d => {
2744 #[cfg(
2745 all(
2746 feature = "arm",
2747 any(
2748 feature = "v5te",
2749 feature = "v5tej",
2750 feature = "v6",
2751 feature = "v6k"
2752 )
2753 )
2754 )]
2755 if (ins & 0xe1000f0) == 0xd0
2756 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
2757 {
2758 return ins;
2759 }
2760 #[cfg(feature = "arm")]
2761 if (ins & 0xde00000) == 0x1800000
2762 && let Some(ins) = parse_arm_orr_0(ins, pc, options)
2763 {
2764 return ins;
2765 }
2766 }
2767 0x60f | 0x61f | 0x62f | 0x63f => {
2768 #[cfg(
2769 all(
2770 feature = "arm",
2771 any(
2772 feature = "v5te",
2773 feature = "v5tej",
2774 feature = "v6",
2775 feature = "v6k"
2776 )
2777 )
2778 )]
2779 if (ins & 0xe1000f0) == 0xf0
2780 && let Some(ins) = parse_arm_strd_0(ins, pc, options)
2781 {
2782 return ins;
2783 }
2784 #[cfg(feature = "arm")]
2785 if (ins & 0xde00000) == 0x1800000
2786 && let Some(ins) = parse_arm_orr_0(ins, pc, options)
2787 {
2788 return ins;
2789 }
2790 }
2791 0x649 | 0x659 | 0x669 | 0x679 => {
2792 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
2793 if (ins & 0xff000f0) == 0x1900090
2794 && let Some(ins) = parse_arm_ldrex_0(ins, pc, options)
2795 {
2796 return ins;
2797 }
2798 #[cfg(feature = "arm")]
2799 if (ins & 0xde00000) == 0x1800000
2800 && let Some(ins) = parse_arm_orr_0(ins, pc, options)
2801 {
2802 return ins;
2803 }
2804 }
2805 0x64b | 0x65b | 0x66b | 0x67b => {
2806 #[cfg(feature = "arm")]
2807 if (ins & 0xe1000f0) == 0x1000b0
2808 && let Some(ins) = parse_arm_ldrh_0(ins, pc, options)
2809 {
2810 return ins;
2811 }
2812 #[cfg(feature = "arm")]
2813 if (ins & 0xde00000) == 0x1800000
2814 && let Some(ins) = parse_arm_orr_0(ins, pc, options)
2815 {
2816 return ins;
2817 }
2818 }
2819 0x64d | 0x65d | 0x66d | 0x67d => {
2820 #[cfg(feature = "arm")]
2821 if (ins & 0xe1000f0) == 0x1000d0
2822 && let Some(ins) = parse_arm_ldrsb_0(ins, pc, options)
2823 {
2824 return ins;
2825 }
2826 #[cfg(feature = "arm")]
2827 if (ins & 0xde00000) == 0x1800000
2828 && let Some(ins) = parse_arm_orr_0(ins, pc, options)
2829 {
2830 return ins;
2831 }
2832 }
2833 0x64f | 0x65f | 0x66f | 0x67f => {
2834 #[cfg(feature = "arm")]
2835 if (ins & 0xe1000f0) == 0x1000f0
2836 && let Some(ins) = parse_arm_ldrsh_0(ins, pc, options)
2837 {
2838 return ins;
2839 }
2840 #[cfg(feature = "arm")]
2841 if (ins & 0xde00000) == 0x1800000
2842 && let Some(ins) = parse_arm_orr_0(ins, pc, options)
2843 {
2844 return ins;
2845 }
2846 }
2847 0x680 | 0x6c0 => {
2848 #[cfg(feature = "arm")]
2849 if (ins & 0xfe00ff0) == 0x1a00000
2850 && let Some(ins) = parse_arm_mov_1(ins, pc, options)
2851 {
2852 return ins;
2853 }
2854 #[cfg(feature = "arm")]
2855 if (ins & 0xfef0060) == 0x1a00000
2856 && let Some(ins) = parse_arm_lsl_0(ins, pc, options)
2857 {
2858 return ins;
2859 }
2860 #[cfg(feature = "arm")]
2861 if (ins & 0xde00000) == 0x1a00000
2862 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
2863 {
2864 return ins;
2865 }
2866 }
2867 0x681 | 0x688 | 0x690 | 0x691 | 0x698 | 0x6c1 | 0x6c8 | 0x6d0 | 0x6d1
2868 | 0x6d8 => {
2869 #[cfg(feature = "arm")]
2870 if (ins & 0xfef0060) == 0x1a00000
2871 && let Some(ins) = parse_arm_lsl_0(ins, pc, options)
2872 {
2873 return ins;
2874 }
2875 #[cfg(feature = "arm")]
2876 if (ins & 0xde00000) == 0x1a00000
2877 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
2878 {
2879 return ins;
2880 }
2881 }
2882 0x682 | 0x683 | 0x68a | 0x692 | 0x693 | 0x69a | 0x6c2 | 0x6c3 | 0x6ca | 0x6d2
2883 | 0x6d3 | 0x6da => {
2884 #[cfg(feature = "arm")]
2885 if (ins & 0xfef0060) == 0x1a00020
2886 && let Some(ins) = parse_arm_lsr_0(ins, pc, options)
2887 {
2888 return ins;
2889 }
2890 #[cfg(feature = "arm")]
2891 if (ins & 0xde00000) == 0x1a00000
2892 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
2893 {
2894 return ins;
2895 }
2896 }
2897 0x684 | 0x685 | 0x68c | 0x694 | 0x695 | 0x69c | 0x6c4 | 0x6c5 | 0x6cc | 0x6d4
2898 | 0x6d5 | 0x6dc => {
2899 #[cfg(feature = "arm")]
2900 if (ins & 0xfef0060) == 0x1a00040
2901 && let Some(ins) = parse_arm_asr_0(ins, pc, options)
2902 {
2903 return ins;
2904 }
2905 #[cfg(feature = "arm")]
2906 if (ins & 0xde00000) == 0x1a00000
2907 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
2908 {
2909 return ins;
2910 }
2911 }
2912 0x686 | 0x6c6 => {
2913 #[cfg(feature = "arm")]
2914 if (ins & 0xfe00ff0) == 0x1a00060
2915 && let Some(ins) = parse_arm_rrx_0(ins, pc, options)
2916 {
2917 return ins;
2918 }
2919 #[cfg(feature = "arm")]
2920 if (ins & 0xfef0060) == 0x1a00060
2921 && let Some(ins) = parse_arm_ror_0(ins, pc, options)
2922 {
2923 return ins;
2924 }
2925 #[cfg(feature = "arm")]
2926 if (ins & 0xde00000) == 0x1a00000
2927 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
2928 {
2929 return ins;
2930 }
2931 }
2932 0x687 | 0x68e | 0x696 | 0x697 | 0x69e | 0x6c7 | 0x6ce | 0x6d6 | 0x6d7
2933 | 0x6de => {
2934 #[cfg(feature = "arm")]
2935 if (ins & 0xfef0060) == 0x1a00060
2936 && let Some(ins) = parse_arm_ror_0(ins, pc, options)
2937 {
2938 return ins;
2939 }
2940 #[cfg(feature = "arm")]
2941 if (ins & 0xde00000) == 0x1a00000
2942 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
2943 {
2944 return ins;
2945 }
2946 }
2947 0x689 | 0x699 => {
2948 #[cfg(feature = "arm")]
2949 if (ins & 0xfef0060) == 0x1a00000
2950 && let Some(ins) = parse_arm_lsl_0(ins, pc, options)
2951 {
2952 return ins;
2953 }
2954 #[cfg(all(feature = "arm", feature = "v6k"))]
2955 if (ins & 0xff000f0) == 0x1a00090
2956 && let Some(ins) = parse_arm_strexd_0(ins, pc, options)
2957 {
2958 return ins;
2959 }
2960 #[cfg(feature = "arm")]
2961 if (ins & 0xde00000) == 0x1a00000
2962 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
2963 {
2964 return ins;
2965 }
2966 }
2967 0x68b | 0x69b => {
2968 #[cfg(feature = "arm")]
2969 if (ins & 0xfef0060) == 0x1a00020
2970 && let Some(ins) = parse_arm_lsr_0(ins, pc, options)
2971 {
2972 return ins;
2973 }
2974 #[cfg(feature = "arm")]
2975 if (ins & 0xe1000f0) == 0xb0
2976 && let Some(ins) = parse_arm_strh_0(ins, pc, options)
2977 {
2978 return ins;
2979 }
2980 #[cfg(feature = "arm")]
2981 if (ins & 0xde00000) == 0x1a00000
2982 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
2983 {
2984 return ins;
2985 }
2986 }
2987 0x68d | 0x69d => {
2988 #[cfg(feature = "arm")]
2989 if (ins & 0xfef0060) == 0x1a00040
2990 && let Some(ins) = parse_arm_asr_0(ins, pc, options)
2991 {
2992 return ins;
2993 }
2994 #[cfg(
2995 all(
2996 feature = "arm",
2997 any(
2998 feature = "v5te",
2999 feature = "v5tej",
3000 feature = "v6",
3001 feature = "v6k"
3002 )
3003 )
3004 )]
3005 if (ins & 0xe1000f0) == 0xd0
3006 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
3007 {
3008 return ins;
3009 }
3010 #[cfg(feature = "arm")]
3011 if (ins & 0xde00000) == 0x1a00000
3012 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
3013 {
3014 return ins;
3015 }
3016 }
3017 0x68f | 0x69f => {
3018 #[cfg(feature = "arm")]
3019 if (ins & 0xfef0060) == 0x1a00060
3020 && let Some(ins) = parse_arm_ror_0(ins, pc, options)
3021 {
3022 return ins;
3023 }
3024 #[cfg(
3025 all(
3026 feature = "arm",
3027 any(
3028 feature = "v5te",
3029 feature = "v5tej",
3030 feature = "v6",
3031 feature = "v6k"
3032 )
3033 )
3034 )]
3035 if (ins & 0xe1000f0) == 0xf0
3036 && let Some(ins) = parse_arm_strd_0(ins, pc, options)
3037 {
3038 return ins;
3039 }
3040 #[cfg(feature = "arm")]
3041 if (ins & 0xde00000) == 0x1a00000
3042 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
3043 {
3044 return ins;
3045 }
3046 }
3047 0x6a0 | 0x6e0 => {
3048 #[cfg(feature = "arm")]
3049 if (ins & 0xfe00ff0) == 0x1a00000
3050 && let Some(ins) = parse_arm_mov_1(ins, pc, options)
3051 {
3052 return ins;
3053 }
3054 #[cfg(feature = "arm")]
3055 if (ins & 0xde00000) == 0x1a00000
3056 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
3057 {
3058 return ins;
3059 }
3060 }
3061 0x6a1 | 0x6a2 | 0x6a3 | 0x6a4 | 0x6a5 | 0x6a7 | 0x6a8 | 0x6aa | 0x6ac | 0x6ae
3062 | 0x6b0 | 0x6b1 | 0x6b2 | 0x6b3 | 0x6b4 | 0x6b5 | 0x6b6 | 0x6b7 | 0x6b8 | 0x6ba
3063 | 0x6bc | 0x6be | 0x6e1 | 0x6e2 | 0x6e3 | 0x6e4 | 0x6e5 | 0x6e7 | 0x6e8 | 0x6ea
3064 | 0x6ec | 0x6ee | 0x6f0 | 0x6f1 | 0x6f2 | 0x6f3 | 0x6f4 | 0x6f5 | 0x6f6 | 0x6f7
3065 | 0x6f8 | 0x6fa | 0x6fc | 0x6fe => {
3066 #[cfg(feature = "arm")]
3067 if let Some(ins) = parse_arm_mov_2(ins, pc, options) {
3068 return ins;
3069 }
3070 }
3071 0x6a6 | 0x6e6 => {
3072 #[cfg(feature = "arm")]
3073 if (ins & 0xfe00ff0) == 0x1a00060
3074 && let Some(ins) = parse_arm_rrx_0(ins, pc, options)
3075 {
3076 return ins;
3077 }
3078 #[cfg(feature = "arm")]
3079 if (ins & 0xde00000) == 0x1a00000
3080 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
3081 {
3082 return ins;
3083 }
3084 }
3085 0x6a9 | 0x6b9 => {
3086 #[cfg(all(feature = "arm", feature = "v6k"))]
3087 if (ins & 0xff000f0) == 0x1a00090
3088 && let Some(ins) = parse_arm_strexd_0(ins, pc, options)
3089 {
3090 return ins;
3091 }
3092 #[cfg(feature = "arm")]
3093 if (ins & 0xde00000) == 0x1a00000
3094 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
3095 {
3096 return ins;
3097 }
3098 }
3099 0x6ab | 0x6bb => {
3100 #[cfg(feature = "arm")]
3101 if (ins & 0xe1000f0) == 0xb0
3102 && let Some(ins) = parse_arm_strh_0(ins, pc, options)
3103 {
3104 return ins;
3105 }
3106 #[cfg(feature = "arm")]
3107 if (ins & 0xde00000) == 0x1a00000
3108 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
3109 {
3110 return ins;
3111 }
3112 }
3113 0x6ad | 0x6bd => {
3114 #[cfg(
3115 all(
3116 feature = "arm",
3117 any(
3118 feature = "v5te",
3119 feature = "v5tej",
3120 feature = "v6",
3121 feature = "v6k"
3122 )
3123 )
3124 )]
3125 if (ins & 0xe1000f0) == 0xd0
3126 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
3127 {
3128 return ins;
3129 }
3130 #[cfg(feature = "arm")]
3131 if (ins & 0xde00000) == 0x1a00000
3132 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
3133 {
3134 return ins;
3135 }
3136 }
3137 0x6af | 0x6bf => {
3138 #[cfg(
3139 all(
3140 feature = "arm",
3141 any(
3142 feature = "v5te",
3143 feature = "v5tej",
3144 feature = "v6",
3145 feature = "v6k"
3146 )
3147 )
3148 )]
3149 if (ins & 0xe1000f0) == 0xf0
3150 && let Some(ins) = parse_arm_strd_0(ins, pc, options)
3151 {
3152 return ins;
3153 }
3154 #[cfg(feature = "arm")]
3155 if (ins & 0xde00000) == 0x1a00000
3156 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
3157 {
3158 return ins;
3159 }
3160 }
3161 0x6c9 | 0x6d9 => {
3162 #[cfg(feature = "arm")]
3163 if (ins & 0xfef0060) == 0x1a00000
3164 && let Some(ins) = parse_arm_lsl_0(ins, pc, options)
3165 {
3166 return ins;
3167 }
3168 #[cfg(all(feature = "arm", feature = "v6k"))]
3169 if (ins & 0xff000f0) == 0x1b00090
3170 && let Some(ins) = parse_arm_ldrexd_0(ins, pc, options)
3171 {
3172 return ins;
3173 }
3174 #[cfg(feature = "arm")]
3175 if (ins & 0xde00000) == 0x1a00000
3176 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
3177 {
3178 return ins;
3179 }
3180 }
3181 0x6cb | 0x6db => {
3182 #[cfg(feature = "arm")]
3183 if (ins & 0xfef0060) == 0x1a00020
3184 && let Some(ins) = parse_arm_lsr_0(ins, pc, options)
3185 {
3186 return ins;
3187 }
3188 #[cfg(feature = "arm")]
3189 if (ins & 0xe1000f0) == 0x1000b0
3190 && let Some(ins) = parse_arm_ldrh_0(ins, pc, options)
3191 {
3192 return ins;
3193 }
3194 #[cfg(feature = "arm")]
3195 if (ins & 0xde00000) == 0x1a00000
3196 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
3197 {
3198 return ins;
3199 }
3200 }
3201 0x6cd | 0x6dd => {
3202 #[cfg(feature = "arm")]
3203 if (ins & 0xfef0060) == 0x1a00040
3204 && let Some(ins) = parse_arm_asr_0(ins, pc, options)
3205 {
3206 return ins;
3207 }
3208 #[cfg(feature = "arm")]
3209 if (ins & 0xe1000f0) == 0x1000d0
3210 && let Some(ins) = parse_arm_ldrsb_0(ins, pc, options)
3211 {
3212 return ins;
3213 }
3214 #[cfg(feature = "arm")]
3215 if (ins & 0xde00000) == 0x1a00000
3216 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
3217 {
3218 return ins;
3219 }
3220 }
3221 0x6cf | 0x6df => {
3222 #[cfg(feature = "arm")]
3223 if (ins & 0xfef0060) == 0x1a00060
3224 && let Some(ins) = parse_arm_ror_0(ins, pc, options)
3225 {
3226 return ins;
3227 }
3228 #[cfg(feature = "arm")]
3229 if (ins & 0xe1000f0) == 0x1000f0
3230 && let Some(ins) = parse_arm_ldrsh_0(ins, pc, options)
3231 {
3232 return ins;
3233 }
3234 #[cfg(feature = "arm")]
3235 if (ins & 0xde00000) == 0x1a00000
3236 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
3237 {
3238 return ins;
3239 }
3240 }
3241 0x6e9 | 0x6f9 => {
3242 #[cfg(all(feature = "arm", feature = "v6k"))]
3243 if (ins & 0xff000f0) == 0x1b00090
3244 && let Some(ins) = parse_arm_ldrexd_0(ins, pc, options)
3245 {
3246 return ins;
3247 }
3248 #[cfg(feature = "arm")]
3249 if (ins & 0xde00000) == 0x1a00000
3250 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
3251 {
3252 return ins;
3253 }
3254 }
3255 0x6eb | 0x6fb => {
3256 #[cfg(feature = "arm")]
3257 if (ins & 0xe1000f0) == 0x1000b0
3258 && let Some(ins) = parse_arm_ldrh_0(ins, pc, options)
3259 {
3260 return ins;
3261 }
3262 #[cfg(feature = "arm")]
3263 if (ins & 0xde00000) == 0x1a00000
3264 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
3265 {
3266 return ins;
3267 }
3268 }
3269 0x6ed | 0x6fd => {
3270 #[cfg(feature = "arm")]
3271 if (ins & 0xe1000f0) == 0x1000d0
3272 && let Some(ins) = parse_arm_ldrsb_0(ins, pc, options)
3273 {
3274 return ins;
3275 }
3276 #[cfg(feature = "arm")]
3277 if (ins & 0xde00000) == 0x1a00000
3278 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
3279 {
3280 return ins;
3281 }
3282 }
3283 0x6ef | 0x6ff => {
3284 #[cfg(feature = "arm")]
3285 if (ins & 0xe1000f0) == 0x1000f0
3286 && let Some(ins) = parse_arm_ldrsh_0(ins, pc, options)
3287 {
3288 return ins;
3289 }
3290 #[cfg(feature = "arm")]
3291 if (ins & 0xde00000) == 0x1a00000
3292 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
3293 {
3294 return ins;
3295 }
3296 }
3297 0x700 | 0x701 | 0x702 | 0x703 | 0x704 | 0x705 | 0x706 | 0x707 | 0x708 | 0x70a
3298 | 0x70c | 0x70e | 0x710 | 0x711 | 0x712 | 0x713 | 0x714 | 0x715 | 0x716 | 0x717
3299 | 0x718 | 0x71a | 0x71c | 0x71e | 0x720 | 0x721 | 0x722 | 0x723 | 0x724 | 0x725
3300 | 0x726 | 0x727 | 0x728 | 0x72a | 0x72c | 0x72e | 0x730 | 0x731 | 0x732 | 0x733
3301 | 0x734 | 0x735 | 0x736 | 0x737 | 0x738 | 0x73a | 0x73c | 0x73e | 0x740 | 0x741
3302 | 0x742 | 0x743 | 0x744 | 0x745 | 0x746 | 0x747 | 0x748 | 0x74a | 0x74c | 0x74e
3303 | 0x750 | 0x751 | 0x752 | 0x753 | 0x754 | 0x755 | 0x756 | 0x757 | 0x758 | 0x75a
3304 | 0x75c | 0x75e | 0x760 | 0x761 | 0x762 | 0x763 | 0x764 | 0x765 | 0x766 | 0x767
3305 | 0x768 | 0x76a | 0x76c | 0x76e | 0x770 | 0x771 | 0x772 | 0x773 | 0x774 | 0x775
3306 | 0x776 | 0x777 | 0x778 | 0x77a | 0x77c | 0x77e | 0xf00 | 0xf01 | 0xf02 | 0xf03
3307 | 0xf04 | 0xf05 | 0xf06 | 0xf07 | 0xf08 | 0xf09 | 0xf0a | 0xf0b | 0xf0c | 0xf0d
3308 | 0xf0e | 0xf0f | 0xf10 | 0xf11 | 0xf12 | 0xf13 | 0xf14 | 0xf15 | 0xf16 | 0xf17
3309 | 0xf18 | 0xf19 | 0xf1a | 0xf1b | 0xf1c | 0xf1d | 0xf1e | 0xf1f | 0xf20 | 0xf21
3310 | 0xf22 | 0xf23 | 0xf24 | 0xf25 | 0xf26 | 0xf27 | 0xf28 | 0xf29 | 0xf2a | 0xf2b
3311 | 0xf2c | 0xf2d | 0xf2e | 0xf2f | 0xf30 | 0xf31 | 0xf32 | 0xf33 | 0xf34 | 0xf35
3312 | 0xf36 | 0xf37 | 0xf38 | 0xf39 | 0xf3a | 0xf3b | 0xf3c | 0xf3d | 0xf3e | 0xf3f
3313 | 0xf40 | 0xf41 | 0xf42 | 0xf43 | 0xf44 | 0xf45 | 0xf46 | 0xf47 | 0xf48 | 0xf49
3314 | 0xf4a | 0xf4b | 0xf4c | 0xf4d | 0xf4e | 0xf4f | 0xf50 | 0xf51 | 0xf52 | 0xf53
3315 | 0xf54 | 0xf55 | 0xf56 | 0xf57 | 0xf58 | 0xf59 | 0xf5a | 0xf5b | 0xf5c | 0xf5d
3316 | 0xf5e | 0xf5f | 0xf60 | 0xf61 | 0xf62 | 0xf63 | 0xf64 | 0xf65 | 0xf66 | 0xf67
3317 | 0xf68 | 0xf69 | 0xf6a | 0xf6b | 0xf6c | 0xf6d | 0xf6e | 0xf6f | 0xf70 | 0xf71
3318 | 0xf72 | 0xf73 | 0xf74 | 0xf75 | 0xf76 | 0xf77 | 0xf78 | 0xf79 | 0xf7a | 0xf7b
3319 | 0xf7c | 0xf7d | 0xf7e | 0xf7f => {
3320 #[cfg(feature = "arm")]
3321 if let Some(ins) = parse_arm_bic_0(ins, pc, options) {
3322 return ins;
3323 }
3324 }
3325 0x709 | 0x719 | 0x729 | 0x739 => {
3326 #[cfg(all(feature = "arm", feature = "v6k"))]
3327 if (ins & 0xff000f0) == 0x1c00090
3328 && let Some(ins) = parse_arm_strexb_0(ins, pc, options)
3329 {
3330 return ins;
3331 }
3332 #[cfg(feature = "arm")]
3333 if (ins & 0xde00000) == 0x1c00000
3334 && let Some(ins) = parse_arm_bic_0(ins, pc, options)
3335 {
3336 return ins;
3337 }
3338 }
3339 0x70b | 0x71b | 0x72b | 0x73b => {
3340 #[cfg(feature = "arm")]
3341 if (ins & 0xe1000f0) == 0xb0
3342 && let Some(ins) = parse_arm_strh_0(ins, pc, options)
3343 {
3344 return ins;
3345 }
3346 #[cfg(feature = "arm")]
3347 if (ins & 0xde00000) == 0x1c00000
3348 && let Some(ins) = parse_arm_bic_0(ins, pc, options)
3349 {
3350 return ins;
3351 }
3352 }
3353 0x70d | 0x71d => {
3354 #[cfg(
3355 all(
3356 feature = "arm",
3357 any(
3358 feature = "v5te",
3359 feature = "v5tej",
3360 feature = "v6",
3361 feature = "v6k"
3362 )
3363 )
3364 )]
3365 if (ins & 0xe1000f0) == 0xd0
3366 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
3367 {
3368 return ins;
3369 }
3370 #[cfg(feature = "arm")]
3371 if (ins & 0xde00000) == 0x1c00000
3372 && let Some(ins) = parse_arm_bic_0(ins, pc, options)
3373 {
3374 return ins;
3375 }
3376 }
3377 0x70f | 0x71f | 0x72f | 0x73f => {
3378 #[cfg(
3379 all(
3380 feature = "arm",
3381 any(
3382 feature = "v5te",
3383 feature = "v5tej",
3384 feature = "v6",
3385 feature = "v6k"
3386 )
3387 )
3388 )]
3389 if (ins & 0xe1000f0) == 0xf0
3390 && let Some(ins) = parse_arm_strd_0(ins, pc, options)
3391 {
3392 return ins;
3393 }
3394 #[cfg(feature = "arm")]
3395 if (ins & 0xde00000) == 0x1c00000
3396 && let Some(ins) = parse_arm_bic_0(ins, pc, options)
3397 {
3398 return ins;
3399 }
3400 }
3401 0x72d | 0x73d => {
3402 #[cfg(
3403 all(
3404 feature = "arm",
3405 any(
3406 feature = "v5te",
3407 feature = "v5tej",
3408 feature = "v6",
3409 feature = "v6k"
3410 )
3411 )
3412 )]
3413 if (ins & 0xe5f00f0) == 0x4f00d0
3414 && let Some(ins) = parse_arm_ldrd_1(ins, pc, options)
3415 {
3416 return ins;
3417 }
3418 #[cfg(
3419 all(
3420 feature = "arm",
3421 any(
3422 feature = "v5te",
3423 feature = "v5tej",
3424 feature = "v6",
3425 feature = "v6k"
3426 )
3427 )
3428 )]
3429 if (ins & 0xe1000f0) == 0xd0
3430 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
3431 {
3432 return ins;
3433 }
3434 #[cfg(feature = "arm")]
3435 if (ins & 0xde00000) == 0x1c00000
3436 && let Some(ins) = parse_arm_bic_0(ins, pc, options)
3437 {
3438 return ins;
3439 }
3440 }
3441 0x749 | 0x759 | 0x769 | 0x779 => {
3442 #[cfg(all(feature = "arm", feature = "v6k"))]
3443 if (ins & 0xff000f0) == 0x1d00090
3444 && let Some(ins) = parse_arm_ldrexb_0(ins, pc, options)
3445 {
3446 return ins;
3447 }
3448 #[cfg(feature = "arm")]
3449 if (ins & 0xde00000) == 0x1c00000
3450 && let Some(ins) = parse_arm_bic_0(ins, pc, options)
3451 {
3452 return ins;
3453 }
3454 }
3455 0x74b | 0x75b | 0x76b | 0x77b => {
3456 #[cfg(feature = "arm")]
3457 if (ins & 0xe1000f0) == 0x1000b0
3458 && let Some(ins) = parse_arm_ldrh_0(ins, pc, options)
3459 {
3460 return ins;
3461 }
3462 #[cfg(feature = "arm")]
3463 if (ins & 0xde00000) == 0x1c00000
3464 && let Some(ins) = parse_arm_bic_0(ins, pc, options)
3465 {
3466 return ins;
3467 }
3468 }
3469 0x74d | 0x75d | 0x76d | 0x77d => {
3470 #[cfg(feature = "arm")]
3471 if (ins & 0xe1000f0) == 0x1000d0
3472 && let Some(ins) = parse_arm_ldrsb_0(ins, pc, options)
3473 {
3474 return ins;
3475 }
3476 #[cfg(feature = "arm")]
3477 if (ins & 0xde00000) == 0x1c00000
3478 && let Some(ins) = parse_arm_bic_0(ins, pc, options)
3479 {
3480 return ins;
3481 }
3482 }
3483 0x74f | 0x75f | 0x76f | 0x77f => {
3484 #[cfg(feature = "arm")]
3485 if (ins & 0xe1000f0) == 0x1000f0
3486 && let Some(ins) = parse_arm_ldrsh_0(ins, pc, options)
3487 {
3488 return ins;
3489 }
3490 #[cfg(feature = "arm")]
3491 if (ins & 0xde00000) == 0x1c00000
3492 && let Some(ins) = parse_arm_bic_0(ins, pc, options)
3493 {
3494 return ins;
3495 }
3496 }
3497 0x780 | 0x781 | 0x782 | 0x783 | 0x784 | 0x785 | 0x786 | 0x787 | 0x788 | 0x78a
3498 | 0x78c | 0x78e | 0x790 | 0x791 | 0x792 | 0x793 | 0x794 | 0x795 | 0x796 | 0x797
3499 | 0x798 | 0x79a | 0x79c | 0x79e | 0x7a0 | 0x7a1 | 0x7a2 | 0x7a3 | 0x7a4 | 0x7a5
3500 | 0x7a6 | 0x7a7 | 0x7a8 | 0x7aa | 0x7ac | 0x7ae | 0x7b0 | 0x7b1 | 0x7b2 | 0x7b3
3501 | 0x7b4 | 0x7b5 | 0x7b6 | 0x7b7 | 0x7b8 | 0x7ba | 0x7bc | 0x7be | 0x7c0 | 0x7c1
3502 | 0x7c2 | 0x7c3 | 0x7c4 | 0x7c5 | 0x7c6 | 0x7c7 | 0x7c8 | 0x7ca | 0x7cc | 0x7ce
3503 | 0x7d0 | 0x7d1 | 0x7d2 | 0x7d3 | 0x7d4 | 0x7d5 | 0x7d6 | 0x7d7 | 0x7d8 | 0x7da
3504 | 0x7dc | 0x7de | 0x7e0 | 0x7e1 | 0x7e2 | 0x7e3 | 0x7e4 | 0x7e5 | 0x7e6 | 0x7e7
3505 | 0x7e8 | 0x7ea | 0x7ec | 0x7ee | 0x7f0 | 0x7f1 | 0x7f2 | 0x7f3 | 0x7f4 | 0x7f5
3506 | 0x7f6 | 0x7f7 | 0x7f8 | 0x7fa | 0x7fc | 0x7fe | 0xf80 | 0xf81 | 0xf82 | 0xf83
3507 | 0xf84 | 0xf85 | 0xf86 | 0xf87 | 0xf88 | 0xf89 | 0xf8a | 0xf8b | 0xf8c | 0xf8d
3508 | 0xf8e | 0xf8f | 0xf90 | 0xf91 | 0xf92 | 0xf93 | 0xf94 | 0xf95 | 0xf96 | 0xf97
3509 | 0xf98 | 0xf99 | 0xf9a | 0xf9b | 0xf9c | 0xf9d | 0xf9e | 0xf9f | 0xfa0 | 0xfa1
3510 | 0xfa2 | 0xfa3 | 0xfa4 | 0xfa5 | 0xfa6 | 0xfa7 | 0xfa8 | 0xfa9 | 0xfaa | 0xfab
3511 | 0xfac | 0xfad | 0xfae | 0xfaf | 0xfb0 | 0xfb1 | 0xfb2 | 0xfb3 | 0xfb4 | 0xfb5
3512 | 0xfb6 | 0xfb7 | 0xfb8 | 0xfb9 | 0xfba | 0xfbb | 0xfbc | 0xfbd | 0xfbe | 0xfbf
3513 | 0xfc0 | 0xfc1 | 0xfc2 | 0xfc3 | 0xfc4 | 0xfc5 | 0xfc6 | 0xfc7 | 0xfc8 | 0xfc9
3514 | 0xfca | 0xfcb | 0xfcc | 0xfcd | 0xfce | 0xfcf | 0xfd0 | 0xfd1 | 0xfd2 | 0xfd3
3515 | 0xfd4 | 0xfd5 | 0xfd6 | 0xfd7 | 0xfd8 | 0xfd9 | 0xfda | 0xfdb | 0xfdc | 0xfdd
3516 | 0xfde | 0xfdf | 0xfe0 | 0xfe1 | 0xfe2 | 0xfe3 | 0xfe4 | 0xfe5 | 0xfe6 | 0xfe7
3517 | 0xfe8 | 0xfe9 | 0xfea | 0xfeb | 0xfec | 0xfed | 0xfee | 0xfef | 0xff0 | 0xff1
3518 | 0xff2 | 0xff3 | 0xff4 | 0xff5 | 0xff6 | 0xff7 | 0xff8 | 0xff9 | 0xffa | 0xffb
3519 | 0xffc | 0xffd | 0xffe | 0xfff => {
3520 #[cfg(feature = "arm")]
3521 if let Some(ins) = parse_arm_mvn_0(ins, pc, options) {
3522 return ins;
3523 }
3524 }
3525 0x789 | 0x799 | 0x7a9 | 0x7b9 => {
3526 #[cfg(all(feature = "arm", feature = "v6k"))]
3527 if (ins & 0xff000f0) == 0x1e00090
3528 && let Some(ins) = parse_arm_strexh_0(ins, pc, options)
3529 {
3530 return ins;
3531 }
3532 #[cfg(feature = "arm")]
3533 if (ins & 0xde00000) == 0x1e00000
3534 && let Some(ins) = parse_arm_mvn_0(ins, pc, options)
3535 {
3536 return ins;
3537 }
3538 }
3539 0x78b | 0x79b | 0x7ab | 0x7bb => {
3540 #[cfg(feature = "arm")]
3541 if (ins & 0xe1000f0) == 0xb0
3542 && let Some(ins) = parse_arm_strh_0(ins, pc, options)
3543 {
3544 return ins;
3545 }
3546 #[cfg(feature = "arm")]
3547 if (ins & 0xde00000) == 0x1e00000
3548 && let Some(ins) = parse_arm_mvn_0(ins, pc, options)
3549 {
3550 return ins;
3551 }
3552 }
3553 0x78d | 0x79d => {
3554 #[cfg(
3555 all(
3556 feature = "arm",
3557 any(
3558 feature = "v5te",
3559 feature = "v5tej",
3560 feature = "v6",
3561 feature = "v6k"
3562 )
3563 )
3564 )]
3565 if (ins & 0xe1000f0) == 0xd0
3566 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
3567 {
3568 return ins;
3569 }
3570 #[cfg(feature = "arm")]
3571 if (ins & 0xde00000) == 0x1e00000
3572 && let Some(ins) = parse_arm_mvn_0(ins, pc, options)
3573 {
3574 return ins;
3575 }
3576 }
3577 0x78f | 0x79f | 0x7af | 0x7bf => {
3578 #[cfg(
3579 all(
3580 feature = "arm",
3581 any(
3582 feature = "v5te",
3583 feature = "v5tej",
3584 feature = "v6",
3585 feature = "v6k"
3586 )
3587 )
3588 )]
3589 if (ins & 0xe1000f0) == 0xf0
3590 && let Some(ins) = parse_arm_strd_0(ins, pc, options)
3591 {
3592 return ins;
3593 }
3594 #[cfg(feature = "arm")]
3595 if (ins & 0xde00000) == 0x1e00000
3596 && let Some(ins) = parse_arm_mvn_0(ins, pc, options)
3597 {
3598 return ins;
3599 }
3600 }
3601 0x7ad | 0x7bd => {
3602 #[cfg(
3603 all(
3604 feature = "arm",
3605 any(
3606 feature = "v5te",
3607 feature = "v5tej",
3608 feature = "v6",
3609 feature = "v6k"
3610 )
3611 )
3612 )]
3613 if (ins & 0xe5f00f0) == 0x4f00d0
3614 && let Some(ins) = parse_arm_ldrd_1(ins, pc, options)
3615 {
3616 return ins;
3617 }
3618 #[cfg(
3619 all(
3620 feature = "arm",
3621 any(
3622 feature = "v5te",
3623 feature = "v5tej",
3624 feature = "v6",
3625 feature = "v6k"
3626 )
3627 )
3628 )]
3629 if (ins & 0xe1000f0) == 0xd0
3630 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
3631 {
3632 return ins;
3633 }
3634 #[cfg(feature = "arm")]
3635 if (ins & 0xde00000) == 0x1e00000
3636 && let Some(ins) = parse_arm_mvn_0(ins, pc, options)
3637 {
3638 return ins;
3639 }
3640 }
3641 0x7c9 | 0x7d9 | 0x7e9 | 0x7f9 => {
3642 #[cfg(all(feature = "arm", feature = "v6k"))]
3643 if (ins & 0xff000f0) == 0x1f00090
3644 && let Some(ins) = parse_arm_ldrexh_0(ins, pc, options)
3645 {
3646 return ins;
3647 }
3648 #[cfg(feature = "arm")]
3649 if (ins & 0xde00000) == 0x1e00000
3650 && let Some(ins) = parse_arm_mvn_0(ins, pc, options)
3651 {
3652 return ins;
3653 }
3654 }
3655 0x7cb | 0x7db | 0x7eb | 0x7fb => {
3656 #[cfg(feature = "arm")]
3657 if (ins & 0xe1000f0) == 0x1000b0
3658 && let Some(ins) = parse_arm_ldrh_0(ins, pc, options)
3659 {
3660 return ins;
3661 }
3662 #[cfg(feature = "arm")]
3663 if (ins & 0xde00000) == 0x1e00000
3664 && let Some(ins) = parse_arm_mvn_0(ins, pc, options)
3665 {
3666 return ins;
3667 }
3668 }
3669 0x7cd | 0x7dd | 0x7ed | 0x7fd => {
3670 #[cfg(feature = "arm")]
3671 if (ins & 0xe1000f0) == 0x1000d0
3672 && let Some(ins) = parse_arm_ldrsb_0(ins, pc, options)
3673 {
3674 return ins;
3675 }
3676 #[cfg(feature = "arm")]
3677 if (ins & 0xde00000) == 0x1e00000
3678 && let Some(ins) = parse_arm_mvn_0(ins, pc, options)
3679 {
3680 return ins;
3681 }
3682 }
3683 0x7cf | 0x7df | 0x7ef | 0x7ff => {
3684 #[cfg(feature = "arm")]
3685 if (ins & 0xe1000f0) == 0x1000f0
3686 && let Some(ins) = parse_arm_ldrsh_0(ins, pc, options)
3687 {
3688 return ins;
3689 }
3690 #[cfg(feature = "arm")]
3691 if (ins & 0xde00000) == 0x1e00000
3692 && let Some(ins) = parse_arm_mvn_0(ins, pc, options)
3693 {
3694 return ins;
3695 }
3696 }
3697 0xc80 | 0xc90 => {
3698 #[cfg(all(feature = "arm", feature = "v6k"))]
3699 if (ins & 0xfff00ff) == 0x3200000
3700 && let Some(ins) = parse_arm_nop_0(ins, pc, options)
3701 {
3702 return ins;
3703 }
3704 #[cfg(all(feature = "arm", feature = "v6k"))]
3705 if (ins & 0xfff00ff) == 0x3200004
3706 && let Some(ins) = parse_arm_sev_0(ins, pc, options)
3707 {
3708 return ins;
3709 }
3710 #[cfg(all(feature = "arm", feature = "v6k"))]
3711 if (ins & 0xfff00ff) == 0x3200002
3712 && let Some(ins) = parse_arm_wfe_0(ins, pc, options)
3713 {
3714 return ins;
3715 }
3716 #[cfg(all(feature = "arm", feature = "v6k"))]
3717 if (ins & 0xfff00ff) == 0x3200003
3718 && let Some(ins) = parse_arm_wfi_0(ins, pc, options)
3719 {
3720 return ins;
3721 }
3722 #[cfg(all(feature = "arm", feature = "v6k"))]
3723 if (ins & 0xfff00ff) == 0x3200001
3724 && let Some(ins) = parse_arm_yield_0(ins, pc, options)
3725 {
3726 return ins;
3727 }
3728 #[cfg(feature = "arm")]
3729 if (ins & 0xdb00000) == 0x1200000
3730 && let Some(ins) = parse_arm_msr_0(ins, pc, options)
3731 {
3732 return ins;
3733 }
3734 }
3735 0xc81 | 0xc91 => {
3736 #[cfg(feature = "arm")]
3737 if (ins & 0xfff00ff) == 0x3200014
3738 && let Some(ins) = parse_arm_csdb_0(ins, pc, options)
3739 {
3740 return ins;
3741 }
3742 #[cfg(feature = "arm")]
3743 if (ins & 0xdb00000) == 0x1200000
3744 && let Some(ins) = parse_arm_msr_0(ins, pc, options)
3745 {
3746 return ins;
3747 }
3748 }
3749 0xc8f | 0xc9f => {
3750 #[cfg(all(feature = "arm", feature = "v6k"))]
3751 if (ins & 0xfff00f0) == 0x32000f0
3752 && let Some(ins) = parse_arm_dbg_0(ins, pc, options)
3753 {
3754 return ins;
3755 }
3756 #[cfg(feature = "arm")]
3757 if (ins & 0xdb00000) == 0x1200000
3758 && let Some(ins) = parse_arm_msr_0(ins, pc, options)
3759 {
3760 return ins;
3761 }
3762 }
3763 0xe80 | 0xe81 | 0xe82 | 0xe83 | 0xe84 | 0xe85 | 0xe86 | 0xe87 | 0xe88 | 0xe89
3764 | 0xe8a | 0xe8b | 0xe8c | 0xe8d | 0xe8e | 0xe8f | 0xe90 | 0xe91 | 0xe92 | 0xe93
3765 | 0xe94 | 0xe95 | 0xe96 | 0xe97 | 0xe98 | 0xe99 | 0xe9a | 0xe9b | 0xe9c | 0xe9d
3766 | 0xe9e | 0xe9f | 0xea0 | 0xea1 | 0xea2 | 0xea3 | 0xea4 | 0xea5 | 0xea6 | 0xea7
3767 | 0xea8 | 0xea9 | 0xeaa | 0xeab | 0xeac | 0xead | 0xeae | 0xeaf | 0xeb0 | 0xeb1
3768 | 0xeb2 | 0xeb3 | 0xeb4 | 0xeb5 | 0xeb6 | 0xeb7 | 0xeb8 | 0xeb9 | 0xeba | 0xebb
3769 | 0xebc | 0xebd | 0xebe | 0xebf | 0xec0 | 0xec1 | 0xec2 | 0xec3 | 0xec4 | 0xec5
3770 | 0xec6 | 0xec7 | 0xec8 | 0xec9 | 0xeca | 0xecb | 0xecc | 0xecd | 0xece | 0xecf
3771 | 0xed0 | 0xed1 | 0xed2 | 0xed3 | 0xed4 | 0xed5 | 0xed6 | 0xed7 | 0xed8 | 0xed9
3772 | 0xeda | 0xedb | 0xedc | 0xedd | 0xede | 0xedf | 0xee0 | 0xee1 | 0xee2 | 0xee3
3773 | 0xee4 | 0xee5 | 0xee6 | 0xee7 | 0xee8 | 0xee9 | 0xeea | 0xeeb | 0xeec | 0xeed
3774 | 0xeee | 0xeef | 0xef0 | 0xef1 | 0xef2 | 0xef3 | 0xef4 | 0xef5 | 0xef6 | 0xef7
3775 | 0xef8 | 0xef9 | 0xefa | 0xefb | 0xefc | 0xefd | 0xefe | 0xeff => {
3776 #[cfg(feature = "arm")]
3777 if (ins & 0xfe00000) == 0x3a00000
3778 && let Some(ins) = parse_arm_mov_0(ins, pc, options)
3779 {
3780 return ins;
3781 }
3782 #[cfg(feature = "arm")]
3783 if (ins & 0xde00000) == 0x1a00000
3784 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
3785 {
3786 return ins;
3787 }
3788 }
3789 0x1000 | 0x1001 | 0x1002 | 0x1003 | 0x1004 | 0x1005 | 0x1006 | 0x1007 | 0x1008
3790 | 0x1009 | 0x100a | 0x100b | 0x100c | 0x100d | 0x100e | 0x100f | 0x1010 | 0x1011
3791 | 0x1012 | 0x1013 | 0x1014 | 0x1015 | 0x1016 | 0x1017 | 0x1018 | 0x1019 | 0x101a
3792 | 0x101b | 0x101c | 0x101d | 0x101e | 0x101f | 0x1020 | 0x1021 | 0x1022 | 0x1023
3793 | 0x1024 | 0x1025 | 0x1026 | 0x1027 | 0x1028 | 0x1029 | 0x102a | 0x102b | 0x102c
3794 | 0x102d | 0x102e | 0x102f | 0x1030 | 0x1031 | 0x1032 | 0x1033 | 0x1034 | 0x1035
3795 | 0x1036 | 0x1037 | 0x1038 | 0x1039 | 0x103a | 0x103b | 0x103c | 0x103d | 0x103e
3796 | 0x103f | 0x1200 | 0x1201 | 0x1202 | 0x1203 | 0x1204 | 0x1205 | 0x1206 | 0x1207
3797 | 0x1208 | 0x1209 | 0x120a | 0x120b | 0x120c | 0x120d | 0x120e | 0x120f | 0x1210
3798 | 0x1211 | 0x1212 | 0x1213 | 0x1214 | 0x1215 | 0x1216 | 0x1217 | 0x1218 | 0x1219
3799 | 0x121a | 0x121b | 0x121c | 0x121d | 0x121e | 0x121f | 0x1220 | 0x1221 | 0x1222
3800 | 0x1223 | 0x1224 | 0x1225 | 0x1226 | 0x1227 | 0x1228 | 0x1229 | 0x122a | 0x122b
3801 | 0x122c | 0x122d | 0x122e | 0x122f | 0x1230 | 0x1231 | 0x1232 | 0x1233 | 0x1234
3802 | 0x1235 | 0x1236 | 0x1237 | 0x1238 | 0x1239 | 0x123a | 0x123b | 0x123c | 0x123d
3803 | 0x123e | 0x123f | 0x1400 | 0x1401 | 0x1402 | 0x1403 | 0x1404 | 0x1405 | 0x1406
3804 | 0x1407 | 0x1408 | 0x1409 | 0x140a | 0x140b | 0x140c | 0x140d | 0x140e | 0x140f
3805 | 0x1410 | 0x1411 | 0x1412 | 0x1413 | 0x1414 | 0x1415 | 0x1416 | 0x1417 | 0x1418
3806 | 0x1419 | 0x141a | 0x141b | 0x141c | 0x141d | 0x141e | 0x141f | 0x1420 | 0x1421
3807 | 0x1422 | 0x1423 | 0x1424 | 0x1425 | 0x1426 | 0x1427 | 0x1428 | 0x1429 | 0x142a
3808 | 0x142b | 0x142c | 0x142d | 0x142e | 0x142f | 0x1430 | 0x1431 | 0x1432 | 0x1433
3809 | 0x1434 | 0x1435 | 0x1436 | 0x1437 | 0x1438 | 0x1439 | 0x143a | 0x143b | 0x143c
3810 | 0x143d | 0x143e | 0x143f | 0x1480 | 0x1481 | 0x1482 | 0x1483 | 0x1484 | 0x1485
3811 | 0x1486 | 0x1487 | 0x1488 | 0x1489 | 0x148a | 0x148b | 0x148c | 0x148d | 0x148e
3812 | 0x148f | 0x1490 | 0x1491 | 0x1492 | 0x1493 | 0x1494 | 0x1495 | 0x1496 | 0x1497
3813 | 0x1498 | 0x1499 | 0x149a | 0x149b | 0x149c | 0x149d | 0x149e | 0x149f | 0x14a1
3814 | 0x14a2 | 0x14a3 | 0x14a4 | 0x14a5 | 0x14a6 | 0x14a7 | 0x14a8 | 0x14a9 | 0x14aa
3815 | 0x14ab | 0x14ac | 0x14ad | 0x14ae | 0x14af | 0x14b0 | 0x14b1 | 0x14b2 | 0x14b3
3816 | 0x14b4 | 0x14b5 | 0x14b6 | 0x14b7 | 0x14b8 | 0x14b9 | 0x14ba | 0x14bb | 0x14bc
3817 | 0x14bd | 0x14be | 0x14bf | 0x1600 | 0x1601 | 0x1602 | 0x1603 | 0x1604 | 0x1605
3818 | 0x1606 | 0x1607 | 0x1608 | 0x1609 | 0x160a | 0x160b | 0x160c | 0x160d | 0x160e
3819 | 0x160f | 0x1610 | 0x1611 | 0x1612 | 0x1613 | 0x1614 | 0x1615 | 0x1616 | 0x1617
3820 | 0x1618 | 0x1619 | 0x161a | 0x161b | 0x161c | 0x161d | 0x161e | 0x161f | 0x1620
3821 | 0x1621 | 0x1622 | 0x1623 | 0x1624 | 0x1625 | 0x1626 | 0x1627 | 0x1628 | 0x1629
3822 | 0x162a | 0x162b | 0x162c | 0x162d | 0x162e | 0x162f | 0x1630 | 0x1631 | 0x1632
3823 | 0x1633 | 0x1634 | 0x1635 | 0x1636 | 0x1637 | 0x1638 | 0x1639 | 0x163a | 0x163b
3824 | 0x163c | 0x163d | 0x163e | 0x163f | 0x1680 | 0x1681 | 0x1682 | 0x1683 | 0x1684
3825 | 0x1685 | 0x1686 | 0x1687 | 0x1688 | 0x1689 | 0x168a | 0x168b | 0x168c | 0x168d
3826 | 0x168e | 0x168f | 0x1690 | 0x1691 | 0x1692 | 0x1693 | 0x1694 | 0x1695 | 0x1696
3827 | 0x1697 | 0x1698 | 0x1699 | 0x169a | 0x169b | 0x169c | 0x169d | 0x169e | 0x169f
3828 | 0x16a0 | 0x16a1 | 0x16a2 | 0x16a3 | 0x16a4 | 0x16a5 | 0x16a6 | 0x16a7 | 0x16a8
3829 | 0x16a9 | 0x16aa | 0x16ab | 0x16ac | 0x16ad | 0x16ae | 0x16af | 0x16b0 | 0x16b1
3830 | 0x16b2 | 0x16b3 | 0x16b4 | 0x16b5 | 0x16b6 | 0x16b7 | 0x16b8 | 0x16b9 | 0x16ba
3831 | 0x16bb | 0x16bc | 0x16bd | 0x16be | 0x16bf | 0x1800 | 0x1801 | 0x1802 | 0x1803
3832 | 0x1804 | 0x1805 | 0x1806 | 0x1807 | 0x1808 | 0x1809 | 0x180a | 0x180b | 0x180c
3833 | 0x180d | 0x180e | 0x180f | 0x1810 | 0x1811 | 0x1812 | 0x1813 | 0x1814 | 0x1815
3834 | 0x1816 | 0x1817 | 0x1818 | 0x1819 | 0x181a | 0x181b | 0x181c | 0x181d | 0x181e
3835 | 0x181f | 0x1820 | 0x1821 | 0x1822 | 0x1823 | 0x1824 | 0x1825 | 0x1826 | 0x1827
3836 | 0x1828 | 0x1829 | 0x182a | 0x182b | 0x182c | 0x182d | 0x182e | 0x182f | 0x1830
3837 | 0x1831 | 0x1832 | 0x1833 | 0x1834 | 0x1835 | 0x1836 | 0x1837 | 0x1838 | 0x1839
3838 | 0x183a | 0x183b | 0x183c | 0x183d | 0x183e | 0x183f | 0x1a00 | 0x1a02 | 0x1a03
3839 | 0x1a04 | 0x1a06 | 0x1a08 | 0x1a0a | 0x1a0c | 0x1a0e | 0x1a0f | 0x1a10 | 0x1a12
3840 | 0x1a13 | 0x1a14 | 0x1a16 | 0x1a18 | 0x1a1a | 0x1a1c | 0x1a1e | 0x1a1f | 0x1a20
3841 | 0x1a22 | 0x1a23 | 0x1a24 | 0x1a26 | 0x1a28 | 0x1a2a | 0x1a2c | 0x1a2e | 0x1a2f
3842 | 0x1a30 | 0x1a32 | 0x1a33 | 0x1a34 | 0x1a36 | 0x1a38 | 0x1a3a | 0x1a3c | 0x1a3e
3843 | 0x1a3f | 0x1c00 | 0x1c02 | 0x1c04 | 0x1c06 | 0x1c08 | 0x1c09 | 0x1c0a | 0x1c0b
3844 | 0x1c0c | 0x1c0d | 0x1c0e | 0x1c0f | 0x1c10 | 0x1c12 | 0x1c14 | 0x1c16 | 0x1c18
3845 | 0x1c19 | 0x1c1a | 0x1c1b | 0x1c1c | 0x1c1d | 0x1c1e | 0x1c1f | 0x1c20 | 0x1c22
3846 | 0x1c24 | 0x1c26 | 0x1c28 | 0x1c29 | 0x1c2a | 0x1c2b | 0x1c2c | 0x1c2d | 0x1c2e
3847 | 0x1c2f | 0x1c30 | 0x1c32 | 0x1c34 | 0x1c36 | 0x1c38 | 0x1c39 | 0x1c3a | 0x1c3b
3848 | 0x1c3c | 0x1c3d | 0x1c3e | 0x1c3f | 0x1c80 | 0x1c81 | 0x1c82 | 0x1c83 | 0x1c84
3849 | 0x1c85 | 0x1c86 | 0x1c87 | 0x1c88 | 0x1c89 | 0x1c8a | 0x1c8b | 0x1c8c | 0x1c8d
3850 | 0x1c8e | 0x1c8f | 0x1c90 | 0x1c91 | 0x1c92 | 0x1c93 | 0x1c94 | 0x1c95 | 0x1c96
3851 | 0x1c97 | 0x1c98 | 0x1c99 | 0x1c9a | 0x1c9b | 0x1c9c | 0x1c9d | 0x1c9e | 0x1c9f
3852 | 0x1ca0 | 0x1ca1 | 0x1ca2 | 0x1ca3 | 0x1ca4 | 0x1ca5 | 0x1ca6 | 0x1ca7 | 0x1ca8
3853 | 0x1ca9 | 0x1caa | 0x1cab | 0x1cac | 0x1cad | 0x1cae | 0x1caf | 0x1cb0 | 0x1cb1
3854 | 0x1cb2 | 0x1cb3 | 0x1cb4 | 0x1cb5 | 0x1cb6 | 0x1cb7 | 0x1cb8 | 0x1cb9 | 0x1cba
3855 | 0x1cbb | 0x1cbc | 0x1cbd | 0x1cbe | 0x1cbf | 0x1e00 | 0x1e02 | 0x1e03 | 0x1e04
3856 | 0x1e05 | 0x1e06 | 0x1e07 | 0x1e08 | 0x1e09 | 0x1e0a | 0x1e0b | 0x1e0c | 0x1e0d
3857 | 0x1e0e | 0x1e0f | 0x1e10 | 0x1e12 | 0x1e13 | 0x1e14 | 0x1e15 | 0x1e16 | 0x1e17
3858 | 0x1e18 | 0x1e19 | 0x1e1a | 0x1e1b | 0x1e1c | 0x1e1d | 0x1e1e | 0x1e1f | 0x1e20
3859 | 0x1e22 | 0x1e23 | 0x1e24 | 0x1e25 | 0x1e26 | 0x1e27 | 0x1e28 | 0x1e29 | 0x1e2a
3860 | 0x1e2b | 0x1e2c | 0x1e2d | 0x1e2e | 0x1e2f | 0x1e30 | 0x1e32 | 0x1e33 | 0x1e34
3861 | 0x1e35 | 0x1e36 | 0x1e37 | 0x1e38 | 0x1e39 | 0x1e3a | 0x1e3b | 0x1e3c | 0x1e3d
3862 | 0x1e3e | 0x1e3f | 0x1e80 | 0x1e81 | 0x1e82 | 0x1e83 | 0x1e84 | 0x1e85 | 0x1e86
3863 | 0x1e87 | 0x1e88 | 0x1e89 | 0x1e8a | 0x1e8b | 0x1e8c | 0x1e8d | 0x1e8e | 0x1e8f
3864 | 0x1e90 | 0x1e91 | 0x1e92 | 0x1e93 | 0x1e94 | 0x1e95 | 0x1e96 | 0x1e97 | 0x1e98
3865 | 0x1e99 | 0x1e9a | 0x1e9b | 0x1e9c | 0x1e9d | 0x1e9e | 0x1e9f | 0x1ea0 | 0x1ea1
3866 | 0x1ea2 | 0x1ea3 | 0x1ea4 | 0x1ea5 | 0x1ea6 | 0x1ea7 | 0x1ea8 | 0x1ea9 | 0x1eaa
3867 | 0x1eab | 0x1eac | 0x1ead | 0x1eae | 0x1eaf | 0x1eb0 | 0x1eb1 | 0x1eb2 | 0x1eb3
3868 | 0x1eb4 | 0x1eb5 | 0x1eb6 | 0x1eb7 | 0x1eb8 | 0x1eb9 | 0x1eba | 0x1ebb | 0x1ebc
3869 | 0x1ebd | 0x1ebe | 0x1ebf => {
3870 #[cfg(feature = "arm")]
3871 if let Some(ins) = parse_arm_str_0(ins, pc, options) {
3872 return ins;
3873 }
3874 }
3875 0x1040 | 0x1041 | 0x1042 | 0x1043 | 0x1044 | 0x1045 | 0x1046 | 0x1047 | 0x1048
3876 | 0x1049 | 0x104a | 0x104b | 0x104c | 0x104d | 0x104e | 0x104f | 0x1050 | 0x1051
3877 | 0x1052 | 0x1053 | 0x1054 | 0x1055 | 0x1056 | 0x1057 | 0x1058 | 0x1059 | 0x105a
3878 | 0x105b | 0x105c | 0x105d | 0x105e | 0x105f | 0x1060 | 0x1061 | 0x1062 | 0x1063
3879 | 0x1064 | 0x1065 | 0x1066 | 0x1067 | 0x1068 | 0x1069 | 0x106a | 0x106b | 0x106c
3880 | 0x106d | 0x106e | 0x106f | 0x1070 | 0x1071 | 0x1072 | 0x1073 | 0x1074 | 0x1075
3881 | 0x1076 | 0x1077 | 0x1078 | 0x1079 | 0x107a | 0x107b | 0x107c | 0x107d | 0x107e
3882 | 0x107f | 0x1240 | 0x1241 | 0x1242 | 0x1243 | 0x1244 | 0x1245 | 0x1246 | 0x1247
3883 | 0x1248 | 0x1249 | 0x124a | 0x124b | 0x124c | 0x124d | 0x124e | 0x124f | 0x1250
3884 | 0x1251 | 0x1252 | 0x1253 | 0x1254 | 0x1255 | 0x1256 | 0x1257 | 0x1258 | 0x1259
3885 | 0x125a | 0x125b | 0x125c | 0x125d | 0x125e | 0x125f | 0x1261 | 0x1262 | 0x1263
3886 | 0x1264 | 0x1265 | 0x1266 | 0x1267 | 0x1268 | 0x1269 | 0x126a | 0x126b | 0x126c
3887 | 0x126d | 0x126e | 0x126f | 0x1270 | 0x1271 | 0x1272 | 0x1273 | 0x1274 | 0x1275
3888 | 0x1276 | 0x1277 | 0x1278 | 0x1279 | 0x127a | 0x127b | 0x127c | 0x127d | 0x127e
3889 | 0x127f | 0x1440 | 0x1441 | 0x1442 | 0x1443 | 0x1444 | 0x1445 | 0x1446 | 0x1447
3890 | 0x1448 | 0x1449 | 0x144a | 0x144b | 0x144c | 0x144d | 0x144e | 0x144f | 0x1450
3891 | 0x1451 | 0x1452 | 0x1453 | 0x1454 | 0x1455 | 0x1456 | 0x1457 | 0x1458 | 0x1459
3892 | 0x145a | 0x145b | 0x145c | 0x145d | 0x145e | 0x145f | 0x1460 | 0x1461 | 0x1462
3893 | 0x1463 | 0x1464 | 0x1465 | 0x1466 | 0x1467 | 0x1468 | 0x1469 | 0x146a | 0x146b
3894 | 0x146c | 0x146d | 0x146e | 0x146f | 0x1470 | 0x1471 | 0x1472 | 0x1473 | 0x1474
3895 | 0x1475 | 0x1476 | 0x1477 | 0x1478 | 0x1479 | 0x147a | 0x147b | 0x147c | 0x147d
3896 | 0x147e | 0x147f | 0x14c0 | 0x14c1 | 0x14c2 | 0x14c3 | 0x14c4 | 0x14c5 | 0x14c6
3897 | 0x14c7 | 0x14c8 | 0x14c9 | 0x14ca | 0x14cb | 0x14cc | 0x14cd | 0x14ce | 0x14cf
3898 | 0x14d0 | 0x14d1 | 0x14d2 | 0x14d3 | 0x14d4 | 0x14d5 | 0x14d6 | 0x14d7 | 0x14d8
3899 | 0x14d9 | 0x14da | 0x14db | 0x14dc | 0x14dd | 0x14de | 0x14df | 0x14e0 | 0x14e1
3900 | 0x14e2 | 0x14e3 | 0x14e4 | 0x14e5 | 0x14e6 | 0x14e7 | 0x14e8 | 0x14e9 | 0x14ea
3901 | 0x14eb | 0x14ec | 0x14ed | 0x14ee | 0x14ef | 0x14f0 | 0x14f1 | 0x14f2 | 0x14f3
3902 | 0x14f4 | 0x14f5 | 0x14f6 | 0x14f7 | 0x14f8 | 0x14f9 | 0x14fa | 0x14fb | 0x14fc
3903 | 0x14fd | 0x14fe | 0x14ff | 0x1640 | 0x1641 | 0x1642 | 0x1643 | 0x1644 | 0x1645
3904 | 0x1646 | 0x1647 | 0x1648 | 0x1649 | 0x164a | 0x164b | 0x164c | 0x164d | 0x164e
3905 | 0x164f | 0x1650 | 0x1651 | 0x1652 | 0x1653 | 0x1654 | 0x1655 | 0x1656 | 0x1657
3906 | 0x1658 | 0x1659 | 0x165a | 0x165b | 0x165c | 0x165d | 0x165e | 0x165f | 0x1660
3907 | 0x1661 | 0x1662 | 0x1663 | 0x1664 | 0x1665 | 0x1666 | 0x1667 | 0x1668 | 0x1669
3908 | 0x166a | 0x166b | 0x166c | 0x166d | 0x166e | 0x166f | 0x1670 | 0x1671 | 0x1672
3909 | 0x1673 | 0x1674 | 0x1675 | 0x1676 | 0x1677 | 0x1678 | 0x1679 | 0x167a | 0x167b
3910 | 0x167c | 0x167d | 0x167e | 0x167f | 0x16c0 | 0x16c1 | 0x16c2 | 0x16c3 | 0x16c4
3911 | 0x16c5 | 0x16c6 | 0x16c7 | 0x16c8 | 0x16c9 | 0x16ca | 0x16cb | 0x16cc | 0x16cd
3912 | 0x16ce | 0x16cf | 0x16d0 | 0x16d1 | 0x16d2 | 0x16d3 | 0x16d4 | 0x16d5 | 0x16d6
3913 | 0x16d7 | 0x16d8 | 0x16d9 | 0x16da | 0x16db | 0x16dc | 0x16dd | 0x16de | 0x16df
3914 | 0x16e0 | 0x16e1 | 0x16e2 | 0x16e3 | 0x16e4 | 0x16e5 | 0x16e6 | 0x16e7 | 0x16e8
3915 | 0x16e9 | 0x16ea | 0x16eb | 0x16ec | 0x16ed | 0x16ee | 0x16ef | 0x16f0 | 0x16f1
3916 | 0x16f2 | 0x16f3 | 0x16f4 | 0x16f5 | 0x16f6 | 0x16f7 | 0x16f8 | 0x16f9 | 0x16fa
3917 | 0x16fb | 0x16fc | 0x16fd | 0x16fe | 0x16ff | 0x1840 | 0x1842 | 0x1844 | 0x1846
3918 | 0x1848 | 0x184a | 0x184b | 0x184c | 0x184d | 0x184e | 0x1850 | 0x1852 | 0x1854
3919 | 0x1856 | 0x1858 | 0x185a | 0x185b | 0x185c | 0x185d | 0x185e | 0x1860 | 0x1862
3920 | 0x1864 | 0x1866 | 0x1868 | 0x186a | 0x186b | 0x186c | 0x186d | 0x186e | 0x1870
3921 | 0x1872 | 0x1874 | 0x1876 | 0x1878 | 0x187a | 0x187b | 0x187c | 0x187d | 0x187e
3922 | 0x1a40 | 0x1a41 | 0x1a42 | 0x1a43 | 0x1a44 | 0x1a45 | 0x1a46 | 0x1a47 | 0x1a48
3923 | 0x1a49 | 0x1a4a | 0x1a4b | 0x1a4c | 0x1a4d | 0x1a4e | 0x1a4f | 0x1a50 | 0x1a51
3924 | 0x1a52 | 0x1a53 | 0x1a54 | 0x1a55 | 0x1a56 | 0x1a57 | 0x1a58 | 0x1a59 | 0x1a5a
3925 | 0x1a5b | 0x1a5c | 0x1a5d | 0x1a5e | 0x1a5f | 0x1a60 | 0x1a61 | 0x1a62 | 0x1a63
3926 | 0x1a64 | 0x1a65 | 0x1a66 | 0x1a67 | 0x1a68 | 0x1a69 | 0x1a6a | 0x1a6b | 0x1a6c
3927 | 0x1a6d | 0x1a6e | 0x1a6f | 0x1a70 | 0x1a71 | 0x1a72 | 0x1a73 | 0x1a74 | 0x1a75
3928 | 0x1a76 | 0x1a77 | 0x1a78 | 0x1a79 | 0x1a7a | 0x1a7b | 0x1a7c | 0x1a7d | 0x1a7e
3929 | 0x1a7f | 0x1c40 | 0x1c41 | 0x1c42 | 0x1c43 | 0x1c44 | 0x1c45 | 0x1c46 | 0x1c47
3930 | 0x1c48 | 0x1c49 | 0x1c4a | 0x1c4b | 0x1c4c | 0x1c4d | 0x1c4e | 0x1c4f | 0x1c50
3931 | 0x1c51 | 0x1c52 | 0x1c53 | 0x1c54 | 0x1c55 | 0x1c56 | 0x1c57 | 0x1c58 | 0x1c59
3932 | 0x1c5a | 0x1c5b | 0x1c5c | 0x1c5d | 0x1c5e | 0x1c5f | 0x1c60 | 0x1c61 | 0x1c62
3933 | 0x1c63 | 0x1c64 | 0x1c65 | 0x1c66 | 0x1c67 | 0x1c68 | 0x1c69 | 0x1c6a | 0x1c6b
3934 | 0x1c6c | 0x1c6d | 0x1c6e | 0x1c6f | 0x1c70 | 0x1c71 | 0x1c72 | 0x1c73 | 0x1c74
3935 | 0x1c75 | 0x1c76 | 0x1c77 | 0x1c78 | 0x1c79 | 0x1c7a | 0x1c7b | 0x1c7c | 0x1c7d
3936 | 0x1c7e | 0x1c7f | 0x1cc0 | 0x1cc1 | 0x1cc2 | 0x1cc3 | 0x1cc4 | 0x1cc5 | 0x1cc6
3937 | 0x1cc7 | 0x1cc8 | 0x1cc9 | 0x1cca | 0x1ccb | 0x1ccc | 0x1ccd | 0x1cce | 0x1ccf
3938 | 0x1cd0 | 0x1cd1 | 0x1cd2 | 0x1cd3 | 0x1cd4 | 0x1cd5 | 0x1cd6 | 0x1cd7 | 0x1cd8
3939 | 0x1cd9 | 0x1cda | 0x1cdb | 0x1cdc | 0x1cdd | 0x1cde | 0x1cdf | 0x1ce0 | 0x1ce1
3940 | 0x1ce2 | 0x1ce3 | 0x1ce4 | 0x1ce5 | 0x1ce6 | 0x1ce7 | 0x1ce8 | 0x1ce9 | 0x1cea
3941 | 0x1ceb | 0x1cec | 0x1ced | 0x1cee | 0x1cef | 0x1cf0 | 0x1cf1 | 0x1cf2 | 0x1cf3
3942 | 0x1cf4 | 0x1cf5 | 0x1cf6 | 0x1cf7 | 0x1cf8 | 0x1cf9 | 0x1cfa | 0x1cfb | 0x1cfc
3943 | 0x1cfd | 0x1cfe | 0x1cff | 0x1e40 | 0x1e41 | 0x1e42 | 0x1e43 | 0x1e44 | 0x1e45
3944 | 0x1e46 | 0x1e47 | 0x1e48 | 0x1e49 | 0x1e4a | 0x1e4b | 0x1e4c | 0x1e4d | 0x1e4e
3945 | 0x1e4f | 0x1e50 | 0x1e51 | 0x1e52 | 0x1e53 | 0x1e54 | 0x1e55 | 0x1e56 | 0x1e57
3946 | 0x1e58 | 0x1e59 | 0x1e5a | 0x1e5b | 0x1e5c | 0x1e5d | 0x1e5e | 0x1e5f | 0x1e60
3947 | 0x1e61 | 0x1e62 | 0x1e63 | 0x1e64 | 0x1e65 | 0x1e66 | 0x1e67 | 0x1e68 | 0x1e69
3948 | 0x1e6a | 0x1e6b | 0x1e6c | 0x1e6d | 0x1e6e | 0x1e6f | 0x1e70 | 0x1e71 | 0x1e72
3949 | 0x1e73 | 0x1e74 | 0x1e75 | 0x1e76 | 0x1e77 | 0x1e78 | 0x1e79 | 0x1e7a | 0x1e7b
3950 | 0x1e7c | 0x1e7d | 0x1e7e | 0x1e7f | 0x1ec0 | 0x1ec1 | 0x1ec2 | 0x1ec3 | 0x1ec4
3951 | 0x1ec5 | 0x1ec6 | 0x1ec7 | 0x1ec8 | 0x1ec9 | 0x1eca | 0x1ecb | 0x1ecc | 0x1ecd
3952 | 0x1ece | 0x1ecf | 0x1ed0 | 0x1ed1 | 0x1ed2 | 0x1ed3 | 0x1ed4 | 0x1ed5 | 0x1ed6
3953 | 0x1ed7 | 0x1ed8 | 0x1ed9 | 0x1eda | 0x1edb | 0x1edc | 0x1edd | 0x1ede | 0x1edf
3954 | 0x1ee0 | 0x1ee1 | 0x1ee2 | 0x1ee3 | 0x1ee4 | 0x1ee5 | 0x1ee6 | 0x1ee7 | 0x1ee8
3955 | 0x1ee9 | 0x1eea | 0x1eeb | 0x1eec | 0x1eed | 0x1eee | 0x1eef | 0x1ef0 | 0x1ef1
3956 | 0x1ef2 | 0x1ef3 | 0x1ef4 | 0x1ef5 | 0x1ef6 | 0x1ef7 | 0x1ef8 | 0x1ef9 | 0x1efa
3957 | 0x1efb | 0x1efc | 0x1efd | 0x1efe | 0x1eff => {
3958 #[cfg(feature = "arm")]
3959 if let Some(ins) = parse_arm_ldr_0(ins, pc, options) {
3960 return ins;
3961 }
3962 }
3963 0x1080 | 0x1081 | 0x1082 | 0x1083 | 0x1084 | 0x1085 | 0x1086 | 0x1087 | 0x1088
3964 | 0x1089 | 0x108a | 0x108b | 0x108c | 0x108d | 0x108e | 0x108f | 0x1090 | 0x1091
3965 | 0x1092 | 0x1093 | 0x1094 | 0x1095 | 0x1096 | 0x1097 | 0x1098 | 0x1099 | 0x109a
3966 | 0x109b | 0x109c | 0x109d | 0x109e | 0x109f | 0x10a0 | 0x10a1 | 0x10a2 | 0x10a3
3967 | 0x10a4 | 0x10a5 | 0x10a6 | 0x10a7 | 0x10a8 | 0x10a9 | 0x10aa | 0x10ab | 0x10ac
3968 | 0x10ad | 0x10ae | 0x10af | 0x10b0 | 0x10b1 | 0x10b2 | 0x10b3 | 0x10b4 | 0x10b5
3969 | 0x10b6 | 0x10b7 | 0x10b8 | 0x10b9 | 0x10ba | 0x10bb | 0x10bc | 0x10bd | 0x10be
3970 | 0x10bf | 0x1280 | 0x1281 | 0x1282 | 0x1283 | 0x1284 | 0x1285 | 0x1286 | 0x1287
3971 | 0x1288 | 0x1289 | 0x128a | 0x128b | 0x128c | 0x128d | 0x128e | 0x128f | 0x1290
3972 | 0x1291 | 0x1292 | 0x1293 | 0x1294 | 0x1295 | 0x1296 | 0x1297 | 0x1298 | 0x1299
3973 | 0x129a | 0x129b | 0x129c | 0x129d | 0x129e | 0x129f | 0x12a0 | 0x12a1 | 0x12a2
3974 | 0x12a3 | 0x12a4 | 0x12a5 | 0x12a6 | 0x12a7 | 0x12a8 | 0x12a9 | 0x12aa | 0x12ab
3975 | 0x12ac | 0x12ad | 0x12ae | 0x12af | 0x12b0 | 0x12b1 | 0x12b2 | 0x12b3 | 0x12b4
3976 | 0x12b5 | 0x12b6 | 0x12b7 | 0x12b8 | 0x12b9 | 0x12ba | 0x12bb | 0x12bc | 0x12bd
3977 | 0x12be | 0x12bf | 0x1880 | 0x1882 | 0x1884 | 0x1886 | 0x1888 | 0x188a | 0x188b
3978 | 0x188c | 0x188d | 0x188e | 0x1890 | 0x1892 | 0x1894 | 0x1896 | 0x1898 | 0x189a
3979 | 0x189b | 0x189c | 0x189d | 0x189e | 0x18a0 | 0x18a2 | 0x18a4 | 0x18a6 | 0x18a8
3980 | 0x18aa | 0x18ab | 0x18ac | 0x18ad | 0x18ae | 0x18b0 | 0x18b2 | 0x18b4 | 0x18b6
3981 | 0x18b8 | 0x18ba | 0x18bb | 0x18bc | 0x18bd | 0x18be | 0x1a80 | 0x1a82 | 0x1a84
3982 | 0x1a86 | 0x1a88 | 0x1a8a | 0x1a8b | 0x1a8c | 0x1a8e | 0x1a8f | 0x1a90 | 0x1a92
3983 | 0x1a94 | 0x1a96 | 0x1a98 | 0x1a9a | 0x1a9b | 0x1a9c | 0x1a9e | 0x1a9f | 0x1aa0
3984 | 0x1aa2 | 0x1aa4 | 0x1aa6 | 0x1aa8 | 0x1aaa | 0x1aab | 0x1aac | 0x1aae | 0x1aaf
3985 | 0x1ab0 | 0x1ab2 | 0x1ab4 | 0x1ab6 | 0x1ab8 | 0x1aba | 0x1abb | 0x1abc | 0x1abe
3986 | 0x1abf => {
3987 #[cfg(feature = "arm")]
3988 if (ins & 0xd700000) == 0x4200000
3989 && let Some(ins) = parse_arm_strt_0(ins, pc, options)
3990 {
3991 return ins;
3992 }
3993 #[cfg(feature = "arm")]
3994 if (ins & 0xc500000) == 0x4000000
3995 && let Some(ins) = parse_arm_str_0(ins, pc, options)
3996 {
3997 return ins;
3998 }
3999 }
4000 0x10c0 | 0x10c1 | 0x10c2 | 0x10c3 | 0x10c4 | 0x10c5 | 0x10c6 | 0x10c7 | 0x10c8
4001 | 0x10c9 | 0x10ca | 0x10cb | 0x10cc | 0x10cd | 0x10ce | 0x10cf | 0x10d0 | 0x10d1
4002 | 0x10d2 | 0x10d3 | 0x10d4 | 0x10d5 | 0x10d6 | 0x10d7 | 0x10d8 | 0x10d9 | 0x10da
4003 | 0x10db | 0x10dc | 0x10dd | 0x10de | 0x10df | 0x10e0 | 0x10e1 | 0x10e2 | 0x10e3
4004 | 0x10e4 | 0x10e5 | 0x10e6 | 0x10e7 | 0x10e8 | 0x10e9 | 0x10ea | 0x10eb | 0x10ec
4005 | 0x10ed | 0x10ee | 0x10ef | 0x10f0 | 0x10f1 | 0x10f2 | 0x10f3 | 0x10f4 | 0x10f5
4006 | 0x10f6 | 0x10f7 | 0x10f8 | 0x10f9 | 0x10fa | 0x10fb | 0x10fc | 0x10fd | 0x10fe
4007 | 0x10ff | 0x12c0 | 0x12c1 | 0x12c2 | 0x12c3 | 0x12c4 | 0x12c5 | 0x12c6 | 0x12c7
4008 | 0x12c8 | 0x12c9 | 0x12ca | 0x12cb | 0x12cc | 0x12cd | 0x12ce | 0x12cf | 0x12d0
4009 | 0x12d1 | 0x12d2 | 0x12d3 | 0x12d4 | 0x12d5 | 0x12d6 | 0x12d7 | 0x12d8 | 0x12d9
4010 | 0x12da | 0x12db | 0x12dc | 0x12dd | 0x12de | 0x12df | 0x12e0 | 0x12e1 | 0x12e2
4011 | 0x12e3 | 0x12e4 | 0x12e5 | 0x12e6 | 0x12e7 | 0x12e8 | 0x12e9 | 0x12ea | 0x12eb
4012 | 0x12ec | 0x12ed | 0x12ee | 0x12ef | 0x12f0 | 0x12f1 | 0x12f2 | 0x12f3 | 0x12f4
4013 | 0x12f5 | 0x12f6 | 0x12f7 | 0x12f8 | 0x12f9 | 0x12fa | 0x12fb | 0x12fc | 0x12fd
4014 | 0x12fe | 0x12ff | 0x18c0 | 0x18c2 | 0x18c4 | 0x18c6 | 0x18c8 | 0x18ca | 0x18cb
4015 | 0x18cc | 0x18cd | 0x18ce | 0x18d0 | 0x18d2 | 0x18d4 | 0x18d6 | 0x18d8 | 0x18da
4016 | 0x18db | 0x18dc | 0x18dd | 0x18de | 0x18e0 | 0x18e2 | 0x18e4 | 0x18e6 | 0x18e8
4017 | 0x18ea | 0x18eb | 0x18ec | 0x18ed | 0x18ee | 0x18f0 | 0x18f2 | 0x18f4 | 0x18f6
4018 | 0x18f8 | 0x18fa | 0x18fb | 0x18fc | 0x18fd | 0x18fe | 0x1ac0 | 0x1ac2 | 0x1ac4
4019 | 0x1ac6 | 0x1ac8 | 0x1aca | 0x1acc | 0x1ace | 0x1acf | 0x1ad0 | 0x1ad2 | 0x1ad4
4020 | 0x1ad6 | 0x1ad8 | 0x1ada | 0x1adc | 0x1ade | 0x1adf | 0x1ae0 | 0x1ae2 | 0x1ae4
4021 | 0x1ae6 | 0x1ae8 | 0x1aea | 0x1aec | 0x1aee | 0x1aef | 0x1af0 | 0x1af2 | 0x1af4
4022 | 0x1af6 | 0x1af8 | 0x1afa | 0x1afc | 0x1afe | 0x1aff => {
4023 #[cfg(feature = "arm")]
4024 if (ins & 0xd700000) == 0x4300000
4025 && let Some(ins) = parse_arm_ldrt_0(ins, pc, options)
4026 {
4027 return ins;
4028 }
4029 #[cfg(feature = "arm")]
4030 if (ins & 0xc500000) == 0x4100000
4031 && let Some(ins) = parse_arm_ldr_0(ins, pc, options)
4032 {
4033 return ins;
4034 }
4035 }
4036 0x1100 | 0x1101 | 0x1102 | 0x1103 | 0x1104 | 0x1105 | 0x1106 | 0x1107 | 0x1108
4037 | 0x1109 | 0x110a | 0x110b | 0x110c | 0x110d | 0x110e | 0x110f | 0x1110 | 0x1111
4038 | 0x1112 | 0x1113 | 0x1114 | 0x1115 | 0x1116 | 0x1117 | 0x1118 | 0x1119 | 0x111a
4039 | 0x111b | 0x111c | 0x111d | 0x111e | 0x111f | 0x1120 | 0x1121 | 0x1122 | 0x1123
4040 | 0x1124 | 0x1125 | 0x1126 | 0x1127 | 0x1128 | 0x1129 | 0x112a | 0x112b | 0x112c
4041 | 0x112d | 0x112e | 0x112f | 0x1130 | 0x1131 | 0x1132 | 0x1133 | 0x1134 | 0x1135
4042 | 0x1136 | 0x1137 | 0x1138 | 0x1139 | 0x113a | 0x113b | 0x113c | 0x113d | 0x113e
4043 | 0x113f | 0x1300 | 0x1301 | 0x1302 | 0x1303 | 0x1304 | 0x1305 | 0x1306 | 0x1307
4044 | 0x1308 | 0x1309 | 0x130a | 0x130b | 0x130c | 0x130d | 0x130e | 0x130f | 0x1310
4045 | 0x1311 | 0x1312 | 0x1313 | 0x1314 | 0x1315 | 0x1316 | 0x1317 | 0x1318 | 0x1319
4046 | 0x131a | 0x131b | 0x131c | 0x131d | 0x131e | 0x131f | 0x1320 | 0x1321 | 0x1322
4047 | 0x1323 | 0x1324 | 0x1325 | 0x1326 | 0x1327 | 0x1328 | 0x1329 | 0x132a | 0x132b
4048 | 0x132c | 0x132d | 0x132e | 0x132f | 0x1330 | 0x1331 | 0x1332 | 0x1333 | 0x1334
4049 | 0x1335 | 0x1336 | 0x1337 | 0x1338 | 0x1339 | 0x133a | 0x133b | 0x133c | 0x133d
4050 | 0x133e | 0x133f | 0x1500 | 0x1501 | 0x1502 | 0x1503 | 0x1504 | 0x1505 | 0x1506
4051 | 0x1507 | 0x1508 | 0x1509 | 0x150a | 0x150b | 0x150c | 0x150d | 0x150e | 0x150f
4052 | 0x1510 | 0x1511 | 0x1512 | 0x1513 | 0x1514 | 0x1515 | 0x1516 | 0x1517 | 0x1518
4053 | 0x1519 | 0x151a | 0x151b | 0x151c | 0x151d | 0x151e | 0x151f | 0x1520 | 0x1521
4054 | 0x1522 | 0x1523 | 0x1524 | 0x1525 | 0x1526 | 0x1527 | 0x1528 | 0x1529 | 0x152a
4055 | 0x152b | 0x152c | 0x152d | 0x152e | 0x152f | 0x1530 | 0x1531 | 0x1532 | 0x1533
4056 | 0x1534 | 0x1535 | 0x1536 | 0x1537 | 0x1538 | 0x1539 | 0x153a | 0x153b | 0x153c
4057 | 0x153d | 0x153e | 0x153f | 0x1580 | 0x1581 | 0x1582 | 0x1583 | 0x1584 | 0x1585
4058 | 0x1586 | 0x1587 | 0x1588 | 0x1589 | 0x158a | 0x158b | 0x158c | 0x158d | 0x158e
4059 | 0x158f | 0x1590 | 0x1591 | 0x1592 | 0x1593 | 0x1594 | 0x1595 | 0x1596 | 0x1597
4060 | 0x1598 | 0x1599 | 0x159a | 0x159b | 0x159c | 0x159d | 0x159e | 0x159f | 0x15a0
4061 | 0x15a1 | 0x15a2 | 0x15a3 | 0x15a4 | 0x15a5 | 0x15a6 | 0x15a7 | 0x15a8 | 0x15a9
4062 | 0x15aa | 0x15ab | 0x15ac | 0x15ad | 0x15ae | 0x15af | 0x15b0 | 0x15b1 | 0x15b2
4063 | 0x15b3 | 0x15b4 | 0x15b5 | 0x15b6 | 0x15b7 | 0x15b8 | 0x15b9 | 0x15ba | 0x15bb
4064 | 0x15bc | 0x15bd | 0x15be | 0x15bf | 0x1700 | 0x1701 | 0x1702 | 0x1703 | 0x1704
4065 | 0x1705 | 0x1706 | 0x1707 | 0x1708 | 0x1709 | 0x170a | 0x170b | 0x170c | 0x170d
4066 | 0x170e | 0x170f | 0x1710 | 0x1711 | 0x1712 | 0x1713 | 0x1714 | 0x1715 | 0x1716
4067 | 0x1717 | 0x1718 | 0x1719 | 0x171a | 0x171b | 0x171c | 0x171d | 0x171e | 0x171f
4068 | 0x1720 | 0x1721 | 0x1722 | 0x1723 | 0x1724 | 0x1725 | 0x1726 | 0x1727 | 0x1728
4069 | 0x1729 | 0x172a | 0x172b | 0x172c | 0x172d | 0x172e | 0x172f | 0x1730 | 0x1731
4070 | 0x1732 | 0x1733 | 0x1734 | 0x1735 | 0x1736 | 0x1737 | 0x1738 | 0x1739 | 0x173a
4071 | 0x173b | 0x173c | 0x173d | 0x173e | 0x173f | 0x1780 | 0x1781 | 0x1782 | 0x1783
4072 | 0x1784 | 0x1785 | 0x1786 | 0x1787 | 0x1788 | 0x1789 | 0x178a | 0x178b | 0x178c
4073 | 0x178d | 0x178e | 0x178f | 0x1790 | 0x1791 | 0x1792 | 0x1793 | 0x1794 | 0x1795
4074 | 0x1796 | 0x1797 | 0x1798 | 0x1799 | 0x179a | 0x179b | 0x179c | 0x179d | 0x179e
4075 | 0x179f | 0x17a0 | 0x17a1 | 0x17a2 | 0x17a3 | 0x17a4 | 0x17a5 | 0x17a6 | 0x17a7
4076 | 0x17a8 | 0x17a9 | 0x17aa | 0x17ab | 0x17ac | 0x17ad | 0x17ae | 0x17af | 0x17b0
4077 | 0x17b1 | 0x17b2 | 0x17b3 | 0x17b4 | 0x17b5 | 0x17b6 | 0x17b7 | 0x17b8 | 0x17b9
4078 | 0x17ba | 0x17bb | 0x17bc | 0x17bd | 0x17be | 0x17bf | 0x1900 | 0x1901 | 0x1902
4079 | 0x1903 | 0x1904 | 0x1905 | 0x1906 | 0x1907 | 0x1908 | 0x1909 | 0x190a | 0x190b
4080 | 0x190c | 0x190d | 0x190e | 0x190f | 0x1910 | 0x1911 | 0x1912 | 0x1913 | 0x1914
4081 | 0x1915 | 0x1916 | 0x1917 | 0x1918 | 0x1919 | 0x191a | 0x191b | 0x191c | 0x191d
4082 | 0x191e | 0x191f | 0x1920 | 0x1921 | 0x1922 | 0x1923 | 0x1924 | 0x1925 | 0x1926
4083 | 0x1927 | 0x1928 | 0x1929 | 0x192a | 0x192b | 0x192c | 0x192d | 0x192e | 0x192f
4084 | 0x1930 | 0x1931 | 0x1932 | 0x1933 | 0x1934 | 0x1935 | 0x1936 | 0x1937 | 0x1938
4085 | 0x1939 | 0x193a | 0x193b | 0x193c | 0x193d | 0x193e | 0x193f | 0x1b00 | 0x1b01
4086 | 0x1b02 | 0x1b03 | 0x1b04 | 0x1b05 | 0x1b06 | 0x1b08 | 0x1b09 | 0x1b0a | 0x1b0b
4087 | 0x1b0c | 0x1b0d | 0x1b0e | 0x1b0f | 0x1b10 | 0x1b11 | 0x1b12 | 0x1b13 | 0x1b14
4088 | 0x1b15 | 0x1b16 | 0x1b18 | 0x1b19 | 0x1b1a | 0x1b1b | 0x1b1c | 0x1b1d | 0x1b1e
4089 | 0x1b1f | 0x1b20 | 0x1b21 | 0x1b22 | 0x1b23 | 0x1b24 | 0x1b25 | 0x1b26 | 0x1b28
4090 | 0x1b29 | 0x1b2a | 0x1b2b | 0x1b2c | 0x1b2d | 0x1b2e | 0x1b2f | 0x1b30 | 0x1b31
4091 | 0x1b32 | 0x1b33 | 0x1b34 | 0x1b35 | 0x1b36 | 0x1b38 | 0x1b39 | 0x1b3a | 0x1b3b
4092 | 0x1b3c | 0x1b3d | 0x1b3e | 0x1b3f | 0x1d00 | 0x1d02 | 0x1d04 | 0x1d06 | 0x1d08
4093 | 0x1d09 | 0x1d0a | 0x1d0b | 0x1d0c | 0x1d0d | 0x1d0e | 0x1d0f | 0x1d10 | 0x1d12
4094 | 0x1d14 | 0x1d16 | 0x1d18 | 0x1d19 | 0x1d1a | 0x1d1b | 0x1d1c | 0x1d1d | 0x1d1e
4095 | 0x1d1f | 0x1d20 | 0x1d22 | 0x1d24 | 0x1d26 | 0x1d28 | 0x1d29 | 0x1d2a | 0x1d2b
4096 | 0x1d2c | 0x1d2d | 0x1d2e | 0x1d2f | 0x1d30 | 0x1d32 | 0x1d34 | 0x1d36 | 0x1d38
4097 | 0x1d39 | 0x1d3a | 0x1d3b | 0x1d3c | 0x1d3d | 0x1d3e | 0x1d3f | 0x1d80 | 0x1d81
4098 | 0x1d82 | 0x1d83 | 0x1d84 | 0x1d85 | 0x1d86 | 0x1d87 | 0x1d88 | 0x1d89 | 0x1d8a
4099 | 0x1d8b | 0x1d8c | 0x1d8d | 0x1d8e | 0x1d8f | 0x1d90 | 0x1d91 | 0x1d92 | 0x1d93
4100 | 0x1d94 | 0x1d95 | 0x1d96 | 0x1d97 | 0x1d98 | 0x1d99 | 0x1d9a | 0x1d9b | 0x1d9c
4101 | 0x1d9d | 0x1d9e | 0x1d9f | 0x1da0 | 0x1da1 | 0x1da2 | 0x1da3 | 0x1da4 | 0x1da5
4102 | 0x1da6 | 0x1da7 | 0x1da8 | 0x1da9 | 0x1daa | 0x1dab | 0x1dac | 0x1dad | 0x1dae
4103 | 0x1daf | 0x1db0 | 0x1db1 | 0x1db2 | 0x1db3 | 0x1db4 | 0x1db5 | 0x1db6 | 0x1db7
4104 | 0x1db8 | 0x1db9 | 0x1dba | 0x1dbb | 0x1dbc | 0x1dbd | 0x1dbe | 0x1dbf | 0x1f00
4105 | 0x1f01 | 0x1f02 | 0x1f03 | 0x1f04 | 0x1f05 | 0x1f06 | 0x1f07 | 0x1f08 | 0x1f09
4106 | 0x1f0a | 0x1f0b | 0x1f0c | 0x1f0d | 0x1f0e | 0x1f0f | 0x1f10 | 0x1f11 | 0x1f12
4107 | 0x1f13 | 0x1f14 | 0x1f15 | 0x1f16 | 0x1f17 | 0x1f18 | 0x1f19 | 0x1f1a | 0x1f1b
4108 | 0x1f1c | 0x1f1d | 0x1f1e | 0x1f1f | 0x1f20 | 0x1f21 | 0x1f22 | 0x1f23 | 0x1f24
4109 | 0x1f25 | 0x1f26 | 0x1f27 | 0x1f28 | 0x1f29 | 0x1f2a | 0x1f2b | 0x1f2c | 0x1f2d
4110 | 0x1f2e | 0x1f2f | 0x1f30 | 0x1f31 | 0x1f32 | 0x1f33 | 0x1f34 | 0x1f35 | 0x1f36
4111 | 0x1f37 | 0x1f38 | 0x1f39 | 0x1f3a | 0x1f3b | 0x1f3c | 0x1f3d | 0x1f3e | 0x1f3f
4112 | 0x1f80 | 0x1f81 | 0x1f82 | 0x1f83 | 0x1f84 | 0x1f85 | 0x1f86 | 0x1f87 | 0x1f88
4113 | 0x1f89 | 0x1f8a | 0x1f8b | 0x1f8c | 0x1f8d | 0x1f8e | 0x1f8f | 0x1f90 | 0x1f91
4114 | 0x1f92 | 0x1f93 | 0x1f94 | 0x1f95 | 0x1f96 | 0x1f97 | 0x1f98 | 0x1f99 | 0x1f9a
4115 | 0x1f9b | 0x1f9c | 0x1f9d | 0x1f9e | 0x1f9f | 0x1fa0 | 0x1fa1 | 0x1fa2 | 0x1fa3
4116 | 0x1fa4 | 0x1fa5 | 0x1fa6 | 0x1fa7 | 0x1fa8 | 0x1fa9 | 0x1faa | 0x1fab | 0x1fac
4117 | 0x1fad | 0x1fae | 0x1faf | 0x1fb0 | 0x1fb1 | 0x1fb2 | 0x1fb3 | 0x1fb4 | 0x1fb5
4118 | 0x1fb6 | 0x1fb7 | 0x1fb8 | 0x1fb9 | 0x1fba | 0x1fbb | 0x1fbc | 0x1fbd | 0x1fbe
4119 | 0x1fbf => {
4120 #[cfg(feature = "arm")]
4121 if let Some(ins) = parse_arm_strb_0(ins, pc, options) {
4122 return ins;
4123 }
4124 }
4125 0x1140 | 0x1141 | 0x1142 | 0x1143 | 0x1144 | 0x1145 | 0x1146 | 0x1147 | 0x1148
4126 | 0x1149 | 0x114a | 0x114b | 0x114c | 0x114d | 0x114e | 0x114f | 0x1150 | 0x1151
4127 | 0x1152 | 0x1153 | 0x1154 | 0x1155 | 0x1156 | 0x1157 | 0x1158 | 0x1159 | 0x115a
4128 | 0x115b | 0x115c | 0x115d | 0x115e | 0x115f | 0x1160 | 0x1161 | 0x1162 | 0x1163
4129 | 0x1164 | 0x1165 | 0x1166 | 0x1167 | 0x1168 | 0x1169 | 0x116a | 0x116b | 0x116c
4130 | 0x116d | 0x116e | 0x116f | 0x1170 | 0x1171 | 0x1172 | 0x1173 | 0x1174 | 0x1175
4131 | 0x1176 | 0x1177 | 0x1178 | 0x1179 | 0x117a | 0x117b | 0x117c | 0x117d | 0x117e
4132 | 0x117f | 0x1340 | 0x1341 | 0x1342 | 0x1343 | 0x1344 | 0x1345 | 0x1346 | 0x1347
4133 | 0x1348 | 0x1349 | 0x134a | 0x134b | 0x134c | 0x134d | 0x134e | 0x134f | 0x1350
4134 | 0x1351 | 0x1352 | 0x1353 | 0x1354 | 0x1355 | 0x1356 | 0x1357 | 0x1358 | 0x1359
4135 | 0x135a | 0x135b | 0x135c | 0x135d | 0x135e | 0x135f | 0x1360 | 0x1361 | 0x1362
4136 | 0x1363 | 0x1364 | 0x1365 | 0x1366 | 0x1367 | 0x1368 | 0x1369 | 0x136a | 0x136b
4137 | 0x136c | 0x136d | 0x136e | 0x136f | 0x1370 | 0x1371 | 0x1372 | 0x1373 | 0x1374
4138 | 0x1375 | 0x1376 | 0x1377 | 0x1378 | 0x1379 | 0x137a | 0x137b | 0x137c | 0x137d
4139 | 0x137e | 0x137f | 0x15c0 | 0x15c2 | 0x15c3 | 0x15c4 | 0x15c5 | 0x15c6 | 0x15c7
4140 | 0x15c8 | 0x15c9 | 0x15ca | 0x15cb | 0x15cc | 0x15cd | 0x15ce | 0x15cf | 0x15d0
4141 | 0x15d2 | 0x15d3 | 0x15d4 | 0x15d5 | 0x15d6 | 0x15d7 | 0x15d8 | 0x15d9 | 0x15da
4142 | 0x15db | 0x15dc | 0x15dd | 0x15de | 0x15df | 0x15e0 | 0x15e2 | 0x15e3 | 0x15e4
4143 | 0x15e5 | 0x15e6 | 0x15e7 | 0x15e8 | 0x15e9 | 0x15ea | 0x15eb | 0x15ec | 0x15ed
4144 | 0x15ee | 0x15ef | 0x15f0 | 0x15f2 | 0x15f3 | 0x15f4 | 0x15f5 | 0x15f6 | 0x15f7
4145 | 0x15f8 | 0x15f9 | 0x15fa | 0x15fb | 0x15fc | 0x15fd | 0x15fe | 0x15ff | 0x17c0
4146 | 0x17c1 | 0x17c2 | 0x17c3 | 0x17c4 | 0x17c5 | 0x17c6 | 0x17c7 | 0x17c8 | 0x17c9
4147 | 0x17ca | 0x17cb | 0x17cc | 0x17cd | 0x17ce | 0x17cf | 0x17d0 | 0x17d1 | 0x17d2
4148 | 0x17d3 | 0x17d4 | 0x17d5 | 0x17d6 | 0x17d7 | 0x17d8 | 0x17d9 | 0x17da | 0x17db
4149 | 0x17dc | 0x17dd | 0x17de | 0x17df | 0x17e0 | 0x17e1 | 0x17e2 | 0x17e3 | 0x17e4
4150 | 0x17e5 | 0x17e6 | 0x17e7 | 0x17e8 | 0x17e9 | 0x17ea | 0x17eb | 0x17ec | 0x17ed
4151 | 0x17ee | 0x17ef | 0x17f0 | 0x17f1 | 0x17f2 | 0x17f3 | 0x17f4 | 0x17f5 | 0x17f6
4152 | 0x17f7 | 0x17f8 | 0x17f9 | 0x17fa | 0x17fb | 0x17fc | 0x17fd | 0x17fe | 0x17ff
4153 | 0x1940 | 0x1942 | 0x1944 | 0x1946 | 0x1948 | 0x194a | 0x194b | 0x194c | 0x194d
4154 | 0x194e | 0x1950 | 0x1952 | 0x1954 | 0x1956 | 0x1958 | 0x195a | 0x195b | 0x195c
4155 | 0x195d | 0x195e | 0x1960 | 0x1962 | 0x1964 | 0x1966 | 0x1968 | 0x196a | 0x196b
4156 | 0x196c | 0x196d | 0x196e | 0x1970 | 0x1972 | 0x1974 | 0x1976 | 0x1978 | 0x197a
4157 | 0x197b | 0x197c | 0x197d | 0x197e | 0x1b40 | 0x1b41 | 0x1b42 | 0x1b43 | 0x1b44
4158 | 0x1b45 | 0x1b46 | 0x1b47 | 0x1b48 | 0x1b49 | 0x1b4a | 0x1b4b | 0x1b4c | 0x1b4d
4159 | 0x1b4e | 0x1b4f | 0x1b50 | 0x1b51 | 0x1b52 | 0x1b53 | 0x1b54 | 0x1b55 | 0x1b56
4160 | 0x1b57 | 0x1b58 | 0x1b59 | 0x1b5a | 0x1b5b | 0x1b5c | 0x1b5d | 0x1b5e | 0x1b5f
4161 | 0x1b60 | 0x1b61 | 0x1b62 | 0x1b63 | 0x1b64 | 0x1b65 | 0x1b66 | 0x1b67 | 0x1b68
4162 | 0x1b69 | 0x1b6a | 0x1b6b | 0x1b6c | 0x1b6d | 0x1b6e | 0x1b6f | 0x1b70 | 0x1b71
4163 | 0x1b72 | 0x1b73 | 0x1b74 | 0x1b75 | 0x1b76 | 0x1b77 | 0x1b78 | 0x1b79 | 0x1b7a
4164 | 0x1b7b | 0x1b7c | 0x1b7d | 0x1b7e | 0x1b7f | 0x1dc0 | 0x1dc1 | 0x1dc2 | 0x1dc3
4165 | 0x1dc4 | 0x1dc5 | 0x1dc6 | 0x1dc7 | 0x1dc8 | 0x1dc9 | 0x1dca | 0x1dcb | 0x1dcc
4166 | 0x1dcd | 0x1dce | 0x1dcf | 0x1dd0 | 0x1dd1 | 0x1dd2 | 0x1dd3 | 0x1dd4 | 0x1dd5
4167 | 0x1dd6 | 0x1dd7 | 0x1dd8 | 0x1dd9 | 0x1dda | 0x1ddb | 0x1ddc | 0x1ddd | 0x1dde
4168 | 0x1ddf | 0x1de0 | 0x1de1 | 0x1de2 | 0x1de3 | 0x1de4 | 0x1de5 | 0x1de6 | 0x1de7
4169 | 0x1de8 | 0x1de9 | 0x1dea | 0x1deb | 0x1dec | 0x1ded | 0x1dee | 0x1def | 0x1df0
4170 | 0x1df1 | 0x1df2 | 0x1df3 | 0x1df4 | 0x1df5 | 0x1df6 | 0x1df7 | 0x1df8 | 0x1df9
4171 | 0x1dfa | 0x1dfb | 0x1dfc | 0x1dfd | 0x1dfe | 0x1dff | 0x1fc0 | 0x1fc1 | 0x1fc2
4172 | 0x1fc3 | 0x1fc4 | 0x1fc5 | 0x1fc6 | 0x1fc7 | 0x1fc8 | 0x1fc9 | 0x1fca | 0x1fcb
4173 | 0x1fcc | 0x1fcd | 0x1fce | 0x1fd0 | 0x1fd1 | 0x1fd2 | 0x1fd3 | 0x1fd4 | 0x1fd5
4174 | 0x1fd6 | 0x1fd7 | 0x1fd8 | 0x1fd9 | 0x1fda | 0x1fdb | 0x1fdc | 0x1fdd | 0x1fde
4175 | 0x1fe0 | 0x1fe1 | 0x1fe2 | 0x1fe3 | 0x1fe4 | 0x1fe5 | 0x1fe6 | 0x1fe7 | 0x1fe8
4176 | 0x1fe9 | 0x1fea | 0x1feb | 0x1fec | 0x1fed | 0x1fee | 0x1ff0 | 0x1ff1 | 0x1ff2
4177 | 0x1ff3 | 0x1ff4 | 0x1ff5 | 0x1ff6 | 0x1ff7 | 0x1ff8 | 0x1ff9 | 0x1ffa | 0x1ffb
4178 | 0x1ffc | 0x1ffd | 0x1ffe => {
4179 #[cfg(feature = "arm")]
4180 if let Some(ins) = parse_arm_ldrb_0(ins, pc, options) {
4181 return ins;
4182 }
4183 }
4184 0x1180 | 0x1181 | 0x1182 | 0x1183 | 0x1184 | 0x1185 | 0x1186 | 0x1187 | 0x1188
4185 | 0x1189 | 0x118a | 0x118b | 0x118c | 0x118d | 0x118e | 0x118f | 0x1190 | 0x1191
4186 | 0x1192 | 0x1193 | 0x1194 | 0x1195 | 0x1196 | 0x1197 | 0x1198 | 0x1199 | 0x119a
4187 | 0x119b | 0x119c | 0x119d | 0x119e | 0x119f | 0x11a0 | 0x11a1 | 0x11a2 | 0x11a3
4188 | 0x11a4 | 0x11a5 | 0x11a6 | 0x11a7 | 0x11a8 | 0x11a9 | 0x11aa | 0x11ab | 0x11ac
4189 | 0x11ad | 0x11ae | 0x11af | 0x11b0 | 0x11b1 | 0x11b2 | 0x11b3 | 0x11b4 | 0x11b5
4190 | 0x11b6 | 0x11b7 | 0x11b8 | 0x11b9 | 0x11ba | 0x11bb | 0x11bc | 0x11bd | 0x11be
4191 | 0x11bf | 0x1380 | 0x1381 | 0x1382 | 0x1383 | 0x1384 | 0x1385 | 0x1386 | 0x1387
4192 | 0x1388 | 0x1389 | 0x138a | 0x138b | 0x138c | 0x138d | 0x138e | 0x138f | 0x1390
4193 | 0x1391 | 0x1392 | 0x1393 | 0x1394 | 0x1395 | 0x1396 | 0x1397 | 0x1398 | 0x1399
4194 | 0x139a | 0x139b | 0x139c | 0x139d | 0x139e | 0x139f | 0x13a0 | 0x13a1 | 0x13a2
4195 | 0x13a3 | 0x13a4 | 0x13a5 | 0x13a6 | 0x13a7 | 0x13a8 | 0x13a9 | 0x13aa | 0x13ab
4196 | 0x13ac | 0x13ad | 0x13ae | 0x13af | 0x13b0 | 0x13b1 | 0x13b2 | 0x13b3 | 0x13b4
4197 | 0x13b5 | 0x13b6 | 0x13b7 | 0x13b8 | 0x13b9 | 0x13ba | 0x13bb | 0x13bc | 0x13bd
4198 | 0x13be | 0x13bf | 0x1980 | 0x1982 | 0x1984 | 0x1986 | 0x1988 | 0x198a | 0x198b
4199 | 0x198c | 0x198d | 0x198e | 0x1990 | 0x1992 | 0x1994 | 0x1996 | 0x1998 | 0x199a
4200 | 0x199b | 0x199c | 0x199d | 0x199e | 0x19a0 | 0x19a2 | 0x19a4 | 0x19a6 | 0x19a8
4201 | 0x19aa | 0x19ab | 0x19ac | 0x19ad | 0x19ae | 0x19b0 | 0x19b2 | 0x19b4 | 0x19b6
4202 | 0x19b8 | 0x19ba | 0x19bb | 0x19bc | 0x19bd | 0x19be | 0x1b80 | 0x1b82 | 0x1b84
4203 | 0x1b86 | 0x1b88 | 0x1b8a | 0x1b8b | 0x1b8c | 0x1b8e | 0x1b8f | 0x1b90 | 0x1b92
4204 | 0x1b94 | 0x1b96 | 0x1b98 | 0x1b9a | 0x1b9b | 0x1b9c | 0x1b9e | 0x1b9f | 0x1ba0
4205 | 0x1ba2 | 0x1ba4 | 0x1ba6 | 0x1ba8 | 0x1baa | 0x1bab | 0x1bac | 0x1bae | 0x1baf
4206 | 0x1bb0 | 0x1bb2 | 0x1bb4 | 0x1bb6 | 0x1bb8 | 0x1bba | 0x1bbb | 0x1bbc | 0x1bbe
4207 | 0x1bbf => {
4208 #[cfg(feature = "arm")]
4209 if (ins & 0xd700000) == 0x4600000
4210 && let Some(ins) = parse_arm_strbt_0(ins, pc, options)
4211 {
4212 return ins;
4213 }
4214 #[cfg(feature = "arm")]
4215 if (ins & 0xc500000) == 0x4400000
4216 && let Some(ins) = parse_arm_strb_0(ins, pc, options)
4217 {
4218 return ins;
4219 }
4220 }
4221 0x11c0 | 0x11c1 | 0x11c2 | 0x11c3 | 0x11c4 | 0x11c5 | 0x11c6 | 0x11c7 | 0x11c8
4222 | 0x11c9 | 0x11ca | 0x11cb | 0x11cc | 0x11cd | 0x11ce | 0x11cf | 0x11d0 | 0x11d1
4223 | 0x11d2 | 0x11d3 | 0x11d4 | 0x11d5 | 0x11d6 | 0x11d7 | 0x11d8 | 0x11d9 | 0x11da
4224 | 0x11db | 0x11dc | 0x11dd | 0x11de | 0x11df | 0x11e0 | 0x11e1 | 0x11e2 | 0x11e3
4225 | 0x11e4 | 0x11e5 | 0x11e6 | 0x11e7 | 0x11e8 | 0x11e9 | 0x11ea | 0x11eb | 0x11ec
4226 | 0x11ed | 0x11ee | 0x11ef | 0x11f0 | 0x11f1 | 0x11f2 | 0x11f3 | 0x11f4 | 0x11f5
4227 | 0x11f6 | 0x11f7 | 0x11f8 | 0x11f9 | 0x11fa | 0x11fb | 0x11fc | 0x11fd | 0x11fe
4228 | 0x11ff | 0x13c0 | 0x13c1 | 0x13c2 | 0x13c3 | 0x13c4 | 0x13c5 | 0x13c6 | 0x13c7
4229 | 0x13c8 | 0x13c9 | 0x13ca | 0x13cb | 0x13cc | 0x13cd | 0x13ce | 0x13cf | 0x13d0
4230 | 0x13d1 | 0x13d2 | 0x13d3 | 0x13d4 | 0x13d5 | 0x13d6 | 0x13d7 | 0x13d8 | 0x13d9
4231 | 0x13da | 0x13db | 0x13dc | 0x13dd | 0x13de | 0x13df | 0x13e0 | 0x13e1 | 0x13e2
4232 | 0x13e3 | 0x13e4 | 0x13e5 | 0x13e6 | 0x13e7 | 0x13e8 | 0x13e9 | 0x13ea | 0x13eb
4233 | 0x13ec | 0x13ed | 0x13ee | 0x13ef | 0x13f0 | 0x13f1 | 0x13f2 | 0x13f3 | 0x13f4
4234 | 0x13f5 | 0x13f6 | 0x13f7 | 0x13f8 | 0x13f9 | 0x13fa | 0x13fb | 0x13fc | 0x13fd
4235 | 0x13fe | 0x13ff | 0x19c0 | 0x19c2 | 0x19c4 | 0x19c6 | 0x19c8 | 0x19ca | 0x19cb
4236 | 0x19cc | 0x19cd | 0x19ce | 0x19d0 | 0x19d2 | 0x19d4 | 0x19d6 | 0x19d8 | 0x19da
4237 | 0x19db | 0x19dc | 0x19dd | 0x19de | 0x19e0 | 0x19e2 | 0x19e4 | 0x19e6 | 0x19e8
4238 | 0x19ea | 0x19eb | 0x19ec | 0x19ed | 0x19ee | 0x19f0 | 0x19f2 | 0x19f4 | 0x19f6
4239 | 0x19f8 | 0x19fa | 0x19fb | 0x19fc | 0x19fd | 0x19fe | 0x1bc0 | 0x1bc2 | 0x1bc3
4240 | 0x1bc4 | 0x1bc6 | 0x1bc8 | 0x1bca | 0x1bcc | 0x1bce | 0x1bcf | 0x1bd0 | 0x1bd2
4241 | 0x1bd3 | 0x1bd4 | 0x1bd6 | 0x1bd8 | 0x1bda | 0x1bdc | 0x1bde | 0x1bdf | 0x1be0
4242 | 0x1be2 | 0x1be3 | 0x1be4 | 0x1be6 | 0x1be8 | 0x1bea | 0x1bec | 0x1bee | 0x1bef
4243 | 0x1bf0 | 0x1bf2 | 0x1bf3 | 0x1bf4 | 0x1bf6 | 0x1bf8 | 0x1bfa | 0x1bfc | 0x1bfe
4244 | 0x1bff => {
4245 #[cfg(feature = "arm")]
4246 if (ins & 0xd700000) == 0x4700000
4247 && let Some(ins) = parse_arm_ldrbt_0(ins, pc, options)
4248 {
4249 return ins;
4250 }
4251 #[cfg(feature = "arm")]
4252 if (ins & 0xc500000) == 0x4500000
4253 && let Some(ins) = parse_arm_ldrb_0(ins, pc, options)
4254 {
4255 return ins;
4256 }
4257 }
4258 0x1260 => {
4259 #[cfg(feature = "arm")]
4260 if (ins & 0xfff0fff) == 0x49d0004
4261 && let Some(ins) = parse_arm_pop_1(ins, pc, options)
4262 {
4263 return ins;
4264 }
4265 #[cfg(feature = "arm")]
4266 if (ins & 0xc500000) == 0x4100000
4267 && let Some(ins) = parse_arm_ldr_0(ins, pc, options)
4268 {
4269 return ins;
4270 }
4271 }
4272 0x14a0 => {
4273 #[cfg(feature = "arm")]
4274 if (ins & 0xfff0fff) == 0x52d0004
4275 && let Some(ins) = parse_arm_push_1(ins, pc, options)
4276 {
4277 return ins;
4278 }
4279 #[cfg(feature = "arm")]
4280 if (ins & 0xc500000) == 0x4000000
4281 && let Some(ins) = parse_arm_str_0(ins, pc, options)
4282 {
4283 return ins;
4284 }
4285 }
4286 0x1540 | 0x1541 | 0x1542 | 0x1543 | 0x1544 | 0x1545 | 0x1546 | 0x1547 | 0x1548
4287 | 0x1549 | 0x154a | 0x154b | 0x154c | 0x154d | 0x154e | 0x154f | 0x1550 | 0x1551
4288 | 0x1552 | 0x1553 | 0x1554 | 0x1555 | 0x1556 | 0x1557 | 0x1558 | 0x1559 | 0x155a
4289 | 0x155b | 0x155c | 0x155d | 0x155e | 0x155f | 0x1560 | 0x1561 | 0x1562 | 0x1563
4290 | 0x1564 | 0x1565 | 0x1566 | 0x1567 | 0x1568 | 0x1569 | 0x156a | 0x156b | 0x156c
4291 | 0x156d | 0x156e | 0x156f | 0x1570 | 0x1571 | 0x1572 | 0x1573 | 0x1574 | 0x1575
4292 | 0x1576 | 0x1577 | 0x1578 | 0x1579 | 0x157a | 0x157b | 0x157c | 0x157d | 0x157e
4293 | 0x157f | 0x1740 | 0x1741 | 0x1742 | 0x1743 | 0x1744 | 0x1745 | 0x1746 | 0x1747
4294 | 0x1748 | 0x1749 | 0x174a | 0x174b | 0x174c | 0x174d | 0x174e | 0x174f | 0x1750
4295 | 0x1751 | 0x1752 | 0x1753 | 0x1754 | 0x1755 | 0x1756 | 0x1757 | 0x1758 | 0x1759
4296 | 0x175a | 0x175b | 0x175c | 0x175d | 0x175e | 0x175f | 0x1760 | 0x1761 | 0x1762
4297 | 0x1763 | 0x1764 | 0x1765 | 0x1766 | 0x1767 | 0x1768 | 0x1769 | 0x176a | 0x176b
4298 | 0x176c | 0x176d | 0x176e | 0x176f | 0x1770 | 0x1771 | 0x1772 | 0x1773 | 0x1774
4299 | 0x1775 | 0x1776 | 0x1777 | 0x1778 | 0x1779 | 0x177a | 0x177b | 0x177c | 0x177d
4300 | 0x177e | 0x177f | 0x1d40 | 0x1d42 | 0x1d44 | 0x1d45 | 0x1d46 | 0x1d47 | 0x1d48
4301 | 0x1d49 | 0x1d4a | 0x1d4b | 0x1d4c | 0x1d4e | 0x1d50 | 0x1d52 | 0x1d54 | 0x1d55
4302 | 0x1d56 | 0x1d57 | 0x1d58 | 0x1d59 | 0x1d5a | 0x1d5b | 0x1d5c | 0x1d5e | 0x1d60
4303 | 0x1d62 | 0x1d64 | 0x1d65 | 0x1d66 | 0x1d67 | 0x1d68 | 0x1d69 | 0x1d6a | 0x1d6b
4304 | 0x1d6c | 0x1d6e | 0x1d70 | 0x1d72 | 0x1d74 | 0x1d75 | 0x1d76 | 0x1d77 | 0x1d78
4305 | 0x1d79 | 0x1d7a | 0x1d7b | 0x1d7c | 0x1d7e | 0x1f40 | 0x1f41 | 0x1f42 | 0x1f43
4306 | 0x1f44 | 0x1f45 | 0x1f46 | 0x1f47 | 0x1f48 | 0x1f49 | 0x1f4a | 0x1f4b | 0x1f4c
4307 | 0x1f4d | 0x1f4e | 0x1f4f | 0x1f50 | 0x1f51 | 0x1f52 | 0x1f53 | 0x1f54 | 0x1f55
4308 | 0x1f56 | 0x1f57 | 0x1f58 | 0x1f59 | 0x1f5a | 0x1f5b | 0x1f5c | 0x1f5d | 0x1f5e
4309 | 0x1f5f | 0x1f60 | 0x1f61 | 0x1f62 | 0x1f63 | 0x1f64 | 0x1f65 | 0x1f66 | 0x1f67
4310 | 0x1f68 | 0x1f69 | 0x1f6a | 0x1f6b | 0x1f6c | 0x1f6d | 0x1f6e | 0x1f6f | 0x1f70
4311 | 0x1f71 | 0x1f72 | 0x1f73 | 0x1f74 | 0x1f75 | 0x1f76 | 0x1f77 | 0x1f78 | 0x1f79
4312 | 0x1f7a | 0x1f7b | 0x1f7c | 0x1f7d | 0x1f7e | 0x1f7f => {
4313 #[cfg(
4314 all(
4315 feature = "arm",
4316 any(
4317 feature = "v5te",
4318 feature = "v5tej",
4319 feature = "v6",
4320 feature = "v6k"
4321 )
4322 )
4323 )]
4324 if (ins & 0xfd700000) == 0xf5500000
4325 && let Some(ins) = parse_arm_pld_0(ins, pc, options)
4326 {
4327 return ins;
4328 }
4329 #[cfg(feature = "arm")]
4330 if (ins & 0xc500000) == 0x4500000
4331 && let Some(ins) = parse_arm_ldrb_0(ins, pc, options)
4332 {
4333 return ins;
4334 }
4335 }
4336 0x15c1 | 0x15d1 | 0x15e1 | 0x15f1 => {
4337 #[cfg(all(feature = "arm", feature = "v6k"))]
4338 if (ins & 0xfff000f0) == 0xf5700010
4339 && let Some(ins) = parse_arm_clrex_0(ins, pc, options)
4340 {
4341 return ins;
4342 }
4343 #[cfg(feature = "arm")]
4344 if (ins & 0xc500000) == 0x4500000
4345 && let Some(ins) = parse_arm_ldrb_0(ins, pc, options)
4346 {
4347 return ins;
4348 }
4349 }
4350 0x1841 | 0x1851 | 0x1861 | 0x1871 => {
4351 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4352 if (ins & 0xff000f0) == 0x6100010
4353 && let Some(ins) = parse_arm_sadd16_0(ins, pc, options)
4354 {
4355 return ins;
4356 }
4357 #[cfg(feature = "arm")]
4358 if (ins & 0xc500000) == 0x4100000
4359 && let Some(ins) = parse_arm_ldr_0(ins, pc, options)
4360 {
4361 return ins;
4362 }
4363 }
4364 0x1843 | 0x1853 | 0x1863 | 0x1873 => {
4365 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4366 if (ins & 0xff000f0) == 0x6100030
4367 && let Some(ins) = parse_arm_sasx_0(ins, pc, options)
4368 {
4369 return ins;
4370 }
4371 #[cfg(feature = "arm")]
4372 if (ins & 0xc500000) == 0x4100000
4373 && let Some(ins) = parse_arm_ldr_0(ins, pc, options)
4374 {
4375 return ins;
4376 }
4377 }
4378 0x1845 | 0x1855 | 0x1865 | 0x1875 => {
4379 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4380 if (ins & 0xff000f0) == 0x6100050
4381 && let Some(ins) = parse_arm_ssax_0(ins, pc, options)
4382 {
4383 return ins;
4384 }
4385 #[cfg(feature = "arm")]
4386 if (ins & 0xc500000) == 0x4100000
4387 && let Some(ins) = parse_arm_ldr_0(ins, pc, options)
4388 {
4389 return ins;
4390 }
4391 }
4392 0x1847 | 0x1857 | 0x1867 | 0x1877 => {
4393 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4394 if (ins & 0xff000f0) == 0x6100070
4395 && let Some(ins) = parse_arm_ssub16_0(ins, pc, options)
4396 {
4397 return ins;
4398 }
4399 #[cfg(feature = "arm")]
4400 if (ins & 0xc500000) == 0x4100000
4401 && let Some(ins) = parse_arm_ldr_0(ins, pc, options)
4402 {
4403 return ins;
4404 }
4405 }
4406 0x1849 | 0x1859 | 0x1869 | 0x1879 => {
4407 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4408 if (ins & 0xff000f0) == 0x6100090
4409 && let Some(ins) = parse_arm_sadd8_0(ins, pc, options)
4410 {
4411 return ins;
4412 }
4413 #[cfg(feature = "arm")]
4414 if (ins & 0xc500000) == 0x4100000
4415 && let Some(ins) = parse_arm_ldr_0(ins, pc, options)
4416 {
4417 return ins;
4418 }
4419 }
4420 0x184f | 0x185f | 0x186f | 0x187f => {
4421 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4422 if (ins & 0xff000f0) == 0x61000f0
4423 && let Some(ins) = parse_arm_ssub8_0(ins, pc, options)
4424 {
4425 return ins;
4426 }
4427 #[cfg(feature = "arm")]
4428 if (ins & 0xc500000) == 0x4100000
4429 && let Some(ins) = parse_arm_ldr_0(ins, pc, options)
4430 {
4431 return ins;
4432 }
4433 }
4434 0x1881 | 0x1891 | 0x18a1 | 0x18b1 => {
4435 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4436 if (ins & 0xff000f0) == 0x6200010
4437 && let Some(ins) = parse_arm_qadd16_0(ins, pc, options)
4438 {
4439 return ins;
4440 }
4441 #[cfg(feature = "arm")]
4442 if (ins & 0xd700000) == 0x4200000
4443 && let Some(ins) = parse_arm_strt_0(ins, pc, options)
4444 {
4445 return ins;
4446 }
4447 #[cfg(feature = "arm")]
4448 if (ins & 0xc500000) == 0x4000000
4449 && let Some(ins) = parse_arm_str_0(ins, pc, options)
4450 {
4451 return ins;
4452 }
4453 }
4454 0x1883 | 0x1893 | 0x18a3 | 0x18b3 => {
4455 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4456 if (ins & 0xff000f0) == 0x6200030
4457 && let Some(ins) = parse_arm_qasx_0(ins, pc, options)
4458 {
4459 return ins;
4460 }
4461 #[cfg(feature = "arm")]
4462 if (ins & 0xd700000) == 0x4200000
4463 && let Some(ins) = parse_arm_strt_0(ins, pc, options)
4464 {
4465 return ins;
4466 }
4467 #[cfg(feature = "arm")]
4468 if (ins & 0xc500000) == 0x4000000
4469 && let Some(ins) = parse_arm_str_0(ins, pc, options)
4470 {
4471 return ins;
4472 }
4473 }
4474 0x1885 | 0x1895 | 0x18a5 | 0x18b5 => {
4475 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4476 if (ins & 0xff000f0) == 0x6200050
4477 && let Some(ins) = parse_arm_qsax_0(ins, pc, options)
4478 {
4479 return ins;
4480 }
4481 #[cfg(feature = "arm")]
4482 if (ins & 0xd700000) == 0x4200000
4483 && let Some(ins) = parse_arm_strt_0(ins, pc, options)
4484 {
4485 return ins;
4486 }
4487 #[cfg(feature = "arm")]
4488 if (ins & 0xc500000) == 0x4000000
4489 && let Some(ins) = parse_arm_str_0(ins, pc, options)
4490 {
4491 return ins;
4492 }
4493 }
4494 0x1887 | 0x1897 | 0x18a7 | 0x18b7 => {
4495 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4496 if (ins & 0xff000f0) == 0x6200070
4497 && let Some(ins) = parse_arm_qsub16_0(ins, pc, options)
4498 {
4499 return ins;
4500 }
4501 #[cfg(feature = "arm")]
4502 if (ins & 0xd700000) == 0x4200000
4503 && let Some(ins) = parse_arm_strt_0(ins, pc, options)
4504 {
4505 return ins;
4506 }
4507 #[cfg(feature = "arm")]
4508 if (ins & 0xc500000) == 0x4000000
4509 && let Some(ins) = parse_arm_str_0(ins, pc, options)
4510 {
4511 return ins;
4512 }
4513 }
4514 0x1889 | 0x1899 | 0x18a9 | 0x18b9 => {
4515 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4516 if (ins & 0xff000f0) == 0x6200090
4517 && let Some(ins) = parse_arm_qadd8_0(ins, pc, options)
4518 {
4519 return ins;
4520 }
4521 #[cfg(feature = "arm")]
4522 if (ins & 0xd700000) == 0x4200000
4523 && let Some(ins) = parse_arm_strt_0(ins, pc, options)
4524 {
4525 return ins;
4526 }
4527 #[cfg(feature = "arm")]
4528 if (ins & 0xc500000) == 0x4000000
4529 && let Some(ins) = parse_arm_str_0(ins, pc, options)
4530 {
4531 return ins;
4532 }
4533 }
4534 0x188f | 0x189f | 0x18af | 0x18bf => {
4535 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4536 if (ins & 0xff000f0) == 0x62000f0
4537 && let Some(ins) = parse_arm_qsub8_0(ins, pc, options)
4538 {
4539 return ins;
4540 }
4541 #[cfg(feature = "arm")]
4542 if (ins & 0xd700000) == 0x4200000
4543 && let Some(ins) = parse_arm_strt_0(ins, pc, options)
4544 {
4545 return ins;
4546 }
4547 #[cfg(feature = "arm")]
4548 if (ins & 0xc500000) == 0x4000000
4549 && let Some(ins) = parse_arm_str_0(ins, pc, options)
4550 {
4551 return ins;
4552 }
4553 }
4554 0x18c1 | 0x18d1 | 0x18e1 | 0x18f1 => {
4555 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4556 if (ins & 0xff000f0) == 0x6300010
4557 && let Some(ins) = parse_arm_shadd16_0(ins, pc, options)
4558 {
4559 return ins;
4560 }
4561 #[cfg(feature = "arm")]
4562 if (ins & 0xd700000) == 0x4300000
4563 && let Some(ins) = parse_arm_ldrt_0(ins, pc, options)
4564 {
4565 return ins;
4566 }
4567 #[cfg(feature = "arm")]
4568 if (ins & 0xc500000) == 0x4100000
4569 && let Some(ins) = parse_arm_ldr_0(ins, pc, options)
4570 {
4571 return ins;
4572 }
4573 }
4574 0x18c3 | 0x18d3 | 0x18e3 | 0x18f3 => {
4575 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4576 if (ins & 0xff000f0) == 0x6300030
4577 && let Some(ins) = parse_arm_shasx_0(ins, pc, options)
4578 {
4579 return ins;
4580 }
4581 #[cfg(feature = "arm")]
4582 if (ins & 0xd700000) == 0x4300000
4583 && let Some(ins) = parse_arm_ldrt_0(ins, pc, options)
4584 {
4585 return ins;
4586 }
4587 #[cfg(feature = "arm")]
4588 if (ins & 0xc500000) == 0x4100000
4589 && let Some(ins) = parse_arm_ldr_0(ins, pc, options)
4590 {
4591 return ins;
4592 }
4593 }
4594 0x18c5 | 0x18d5 | 0x18e5 | 0x18f5 => {
4595 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4596 if (ins & 0xff000f0) == 0x6300050
4597 && let Some(ins) = parse_arm_shsax_0(ins, pc, options)
4598 {
4599 return ins;
4600 }
4601 #[cfg(feature = "arm")]
4602 if (ins & 0xd700000) == 0x4300000
4603 && let Some(ins) = parse_arm_ldrt_0(ins, pc, options)
4604 {
4605 return ins;
4606 }
4607 #[cfg(feature = "arm")]
4608 if (ins & 0xc500000) == 0x4100000
4609 && let Some(ins) = parse_arm_ldr_0(ins, pc, options)
4610 {
4611 return ins;
4612 }
4613 }
4614 0x18c7 | 0x18d7 | 0x18e7 | 0x18f7 => {
4615 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4616 if (ins & 0xff000f0) == 0x6300070
4617 && let Some(ins) = parse_arm_shsub16_0(ins, pc, options)
4618 {
4619 return ins;
4620 }
4621 #[cfg(feature = "arm")]
4622 if (ins & 0xd700000) == 0x4300000
4623 && let Some(ins) = parse_arm_ldrt_0(ins, pc, options)
4624 {
4625 return ins;
4626 }
4627 #[cfg(feature = "arm")]
4628 if (ins & 0xc500000) == 0x4100000
4629 && let Some(ins) = parse_arm_ldr_0(ins, pc, options)
4630 {
4631 return ins;
4632 }
4633 }
4634 0x18c9 | 0x18d9 | 0x18e9 | 0x18f9 => {
4635 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4636 if (ins & 0xff000f0) == 0x6300090
4637 && let Some(ins) = parse_arm_shadd8_0(ins, pc, options)
4638 {
4639 return ins;
4640 }
4641 #[cfg(feature = "arm")]
4642 if (ins & 0xd700000) == 0x4300000
4643 && let Some(ins) = parse_arm_ldrt_0(ins, pc, options)
4644 {
4645 return ins;
4646 }
4647 #[cfg(feature = "arm")]
4648 if (ins & 0xc500000) == 0x4100000
4649 && let Some(ins) = parse_arm_ldr_0(ins, pc, options)
4650 {
4651 return ins;
4652 }
4653 }
4654 0x18cf | 0x18df | 0x18ef | 0x18ff => {
4655 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4656 if (ins & 0xff000f0) == 0x63000f0
4657 && let Some(ins) = parse_arm_shsub8_0(ins, pc, options)
4658 {
4659 return ins;
4660 }
4661 #[cfg(feature = "arm")]
4662 if (ins & 0xd700000) == 0x4300000
4663 && let Some(ins) = parse_arm_ldrt_0(ins, pc, options)
4664 {
4665 return ins;
4666 }
4667 #[cfg(feature = "arm")]
4668 if (ins & 0xc500000) == 0x4100000
4669 && let Some(ins) = parse_arm_ldr_0(ins, pc, options)
4670 {
4671 return ins;
4672 }
4673 }
4674 0x1941 | 0x1951 | 0x1961 | 0x1971 => {
4675 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4676 if (ins & 0xff000f0) == 0x6500010
4677 && let Some(ins) = parse_arm_uadd16_0(ins, pc, options)
4678 {
4679 return ins;
4680 }
4681 #[cfg(feature = "arm")]
4682 if (ins & 0xc500000) == 0x4500000
4683 && let Some(ins) = parse_arm_ldrb_0(ins, pc, options)
4684 {
4685 return ins;
4686 }
4687 }
4688 0x1943 | 0x1953 | 0x1963 | 0x1973 => {
4689 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4690 if (ins & 0xff000f0) == 0x6500030
4691 && let Some(ins) = parse_arm_uasx_0(ins, pc, options)
4692 {
4693 return ins;
4694 }
4695 #[cfg(feature = "arm")]
4696 if (ins & 0xc500000) == 0x4500000
4697 && let Some(ins) = parse_arm_ldrb_0(ins, pc, options)
4698 {
4699 return ins;
4700 }
4701 }
4702 0x1945 | 0x1955 | 0x1965 | 0x1975 => {
4703 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4704 if (ins & 0xff000f0) == 0x6500050
4705 && let Some(ins) = parse_arm_usax_0(ins, pc, options)
4706 {
4707 return ins;
4708 }
4709 #[cfg(feature = "arm")]
4710 if (ins & 0xc500000) == 0x4500000
4711 && let Some(ins) = parse_arm_ldrb_0(ins, pc, options)
4712 {
4713 return ins;
4714 }
4715 }
4716 0x1947 | 0x1957 | 0x1967 | 0x1977 => {
4717 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4718 if (ins & 0xff000f0) == 0x6500070
4719 && let Some(ins) = parse_arm_usub16_0(ins, pc, options)
4720 {
4721 return ins;
4722 }
4723 #[cfg(feature = "arm")]
4724 if (ins & 0xc500000) == 0x4500000
4725 && let Some(ins) = parse_arm_ldrb_0(ins, pc, options)
4726 {
4727 return ins;
4728 }
4729 }
4730 0x1949 | 0x1959 | 0x1969 | 0x1979 => {
4731 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4732 if (ins & 0xff000f0) == 0x6500090
4733 && let Some(ins) = parse_arm_uadd8_0(ins, pc, options)
4734 {
4735 return ins;
4736 }
4737 #[cfg(feature = "arm")]
4738 if (ins & 0xc500000) == 0x4500000
4739 && let Some(ins) = parse_arm_ldrb_0(ins, pc, options)
4740 {
4741 return ins;
4742 }
4743 }
4744 0x194f | 0x195f | 0x196f | 0x197f => {
4745 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4746 if (ins & 0xff000f0) == 0x65000f0
4747 && let Some(ins) = parse_arm_usub8_0(ins, pc, options)
4748 {
4749 return ins;
4750 }
4751 #[cfg(feature = "arm")]
4752 if (ins & 0xc500000) == 0x4500000
4753 && let Some(ins) = parse_arm_ldrb_0(ins, pc, options)
4754 {
4755 return ins;
4756 }
4757 }
4758 0x1981 | 0x1991 | 0x19a1 | 0x19b1 => {
4759 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4760 if (ins & 0xff000f0) == 0x6600010
4761 && let Some(ins) = parse_arm_uqadd16_0(ins, pc, options)
4762 {
4763 return ins;
4764 }
4765 #[cfg(feature = "arm")]
4766 if (ins & 0xd700000) == 0x4600000
4767 && let Some(ins) = parse_arm_strbt_0(ins, pc, options)
4768 {
4769 return ins;
4770 }
4771 #[cfg(feature = "arm")]
4772 if (ins & 0xc500000) == 0x4400000
4773 && let Some(ins) = parse_arm_strb_0(ins, pc, options)
4774 {
4775 return ins;
4776 }
4777 }
4778 0x1983 | 0x1993 | 0x19a3 | 0x19b3 => {
4779 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4780 if (ins & 0xff000f0) == 0x6600030
4781 && let Some(ins) = parse_arm_uqasx_0(ins, pc, options)
4782 {
4783 return ins;
4784 }
4785 #[cfg(feature = "arm")]
4786 if (ins & 0xd700000) == 0x4600000
4787 && let Some(ins) = parse_arm_strbt_0(ins, pc, options)
4788 {
4789 return ins;
4790 }
4791 #[cfg(feature = "arm")]
4792 if (ins & 0xc500000) == 0x4400000
4793 && let Some(ins) = parse_arm_strb_0(ins, pc, options)
4794 {
4795 return ins;
4796 }
4797 }
4798 0x1985 | 0x1995 | 0x19a5 | 0x19b5 => {
4799 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4800 if (ins & 0xff000f0) == 0x6600050
4801 && let Some(ins) = parse_arm_uqsax_0(ins, pc, options)
4802 {
4803 return ins;
4804 }
4805 #[cfg(feature = "arm")]
4806 if (ins & 0xd700000) == 0x4600000
4807 && let Some(ins) = parse_arm_strbt_0(ins, pc, options)
4808 {
4809 return ins;
4810 }
4811 #[cfg(feature = "arm")]
4812 if (ins & 0xc500000) == 0x4400000
4813 && let Some(ins) = parse_arm_strb_0(ins, pc, options)
4814 {
4815 return ins;
4816 }
4817 }
4818 0x1987 | 0x1997 | 0x19a7 | 0x19b7 => {
4819 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4820 if (ins & 0xff000f0) == 0x6600070
4821 && let Some(ins) = parse_arm_uqsub16_0(ins, pc, options)
4822 {
4823 return ins;
4824 }
4825 #[cfg(feature = "arm")]
4826 if (ins & 0xd700000) == 0x4600000
4827 && let Some(ins) = parse_arm_strbt_0(ins, pc, options)
4828 {
4829 return ins;
4830 }
4831 #[cfg(feature = "arm")]
4832 if (ins & 0xc500000) == 0x4400000
4833 && let Some(ins) = parse_arm_strb_0(ins, pc, options)
4834 {
4835 return ins;
4836 }
4837 }
4838 0x1989 | 0x1999 | 0x19a9 | 0x19b9 => {
4839 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4840 if (ins & 0xff000f0) == 0x6600090
4841 && let Some(ins) = parse_arm_uqadd8_0(ins, pc, options)
4842 {
4843 return ins;
4844 }
4845 #[cfg(feature = "arm")]
4846 if (ins & 0xd700000) == 0x4600000
4847 && let Some(ins) = parse_arm_strbt_0(ins, pc, options)
4848 {
4849 return ins;
4850 }
4851 #[cfg(feature = "arm")]
4852 if (ins & 0xc500000) == 0x4400000
4853 && let Some(ins) = parse_arm_strb_0(ins, pc, options)
4854 {
4855 return ins;
4856 }
4857 }
4858 0x198f | 0x199f | 0x19af | 0x19bf => {
4859 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4860 if (ins & 0xff000f0) == 0x66000f0
4861 && let Some(ins) = parse_arm_uqsub8_0(ins, pc, options)
4862 {
4863 return ins;
4864 }
4865 #[cfg(feature = "arm")]
4866 if (ins & 0xd700000) == 0x4600000
4867 && let Some(ins) = parse_arm_strbt_0(ins, pc, options)
4868 {
4869 return ins;
4870 }
4871 #[cfg(feature = "arm")]
4872 if (ins & 0xc500000) == 0x4400000
4873 && let Some(ins) = parse_arm_strb_0(ins, pc, options)
4874 {
4875 return ins;
4876 }
4877 }
4878 0x19c1 | 0x19d1 | 0x19e1 | 0x19f1 => {
4879 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4880 if (ins & 0xff000f0) == 0x6700010
4881 && let Some(ins) = parse_arm_uhadd16_0(ins, pc, options)
4882 {
4883 return ins;
4884 }
4885 #[cfg(feature = "arm")]
4886 if (ins & 0xd700000) == 0x4700000
4887 && let Some(ins) = parse_arm_ldrbt_0(ins, pc, options)
4888 {
4889 return ins;
4890 }
4891 #[cfg(feature = "arm")]
4892 if (ins & 0xc500000) == 0x4500000
4893 && let Some(ins) = parse_arm_ldrb_0(ins, pc, options)
4894 {
4895 return ins;
4896 }
4897 }
4898 0x19c3 | 0x19d3 | 0x19e3 | 0x19f3 => {
4899 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4900 if (ins & 0xff000f0) == 0x6700030
4901 && let Some(ins) = parse_arm_uhasx_0(ins, pc, options)
4902 {
4903 return ins;
4904 }
4905 #[cfg(feature = "arm")]
4906 if (ins & 0xd700000) == 0x4700000
4907 && let Some(ins) = parse_arm_ldrbt_0(ins, pc, options)
4908 {
4909 return ins;
4910 }
4911 #[cfg(feature = "arm")]
4912 if (ins & 0xc500000) == 0x4500000
4913 && let Some(ins) = parse_arm_ldrb_0(ins, pc, options)
4914 {
4915 return ins;
4916 }
4917 }
4918 0x19c5 | 0x19d5 | 0x19e5 | 0x19f5 => {
4919 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4920 if (ins & 0xff000f0) == 0x6700050
4921 && let Some(ins) = parse_arm_uhsax_0(ins, pc, options)
4922 {
4923 return ins;
4924 }
4925 #[cfg(feature = "arm")]
4926 if (ins & 0xd700000) == 0x4700000
4927 && let Some(ins) = parse_arm_ldrbt_0(ins, pc, options)
4928 {
4929 return ins;
4930 }
4931 #[cfg(feature = "arm")]
4932 if (ins & 0xc500000) == 0x4500000
4933 && let Some(ins) = parse_arm_ldrb_0(ins, pc, options)
4934 {
4935 return ins;
4936 }
4937 }
4938 0x19c7 | 0x19d7 | 0x19e7 | 0x19f7 => {
4939 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4940 if (ins & 0xff000f0) == 0x6700070
4941 && let Some(ins) = parse_arm_uhsub16_0(ins, pc, options)
4942 {
4943 return ins;
4944 }
4945 #[cfg(feature = "arm")]
4946 if (ins & 0xd700000) == 0x4700000
4947 && let Some(ins) = parse_arm_ldrbt_0(ins, pc, options)
4948 {
4949 return ins;
4950 }
4951 #[cfg(feature = "arm")]
4952 if (ins & 0xc500000) == 0x4500000
4953 && let Some(ins) = parse_arm_ldrb_0(ins, pc, options)
4954 {
4955 return ins;
4956 }
4957 }
4958 0x19c9 | 0x19d9 | 0x19e9 | 0x19f9 => {
4959 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4960 if (ins & 0xff000f0) == 0x6700090
4961 && let Some(ins) = parse_arm_uhadd8_0(ins, pc, options)
4962 {
4963 return ins;
4964 }
4965 #[cfg(feature = "arm")]
4966 if (ins & 0xd700000) == 0x4700000
4967 && let Some(ins) = parse_arm_ldrbt_0(ins, pc, options)
4968 {
4969 return ins;
4970 }
4971 #[cfg(feature = "arm")]
4972 if (ins & 0xc500000) == 0x4500000
4973 && let Some(ins) = parse_arm_ldrb_0(ins, pc, options)
4974 {
4975 return ins;
4976 }
4977 }
4978 0x19cf | 0x19df | 0x19ef | 0x19ff => {
4979 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
4980 if (ins & 0xff000f0) == 0x67000f0
4981 && let Some(ins) = parse_arm_uhsub8_0(ins, pc, options)
4982 {
4983 return ins;
4984 }
4985 #[cfg(feature = "arm")]
4986 if (ins & 0xd700000) == 0x4700000
4987 && let Some(ins) = parse_arm_ldrbt_0(ins, pc, options)
4988 {
4989 return ins;
4990 }
4991 #[cfg(feature = "arm")]
4992 if (ins & 0xc500000) == 0x4500000
4993 && let Some(ins) = parse_arm_ldrb_0(ins, pc, options)
4994 {
4995 return ins;
4996 }
4997 }
4998 0x1a01 | 0x1a09 | 0x1a11 | 0x1a19 | 0x1a21 | 0x1a29 | 0x1a31 | 0x1a39 => {
4999 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5000 if (ins & 0xff00070) == 0x6800010
5001 && let Some(ins) = parse_arm_pkhbt_0(ins, pc, options)
5002 {
5003 return ins;
5004 }
5005 #[cfg(feature = "arm")]
5006 if (ins & 0xc500000) == 0x4000000
5007 && let Some(ins) = parse_arm_str_0(ins, pc, options)
5008 {
5009 return ins;
5010 }
5011 }
5012 0x1a05 | 0x1a0d | 0x1a15 | 0x1a1d | 0x1a25 | 0x1a2d | 0x1a35 | 0x1a3d => {
5013 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5014 if (ins & 0xff00070) == 0x6800050
5015 && let Some(ins) = parse_arm_pkhtb_0(ins, pc, options)
5016 {
5017 return ins;
5018 }
5019 #[cfg(feature = "arm")]
5020 if (ins & 0xc500000) == 0x4000000
5021 && let Some(ins) = parse_arm_str_0(ins, pc, options)
5022 {
5023 return ins;
5024 }
5025 }
5026 0x1a07 | 0x1a17 => {
5027 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5028 if (ins & 0xff000f0) == 0x6800070
5029 && let Some(ins) = parse_arm_sxtab16_0(ins, pc, options)
5030 {
5031 return ins;
5032 }
5033 #[cfg(feature = "arm")]
5034 if (ins & 0xc500000) == 0x4000000
5035 && let Some(ins) = parse_arm_str_0(ins, pc, options)
5036 {
5037 return ins;
5038 }
5039 }
5040 0x1a0b | 0x1a1b | 0x1a2b | 0x1a3b => {
5041 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5042 if (ins & 0xff000f0) == 0x68000b0
5043 && let Some(ins) = parse_arm_sel_0(ins, pc, options)
5044 {
5045 return ins;
5046 }
5047 #[cfg(feature = "arm")]
5048 if (ins & 0xc500000) == 0x4000000
5049 && let Some(ins) = parse_arm_str_0(ins, pc, options)
5050 {
5051 return ins;
5052 }
5053 }
5054 0x1a27 | 0x1a37 => {
5055 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5056 if (ins & 0xfff00f0) == 0x68f0070
5057 && let Some(ins) = parse_arm_sxtb16_0(ins, pc, options)
5058 {
5059 return ins;
5060 }
5061 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5062 if (ins & 0xff000f0) == 0x6800070
5063 && let Some(ins) = parse_arm_sxtab16_0(ins, pc, options)
5064 {
5065 return ins;
5066 }
5067 #[cfg(feature = "arm")]
5068 if (ins & 0xc500000) == 0x4000000
5069 && let Some(ins) = parse_arm_str_0(ins, pc, options)
5070 {
5071 return ins;
5072 }
5073 }
5074 0x1a81 | 0x1a85 | 0x1a89 | 0x1a8d | 0x1a91 | 0x1a95 | 0x1a99 | 0x1a9d | 0x1aa1
5075 | 0x1aa5 | 0x1aa9 | 0x1aad | 0x1ab1 | 0x1ab5 | 0x1ab9 | 0x1abd => {
5076 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5077 if (ins & 0xfe00030) == 0x6a00010
5078 && let Some(ins) = parse_arm_ssat_0(ins, pc, options)
5079 {
5080 return ins;
5081 }
5082 #[cfg(feature = "arm")]
5083 if (ins & 0xd700000) == 0x4200000
5084 && let Some(ins) = parse_arm_strt_0(ins, pc, options)
5085 {
5086 return ins;
5087 }
5088 #[cfg(feature = "arm")]
5089 if (ins & 0xc500000) == 0x4000000
5090 && let Some(ins) = parse_arm_str_0(ins, pc, options)
5091 {
5092 return ins;
5093 }
5094 }
5095 0x1a83 | 0x1a93 | 0x1aa3 | 0x1ab3 => {
5096 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5097 if (ins & 0xff000f0) == 0x6a00030
5098 && let Some(ins) = parse_arm_ssat16_0(ins, pc, options)
5099 {
5100 return ins;
5101 }
5102 #[cfg(feature = "arm")]
5103 if (ins & 0xd700000) == 0x4200000
5104 && let Some(ins) = parse_arm_strt_0(ins, pc, options)
5105 {
5106 return ins;
5107 }
5108 #[cfg(feature = "arm")]
5109 if (ins & 0xc500000) == 0x4000000
5110 && let Some(ins) = parse_arm_str_0(ins, pc, options)
5111 {
5112 return ins;
5113 }
5114 }
5115 0x1a87 | 0x1a97 => {
5116 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5117 if (ins & 0xff000f0) == 0x6a00070
5118 && let Some(ins) = parse_arm_sxtab_0(ins, pc, options)
5119 {
5120 return ins;
5121 }
5122 #[cfg(feature = "arm")]
5123 if (ins & 0xd700000) == 0x4200000
5124 && let Some(ins) = parse_arm_strt_0(ins, pc, options)
5125 {
5126 return ins;
5127 }
5128 #[cfg(feature = "arm")]
5129 if (ins & 0xc500000) == 0x4000000
5130 && let Some(ins) = parse_arm_str_0(ins, pc, options)
5131 {
5132 return ins;
5133 }
5134 }
5135 0x1aa7 | 0x1ab7 => {
5136 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5137 if (ins & 0xfff00f0) == 0x6af0070
5138 && let Some(ins) = parse_arm_sxtb_0(ins, pc, options)
5139 {
5140 return ins;
5141 }
5142 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5143 if (ins & 0xff000f0) == 0x6a00070
5144 && let Some(ins) = parse_arm_sxtab_0(ins, pc, options)
5145 {
5146 return ins;
5147 }
5148 #[cfg(feature = "arm")]
5149 if (ins & 0xd700000) == 0x4200000
5150 && let Some(ins) = parse_arm_strt_0(ins, pc, options)
5151 {
5152 return ins;
5153 }
5154 #[cfg(feature = "arm")]
5155 if (ins & 0xc500000) == 0x4000000
5156 && let Some(ins) = parse_arm_str_0(ins, pc, options)
5157 {
5158 return ins;
5159 }
5160 }
5161 0x1ac1 | 0x1ac5 | 0x1ac9 | 0x1acd | 0x1ad1 | 0x1ad5 | 0x1ad9 | 0x1add | 0x1ae1
5162 | 0x1ae5 | 0x1ae9 | 0x1aed | 0x1af1 | 0x1af5 | 0x1af9 | 0x1afd => {
5163 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5164 if (ins & 0xfe00030) == 0x6a00010
5165 && let Some(ins) = parse_arm_ssat_0(ins, pc, options)
5166 {
5167 return ins;
5168 }
5169 #[cfg(feature = "arm")]
5170 if (ins & 0xd700000) == 0x4300000
5171 && let Some(ins) = parse_arm_ldrt_0(ins, pc, options)
5172 {
5173 return ins;
5174 }
5175 #[cfg(feature = "arm")]
5176 if (ins & 0xc500000) == 0x4100000
5177 && let Some(ins) = parse_arm_ldr_0(ins, pc, options)
5178 {
5179 return ins;
5180 }
5181 }
5182 0x1ac3 | 0x1ad3 | 0x1ae3 | 0x1af3 => {
5183 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5184 if (ins & 0xff000f0) == 0x6b00030
5185 && let Some(ins) = parse_arm_rev_0(ins, pc, options)
5186 {
5187 return ins;
5188 }
5189 #[cfg(feature = "arm")]
5190 if (ins & 0xd700000) == 0x4300000
5191 && let Some(ins) = parse_arm_ldrt_0(ins, pc, options)
5192 {
5193 return ins;
5194 }
5195 #[cfg(feature = "arm")]
5196 if (ins & 0xc500000) == 0x4100000
5197 && let Some(ins) = parse_arm_ldr_0(ins, pc, options)
5198 {
5199 return ins;
5200 }
5201 }
5202 0x1ac7 | 0x1ad7 => {
5203 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5204 if (ins & 0xff000f0) == 0x6b00070
5205 && let Some(ins) = parse_arm_sxtah_0(ins, pc, options)
5206 {
5207 return ins;
5208 }
5209 #[cfg(feature = "arm")]
5210 if (ins & 0xd700000) == 0x4300000
5211 && let Some(ins) = parse_arm_ldrt_0(ins, pc, options)
5212 {
5213 return ins;
5214 }
5215 #[cfg(feature = "arm")]
5216 if (ins & 0xc500000) == 0x4100000
5217 && let Some(ins) = parse_arm_ldr_0(ins, pc, options)
5218 {
5219 return ins;
5220 }
5221 }
5222 0x1acb | 0x1adb | 0x1aeb | 0x1afb => {
5223 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5224 if (ins & 0xff000f0) == 0x6b000b0
5225 && let Some(ins) = parse_arm_rev16_0(ins, pc, options)
5226 {
5227 return ins;
5228 }
5229 #[cfg(feature = "arm")]
5230 if (ins & 0xd700000) == 0x4300000
5231 && let Some(ins) = parse_arm_ldrt_0(ins, pc, options)
5232 {
5233 return ins;
5234 }
5235 #[cfg(feature = "arm")]
5236 if (ins & 0xc500000) == 0x4100000
5237 && let Some(ins) = parse_arm_ldr_0(ins, pc, options)
5238 {
5239 return ins;
5240 }
5241 }
5242 0x1ae7 | 0x1af7 => {
5243 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5244 if (ins & 0xfff00f0) == 0x6bf0070
5245 && let Some(ins) = parse_arm_sxth_0(ins, pc, options)
5246 {
5247 return ins;
5248 }
5249 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5250 if (ins & 0xff000f0) == 0x6b00070
5251 && let Some(ins) = parse_arm_sxtah_0(ins, pc, options)
5252 {
5253 return ins;
5254 }
5255 #[cfg(feature = "arm")]
5256 if (ins & 0xd700000) == 0x4300000
5257 && let Some(ins) = parse_arm_ldrt_0(ins, pc, options)
5258 {
5259 return ins;
5260 }
5261 #[cfg(feature = "arm")]
5262 if (ins & 0xc500000) == 0x4100000
5263 && let Some(ins) = parse_arm_ldr_0(ins, pc, options)
5264 {
5265 return ins;
5266 }
5267 }
5268 0x1b07 | 0x1b17 => {
5269 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5270 if (ins & 0xff000f0) == 0x6c00070
5271 && let Some(ins) = parse_arm_uxtab16_0(ins, pc, options)
5272 {
5273 return ins;
5274 }
5275 #[cfg(feature = "arm")]
5276 if (ins & 0xc500000) == 0x4400000
5277 && let Some(ins) = parse_arm_strb_0(ins, pc, options)
5278 {
5279 return ins;
5280 }
5281 }
5282 0x1b27 | 0x1b37 => {
5283 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5284 if (ins & 0xfff00f0) == 0x6cf0070
5285 && let Some(ins) = parse_arm_uxtb16_0(ins, pc, options)
5286 {
5287 return ins;
5288 }
5289 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5290 if (ins & 0xff000f0) == 0x6c00070
5291 && let Some(ins) = parse_arm_uxtab16_0(ins, pc, options)
5292 {
5293 return ins;
5294 }
5295 #[cfg(feature = "arm")]
5296 if (ins & 0xc500000) == 0x4400000
5297 && let Some(ins) = parse_arm_strb_0(ins, pc, options)
5298 {
5299 return ins;
5300 }
5301 }
5302 0x1b81 | 0x1b85 | 0x1b89 | 0x1b8d | 0x1b91 | 0x1b95 | 0x1b99 | 0x1b9d | 0x1ba1
5303 | 0x1ba5 | 0x1ba9 | 0x1bad | 0x1bb1 | 0x1bb5 | 0x1bb9 | 0x1bbd => {
5304 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5305 if (ins & 0xfe00030) == 0x6e00010
5306 && let Some(ins) = parse_arm_usat_0(ins, pc, options)
5307 {
5308 return ins;
5309 }
5310 #[cfg(feature = "arm")]
5311 if (ins & 0xd700000) == 0x4600000
5312 && let Some(ins) = parse_arm_strbt_0(ins, pc, options)
5313 {
5314 return ins;
5315 }
5316 #[cfg(feature = "arm")]
5317 if (ins & 0xc500000) == 0x4400000
5318 && let Some(ins) = parse_arm_strb_0(ins, pc, options)
5319 {
5320 return ins;
5321 }
5322 }
5323 0x1b83 | 0x1b93 | 0x1ba3 | 0x1bb3 => {
5324 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5325 if (ins & 0xff000f0) == 0x6e00030
5326 && let Some(ins) = parse_arm_usat16_0(ins, pc, options)
5327 {
5328 return ins;
5329 }
5330 #[cfg(feature = "arm")]
5331 if (ins & 0xd700000) == 0x4600000
5332 && let Some(ins) = parse_arm_strbt_0(ins, pc, options)
5333 {
5334 return ins;
5335 }
5336 #[cfg(feature = "arm")]
5337 if (ins & 0xc500000) == 0x4400000
5338 && let Some(ins) = parse_arm_strb_0(ins, pc, options)
5339 {
5340 return ins;
5341 }
5342 }
5343 0x1b87 | 0x1b97 => {
5344 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5345 if (ins & 0xff000f0) == 0x6e00070
5346 && let Some(ins) = parse_arm_uxtab_0(ins, pc, options)
5347 {
5348 return ins;
5349 }
5350 #[cfg(feature = "arm")]
5351 if (ins & 0xd700000) == 0x4600000
5352 && let Some(ins) = parse_arm_strbt_0(ins, pc, options)
5353 {
5354 return ins;
5355 }
5356 #[cfg(feature = "arm")]
5357 if (ins & 0xc500000) == 0x4400000
5358 && let Some(ins) = parse_arm_strb_0(ins, pc, options)
5359 {
5360 return ins;
5361 }
5362 }
5363 0x1ba7 | 0x1bb7 => {
5364 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5365 if (ins & 0xfff00f0) == 0x6ef0070
5366 && let Some(ins) = parse_arm_uxtb_0(ins, pc, options)
5367 {
5368 return ins;
5369 }
5370 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5371 if (ins & 0xff000f0) == 0x6e00070
5372 && let Some(ins) = parse_arm_uxtab_0(ins, pc, options)
5373 {
5374 return ins;
5375 }
5376 #[cfg(feature = "arm")]
5377 if (ins & 0xd700000) == 0x4600000
5378 && let Some(ins) = parse_arm_strbt_0(ins, pc, options)
5379 {
5380 return ins;
5381 }
5382 #[cfg(feature = "arm")]
5383 if (ins & 0xc500000) == 0x4400000
5384 && let Some(ins) = parse_arm_strb_0(ins, pc, options)
5385 {
5386 return ins;
5387 }
5388 }
5389 0x1bc1 | 0x1bc5 | 0x1bc9 | 0x1bcd | 0x1bd1 | 0x1bd5 | 0x1bd9 | 0x1bdd | 0x1be1
5390 | 0x1be5 | 0x1be9 | 0x1bed | 0x1bf1 | 0x1bf5 | 0x1bf9 | 0x1bfd => {
5391 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5392 if (ins & 0xfe00030) == 0x6e00010
5393 && let Some(ins) = parse_arm_usat_0(ins, pc, options)
5394 {
5395 return ins;
5396 }
5397 #[cfg(feature = "arm")]
5398 if (ins & 0xd700000) == 0x4700000
5399 && let Some(ins) = parse_arm_ldrbt_0(ins, pc, options)
5400 {
5401 return ins;
5402 }
5403 #[cfg(feature = "arm")]
5404 if (ins & 0xc500000) == 0x4500000
5405 && let Some(ins) = parse_arm_ldrb_0(ins, pc, options)
5406 {
5407 return ins;
5408 }
5409 }
5410 0x1bc7 | 0x1bd7 => {
5411 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5412 if (ins & 0xff000f0) == 0x6f00070
5413 && let Some(ins) = parse_arm_uxtah_0(ins, pc, options)
5414 {
5415 return ins;
5416 }
5417 #[cfg(feature = "arm")]
5418 if (ins & 0xd700000) == 0x4700000
5419 && let Some(ins) = parse_arm_ldrbt_0(ins, pc, options)
5420 {
5421 return ins;
5422 }
5423 #[cfg(feature = "arm")]
5424 if (ins & 0xc500000) == 0x4500000
5425 && let Some(ins) = parse_arm_ldrb_0(ins, pc, options)
5426 {
5427 return ins;
5428 }
5429 }
5430 0x1bcb | 0x1bdb | 0x1beb | 0x1bfb => {
5431 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5432 if (ins & 0xff000f0) == 0x6f000b0
5433 && let Some(ins) = parse_arm_revsh_0(ins, pc, options)
5434 {
5435 return ins;
5436 }
5437 #[cfg(feature = "arm")]
5438 if (ins & 0xd700000) == 0x4700000
5439 && let Some(ins) = parse_arm_ldrbt_0(ins, pc, options)
5440 {
5441 return ins;
5442 }
5443 #[cfg(feature = "arm")]
5444 if (ins & 0xc500000) == 0x4500000
5445 && let Some(ins) = parse_arm_ldrb_0(ins, pc, options)
5446 {
5447 return ins;
5448 }
5449 }
5450 0x1be7 | 0x1bf7 => {
5451 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5452 if (ins & 0xfff00f0) == 0x6ff0070
5453 && let Some(ins) = parse_arm_uxth_0(ins, pc, options)
5454 {
5455 return ins;
5456 }
5457 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5458 if (ins & 0xff000f0) == 0x6f00070
5459 && let Some(ins) = parse_arm_uxtah_0(ins, pc, options)
5460 {
5461 return ins;
5462 }
5463 #[cfg(feature = "arm")]
5464 if (ins & 0xd700000) == 0x4700000
5465 && let Some(ins) = parse_arm_ldrbt_0(ins, pc, options)
5466 {
5467 return ins;
5468 }
5469 #[cfg(feature = "arm")]
5470 if (ins & 0xc500000) == 0x4500000
5471 && let Some(ins) = parse_arm_ldrb_0(ins, pc, options)
5472 {
5473 return ins;
5474 }
5475 }
5476 0x1c01 | 0x1c03 | 0x1c11 | 0x1c13 | 0x1c21 | 0x1c23 | 0x1c31 | 0x1c33 => {
5477 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5478 if (ins & 0xff0f0d0) == 0x700f010
5479 && let Some(ins) = parse_arm_smuad_0(ins, pc, options)
5480 {
5481 return ins;
5482 }
5483 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5484 if (ins & 0xff000d0) == 0x7000010
5485 && let Some(ins) = parse_arm_smlad_0(ins, pc, options)
5486 {
5487 return ins;
5488 }
5489 #[cfg(feature = "arm")]
5490 if (ins & 0xc500000) == 0x4000000
5491 && let Some(ins) = parse_arm_str_0(ins, pc, options)
5492 {
5493 return ins;
5494 }
5495 }
5496 0x1c05 | 0x1c07 | 0x1c15 | 0x1c17 | 0x1c25 | 0x1c27 | 0x1c35 | 0x1c37 => {
5497 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5498 if (ins & 0xff0f0d0) == 0x700f050
5499 && let Some(ins) = parse_arm_smusd_0(ins, pc, options)
5500 {
5501 return ins;
5502 }
5503 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5504 if (ins & 0xff000d0) == 0x7000050
5505 && let Some(ins) = parse_arm_smlsd_0(ins, pc, options)
5506 {
5507 return ins;
5508 }
5509 #[cfg(feature = "arm")]
5510 if (ins & 0xc500000) == 0x4000000
5511 && let Some(ins) = parse_arm_str_0(ins, pc, options)
5512 {
5513 return ins;
5514 }
5515 }
5516 0x1d01 | 0x1d03 | 0x1d11 | 0x1d13 | 0x1d21 | 0x1d23 | 0x1d31 | 0x1d33 => {
5517 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5518 if (ins & 0xff000d0) == 0x7400010
5519 && let Some(ins) = parse_arm_smlald_0(ins, pc, options)
5520 {
5521 return ins;
5522 }
5523 #[cfg(feature = "arm")]
5524 if (ins & 0xc500000) == 0x4400000
5525 && let Some(ins) = parse_arm_strb_0(ins, pc, options)
5526 {
5527 return ins;
5528 }
5529 }
5530 0x1d05 | 0x1d07 | 0x1d15 | 0x1d17 | 0x1d25 | 0x1d27 | 0x1d35 | 0x1d37 => {
5531 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5532 if (ins & 0xff000d0) == 0x7400050
5533 && let Some(ins) = parse_arm_smlsld_0(ins, pc, options)
5534 {
5535 return ins;
5536 }
5537 #[cfg(feature = "arm")]
5538 if (ins & 0xc500000) == 0x4400000
5539 && let Some(ins) = parse_arm_strb_0(ins, pc, options)
5540 {
5541 return ins;
5542 }
5543 }
5544 0x1d41 | 0x1d43 | 0x1d51 | 0x1d53 | 0x1d61 | 0x1d63 | 0x1d71 | 0x1d73 => {
5545 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5546 if (ins & 0xff0f0d0) == 0x750f010
5547 && let Some(ins) = parse_arm_smmul_0(ins, pc, options)
5548 {
5549 return ins;
5550 }
5551 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5552 if (ins & 0xff000d0) == 0x7500010
5553 && let Some(ins) = parse_arm_smmla_0(ins, pc, options)
5554 {
5555 return ins;
5556 }
5557 #[cfg(
5558 all(
5559 feature = "arm",
5560 any(
5561 feature = "v5te",
5562 feature = "v5tej",
5563 feature = "v6",
5564 feature = "v6k"
5565 )
5566 )
5567 )]
5568 if (ins & 0xfd700000) == 0xf5500000
5569 && let Some(ins) = parse_arm_pld_0(ins, pc, options)
5570 {
5571 return ins;
5572 }
5573 #[cfg(feature = "arm")]
5574 if (ins & 0xc500000) == 0x4500000
5575 && let Some(ins) = parse_arm_ldrb_0(ins, pc, options)
5576 {
5577 return ins;
5578 }
5579 }
5580 0x1d4d | 0x1d4f | 0x1d5d | 0x1d5f | 0x1d6d | 0x1d6f | 0x1d7d | 0x1d7f => {
5581 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5582 if (ins & 0xff000d0) == 0x75000d0
5583 && let Some(ins) = parse_arm_smmls_0(ins, pc, options)
5584 {
5585 return ins;
5586 }
5587 #[cfg(
5588 all(
5589 feature = "arm",
5590 any(
5591 feature = "v5te",
5592 feature = "v5tej",
5593 feature = "v6",
5594 feature = "v6k"
5595 )
5596 )
5597 )]
5598 if (ins & 0xfd700000) == 0xf5500000
5599 && let Some(ins) = parse_arm_pld_0(ins, pc, options)
5600 {
5601 return ins;
5602 }
5603 #[cfg(feature = "arm")]
5604 if (ins & 0xc500000) == 0x4500000
5605 && let Some(ins) = parse_arm_ldrb_0(ins, pc, options)
5606 {
5607 return ins;
5608 }
5609 }
5610 0x1e01 | 0x1e11 | 0x1e21 | 0x1e31 => {
5611 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5612 if (ins & 0xff0f0f0) == 0x780f010
5613 && let Some(ins) = parse_arm_usad8_0(ins, pc, options)
5614 {
5615 return ins;
5616 }
5617 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5618 if (ins & 0xff000f0) == 0x7800010
5619 && let Some(ins) = parse_arm_usada8_0(ins, pc, options)
5620 {
5621 return ins;
5622 }
5623 #[cfg(feature = "arm")]
5624 if (ins & 0xc500000) == 0x4000000
5625 && let Some(ins) = parse_arm_str_0(ins, pc, options)
5626 {
5627 return ins;
5628 }
5629 }
5630 0x1fcf | 0x1fdf | 0x1fef | 0x1fff => {
5631 #[cfg(
5632 all(
5633 feature = "arm",
5634 any(
5635 feature = "v4t",
5636 feature = "v5t",
5637 feature = "v5te",
5638 feature = "v5tej",
5639 feature = "v6",
5640 feature = "v6k"
5641 )
5642 )
5643 )]
5644 if (ins & 0xfff000f0) == 0xe7f000f0
5645 && let Some(ins) = parse_arm_udf_0(ins, pc, options)
5646 {
5647 return ins;
5648 }
5649 #[cfg(feature = "arm")]
5650 if (ins & 0xc500000) == 0x4500000
5651 && let Some(ins) = parse_arm_ldrb_0(ins, pc, options)
5652 {
5653 return ins;
5654 }
5655 }
5656 0x2000 | 0x2001 | 0x2002 | 0x2003 | 0x2004 | 0x2005 | 0x2006 | 0x2007 | 0x2008
5657 | 0x2009 | 0x200a | 0x200b | 0x200c | 0x200d | 0x200e | 0x200f | 0x2010 | 0x2011
5658 | 0x2012 | 0x2013 | 0x2014 | 0x2015 | 0x2016 | 0x2017 | 0x2018 | 0x2019 | 0x201a
5659 | 0x201b | 0x201c | 0x201d | 0x201e | 0x201f | 0x2020 | 0x2021 | 0x2022 | 0x2023
5660 | 0x2024 | 0x2025 | 0x2026 | 0x2027 | 0x2028 | 0x2029 | 0x202a | 0x202b | 0x202c
5661 | 0x202d | 0x202e | 0x202f | 0x2030 | 0x2031 | 0x2032 | 0x2033 | 0x2034 | 0x2035
5662 | 0x2036 | 0x2037 | 0x2038 | 0x2039 | 0x203a | 0x203b | 0x203c | 0x203d | 0x203e
5663 | 0x203f | 0x2080 | 0x2081 | 0x2082 | 0x2083 | 0x2084 | 0x2085 | 0x2086 | 0x2087
5664 | 0x2088 | 0x2089 | 0x208a | 0x208b | 0x208c | 0x208d | 0x208e | 0x208f | 0x2090
5665 | 0x2091 | 0x2092 | 0x2093 | 0x2094 | 0x2095 | 0x2096 | 0x2097 | 0x2098 | 0x2099
5666 | 0x209a | 0x209b | 0x209c | 0x209d | 0x209e | 0x209f | 0x20a0 | 0x20a1 | 0x20a2
5667 | 0x20a3 | 0x20a4 | 0x20a5 | 0x20a6 | 0x20a7 | 0x20a8 | 0x20a9 | 0x20aa | 0x20ab
5668 | 0x20ac | 0x20ad | 0x20ae | 0x20af | 0x20b0 | 0x20b1 | 0x20b2 | 0x20b3 | 0x20b4
5669 | 0x20b5 | 0x20b6 | 0x20b7 | 0x20b8 | 0x20b9 | 0x20ba | 0x20bb | 0x20bc | 0x20bd
5670 | 0x20be | 0x20bf | 0x2200 | 0x2201 | 0x2202 | 0x2203 | 0x2204 | 0x2205 | 0x2206
5671 | 0x2207 | 0x2208 | 0x2209 | 0x220a | 0x220b | 0x220c | 0x220d | 0x220e | 0x220f
5672 | 0x2210 | 0x2211 | 0x2212 | 0x2213 | 0x2214 | 0x2215 | 0x2216 | 0x2217 | 0x2218
5673 | 0x2219 | 0x221a | 0x221b | 0x221c | 0x221d | 0x221e | 0x221f | 0x2220 | 0x2221
5674 | 0x2222 | 0x2223 | 0x2224 | 0x2225 | 0x2226 | 0x2227 | 0x2228 | 0x2229 | 0x222a
5675 | 0x222b | 0x222c | 0x222d | 0x222e | 0x222f | 0x2230 | 0x2231 | 0x2232 | 0x2233
5676 | 0x2234 | 0x2235 | 0x2236 | 0x2237 | 0x2238 | 0x2239 | 0x223a | 0x223b | 0x223c
5677 | 0x223d | 0x223e | 0x223f | 0x2280 | 0x2281 | 0x2282 | 0x2283 | 0x2284 | 0x2285
5678 | 0x2286 | 0x2287 | 0x2288 | 0x2289 | 0x228a | 0x228b | 0x228c | 0x228d | 0x228e
5679 | 0x228f | 0x2290 | 0x2291 | 0x2292 | 0x2293 | 0x2294 | 0x2295 | 0x2296 | 0x2297
5680 | 0x2298 | 0x2299 | 0x229a | 0x229b | 0x229c | 0x229d | 0x229e | 0x229f | 0x22a0
5681 | 0x22a1 | 0x22a2 | 0x22a3 | 0x22a4 | 0x22a5 | 0x22a6 | 0x22a7 | 0x22a8 | 0x22a9
5682 | 0x22aa | 0x22ab | 0x22ac | 0x22ad | 0x22ae | 0x22af | 0x22b0 | 0x22b1 | 0x22b2
5683 | 0x22b3 | 0x22b4 | 0x22b5 | 0x22b6 | 0x22b7 | 0x22b8 | 0x22b9 | 0x22ba | 0x22bb
5684 | 0x22bc | 0x22bd | 0x22be | 0x22bf | 0x2400 | 0x2401 | 0x2402 | 0x2403 | 0x2404
5685 | 0x2405 | 0x2406 | 0x2407 | 0x2408 | 0x2409 | 0x240a | 0x240b | 0x240c | 0x240d
5686 | 0x240e | 0x240f | 0x2410 | 0x2411 | 0x2412 | 0x2413 | 0x2414 | 0x2415 | 0x2416
5687 | 0x2417 | 0x2418 | 0x2419 | 0x241a | 0x241b | 0x241c | 0x241d | 0x241e | 0x241f
5688 | 0x2420 | 0x2421 | 0x2422 | 0x2423 | 0x2424 | 0x2425 | 0x2426 | 0x2427 | 0x2428
5689 | 0x2429 | 0x242a | 0x242b | 0x242c | 0x242d | 0x242e | 0x242f | 0x2430 | 0x2431
5690 | 0x2432 | 0x2433 | 0x2434 | 0x2435 | 0x2436 | 0x2437 | 0x2438 | 0x2439 | 0x243a
5691 | 0x243b | 0x243c | 0x243d | 0x243e | 0x243f | 0x2480 | 0x2481 | 0x2482 | 0x2483
5692 | 0x2484 | 0x2485 | 0x2486 | 0x2487 | 0x2488 | 0x2489 | 0x248a | 0x248b | 0x248c
5693 | 0x248d | 0x248e | 0x248f | 0x2490 | 0x2491 | 0x2492 | 0x2493 | 0x2494 | 0x2495
5694 | 0x2496 | 0x2497 | 0x2498 | 0x2499 | 0x249a | 0x249b | 0x249c | 0x249d | 0x249e
5695 | 0x249f | 0x2600 | 0x2601 | 0x2602 | 0x2603 | 0x2604 | 0x2605 | 0x2606 | 0x2607
5696 | 0x2608 | 0x2609 | 0x260a | 0x260b | 0x260c | 0x260d | 0x260e | 0x260f | 0x2610
5697 | 0x2611 | 0x2612 | 0x2613 | 0x2614 | 0x2615 | 0x2616 | 0x2617 | 0x2618 | 0x2619
5698 | 0x261a | 0x261b | 0x261c | 0x261d | 0x261e | 0x261f | 0x2620 | 0x2621 | 0x2622
5699 | 0x2623 | 0x2624 | 0x2625 | 0x2626 | 0x2627 | 0x2628 | 0x2629 | 0x262a | 0x262b
5700 | 0x262c | 0x262d | 0x262e | 0x262f | 0x2630 | 0x2631 | 0x2632 | 0x2633 | 0x2634
5701 | 0x2635 | 0x2636 | 0x2637 | 0x2638 | 0x2639 | 0x263a | 0x263b | 0x263c | 0x263d
5702 | 0x263e | 0x263f | 0x2680 | 0x2681 | 0x2682 | 0x2683 | 0x2684 | 0x2685 | 0x2686
5703 | 0x2687 | 0x2688 | 0x2689 | 0x268a | 0x268b | 0x268c | 0x268d | 0x268e | 0x268f
5704 | 0x2690 | 0x2691 | 0x2692 | 0x2693 | 0x2694 | 0x2695 | 0x2696 | 0x2697 | 0x2698
5705 | 0x2699 | 0x269a | 0x269b | 0x269c | 0x269d | 0x269e | 0x269f | 0x26a0 | 0x26a1
5706 | 0x26a2 | 0x26a3 | 0x26a4 | 0x26a5 | 0x26a6 | 0x26a7 | 0x26a8 | 0x26a9 | 0x26aa
5707 | 0x26ab | 0x26ac | 0x26ad | 0x26ae | 0x26af | 0x26b0 | 0x26b1 | 0x26b2 | 0x26b3
5708 | 0x26b4 | 0x26b5 | 0x26b6 | 0x26b7 | 0x26b8 | 0x26b9 | 0x26ba | 0x26bb | 0x26bc
5709 | 0x26bd | 0x26be | 0x26bf => {
5710 #[cfg(feature = "arm")]
5711 if let Some(ins) = parse_arm_stm_0(ins, pc, options) {
5712 return ins;
5713 }
5714 }
5715 0x2040 | 0x2041 | 0x2042 | 0x2043 | 0x2044 | 0x2045 | 0x2046 | 0x2047 | 0x2048
5716 | 0x2049 | 0x204a | 0x204b | 0x204c | 0x204d | 0x204e | 0x204f | 0x2050 | 0x2051
5717 | 0x2052 | 0x2053 | 0x2054 | 0x2055 | 0x2056 | 0x2057 | 0x2058 | 0x2059 | 0x205a
5718 | 0x205b | 0x205c | 0x205d | 0x205e | 0x205f | 0x2060 | 0x2061 | 0x2062 | 0x2063
5719 | 0x2064 | 0x2065 | 0x2066 | 0x2067 | 0x2068 | 0x2069 | 0x206a | 0x206b | 0x206c
5720 | 0x206d | 0x206e | 0x206f | 0x2070 | 0x2071 | 0x2072 | 0x2073 | 0x2074 | 0x2075
5721 | 0x2076 | 0x2077 | 0x2078 | 0x2079 | 0x207a | 0x207b | 0x207c | 0x207d | 0x207e
5722 | 0x207f | 0x20c0 | 0x20c1 | 0x20c2 | 0x20c3 | 0x20c4 | 0x20c5 | 0x20c6 | 0x20c7
5723 | 0x20c8 | 0x20c9 | 0x20ca | 0x20cb | 0x20cc | 0x20cd | 0x20ce | 0x20cf | 0x20d0
5724 | 0x20d1 | 0x20d2 | 0x20d3 | 0x20d4 | 0x20d5 | 0x20d6 | 0x20d7 | 0x20d8 | 0x20d9
5725 | 0x20da | 0x20db | 0x20dc | 0x20dd | 0x20de | 0x20df | 0x20e0 | 0x20e1 | 0x20e2
5726 | 0x20e3 | 0x20e4 | 0x20e5 | 0x20e6 | 0x20e7 | 0x20e8 | 0x20e9 | 0x20ea | 0x20eb
5727 | 0x20ec | 0x20ed | 0x20ee | 0x20ef | 0x20f0 | 0x20f1 | 0x20f2 | 0x20f3 | 0x20f4
5728 | 0x20f5 | 0x20f6 | 0x20f7 | 0x20f8 | 0x20f9 | 0x20fa | 0x20fb | 0x20fc | 0x20fd
5729 | 0x20fe | 0x20ff | 0x2240 | 0x2241 | 0x2242 | 0x2243 | 0x2244 | 0x2245 | 0x2246
5730 | 0x2247 | 0x2248 | 0x2249 | 0x224a | 0x224b | 0x224c | 0x224d | 0x224e | 0x224f
5731 | 0x2250 | 0x2251 | 0x2252 | 0x2253 | 0x2254 | 0x2255 | 0x2256 | 0x2257 | 0x2258
5732 | 0x2259 | 0x225a | 0x225b | 0x225c | 0x225d | 0x225e | 0x225f | 0x2260 | 0x2261
5733 | 0x2262 | 0x2263 | 0x2264 | 0x2265 | 0x2266 | 0x2267 | 0x2268 | 0x2269 | 0x226a
5734 | 0x226b | 0x226c | 0x226d | 0x226e | 0x226f | 0x2270 | 0x2271 | 0x2272 | 0x2273
5735 | 0x2274 | 0x2275 | 0x2276 | 0x2277 | 0x2278 | 0x2279 | 0x227a | 0x227b | 0x227c
5736 | 0x227d | 0x227e | 0x227f | 0x22c0 | 0x22c1 | 0x22c2 | 0x22c3 | 0x22c4 | 0x22c5
5737 | 0x22c6 | 0x22c7 | 0x22c8 | 0x22c9 | 0x22ca | 0x22cb | 0x22cc | 0x22cd | 0x22ce
5738 | 0x22cf | 0x22d0 | 0x22d1 | 0x22d2 | 0x22d3 | 0x22d4 | 0x22d5 | 0x22d6 | 0x22d7
5739 | 0x22d8 | 0x22d9 | 0x22da | 0x22db | 0x22dc | 0x22dd | 0x22de | 0x22df | 0x2440
5740 | 0x2441 | 0x2442 | 0x2443 | 0x2444 | 0x2445 | 0x2446 | 0x2447 | 0x2448 | 0x2449
5741 | 0x244a | 0x244b | 0x244c | 0x244d | 0x244e | 0x244f | 0x2450 | 0x2451 | 0x2452
5742 | 0x2453 | 0x2454 | 0x2455 | 0x2456 | 0x2457 | 0x2458 | 0x2459 | 0x245a | 0x245b
5743 | 0x245c | 0x245d | 0x245e | 0x245f | 0x2460 | 0x2461 | 0x2462 | 0x2463 | 0x2464
5744 | 0x2465 | 0x2466 | 0x2467 | 0x2468 | 0x2469 | 0x246a | 0x246b | 0x246c | 0x246d
5745 | 0x246e | 0x246f | 0x2470 | 0x2471 | 0x2472 | 0x2473 | 0x2474 | 0x2475 | 0x2476
5746 | 0x2477 | 0x2478 | 0x2479 | 0x247a | 0x247b | 0x247c | 0x247d | 0x247e | 0x247f
5747 | 0x24c0 | 0x24c1 | 0x24c2 | 0x24c3 | 0x24c4 | 0x24c5 | 0x24c6 | 0x24c7 | 0x24c8
5748 | 0x24c9 | 0x24ca | 0x24cb | 0x24cc | 0x24cd | 0x24ce | 0x24cf | 0x24d0 | 0x24d1
5749 | 0x24d2 | 0x24d3 | 0x24d4 | 0x24d5 | 0x24d6 | 0x24d7 | 0x24d8 | 0x24d9 | 0x24da
5750 | 0x24db | 0x24dc | 0x24dd | 0x24de | 0x24df | 0x24e0 | 0x24e1 | 0x24e2 | 0x24e3
5751 | 0x24e4 | 0x24e5 | 0x24e6 | 0x24e7 | 0x24e8 | 0x24e9 | 0x24ea | 0x24eb | 0x24ec
5752 | 0x24ed | 0x24ee | 0x24ef | 0x24f0 | 0x24f1 | 0x24f2 | 0x24f3 | 0x24f4 | 0x24f5
5753 | 0x24f6 | 0x24f7 | 0x24f8 | 0x24f9 | 0x24fa | 0x24fb | 0x24fc | 0x24fd | 0x24fe
5754 | 0x24ff | 0x2640 | 0x2641 | 0x2642 | 0x2643 | 0x2644 | 0x2645 | 0x2646 | 0x2647
5755 | 0x2648 | 0x2649 | 0x264a | 0x264b | 0x264c | 0x264d | 0x264e | 0x264f | 0x2650
5756 | 0x2651 | 0x2652 | 0x2653 | 0x2654 | 0x2655 | 0x2656 | 0x2657 | 0x2658 | 0x2659
5757 | 0x265a | 0x265b | 0x265c | 0x265d | 0x265e | 0x265f | 0x2660 | 0x2661 | 0x2662
5758 | 0x2663 | 0x2664 | 0x2665 | 0x2666 | 0x2667 | 0x2668 | 0x2669 | 0x266a | 0x266b
5759 | 0x266c | 0x266d | 0x266e | 0x266f | 0x2670 | 0x2671 | 0x2672 | 0x2673 | 0x2674
5760 | 0x2675 | 0x2676 | 0x2677 | 0x2678 | 0x2679 | 0x267a | 0x267b | 0x267c | 0x267d
5761 | 0x267e | 0x267f | 0x26c0 | 0x26c1 | 0x26c2 | 0x26c3 | 0x26c4 | 0x26c5 | 0x26c6
5762 | 0x26c7 | 0x26c8 | 0x26c9 | 0x26ca | 0x26cb | 0x26cc | 0x26cd | 0x26ce | 0x26cf
5763 | 0x26d0 | 0x26d1 | 0x26d2 | 0x26d3 | 0x26d4 | 0x26d5 | 0x26d6 | 0x26d7 | 0x26d8
5764 | 0x26d9 | 0x26da | 0x26db | 0x26dc | 0x26dd | 0x26de | 0x26df | 0x26e0 | 0x26e1
5765 | 0x26e2 | 0x26e3 | 0x26e4 | 0x26e5 | 0x26e6 | 0x26e7 | 0x26e8 | 0x26e9 | 0x26ea
5766 | 0x26eb | 0x26ec | 0x26ed | 0x26ee | 0x26ef | 0x26f0 | 0x26f1 | 0x26f2 | 0x26f3
5767 | 0x26f4 | 0x26f5 | 0x26f6 | 0x26f7 | 0x26f8 | 0x26f9 | 0x26fa | 0x26fb | 0x26fc
5768 | 0x26fd | 0x26fe | 0x26ff => {
5769 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5770 if (ins & 0xfe500000) == 0xf8100000
5771 && let Some(ins) = parse_arm_rfe_0(ins, pc, options)
5772 {
5773 return ins;
5774 }
5775 #[cfg(feature = "arm")]
5776 if (ins & 0xe500000) == 0x8100000
5777 && let Some(ins) = parse_arm_ldm_0(ins, pc, options)
5778 {
5779 return ins;
5780 }
5781 }
5782 0x2100 | 0x2101 | 0x2102 | 0x2103 | 0x2104 | 0x2105 | 0x2106 | 0x2107 | 0x2108
5783 | 0x2109 | 0x210a | 0x210b | 0x210c | 0x210d | 0x210e | 0x210f | 0x2110 | 0x2111
5784 | 0x2112 | 0x2113 | 0x2114 | 0x2115 | 0x2116 | 0x2117 | 0x2118 | 0x2119 | 0x211a
5785 | 0x211b | 0x211c | 0x211d | 0x211e | 0x211f | 0x2120 | 0x2121 | 0x2122 | 0x2123
5786 | 0x2124 | 0x2125 | 0x2126 | 0x2127 | 0x2128 | 0x2129 | 0x212a | 0x212b | 0x212c
5787 | 0x212d | 0x212e | 0x212f | 0x2130 | 0x2131 | 0x2132 | 0x2133 | 0x2134 | 0x2135
5788 | 0x2136 | 0x2137 | 0x2138 | 0x2139 | 0x213a | 0x213b | 0x213c | 0x213d | 0x213e
5789 | 0x213f | 0x2180 | 0x2181 | 0x2182 | 0x2183 | 0x2184 | 0x2185 | 0x2186 | 0x2187
5790 | 0x2188 | 0x2189 | 0x218a | 0x218b | 0x218c | 0x218d | 0x218e | 0x218f | 0x2190
5791 | 0x2191 | 0x2192 | 0x2193 | 0x2194 | 0x2195 | 0x2196 | 0x2197 | 0x2198 | 0x2199
5792 | 0x219a | 0x219b | 0x219c | 0x219d | 0x219e | 0x219f | 0x21a0 | 0x21a1 | 0x21a2
5793 | 0x21a3 | 0x21a4 | 0x21a5 | 0x21a6 | 0x21a7 | 0x21a8 | 0x21a9 | 0x21aa | 0x21ab
5794 | 0x21ac | 0x21ad | 0x21ae | 0x21af | 0x21b0 | 0x21b1 | 0x21b2 | 0x21b3 | 0x21b4
5795 | 0x21b5 | 0x21b6 | 0x21b7 | 0x21b8 | 0x21b9 | 0x21ba | 0x21bb | 0x21bc | 0x21bd
5796 | 0x21be | 0x21bf | 0x2300 | 0x2301 | 0x2302 | 0x2303 | 0x2304 | 0x2305 | 0x2306
5797 | 0x2307 | 0x2308 | 0x2309 | 0x230a | 0x230b | 0x230c | 0x230d | 0x230e | 0x230f
5798 | 0x2310 | 0x2311 | 0x2312 | 0x2313 | 0x2314 | 0x2315 | 0x2316 | 0x2317 | 0x2318
5799 | 0x2319 | 0x231a | 0x231b | 0x231c | 0x231d | 0x231e | 0x231f | 0x2320 | 0x2321
5800 | 0x2322 | 0x2323 | 0x2324 | 0x2325 | 0x2326 | 0x2327 | 0x2328 | 0x2329 | 0x232a
5801 | 0x232b | 0x232c | 0x232d | 0x232e | 0x232f | 0x2330 | 0x2331 | 0x2332 | 0x2333
5802 | 0x2334 | 0x2335 | 0x2336 | 0x2337 | 0x2338 | 0x2339 | 0x233a | 0x233b | 0x233c
5803 | 0x233d | 0x233e | 0x233f | 0x2380 | 0x2381 | 0x2382 | 0x2383 | 0x2384 | 0x2385
5804 | 0x2386 | 0x2387 | 0x2388 | 0x2389 | 0x238a | 0x238b | 0x238c | 0x238d | 0x238e
5805 | 0x238f | 0x2390 | 0x2391 | 0x2392 | 0x2393 | 0x2394 | 0x2395 | 0x2396 | 0x2397
5806 | 0x2398 | 0x2399 | 0x239a | 0x239b | 0x239c | 0x239d | 0x239e | 0x239f | 0x23a0
5807 | 0x23a1 | 0x23a2 | 0x23a3 | 0x23a4 | 0x23a5 | 0x23a6 | 0x23a7 | 0x23a8 | 0x23a9
5808 | 0x23aa | 0x23ab | 0x23ac | 0x23ad | 0x23ae | 0x23af | 0x23b0 | 0x23b1 | 0x23b2
5809 | 0x23b3 | 0x23b4 | 0x23b5 | 0x23b6 | 0x23b7 | 0x23b8 | 0x23b9 | 0x23ba | 0x23bb
5810 | 0x23bc | 0x23bd | 0x23be | 0x23bf | 0x2500 | 0x2501 | 0x2502 | 0x2503 | 0x2504
5811 | 0x2505 | 0x2506 | 0x2507 | 0x2508 | 0x2509 | 0x250a | 0x250b | 0x250c | 0x250d
5812 | 0x250e | 0x250f | 0x2510 | 0x2511 | 0x2512 | 0x2513 | 0x2514 | 0x2515 | 0x2516
5813 | 0x2517 | 0x2518 | 0x2519 | 0x251a | 0x251b | 0x251c | 0x251d | 0x251e | 0x251f
5814 | 0x2520 | 0x2521 | 0x2522 | 0x2523 | 0x2524 | 0x2525 | 0x2526 | 0x2527 | 0x2528
5815 | 0x2529 | 0x252a | 0x252b | 0x252c | 0x252d | 0x252e | 0x252f | 0x2530 | 0x2531
5816 | 0x2532 | 0x2533 | 0x2534 | 0x2535 | 0x2536 | 0x2537 | 0x2538 | 0x2539 | 0x253a
5817 | 0x253b | 0x253c | 0x253d | 0x253e | 0x253f | 0x2580 | 0x2581 | 0x2582 | 0x2583
5818 | 0x2584 | 0x2585 | 0x2586 | 0x2587 | 0x2588 | 0x2589 | 0x258a | 0x258b | 0x258c
5819 | 0x258d | 0x258e | 0x258f | 0x2590 | 0x2591 | 0x2592 | 0x2593 | 0x2594 | 0x2595
5820 | 0x2596 | 0x2597 | 0x2598 | 0x2599 | 0x259a | 0x259b | 0x259c | 0x259d | 0x259e
5821 | 0x259f | 0x25a0 | 0x25a1 | 0x25a2 | 0x25a3 | 0x25a4 | 0x25a5 | 0x25a6 | 0x25a7
5822 | 0x25a8 | 0x25a9 | 0x25aa | 0x25ab | 0x25ac | 0x25ad | 0x25ae | 0x25af | 0x25b0
5823 | 0x25b1 | 0x25b2 | 0x25b3 | 0x25b4 | 0x25b5 | 0x25b6 | 0x25b7 | 0x25b8 | 0x25b9
5824 | 0x25ba | 0x25bb | 0x25bc | 0x25bd | 0x25be | 0x25bf | 0x2700 | 0x2701 | 0x2702
5825 | 0x2703 | 0x2704 | 0x2705 | 0x2706 | 0x2707 | 0x2708 | 0x2709 | 0x270a | 0x270b
5826 | 0x270c | 0x270d | 0x270e | 0x270f | 0x2710 | 0x2711 | 0x2712 | 0x2713 | 0x2714
5827 | 0x2715 | 0x2716 | 0x2717 | 0x2718 | 0x2719 | 0x271a | 0x271b | 0x271c | 0x271d
5828 | 0x271e | 0x271f | 0x2720 | 0x2721 | 0x2722 | 0x2723 | 0x2724 | 0x2725 | 0x2726
5829 | 0x2727 | 0x2728 | 0x2729 | 0x272a | 0x272b | 0x272c | 0x272d | 0x272e | 0x272f
5830 | 0x2730 | 0x2731 | 0x2732 | 0x2733 | 0x2734 | 0x2735 | 0x2736 | 0x2737 | 0x2738
5831 | 0x2739 | 0x273a | 0x273b | 0x273c | 0x273d | 0x273e | 0x273f | 0x2780 | 0x2781
5832 | 0x2782 | 0x2783 | 0x2784 | 0x2785 | 0x2786 | 0x2787 | 0x2788 | 0x2789 | 0x278a
5833 | 0x278b | 0x278c | 0x278d | 0x278e | 0x278f | 0x2790 | 0x2791 | 0x2792 | 0x2793
5834 | 0x2794 | 0x2795 | 0x2796 | 0x2797 | 0x2798 | 0x2799 | 0x279a | 0x279b | 0x279c
5835 | 0x279d | 0x279e | 0x279f | 0x27a0 | 0x27a1 | 0x27a2 | 0x27a3 | 0x27a4 | 0x27a5
5836 | 0x27a6 | 0x27a7 | 0x27a8 | 0x27a9 | 0x27aa | 0x27ab | 0x27ac | 0x27ad | 0x27ae
5837 | 0x27af | 0x27b0 | 0x27b1 | 0x27b2 | 0x27b3 | 0x27b4 | 0x27b5 | 0x27b6 | 0x27b7
5838 | 0x27b8 | 0x27b9 | 0x27ba | 0x27bb | 0x27bc | 0x27bd | 0x27be | 0x27bf => {
5839 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5840 if (ins & 0xfe500000) == 0xf8400000
5841 && let Some(ins) = parse_arm_srs_0(ins, pc, options)
5842 {
5843 return ins;
5844 }
5845 #[cfg(feature = "arm")]
5846 if (ins & 0xe100000) == 0x8000000
5847 && let Some(ins) = parse_arm_stm_0(ins, pc, options)
5848 {
5849 return ins;
5850 }
5851 }
5852 0x2140 | 0x2141 | 0x2142 | 0x2143 | 0x2144 | 0x2145 | 0x2146 | 0x2147 | 0x2148
5853 | 0x2149 | 0x214a | 0x214b | 0x214c | 0x214d | 0x214e | 0x214f | 0x2150 | 0x2151
5854 | 0x2152 | 0x2153 | 0x2154 | 0x2155 | 0x2156 | 0x2157 | 0x2158 | 0x2159 | 0x215a
5855 | 0x215b | 0x215c | 0x215d | 0x215e | 0x215f | 0x2160 | 0x2161 | 0x2162 | 0x2163
5856 | 0x2164 | 0x2165 | 0x2166 | 0x2167 | 0x2168 | 0x2169 | 0x216a | 0x216b | 0x216c
5857 | 0x216d | 0x216e | 0x216f | 0x2170 | 0x2171 | 0x2172 | 0x2173 | 0x2174 | 0x2175
5858 | 0x2176 | 0x2177 | 0x2178 | 0x2179 | 0x217a | 0x217b | 0x217c | 0x217d | 0x217e
5859 | 0x217f | 0x2340 | 0x2341 | 0x2342 | 0x2343 | 0x2344 | 0x2345 | 0x2346 | 0x2347
5860 | 0x2348 | 0x2349 | 0x234a | 0x234b | 0x234c | 0x234d | 0x234e | 0x234f | 0x2350
5861 | 0x2351 | 0x2352 | 0x2353 | 0x2354 | 0x2355 | 0x2356 | 0x2357 | 0x2358 | 0x2359
5862 | 0x235a | 0x235b | 0x235c | 0x235d | 0x235e | 0x235f | 0x2360 | 0x2361 | 0x2362
5863 | 0x2363 | 0x2364 | 0x2365 | 0x2366 | 0x2367 | 0x2368 | 0x2369 | 0x236a | 0x236b
5864 | 0x236c | 0x236d | 0x236e | 0x236f | 0x2370 | 0x2371 | 0x2372 | 0x2373 | 0x2374
5865 | 0x2375 | 0x2376 | 0x2377 | 0x2378 | 0x2379 | 0x237a | 0x237b | 0x237c | 0x237d
5866 | 0x237e | 0x237f | 0x2540 | 0x2541 | 0x2542 | 0x2543 | 0x2544 | 0x2545 | 0x2546
5867 | 0x2547 | 0x2548 | 0x2549 | 0x254a | 0x254b | 0x254c | 0x254d | 0x254e | 0x254f
5868 | 0x2550 | 0x2551 | 0x2552 | 0x2553 | 0x2554 | 0x2555 | 0x2556 | 0x2557 | 0x2558
5869 | 0x2559 | 0x255a | 0x255b | 0x255c | 0x255d | 0x255e | 0x255f | 0x2560 | 0x2561
5870 | 0x2562 | 0x2563 | 0x2564 | 0x2565 | 0x2566 | 0x2567 | 0x2568 | 0x2569 | 0x256a
5871 | 0x256b | 0x256c | 0x256d | 0x256e | 0x256f | 0x2570 | 0x2571 | 0x2572 | 0x2573
5872 | 0x2574 | 0x2575 | 0x2576 | 0x2577 | 0x2578 | 0x2579 | 0x257a | 0x257b | 0x257c
5873 | 0x257d | 0x257e | 0x257f | 0x2740 | 0x2741 | 0x2742 | 0x2743 | 0x2744 | 0x2745
5874 | 0x2746 | 0x2747 | 0x2748 | 0x2749 | 0x274a | 0x274b | 0x274c | 0x274d | 0x274e
5875 | 0x274f | 0x2750 | 0x2751 | 0x2752 | 0x2753 | 0x2754 | 0x2755 | 0x2756 | 0x2757
5876 | 0x2758 | 0x2759 | 0x275a | 0x275b | 0x275c | 0x275d | 0x275e | 0x275f | 0x2760
5877 | 0x2761 | 0x2762 | 0x2763 | 0x2764 | 0x2765 | 0x2766 | 0x2767 | 0x2768 | 0x2769
5878 | 0x276a | 0x276b | 0x276c | 0x276d | 0x276e | 0x276f | 0x2770 | 0x2771 | 0x2772
5879 | 0x2773 | 0x2774 | 0x2775 | 0x2776 | 0x2777 | 0x2778 | 0x2779 | 0x277a | 0x277b
5880 | 0x277c | 0x277d | 0x277e | 0x277f => {
5881 #[cfg(feature = "arm")]
5882 if (ins & 0xe708000) == 0x8500000
5883 && let Some(ins) = parse_arm_ldm_1(ins, pc, options)
5884 {
5885 return ins;
5886 }
5887 #[cfg(feature = "arm")]
5888 if (ins & 0xe508000) == 0x8508000
5889 && let Some(ins) = parse_arm_ldm_2(ins, pc, options)
5890 {
5891 return ins;
5892 }
5893 }
5894 0x21c0 | 0x21c1 | 0x21c2 | 0x21c3 | 0x21c4 | 0x21c5 | 0x21c6 | 0x21c7 | 0x21c8
5895 | 0x21c9 | 0x21ca | 0x21cb | 0x21cc | 0x21cd | 0x21ce | 0x21cf | 0x21d0 | 0x21d1
5896 | 0x21d2 | 0x21d3 | 0x21d4 | 0x21d5 | 0x21d6 | 0x21d7 | 0x21d8 | 0x21d9 | 0x21da
5897 | 0x21db | 0x21dc | 0x21dd | 0x21de | 0x21df | 0x21e0 | 0x21e1 | 0x21e2 | 0x21e3
5898 | 0x21e4 | 0x21e5 | 0x21e6 | 0x21e7 | 0x21e8 | 0x21e9 | 0x21ea | 0x21eb | 0x21ec
5899 | 0x21ed | 0x21ee | 0x21ef | 0x21f0 | 0x21f1 | 0x21f2 | 0x21f3 | 0x21f4 | 0x21f5
5900 | 0x21f6 | 0x21f7 | 0x21f8 | 0x21f9 | 0x21fa | 0x21fb | 0x21fc | 0x21fd | 0x21fe
5901 | 0x21ff | 0x23c0 | 0x23c1 | 0x23c2 | 0x23c3 | 0x23c4 | 0x23c5 | 0x23c6 | 0x23c7
5902 | 0x23c8 | 0x23c9 | 0x23ca | 0x23cb | 0x23cc | 0x23cd | 0x23ce | 0x23cf | 0x23d0
5903 | 0x23d1 | 0x23d2 | 0x23d3 | 0x23d4 | 0x23d5 | 0x23d6 | 0x23d7 | 0x23d8 | 0x23d9
5904 | 0x23da | 0x23db | 0x23dc | 0x23dd | 0x23de | 0x23df | 0x23e0 | 0x23e1 | 0x23e2
5905 | 0x23e3 | 0x23e4 | 0x23e5 | 0x23e6 | 0x23e7 | 0x23e8 | 0x23e9 | 0x23ea | 0x23eb
5906 | 0x23ec | 0x23ed | 0x23ee | 0x23ef | 0x23f0 | 0x23f1 | 0x23f2 | 0x23f3 | 0x23f4
5907 | 0x23f5 | 0x23f6 | 0x23f7 | 0x23f8 | 0x23f9 | 0x23fa | 0x23fb | 0x23fc | 0x23fd
5908 | 0x23fe | 0x23ff | 0x25c0 | 0x25c1 | 0x25c2 | 0x25c3 | 0x25c4 | 0x25c5 | 0x25c6
5909 | 0x25c7 | 0x25c8 | 0x25c9 | 0x25ca | 0x25cb | 0x25cc | 0x25cd | 0x25ce | 0x25cf
5910 | 0x25d0 | 0x25d1 | 0x25d2 | 0x25d3 | 0x25d4 | 0x25d5 | 0x25d6 | 0x25d7 | 0x25d8
5911 | 0x25d9 | 0x25da | 0x25db | 0x25dc | 0x25dd | 0x25de | 0x25df | 0x25e0 | 0x25e1
5912 | 0x25e2 | 0x25e3 | 0x25e4 | 0x25e5 | 0x25e6 | 0x25e7 | 0x25e8 | 0x25e9 | 0x25ea
5913 | 0x25eb | 0x25ec | 0x25ed | 0x25ee | 0x25ef | 0x25f0 | 0x25f1 | 0x25f2 | 0x25f3
5914 | 0x25f4 | 0x25f5 | 0x25f6 | 0x25f7 | 0x25f8 | 0x25f9 | 0x25fa | 0x25fb | 0x25fc
5915 | 0x25fd | 0x25fe | 0x25ff | 0x27c0 | 0x27c1 | 0x27c2 | 0x27c3 | 0x27c4 | 0x27c5
5916 | 0x27c6 | 0x27c7 | 0x27c8 | 0x27c9 | 0x27ca | 0x27cb | 0x27cc | 0x27cd | 0x27ce
5917 | 0x27cf | 0x27d0 | 0x27d1 | 0x27d2 | 0x27d3 | 0x27d4 | 0x27d5 | 0x27d6 | 0x27d7
5918 | 0x27d8 | 0x27d9 | 0x27da | 0x27db | 0x27dc | 0x27dd | 0x27de | 0x27df | 0x27e0
5919 | 0x27e1 | 0x27e2 | 0x27e3 | 0x27e4 | 0x27e5 | 0x27e6 | 0x27e7 | 0x27e8 | 0x27e9
5920 | 0x27ea | 0x27eb | 0x27ec | 0x27ed | 0x27ee | 0x27ef | 0x27f0 | 0x27f1 | 0x27f2
5921 | 0x27f3 | 0x27f4 | 0x27f5 | 0x27f6 | 0x27f7 | 0x27f8 | 0x27f9 | 0x27fa | 0x27fb
5922 | 0x27fc | 0x27fd | 0x27fe | 0x27ff => {
5923 #[cfg(feature = "arm")]
5924 if let Some(ins) = parse_arm_ldm_2(ins, pc, options) {
5925 return ins;
5926 }
5927 }
5928 0x22e0 | 0x22e1 | 0x22e2 | 0x22e3 | 0x22e4 | 0x22e5 | 0x22e6 | 0x22e7 | 0x22e8
5929 | 0x22e9 | 0x22ea | 0x22eb | 0x22ec | 0x22ed | 0x22ee | 0x22ef | 0x22f0 | 0x22f1
5930 | 0x22f2 | 0x22f3 | 0x22f4 | 0x22f5 | 0x22f6 | 0x22f7 | 0x22f8 | 0x22f9 | 0x22fa
5931 | 0x22fb | 0x22fc | 0x22fd | 0x22fe | 0x22ff => {
5932 #[cfg(feature = "arm")]
5933 if (ins & 0xfff0000) == 0x8bd0000
5934 && let Some(ins) = parse_arm_pop_0(ins, pc, options)
5935 {
5936 return ins;
5937 }
5938 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
5939 if (ins & 0xfe500000) == 0xf8100000
5940 && let Some(ins) = parse_arm_rfe_0(ins, pc, options)
5941 {
5942 return ins;
5943 }
5944 #[cfg(feature = "arm")]
5945 if (ins & 0xe500000) == 0x8100000
5946 && let Some(ins) = parse_arm_ldm_0(ins, pc, options)
5947 {
5948 return ins;
5949 }
5950 }
5951 0x24a0 | 0x24a1 | 0x24a2 | 0x24a3 | 0x24a4 | 0x24a5 | 0x24a6 | 0x24a7 | 0x24a8
5952 | 0x24a9 | 0x24aa | 0x24ab | 0x24ac | 0x24ad | 0x24ae | 0x24af | 0x24b0 | 0x24b1
5953 | 0x24b2 | 0x24b3 | 0x24b4 | 0x24b5 | 0x24b6 | 0x24b7 | 0x24b8 | 0x24b9 | 0x24ba
5954 | 0x24bb | 0x24bc | 0x24bd | 0x24be | 0x24bf => {
5955 #[cfg(feature = "arm")]
5956 if (ins & 0xfff0000) == 0x92d0000
5957 && let Some(ins) = parse_arm_push_0(ins, pc, options)
5958 {
5959 return ins;
5960 }
5961 #[cfg(feature = "arm")]
5962 if (ins & 0xe100000) == 0x8000000
5963 && let Some(ins) = parse_arm_stm_0(ins, pc, options)
5964 {
5965 return ins;
5966 }
5967 }
5968 0x2800 | 0x2801 | 0x2802 | 0x2803 | 0x2804 | 0x2805 | 0x2806 | 0x2807 | 0x2808
5969 | 0x2809 | 0x280a | 0x280b | 0x280c | 0x280d | 0x280e | 0x280f | 0x2810 | 0x2811
5970 | 0x2812 | 0x2813 | 0x2814 | 0x2815 | 0x2816 | 0x2817 | 0x2818 | 0x2819 | 0x281a
5971 | 0x281b | 0x281c | 0x281d | 0x281e | 0x281f | 0x2820 | 0x2821 | 0x2822 | 0x2823
5972 | 0x2824 | 0x2825 | 0x2826 | 0x2827 | 0x2828 | 0x2829 | 0x282a | 0x282b | 0x282c
5973 | 0x282d | 0x282e | 0x282f | 0x2830 | 0x2831 | 0x2832 | 0x2833 | 0x2834 | 0x2835
5974 | 0x2836 | 0x2837 | 0x2838 | 0x2839 | 0x283a | 0x283b | 0x283c | 0x283d | 0x283e
5975 | 0x283f | 0x2840 | 0x2841 | 0x2842 | 0x2843 | 0x2844 | 0x2845 | 0x2846 | 0x2847
5976 | 0x2848 | 0x2849 | 0x284a | 0x284b | 0x284c | 0x284d | 0x284e | 0x284f | 0x2850
5977 | 0x2851 | 0x2852 | 0x2853 | 0x2854 | 0x2855 | 0x2856 | 0x2857 | 0x2858 | 0x2859
5978 | 0x285a | 0x285b | 0x285c | 0x285d | 0x285e | 0x285f | 0x2860 | 0x2861 | 0x2862
5979 | 0x2863 | 0x2864 | 0x2865 | 0x2866 | 0x2867 | 0x2868 | 0x2869 | 0x286a | 0x286b
5980 | 0x286c | 0x286d | 0x286e | 0x286f | 0x2870 | 0x2871 | 0x2872 | 0x2873 | 0x2874
5981 | 0x2875 | 0x2876 | 0x2877 | 0x2878 | 0x2879 | 0x287a | 0x287b | 0x287c | 0x287d
5982 | 0x287e | 0x287f | 0x2880 | 0x2881 | 0x2882 | 0x2883 | 0x2884 | 0x2885 | 0x2886
5983 | 0x2887 | 0x2888 | 0x2889 | 0x288a | 0x288b | 0x288c | 0x288d | 0x288e | 0x288f
5984 | 0x2890 | 0x2891 | 0x2892 | 0x2893 | 0x2894 | 0x2895 | 0x2896 | 0x2897 | 0x2898
5985 | 0x2899 | 0x289a | 0x289b | 0x289c | 0x289d | 0x289e | 0x289f | 0x28a0 | 0x28a1
5986 | 0x28a2 | 0x28a3 | 0x28a4 | 0x28a5 | 0x28a6 | 0x28a7 | 0x28a8 | 0x28a9 | 0x28aa
5987 | 0x28ab | 0x28ac | 0x28ad | 0x28ae | 0x28af | 0x28b0 | 0x28b1 | 0x28b2 | 0x28b3
5988 | 0x28b4 | 0x28b5 | 0x28b6 | 0x28b7 | 0x28b8 | 0x28b9 | 0x28ba | 0x28bb | 0x28bc
5989 | 0x28bd | 0x28be | 0x28bf | 0x28c0 | 0x28c1 | 0x28c2 | 0x28c3 | 0x28c4 | 0x28c5
5990 | 0x28c6 | 0x28c7 | 0x28c8 | 0x28c9 | 0x28ca | 0x28cb | 0x28cc | 0x28cd | 0x28ce
5991 | 0x28cf | 0x28d0 | 0x28d1 | 0x28d2 | 0x28d3 | 0x28d4 | 0x28d5 | 0x28d6 | 0x28d7
5992 | 0x28d8 | 0x28d9 | 0x28da | 0x28db | 0x28dc | 0x28dd | 0x28de | 0x28df | 0x28e0
5993 | 0x28e1 | 0x28e2 | 0x28e3 | 0x28e4 | 0x28e5 | 0x28e6 | 0x28e7 | 0x28e8 | 0x28e9
5994 | 0x28ea | 0x28eb | 0x28ec | 0x28ed | 0x28ee | 0x28ef | 0x28f0 | 0x28f1 | 0x28f2
5995 | 0x28f3 | 0x28f4 | 0x28f5 | 0x28f6 | 0x28f7 | 0x28f8 | 0x28f9 | 0x28fa | 0x28fb
5996 | 0x28fc | 0x28fd | 0x28fe | 0x28ff | 0x2900 | 0x2901 | 0x2902 | 0x2903 | 0x2904
5997 | 0x2905 | 0x2906 | 0x2907 | 0x2908 | 0x2909 | 0x290a | 0x290b | 0x290c | 0x290d
5998 | 0x290e | 0x290f | 0x2910 | 0x2911 | 0x2912 | 0x2913 | 0x2914 | 0x2915 | 0x2916
5999 | 0x2917 | 0x2918 | 0x2919 | 0x291a | 0x291b | 0x291c | 0x291d | 0x291e | 0x291f
6000 | 0x2920 | 0x2921 | 0x2922 | 0x2923 | 0x2924 | 0x2925 | 0x2926 | 0x2927 | 0x2928
6001 | 0x2929 | 0x292a | 0x292b | 0x292c | 0x292d | 0x292e | 0x292f | 0x2930 | 0x2931
6002 | 0x2932 | 0x2933 | 0x2934 | 0x2935 | 0x2936 | 0x2937 | 0x2938 | 0x2939 | 0x293a
6003 | 0x293b | 0x293c | 0x293d | 0x293e | 0x293f | 0x2940 | 0x2941 | 0x2942 | 0x2943
6004 | 0x2944 | 0x2945 | 0x2946 | 0x2947 | 0x2948 | 0x2949 | 0x294a | 0x294b | 0x294c
6005 | 0x294d | 0x294e | 0x294f | 0x2950 | 0x2951 | 0x2952 | 0x2953 | 0x2954 | 0x2955
6006 | 0x2956 | 0x2957 | 0x2958 | 0x2959 | 0x295a | 0x295b | 0x295c | 0x295d | 0x295e
6007 | 0x295f | 0x2960 | 0x2961 | 0x2962 | 0x2963 | 0x2964 | 0x2965 | 0x2966 | 0x2967
6008 | 0x2968 | 0x2969 | 0x296a | 0x296b | 0x296c | 0x296d | 0x296e | 0x296f | 0x2970
6009 | 0x2971 | 0x2972 | 0x2973 | 0x2974 | 0x2975 | 0x2976 | 0x2977 | 0x2978 | 0x2979
6010 | 0x297a | 0x297b | 0x297c | 0x297d | 0x297e | 0x297f | 0x2980 | 0x2981 | 0x2982
6011 | 0x2983 | 0x2984 | 0x2985 | 0x2986 | 0x2987 | 0x2988 | 0x2989 | 0x298a | 0x298b
6012 | 0x298c | 0x298d | 0x298e | 0x298f | 0x2990 | 0x2991 | 0x2992 | 0x2993 | 0x2994
6013 | 0x2995 | 0x2996 | 0x2997 | 0x2998 | 0x2999 | 0x299a | 0x299b | 0x299c | 0x299d
6014 | 0x299e | 0x299f | 0x29a0 | 0x29a1 | 0x29a2 | 0x29a3 | 0x29a4 | 0x29a5 | 0x29a6
6015 | 0x29a7 | 0x29a8 | 0x29a9 | 0x29aa | 0x29ab | 0x29ac | 0x29ad | 0x29ae | 0x29af
6016 | 0x29b0 | 0x29b1 | 0x29b2 | 0x29b3 | 0x29b4 | 0x29b5 | 0x29b6 | 0x29b7 | 0x29b8
6017 | 0x29b9 | 0x29ba | 0x29bb | 0x29bc | 0x29bd | 0x29be | 0x29bf | 0x29c0 | 0x29c1
6018 | 0x29c2 | 0x29c3 | 0x29c4 | 0x29c5 | 0x29c6 | 0x29c7 | 0x29c8 | 0x29c9 | 0x29ca
6019 | 0x29cb | 0x29cc | 0x29cd | 0x29ce | 0x29cf | 0x29d0 | 0x29d1 | 0x29d2 | 0x29d3
6020 | 0x29d4 | 0x29d5 | 0x29d6 | 0x29d7 | 0x29d8 | 0x29d9 | 0x29da | 0x29db | 0x29dc
6021 | 0x29dd | 0x29de | 0x29df | 0x29e0 | 0x29e1 | 0x29e2 | 0x29e3 | 0x29e4 | 0x29e5
6022 | 0x29e6 | 0x29e7 | 0x29e8 | 0x29e9 | 0x29ea | 0x29eb | 0x29ec | 0x29ed | 0x29ee
6023 | 0x29ef | 0x29f0 | 0x29f1 | 0x29f2 | 0x29f3 | 0x29f4 | 0x29f5 | 0x29f6 | 0x29f7
6024 | 0x29f8 | 0x29f9 | 0x29fa | 0x29fb | 0x29fc | 0x29fd | 0x29fe | 0x29ff | 0x2a00
6025 | 0x2a01 | 0x2a02 | 0x2a03 | 0x2a04 | 0x2a05 | 0x2a06 | 0x2a07 | 0x2a08 | 0x2a09
6026 | 0x2a0a | 0x2a0b | 0x2a0c | 0x2a0d | 0x2a0e | 0x2a0f | 0x2a10 | 0x2a11 | 0x2a12
6027 | 0x2a13 | 0x2a14 | 0x2a15 | 0x2a16 | 0x2a17 | 0x2a18 | 0x2a19 | 0x2a1a | 0x2a1b
6028 | 0x2a1c | 0x2a1d | 0x2a1e | 0x2a1f | 0x2a20 | 0x2a21 | 0x2a22 | 0x2a23 | 0x2a24
6029 | 0x2a25 | 0x2a26 | 0x2a27 | 0x2a28 | 0x2a29 | 0x2a2a | 0x2a2b | 0x2a2c | 0x2a2d
6030 | 0x2a2e | 0x2a2f | 0x2a30 | 0x2a31 | 0x2a32 | 0x2a33 | 0x2a34 | 0x2a35 | 0x2a36
6031 | 0x2a37 | 0x2a38 | 0x2a39 | 0x2a3a | 0x2a3b | 0x2a3c | 0x2a3d | 0x2a3e | 0x2a3f
6032 | 0x2a40 | 0x2a41 | 0x2a42 | 0x2a43 | 0x2a44 | 0x2a45 | 0x2a46 | 0x2a47 | 0x2a48
6033 | 0x2a49 | 0x2a4a | 0x2a4b | 0x2a4c | 0x2a4d | 0x2a4e | 0x2a4f | 0x2a50 | 0x2a51
6034 | 0x2a52 | 0x2a53 | 0x2a54 | 0x2a55 | 0x2a56 | 0x2a57 | 0x2a58 | 0x2a59 | 0x2a5a
6035 | 0x2a5b | 0x2a5c | 0x2a5d | 0x2a5e | 0x2a5f | 0x2a60 | 0x2a61 | 0x2a62 | 0x2a63
6036 | 0x2a64 | 0x2a65 | 0x2a66 | 0x2a67 | 0x2a68 | 0x2a69 | 0x2a6a | 0x2a6b | 0x2a6c
6037 | 0x2a6d | 0x2a6e | 0x2a6f | 0x2a70 | 0x2a71 | 0x2a72 | 0x2a73 | 0x2a74 | 0x2a75
6038 | 0x2a76 | 0x2a77 | 0x2a78 | 0x2a79 | 0x2a7a | 0x2a7b | 0x2a7c | 0x2a7d | 0x2a7e
6039 | 0x2a7f | 0x2a80 | 0x2a81 | 0x2a82 | 0x2a83 | 0x2a84 | 0x2a85 | 0x2a86 | 0x2a87
6040 | 0x2a88 | 0x2a89 | 0x2a8a | 0x2a8b | 0x2a8c | 0x2a8d | 0x2a8e | 0x2a8f | 0x2a90
6041 | 0x2a91 | 0x2a92 | 0x2a93 | 0x2a94 | 0x2a95 | 0x2a96 | 0x2a97 | 0x2a98 | 0x2a99
6042 | 0x2a9a | 0x2a9b | 0x2a9c | 0x2a9d | 0x2a9e | 0x2a9f | 0x2aa0 | 0x2aa1 | 0x2aa2
6043 | 0x2aa3 | 0x2aa4 | 0x2aa5 | 0x2aa6 | 0x2aa7 | 0x2aa8 | 0x2aa9 | 0x2aaa | 0x2aab
6044 | 0x2aac | 0x2aad | 0x2aae | 0x2aaf | 0x2ab0 | 0x2ab1 | 0x2ab2 | 0x2ab3 | 0x2ab4
6045 | 0x2ab5 | 0x2ab6 | 0x2ab7 | 0x2ab8 | 0x2ab9 | 0x2aba | 0x2abb | 0x2abc | 0x2abd
6046 | 0x2abe | 0x2abf | 0x2ac0 | 0x2ac1 | 0x2ac2 | 0x2ac3 | 0x2ac4 | 0x2ac5 | 0x2ac6
6047 | 0x2ac7 | 0x2ac8 | 0x2ac9 | 0x2aca | 0x2acb | 0x2acc | 0x2acd | 0x2ace | 0x2acf
6048 | 0x2ad0 | 0x2ad1 | 0x2ad2 | 0x2ad3 | 0x2ad4 | 0x2ad5 | 0x2ad6 | 0x2ad7 | 0x2ad8
6049 | 0x2ad9 | 0x2ada | 0x2adb | 0x2adc | 0x2add | 0x2ade | 0x2adf | 0x2ae0 | 0x2ae1
6050 | 0x2ae2 | 0x2ae3 | 0x2ae4 | 0x2ae5 | 0x2ae6 | 0x2ae7 | 0x2ae8 | 0x2ae9 | 0x2aea
6051 | 0x2aeb | 0x2aec | 0x2aed | 0x2aee | 0x2aef | 0x2af0 | 0x2af1 | 0x2af2 | 0x2af3
6052 | 0x2af4 | 0x2af5 | 0x2af6 | 0x2af7 | 0x2af8 | 0x2af9 | 0x2afa | 0x2afb | 0x2afc
6053 | 0x2afd | 0x2afe | 0x2aff | 0x2b00 | 0x2b01 | 0x2b02 | 0x2b03 | 0x2b04 | 0x2b05
6054 | 0x2b06 | 0x2b07 | 0x2b08 | 0x2b09 | 0x2b0a | 0x2b0b | 0x2b0c | 0x2b0d | 0x2b0e
6055 | 0x2b0f | 0x2b10 | 0x2b11 | 0x2b12 | 0x2b13 | 0x2b14 | 0x2b15 | 0x2b16 | 0x2b17
6056 | 0x2b18 | 0x2b19 | 0x2b1a | 0x2b1b | 0x2b1c | 0x2b1d | 0x2b1e | 0x2b1f | 0x2b20
6057 | 0x2b21 | 0x2b22 | 0x2b23 | 0x2b24 | 0x2b25 | 0x2b26 | 0x2b27 | 0x2b28 | 0x2b29
6058 | 0x2b2a | 0x2b2b | 0x2b2c | 0x2b2d | 0x2b2e | 0x2b2f | 0x2b30 | 0x2b31 | 0x2b32
6059 | 0x2b33 | 0x2b34 | 0x2b35 | 0x2b36 | 0x2b37 | 0x2b38 | 0x2b39 | 0x2b3a | 0x2b3b
6060 | 0x2b3c | 0x2b3d | 0x2b3e | 0x2b3f | 0x2b40 | 0x2b41 | 0x2b42 | 0x2b43 | 0x2b44
6061 | 0x2b45 | 0x2b46 | 0x2b47 | 0x2b48 | 0x2b49 | 0x2b4a | 0x2b4b | 0x2b4c | 0x2b4d
6062 | 0x2b4e | 0x2b4f | 0x2b50 | 0x2b51 | 0x2b52 | 0x2b53 | 0x2b54 | 0x2b55 | 0x2b56
6063 | 0x2b57 | 0x2b58 | 0x2b59 | 0x2b5a | 0x2b5b | 0x2b5c | 0x2b5d | 0x2b5e | 0x2b5f
6064 | 0x2b60 | 0x2b61 | 0x2b62 | 0x2b63 | 0x2b64 | 0x2b65 | 0x2b66 | 0x2b67 | 0x2b68
6065 | 0x2b69 | 0x2b6a | 0x2b6b | 0x2b6c | 0x2b6d | 0x2b6e | 0x2b6f | 0x2b70 | 0x2b71
6066 | 0x2b72 | 0x2b73 | 0x2b74 | 0x2b75 | 0x2b76 | 0x2b77 | 0x2b78 | 0x2b79 | 0x2b7a
6067 | 0x2b7b | 0x2b7c | 0x2b7d | 0x2b7e | 0x2b7f | 0x2b80 | 0x2b81 | 0x2b82 | 0x2b83
6068 | 0x2b84 | 0x2b85 | 0x2b86 | 0x2b87 | 0x2b88 | 0x2b89 | 0x2b8a | 0x2b8b | 0x2b8c
6069 | 0x2b8d | 0x2b8e | 0x2b8f | 0x2b90 | 0x2b91 | 0x2b92 | 0x2b93 | 0x2b94 | 0x2b95
6070 | 0x2b96 | 0x2b97 | 0x2b98 | 0x2b99 | 0x2b9a | 0x2b9b | 0x2b9c | 0x2b9d | 0x2b9e
6071 | 0x2b9f | 0x2ba0 | 0x2ba1 | 0x2ba2 | 0x2ba3 | 0x2ba4 | 0x2ba5 | 0x2ba6 | 0x2ba7
6072 | 0x2ba8 | 0x2ba9 | 0x2baa | 0x2bab | 0x2bac | 0x2bad | 0x2bae | 0x2baf | 0x2bb0
6073 | 0x2bb1 | 0x2bb2 | 0x2bb3 | 0x2bb4 | 0x2bb5 | 0x2bb6 | 0x2bb7 | 0x2bb8 | 0x2bb9
6074 | 0x2bba | 0x2bbb | 0x2bbc | 0x2bbd | 0x2bbe | 0x2bbf | 0x2bc0 | 0x2bc1 | 0x2bc2
6075 | 0x2bc3 | 0x2bc4 | 0x2bc5 | 0x2bc6 | 0x2bc7 | 0x2bc8 | 0x2bc9 | 0x2bca | 0x2bcb
6076 | 0x2bcc | 0x2bcd | 0x2bce | 0x2bcf | 0x2bd0 | 0x2bd1 | 0x2bd2 | 0x2bd3 | 0x2bd4
6077 | 0x2bd5 | 0x2bd6 | 0x2bd7 | 0x2bd8 | 0x2bd9 | 0x2bda | 0x2bdb | 0x2bdc | 0x2bdd
6078 | 0x2bde | 0x2bdf | 0x2be0 | 0x2be1 | 0x2be2 | 0x2be3 | 0x2be4 | 0x2be5 | 0x2be6
6079 | 0x2be7 | 0x2be8 | 0x2be9 | 0x2bea | 0x2beb | 0x2bec | 0x2bed | 0x2bee | 0x2bef
6080 | 0x2bf0 | 0x2bf1 | 0x2bf2 | 0x2bf3 | 0x2bf4 | 0x2bf5 | 0x2bf6 | 0x2bf7 | 0x2bf8
6081 | 0x2bf9 | 0x2bfa | 0x2bfb | 0x2bfc | 0x2bfd | 0x2bfe | 0x2bff => {
6082 #[cfg(
6083 all(
6084 feature = "arm",
6085 any(
6086 feature = "v5t",
6087 feature = "v5te",
6088 feature = "v5tej",
6089 feature = "v6",
6090 feature = "v6k"
6091 )
6092 )
6093 )]
6094 if (ins & 0xfe000000) == 0xfa000000
6095 && let Some(ins) = parse_arm_blx_0(ins, pc, options)
6096 {
6097 return ins;
6098 }
6099 #[cfg(feature = "arm")]
6100 if (ins & 0xf000000) == 0xa000000
6101 && let Some(ins) = parse_arm_b_0(ins, pc, options)
6102 {
6103 return ins;
6104 }
6105 }
6106 0x2c00 | 0x2c01 | 0x2c02 | 0x2c03 | 0x2c04 | 0x2c05 | 0x2c06 | 0x2c07 | 0x2c08
6107 | 0x2c09 | 0x2c0a | 0x2c0b | 0x2c0c | 0x2c0d | 0x2c0e | 0x2c0f | 0x2c10 | 0x2c11
6108 | 0x2c12 | 0x2c13 | 0x2c14 | 0x2c15 | 0x2c16 | 0x2c17 | 0x2c18 | 0x2c19 | 0x2c1a
6109 | 0x2c1b | 0x2c1c | 0x2c1d | 0x2c1e | 0x2c1f | 0x2c20 | 0x2c21 | 0x2c22 | 0x2c23
6110 | 0x2c24 | 0x2c25 | 0x2c26 | 0x2c27 | 0x2c28 | 0x2c29 | 0x2c2a | 0x2c2b | 0x2c2c
6111 | 0x2c2d | 0x2c2e | 0x2c2f | 0x2c30 | 0x2c31 | 0x2c32 | 0x2c33 | 0x2c34 | 0x2c35
6112 | 0x2c36 | 0x2c37 | 0x2c38 | 0x2c39 | 0x2c3a | 0x2c3b | 0x2c3c | 0x2c3d | 0x2c3e
6113 | 0x2c3f | 0x2c40 | 0x2c41 | 0x2c42 | 0x2c43 | 0x2c44 | 0x2c45 | 0x2c46 | 0x2c47
6114 | 0x2c48 | 0x2c49 | 0x2c4a | 0x2c4b | 0x2c4c | 0x2c4d | 0x2c4e | 0x2c4f | 0x2c50
6115 | 0x2c51 | 0x2c52 | 0x2c53 | 0x2c54 | 0x2c55 | 0x2c56 | 0x2c57 | 0x2c58 | 0x2c59
6116 | 0x2c5a | 0x2c5b | 0x2c5c | 0x2c5d | 0x2c5e | 0x2c5f | 0x2c60 | 0x2c61 | 0x2c62
6117 | 0x2c63 | 0x2c64 | 0x2c65 | 0x2c66 | 0x2c67 | 0x2c68 | 0x2c69 | 0x2c6a | 0x2c6b
6118 | 0x2c6c | 0x2c6d | 0x2c6e | 0x2c6f | 0x2c70 | 0x2c71 | 0x2c72 | 0x2c73 | 0x2c74
6119 | 0x2c75 | 0x2c76 | 0x2c77 | 0x2c78 | 0x2c79 | 0x2c7a | 0x2c7b | 0x2c7c | 0x2c7d
6120 | 0x2c7e | 0x2c7f | 0x2c80 | 0x2c81 | 0x2c82 | 0x2c83 | 0x2c84 | 0x2c85 | 0x2c86
6121 | 0x2c87 | 0x2c88 | 0x2c89 | 0x2c8a | 0x2c8b | 0x2c8c | 0x2c8d | 0x2c8e | 0x2c8f
6122 | 0x2c90 | 0x2c91 | 0x2c92 | 0x2c93 | 0x2c94 | 0x2c95 | 0x2c96 | 0x2c97 | 0x2c98
6123 | 0x2c99 | 0x2c9a | 0x2c9b | 0x2c9c | 0x2c9d | 0x2c9e | 0x2c9f | 0x2ca0 | 0x2ca1
6124 | 0x2ca2 | 0x2ca3 | 0x2ca4 | 0x2ca5 | 0x2ca6 | 0x2ca7 | 0x2ca8 | 0x2ca9 | 0x2caa
6125 | 0x2cab | 0x2cac | 0x2cad | 0x2cae | 0x2caf | 0x2cb0 | 0x2cb1 | 0x2cb2 | 0x2cb3
6126 | 0x2cb4 | 0x2cb5 | 0x2cb6 | 0x2cb7 | 0x2cb8 | 0x2cb9 | 0x2cba | 0x2cbb | 0x2cbc
6127 | 0x2cbd | 0x2cbe | 0x2cbf | 0x2cc0 | 0x2cc1 | 0x2cc2 | 0x2cc3 | 0x2cc4 | 0x2cc5
6128 | 0x2cc6 | 0x2cc7 | 0x2cc8 | 0x2cc9 | 0x2cca | 0x2ccb | 0x2ccc | 0x2ccd | 0x2cce
6129 | 0x2ccf | 0x2cd0 | 0x2cd1 | 0x2cd2 | 0x2cd3 | 0x2cd4 | 0x2cd5 | 0x2cd6 | 0x2cd7
6130 | 0x2cd8 | 0x2cd9 | 0x2cda | 0x2cdb | 0x2cdc | 0x2cdd | 0x2cde | 0x2cdf | 0x2ce0
6131 | 0x2ce1 | 0x2ce2 | 0x2ce3 | 0x2ce4 | 0x2ce5 | 0x2ce6 | 0x2ce7 | 0x2ce8 | 0x2ce9
6132 | 0x2cea | 0x2ceb | 0x2cec | 0x2ced | 0x2cee | 0x2cef | 0x2cf0 | 0x2cf1 | 0x2cf2
6133 | 0x2cf3 | 0x2cf4 | 0x2cf5 | 0x2cf6 | 0x2cf7 | 0x2cf8 | 0x2cf9 | 0x2cfa | 0x2cfb
6134 | 0x2cfc | 0x2cfd | 0x2cfe | 0x2cff | 0x2d00 | 0x2d01 | 0x2d02 | 0x2d03 | 0x2d04
6135 | 0x2d05 | 0x2d06 | 0x2d07 | 0x2d08 | 0x2d09 | 0x2d0a | 0x2d0b | 0x2d0c | 0x2d0d
6136 | 0x2d0e | 0x2d0f | 0x2d10 | 0x2d11 | 0x2d12 | 0x2d13 | 0x2d14 | 0x2d15 | 0x2d16
6137 | 0x2d17 | 0x2d18 | 0x2d19 | 0x2d1a | 0x2d1b | 0x2d1c | 0x2d1d | 0x2d1e | 0x2d1f
6138 | 0x2d20 | 0x2d21 | 0x2d22 | 0x2d23 | 0x2d24 | 0x2d25 | 0x2d26 | 0x2d27 | 0x2d28
6139 | 0x2d29 | 0x2d2a | 0x2d2b | 0x2d2c | 0x2d2d | 0x2d2e | 0x2d2f | 0x2d30 | 0x2d31
6140 | 0x2d32 | 0x2d33 | 0x2d34 | 0x2d35 | 0x2d36 | 0x2d37 | 0x2d38 | 0x2d39 | 0x2d3a
6141 | 0x2d3b | 0x2d3c | 0x2d3d | 0x2d3e | 0x2d3f | 0x2d40 | 0x2d41 | 0x2d42 | 0x2d43
6142 | 0x2d44 | 0x2d45 | 0x2d46 | 0x2d47 | 0x2d48 | 0x2d49 | 0x2d4a | 0x2d4b | 0x2d4c
6143 | 0x2d4d | 0x2d4e | 0x2d4f | 0x2d50 | 0x2d51 | 0x2d52 | 0x2d53 | 0x2d54 | 0x2d55
6144 | 0x2d56 | 0x2d57 | 0x2d58 | 0x2d59 | 0x2d5a | 0x2d5b | 0x2d5c | 0x2d5d | 0x2d5e
6145 | 0x2d5f | 0x2d60 | 0x2d61 | 0x2d62 | 0x2d63 | 0x2d64 | 0x2d65 | 0x2d66 | 0x2d67
6146 | 0x2d68 | 0x2d69 | 0x2d6a | 0x2d6b | 0x2d6c | 0x2d6d | 0x2d6e | 0x2d6f | 0x2d70
6147 | 0x2d71 | 0x2d72 | 0x2d73 | 0x2d74 | 0x2d75 | 0x2d76 | 0x2d77 | 0x2d78 | 0x2d79
6148 | 0x2d7a | 0x2d7b | 0x2d7c | 0x2d7d | 0x2d7e | 0x2d7f | 0x2d80 | 0x2d81 | 0x2d82
6149 | 0x2d83 | 0x2d84 | 0x2d85 | 0x2d86 | 0x2d87 | 0x2d88 | 0x2d89 | 0x2d8a | 0x2d8b
6150 | 0x2d8c | 0x2d8d | 0x2d8e | 0x2d8f | 0x2d90 | 0x2d91 | 0x2d92 | 0x2d93 | 0x2d94
6151 | 0x2d95 | 0x2d96 | 0x2d97 | 0x2d98 | 0x2d99 | 0x2d9a | 0x2d9b | 0x2d9c | 0x2d9d
6152 | 0x2d9e | 0x2d9f | 0x2da0 | 0x2da1 | 0x2da2 | 0x2da3 | 0x2da4 | 0x2da5 | 0x2da6
6153 | 0x2da7 | 0x2da8 | 0x2da9 | 0x2daa | 0x2dab | 0x2dac | 0x2dad | 0x2dae | 0x2daf
6154 | 0x2db0 | 0x2db1 | 0x2db2 | 0x2db3 | 0x2db4 | 0x2db5 | 0x2db6 | 0x2db7 | 0x2db8
6155 | 0x2db9 | 0x2dba | 0x2dbb | 0x2dbc | 0x2dbd | 0x2dbe | 0x2dbf | 0x2dc0 | 0x2dc1
6156 | 0x2dc2 | 0x2dc3 | 0x2dc4 | 0x2dc5 | 0x2dc6 | 0x2dc7 | 0x2dc8 | 0x2dc9 | 0x2dca
6157 | 0x2dcb | 0x2dcc | 0x2dcd | 0x2dce | 0x2dcf | 0x2dd0 | 0x2dd1 | 0x2dd2 | 0x2dd3
6158 | 0x2dd4 | 0x2dd5 | 0x2dd6 | 0x2dd7 | 0x2dd8 | 0x2dd9 | 0x2dda | 0x2ddb | 0x2ddc
6159 | 0x2ddd | 0x2dde | 0x2ddf | 0x2de0 | 0x2de1 | 0x2de2 | 0x2de3 | 0x2de4 | 0x2de5
6160 | 0x2de6 | 0x2de7 | 0x2de8 | 0x2de9 | 0x2dea | 0x2deb | 0x2dec | 0x2ded | 0x2dee
6161 | 0x2def | 0x2df0 | 0x2df1 | 0x2df2 | 0x2df3 | 0x2df4 | 0x2df5 | 0x2df6 | 0x2df7
6162 | 0x2df8 | 0x2df9 | 0x2dfa | 0x2dfb | 0x2dfc | 0x2dfd | 0x2dfe | 0x2dff | 0x2e00
6163 | 0x2e01 | 0x2e02 | 0x2e03 | 0x2e04 | 0x2e05 | 0x2e06 | 0x2e07 | 0x2e08 | 0x2e09
6164 | 0x2e0a | 0x2e0b | 0x2e0c | 0x2e0d | 0x2e0e | 0x2e0f | 0x2e10 | 0x2e11 | 0x2e12
6165 | 0x2e13 | 0x2e14 | 0x2e15 | 0x2e16 | 0x2e17 | 0x2e18 | 0x2e19 | 0x2e1a | 0x2e1b
6166 | 0x2e1c | 0x2e1d | 0x2e1e | 0x2e1f | 0x2e20 | 0x2e21 | 0x2e22 | 0x2e23 | 0x2e24
6167 | 0x2e25 | 0x2e26 | 0x2e27 | 0x2e28 | 0x2e29 | 0x2e2a | 0x2e2b | 0x2e2c | 0x2e2d
6168 | 0x2e2e | 0x2e2f | 0x2e30 | 0x2e31 | 0x2e32 | 0x2e33 | 0x2e34 | 0x2e35 | 0x2e36
6169 | 0x2e37 | 0x2e38 | 0x2e39 | 0x2e3a | 0x2e3b | 0x2e3c | 0x2e3d | 0x2e3e | 0x2e3f
6170 | 0x2e40 | 0x2e41 | 0x2e42 | 0x2e43 | 0x2e44 | 0x2e45 | 0x2e46 | 0x2e47 | 0x2e48
6171 | 0x2e49 | 0x2e4a | 0x2e4b | 0x2e4c | 0x2e4d | 0x2e4e | 0x2e4f | 0x2e50 | 0x2e51
6172 | 0x2e52 | 0x2e53 | 0x2e54 | 0x2e55 | 0x2e56 | 0x2e57 | 0x2e58 | 0x2e59 | 0x2e5a
6173 | 0x2e5b | 0x2e5c | 0x2e5d | 0x2e5e | 0x2e5f | 0x2e60 | 0x2e61 | 0x2e62 | 0x2e63
6174 | 0x2e64 | 0x2e65 | 0x2e66 | 0x2e67 | 0x2e68 | 0x2e69 | 0x2e6a | 0x2e6b | 0x2e6c
6175 | 0x2e6d | 0x2e6e | 0x2e6f | 0x2e70 | 0x2e71 | 0x2e72 | 0x2e73 | 0x2e74 | 0x2e75
6176 | 0x2e76 | 0x2e77 | 0x2e78 | 0x2e79 | 0x2e7a | 0x2e7b | 0x2e7c | 0x2e7d | 0x2e7e
6177 | 0x2e7f | 0x2e80 | 0x2e81 | 0x2e82 | 0x2e83 | 0x2e84 | 0x2e85 | 0x2e86 | 0x2e87
6178 | 0x2e88 | 0x2e89 | 0x2e8a | 0x2e8b | 0x2e8c | 0x2e8d | 0x2e8e | 0x2e8f | 0x2e90
6179 | 0x2e91 | 0x2e92 | 0x2e93 | 0x2e94 | 0x2e95 | 0x2e96 | 0x2e97 | 0x2e98 | 0x2e99
6180 | 0x2e9a | 0x2e9b | 0x2e9c | 0x2e9d | 0x2e9e | 0x2e9f | 0x2ea0 | 0x2ea1 | 0x2ea2
6181 | 0x2ea3 | 0x2ea4 | 0x2ea5 | 0x2ea6 | 0x2ea7 | 0x2ea8 | 0x2ea9 | 0x2eaa | 0x2eab
6182 | 0x2eac | 0x2ead | 0x2eae | 0x2eaf | 0x2eb0 | 0x2eb1 | 0x2eb2 | 0x2eb3 | 0x2eb4
6183 | 0x2eb5 | 0x2eb6 | 0x2eb7 | 0x2eb8 | 0x2eb9 | 0x2eba | 0x2ebb | 0x2ebc | 0x2ebd
6184 | 0x2ebe | 0x2ebf | 0x2ec0 | 0x2ec1 | 0x2ec2 | 0x2ec3 | 0x2ec4 | 0x2ec5 | 0x2ec6
6185 | 0x2ec7 | 0x2ec8 | 0x2ec9 | 0x2eca | 0x2ecb | 0x2ecc | 0x2ecd | 0x2ece | 0x2ecf
6186 | 0x2ed0 | 0x2ed1 | 0x2ed2 | 0x2ed3 | 0x2ed4 | 0x2ed5 | 0x2ed6 | 0x2ed7 | 0x2ed8
6187 | 0x2ed9 | 0x2eda | 0x2edb | 0x2edc | 0x2edd | 0x2ede | 0x2edf | 0x2ee0 | 0x2ee1
6188 | 0x2ee2 | 0x2ee3 | 0x2ee4 | 0x2ee5 | 0x2ee6 | 0x2ee7 | 0x2ee8 | 0x2ee9 | 0x2eea
6189 | 0x2eeb | 0x2eec | 0x2eed | 0x2eee | 0x2eef | 0x2ef0 | 0x2ef1 | 0x2ef2 | 0x2ef3
6190 | 0x2ef4 | 0x2ef5 | 0x2ef6 | 0x2ef7 | 0x2ef8 | 0x2ef9 | 0x2efa | 0x2efb | 0x2efc
6191 | 0x2efd | 0x2efe | 0x2eff | 0x2f00 | 0x2f01 | 0x2f02 | 0x2f03 | 0x2f04 | 0x2f05
6192 | 0x2f06 | 0x2f07 | 0x2f08 | 0x2f09 | 0x2f0a | 0x2f0b | 0x2f0c | 0x2f0d | 0x2f0e
6193 | 0x2f0f | 0x2f10 | 0x2f11 | 0x2f12 | 0x2f13 | 0x2f14 | 0x2f15 | 0x2f16 | 0x2f17
6194 | 0x2f18 | 0x2f19 | 0x2f1a | 0x2f1b | 0x2f1c | 0x2f1d | 0x2f1e | 0x2f1f | 0x2f20
6195 | 0x2f21 | 0x2f22 | 0x2f23 | 0x2f24 | 0x2f25 | 0x2f26 | 0x2f27 | 0x2f28 | 0x2f29
6196 | 0x2f2a | 0x2f2b | 0x2f2c | 0x2f2d | 0x2f2e | 0x2f2f | 0x2f30 | 0x2f31 | 0x2f32
6197 | 0x2f33 | 0x2f34 | 0x2f35 | 0x2f36 | 0x2f37 | 0x2f38 | 0x2f39 | 0x2f3a | 0x2f3b
6198 | 0x2f3c | 0x2f3d | 0x2f3e | 0x2f3f | 0x2f40 | 0x2f41 | 0x2f42 | 0x2f43 | 0x2f44
6199 | 0x2f45 | 0x2f46 | 0x2f47 | 0x2f48 | 0x2f49 | 0x2f4a | 0x2f4b | 0x2f4c | 0x2f4d
6200 | 0x2f4e | 0x2f4f | 0x2f50 | 0x2f51 | 0x2f52 | 0x2f53 | 0x2f54 | 0x2f55 | 0x2f56
6201 | 0x2f57 | 0x2f58 | 0x2f59 | 0x2f5a | 0x2f5b | 0x2f5c | 0x2f5d | 0x2f5e | 0x2f5f
6202 | 0x2f60 | 0x2f61 | 0x2f62 | 0x2f63 | 0x2f64 | 0x2f65 | 0x2f66 | 0x2f67 | 0x2f68
6203 | 0x2f69 | 0x2f6a | 0x2f6b | 0x2f6c | 0x2f6d | 0x2f6e | 0x2f6f | 0x2f70 | 0x2f71
6204 | 0x2f72 | 0x2f73 | 0x2f74 | 0x2f75 | 0x2f76 | 0x2f77 | 0x2f78 | 0x2f79 | 0x2f7a
6205 | 0x2f7b | 0x2f7c | 0x2f7d | 0x2f7e | 0x2f7f | 0x2f80 | 0x2f81 | 0x2f82 | 0x2f83
6206 | 0x2f84 | 0x2f85 | 0x2f86 | 0x2f87 | 0x2f88 | 0x2f89 | 0x2f8a | 0x2f8b | 0x2f8c
6207 | 0x2f8d | 0x2f8e | 0x2f8f | 0x2f90 | 0x2f91 | 0x2f92 | 0x2f93 | 0x2f94 | 0x2f95
6208 | 0x2f96 | 0x2f97 | 0x2f98 | 0x2f99 | 0x2f9a | 0x2f9b | 0x2f9c | 0x2f9d | 0x2f9e
6209 | 0x2f9f | 0x2fa0 | 0x2fa1 | 0x2fa2 | 0x2fa3 | 0x2fa4 | 0x2fa5 | 0x2fa6 | 0x2fa7
6210 | 0x2fa8 | 0x2fa9 | 0x2faa | 0x2fab | 0x2fac | 0x2fad | 0x2fae | 0x2faf | 0x2fb0
6211 | 0x2fb1 | 0x2fb2 | 0x2fb3 | 0x2fb4 | 0x2fb5 | 0x2fb6 | 0x2fb7 | 0x2fb8 | 0x2fb9
6212 | 0x2fba | 0x2fbb | 0x2fbc | 0x2fbd | 0x2fbe | 0x2fbf | 0x2fc0 | 0x2fc1 | 0x2fc2
6213 | 0x2fc3 | 0x2fc4 | 0x2fc5 | 0x2fc6 | 0x2fc7 | 0x2fc8 | 0x2fc9 | 0x2fca | 0x2fcb
6214 | 0x2fcc | 0x2fcd | 0x2fce | 0x2fcf | 0x2fd0 | 0x2fd1 | 0x2fd2 | 0x2fd3 | 0x2fd4
6215 | 0x2fd5 | 0x2fd6 | 0x2fd7 | 0x2fd8 | 0x2fd9 | 0x2fda | 0x2fdb | 0x2fdc | 0x2fdd
6216 | 0x2fde | 0x2fdf | 0x2fe0 | 0x2fe1 | 0x2fe2 | 0x2fe3 | 0x2fe4 | 0x2fe5 | 0x2fe6
6217 | 0x2fe7 | 0x2fe8 | 0x2fe9 | 0x2fea | 0x2feb | 0x2fec | 0x2fed | 0x2fee | 0x2fef
6218 | 0x2ff0 | 0x2ff1 | 0x2ff2 | 0x2ff3 | 0x2ff4 | 0x2ff5 | 0x2ff6 | 0x2ff7 | 0x2ff8
6219 | 0x2ff9 | 0x2ffa | 0x2ffb | 0x2ffc | 0x2ffd | 0x2ffe | 0x2fff => {
6220 #[cfg(
6221 all(
6222 feature = "arm",
6223 any(
6224 feature = "v5t",
6225 feature = "v5te",
6226 feature = "v5tej",
6227 feature = "v6",
6228 feature = "v6k"
6229 )
6230 )
6231 )]
6232 if (ins & 0xfe000000) == 0xfa000000
6233 && let Some(ins) = parse_arm_blx_0(ins, pc, options)
6234 {
6235 return ins;
6236 }
6237 #[cfg(feature = "arm")]
6238 if (ins & 0xf000000) == 0xb000000
6239 && let Some(ins) = parse_arm_bl_0(ins, pc, options)
6240 {
6241 return ins;
6242 }
6243 }
6244 0x3000 | 0x3001 | 0x3002 | 0x3003 | 0x3004 | 0x3005 | 0x3006 | 0x3007 | 0x3008
6245 | 0x3009 | 0x300a | 0x300b | 0x300c | 0x300d | 0x300e | 0x300f | 0x3020 | 0x3021
6246 | 0x3022 | 0x3023 | 0x3024 | 0x3025 | 0x3026 | 0x3027 | 0x3028 | 0x3029 | 0x302a
6247 | 0x302b | 0x302c | 0x302d | 0x302e | 0x302f | 0x3080 | 0x3081 | 0x3082 | 0x3083
6248 | 0x3084 | 0x3085 | 0x3086 | 0x3087 | 0x3088 | 0x3089 | 0x308a | 0x308b | 0x308c
6249 | 0x308d | 0x308e | 0x308f | 0x30a0 | 0x30a1 | 0x30a2 | 0x30a3 | 0x30a4 | 0x30a5
6250 | 0x30a6 | 0x30a7 | 0x30a8 | 0x30a9 | 0x30aa | 0x30ab | 0x30ac | 0x30ad | 0x30ae
6251 | 0x30af | 0x3180 | 0x3181 | 0x3182 | 0x3183 | 0x3184 | 0x3185 | 0x3186 | 0x3187
6252 | 0x3188 | 0x3189 | 0x318a | 0x318b | 0x318c | 0x318d | 0x318e | 0x318f | 0x31a0
6253 | 0x31a1 | 0x31a2 | 0x31a3 | 0x31a4 | 0x31a5 | 0x31a6 | 0x31a7 | 0x31a8 | 0x31a9
6254 | 0x31aa | 0x31ab | 0x31ac | 0x31ad | 0x31ae | 0x31af | 0x3200 | 0x3201 | 0x3202
6255 | 0x3203 | 0x3204 | 0x3205 | 0x3206 | 0x3207 | 0x3208 | 0x3209 | 0x320a | 0x320b
6256 | 0x320c | 0x320d | 0x320e | 0x320f | 0x3220 | 0x3221 | 0x3222 | 0x3223 | 0x3224
6257 | 0x3225 | 0x3226 | 0x3227 | 0x3228 | 0x3229 | 0x322a | 0x322b | 0x322c | 0x322d
6258 | 0x322e | 0x322f | 0x3280 | 0x3281 | 0x3282 | 0x3283 | 0x3284 | 0x3285 | 0x3286
6259 | 0x3287 | 0x3288 | 0x3289 | 0x328a | 0x328b | 0x328c | 0x328d | 0x328e | 0x328f
6260 | 0x32a0 | 0x32a1 | 0x32a2 | 0x32a3 | 0x32a4 | 0x32a5 | 0x32a6 | 0x32a7 | 0x32a8
6261 | 0x32a9 | 0x32aa | 0x32ab | 0x32ac | 0x32ad | 0x32ae | 0x32af | 0x3300 | 0x3301
6262 | 0x3302 | 0x3303 | 0x3304 | 0x3305 | 0x3306 | 0x3307 | 0x3308 | 0x3309 | 0x330a
6263 | 0x330b | 0x330c | 0x330d | 0x330e | 0x330f | 0x3320 | 0x3321 | 0x3322 | 0x3323
6264 | 0x3324 | 0x3325 | 0x3326 | 0x3327 | 0x3328 | 0x3329 | 0x332a | 0x332b | 0x332c
6265 | 0x332d | 0x332e | 0x332f | 0x3380 | 0x3381 | 0x3382 | 0x3383 | 0x3384 | 0x3385
6266 | 0x3386 | 0x3387 | 0x3388 | 0x3389 | 0x338a | 0x338b | 0x338c | 0x338d | 0x338e
6267 | 0x338f | 0x33a0 | 0x33a1 | 0x33a2 | 0x33a3 | 0x33a4 | 0x33a5 | 0x33a6 | 0x33a7
6268 | 0x33a8 | 0x33a9 | 0x33aa | 0x33ab | 0x33ac | 0x33ad | 0x33ae | 0x33af | 0x3480
6269 | 0x3481 | 0x3482 | 0x3483 | 0x3484 | 0x3485 | 0x3486 | 0x3487 | 0x3488 | 0x3489
6270 | 0x348a | 0x348b | 0x348c | 0x348d | 0x348e | 0x348f | 0x3580 | 0x3581 | 0x3582
6271 | 0x3583 | 0x3584 | 0x3585 | 0x3586 | 0x3587 | 0x3588 | 0x3589 | 0x358a | 0x358b
6272 | 0x358c | 0x358d | 0x358e | 0x358f | 0x3680 | 0x3681 | 0x3682 | 0x3683 | 0x3684
6273 | 0x3685 | 0x3686 | 0x3687 | 0x3688 | 0x3689 | 0x368a | 0x368b | 0x368c | 0x368d
6274 | 0x368e | 0x368f | 0x36a0 | 0x36a1 | 0x36a2 | 0x36a3 | 0x36a4 | 0x36a5 | 0x36a6
6275 | 0x36a7 | 0x36a8 | 0x36a9 | 0x36aa | 0x36ab | 0x36ac | 0x36ad | 0x36ae | 0x36af
6276 | 0x3780 | 0x3781 | 0x3782 | 0x3783 | 0x3784 | 0x3785 | 0x3786 | 0x3787 | 0x3788
6277 | 0x3789 | 0x378a | 0x378b | 0x378c | 0x378d | 0x378e | 0x378f | 0x37a0 | 0x37a1
6278 | 0x37a2 | 0x37a3 | 0x37a4 | 0x37a5 | 0x37a6 | 0x37a7 | 0x37a8 | 0x37a9 | 0x37aa
6279 | 0x37ab | 0x37ac | 0x37ad | 0x37ae | 0x37af => {
6280 #[cfg(
6281 all(
6282 feature = "arm",
6283 any(
6284 feature = "v5t",
6285 feature = "v5te",
6286 feature = "v5tej",
6287 feature = "v6",
6288 feature = "v6k"
6289 )
6290 )
6291 )]
6292 if (ins & 0xfe100000) == 0xfc000000
6293 && let Some(ins) = parse_arm_stc2_0(ins, pc, options)
6294 {
6295 return ins;
6296 }
6297 #[cfg(
6298 all(
6299 feature = "arm",
6300 feature = "vfp_v2",
6301 any(
6302 feature = "v5te",
6303 feature = "v5tej",
6304 feature = "v6",
6305 feature = "v6k"
6306 )
6307 )
6308 )]
6309 if (ins & 0xe100f00) == 0xc000a00
6310 && let Some(ins) = parse_arm_vstm_f32_0(ins, pc, options)
6311 {
6312 return ins;
6313 }
6314 #[cfg(feature = "arm")]
6315 if (ins & 0xe100000) == 0xc000000
6316 && let Some(ins) = parse_arm_stc_0(ins, pc, options)
6317 {
6318 return ins;
6319 }
6320 }
6321 0x3010 | 0x3011 | 0x3012 | 0x3013 | 0x3014 | 0x3015 | 0x3016 | 0x3017 | 0x3018
6322 | 0x3019 | 0x301a | 0x301b | 0x301c | 0x301d | 0x301e | 0x301f | 0x3030 | 0x3031
6323 | 0x3032 | 0x3033 | 0x3034 | 0x3035 | 0x3036 | 0x3037 | 0x3038 | 0x3039 | 0x303a
6324 | 0x303b | 0x303c | 0x303d | 0x303e | 0x303f | 0x3090 | 0x3091 | 0x3092 | 0x3093
6325 | 0x3094 | 0x3095 | 0x3096 | 0x3097 | 0x3098 | 0x3099 | 0x309a | 0x309b | 0x309c
6326 | 0x309d | 0x309e | 0x309f | 0x30b0 | 0x30b1 | 0x30b2 | 0x30b3 | 0x30b4 | 0x30b5
6327 | 0x30b6 | 0x30b7 | 0x30b8 | 0x30b9 | 0x30ba | 0x30bb | 0x30bc | 0x30bd | 0x30be
6328 | 0x30bf | 0x3190 | 0x3191 | 0x3192 | 0x3193 | 0x3194 | 0x3195 | 0x3196 | 0x3197
6329 | 0x3198 | 0x3199 | 0x319a | 0x319b | 0x319c | 0x319d | 0x319e | 0x319f | 0x31b0
6330 | 0x31b1 | 0x31b2 | 0x31b3 | 0x31b4 | 0x31b5 | 0x31b6 | 0x31b7 | 0x31b8 | 0x31b9
6331 | 0x31ba | 0x31bb | 0x31bc | 0x31bd | 0x31be | 0x31bf | 0x3210 | 0x3211 | 0x3212
6332 | 0x3213 | 0x3214 | 0x3215 | 0x3216 | 0x3217 | 0x3218 | 0x3219 | 0x321a | 0x321b
6333 | 0x321c | 0x321d | 0x321e | 0x321f | 0x3230 | 0x3231 | 0x3232 | 0x3233 | 0x3234
6334 | 0x3235 | 0x3236 | 0x3237 | 0x3238 | 0x3239 | 0x323a | 0x323b | 0x323c | 0x323d
6335 | 0x323e | 0x323f | 0x3290 | 0x3291 | 0x3292 | 0x3293 | 0x3294 | 0x3295 | 0x3296
6336 | 0x3297 | 0x3298 | 0x3299 | 0x329a | 0x329b | 0x329c | 0x329d | 0x329e | 0x329f
6337 | 0x32b0 | 0x32b1 | 0x32b2 | 0x32b3 | 0x32b4 | 0x32b5 | 0x32b6 | 0x32b7 | 0x32b8
6338 | 0x32b9 | 0x32ba | 0x32bb | 0x32bc | 0x32bd | 0x32be | 0x32bf | 0x3310 | 0x3311
6339 | 0x3312 | 0x3313 | 0x3314 | 0x3315 | 0x3316 | 0x3317 | 0x3318 | 0x3319 | 0x331a
6340 | 0x331b | 0x331c | 0x331d | 0x331e | 0x331f | 0x3330 | 0x3331 | 0x3332 | 0x3333
6341 | 0x3334 | 0x3335 | 0x3336 | 0x3337 | 0x3338 | 0x3339 | 0x333a | 0x333b | 0x333c
6342 | 0x333d | 0x333e | 0x333f | 0x3390 | 0x3391 | 0x3392 | 0x3393 | 0x3394 | 0x3395
6343 | 0x3396 | 0x3397 | 0x3398 | 0x3399 | 0x339a | 0x339b | 0x339c | 0x339d | 0x339e
6344 | 0x339f | 0x33b0 | 0x33b1 | 0x33b2 | 0x33b3 | 0x33b4 | 0x33b5 | 0x33b6 | 0x33b7
6345 | 0x33b8 | 0x33b9 | 0x33ba | 0x33bb | 0x33bc | 0x33bd | 0x33be | 0x33bf | 0x3490
6346 | 0x3491 | 0x3492 | 0x3493 | 0x3494 | 0x3495 | 0x3496 | 0x3497 | 0x3498 | 0x3499
6347 | 0x349a | 0x349b | 0x349c | 0x349d | 0x349e | 0x349f | 0x3590 | 0x3591 | 0x3592
6348 | 0x3593 | 0x3594 | 0x3595 | 0x3596 | 0x3597 | 0x3598 | 0x3599 | 0x359a | 0x359b
6349 | 0x359c | 0x359d | 0x359e | 0x359f | 0x3690 | 0x3691 | 0x3692 | 0x3693 | 0x3694
6350 | 0x3695 | 0x3696 | 0x3697 | 0x3698 | 0x3699 | 0x369a | 0x369b | 0x369c | 0x369d
6351 | 0x369e | 0x369f | 0x36b0 | 0x36b1 | 0x36b2 | 0x36b3 | 0x36b4 | 0x36b5 | 0x36b6
6352 | 0x36b7 | 0x36b8 | 0x36b9 | 0x36ba | 0x36bb | 0x36bc | 0x36bd | 0x36be | 0x36bf
6353 | 0x3790 | 0x3791 | 0x3792 | 0x3793 | 0x3794 | 0x3795 | 0x3796 | 0x3797 | 0x3798
6354 | 0x3799 | 0x379a | 0x379b | 0x379c | 0x379d | 0x379e | 0x379f | 0x37b0 | 0x37b1
6355 | 0x37b2 | 0x37b3 | 0x37b4 | 0x37b5 | 0x37b6 | 0x37b7 | 0x37b8 | 0x37b9 | 0x37ba
6356 | 0x37bb | 0x37bc | 0x37bd | 0x37be | 0x37bf => {
6357 #[cfg(
6358 all(
6359 feature = "arm",
6360 any(
6361 feature = "v5t",
6362 feature = "v5te",
6363 feature = "v5tej",
6364 feature = "v6",
6365 feature = "v6k"
6366 )
6367 )
6368 )]
6369 if (ins & 0xfe100000) == 0xfc000000
6370 && let Some(ins) = parse_arm_stc2_0(ins, pc, options)
6371 {
6372 return ins;
6373 }
6374 #[cfg(
6375 all(
6376 feature = "arm",
6377 feature = "vfp_v2",
6378 any(
6379 feature = "v5te",
6380 feature = "v5tej",
6381 feature = "v6",
6382 feature = "v6k"
6383 )
6384 )
6385 )]
6386 if (ins & 0xe100f00) == 0xc000b00
6387 && let Some(ins) = parse_arm_vstm_f64_0(ins, pc, options)
6388 {
6389 return ins;
6390 }
6391 #[cfg(feature = "arm")]
6392 if (ins & 0xe100000) == 0xc000000
6393 && let Some(ins) = parse_arm_stc_0(ins, pc, options)
6394 {
6395 return ins;
6396 }
6397 }
6398 0x3040 | 0x3041 | 0x3042 | 0x3043 | 0x3044 | 0x3045 | 0x3046 | 0x3047 | 0x3048
6399 | 0x3049 | 0x304a | 0x304b | 0x304c | 0x304d | 0x304e | 0x304f | 0x3060 | 0x3061
6400 | 0x3062 | 0x3063 | 0x3064 | 0x3065 | 0x3066 | 0x3067 | 0x3068 | 0x3069 | 0x306a
6401 | 0x306b | 0x306c | 0x306d | 0x306e | 0x306f | 0x30c0 | 0x30c1 | 0x30c2 | 0x30c3
6402 | 0x30c4 | 0x30c5 | 0x30c6 | 0x30c7 | 0x30c8 | 0x30c9 | 0x30ca | 0x30cb | 0x30cc
6403 | 0x30cd | 0x30ce | 0x30cf | 0x30e0 | 0x30e1 | 0x30e2 | 0x30e3 | 0x30e4 | 0x30e5
6404 | 0x30e6 | 0x30e7 | 0x30e8 | 0x30e9 | 0x30ea | 0x30eb | 0x30ec | 0x30ed | 0x30ee
6405 | 0x30ef | 0x31c0 | 0x31c1 | 0x31c2 | 0x31c3 | 0x31c4 | 0x31c5 | 0x31c6 | 0x31c7
6406 | 0x31c8 | 0x31c9 | 0x31ca | 0x31cb | 0x31cc | 0x31cd | 0x31ce | 0x31cf | 0x31e0
6407 | 0x31e1 | 0x31e2 | 0x31e3 | 0x31e4 | 0x31e5 | 0x31e6 | 0x31e7 | 0x31e8 | 0x31e9
6408 | 0x31ea | 0x31eb | 0x31ec | 0x31ed | 0x31ee | 0x31ef | 0x3240 | 0x3241 | 0x3242
6409 | 0x3243 | 0x3244 | 0x3245 | 0x3246 | 0x3247 | 0x3248 | 0x3249 | 0x324a | 0x324b
6410 | 0x324c | 0x324d | 0x324e | 0x324f | 0x3260 | 0x3261 | 0x3262 | 0x3263 | 0x3264
6411 | 0x3265 | 0x3266 | 0x3267 | 0x3268 | 0x3269 | 0x326a | 0x326b | 0x326c | 0x326d
6412 | 0x326e | 0x326f | 0x32c0 | 0x32c1 | 0x32c2 | 0x32c3 | 0x32c4 | 0x32c5 | 0x32c6
6413 | 0x32c7 | 0x32c8 | 0x32c9 | 0x32ca | 0x32cb | 0x32cc | 0x32cd | 0x32ce | 0x32cf
6414 | 0x3340 | 0x3341 | 0x3342 | 0x3343 | 0x3344 | 0x3345 | 0x3346 | 0x3347 | 0x3348
6415 | 0x3349 | 0x334a | 0x334b | 0x334c | 0x334d | 0x334e | 0x334f | 0x3360 | 0x3361
6416 | 0x3362 | 0x3363 | 0x3364 | 0x3365 | 0x3366 | 0x3367 | 0x3368 | 0x3369 | 0x336a
6417 | 0x336b | 0x336c | 0x336d | 0x336e | 0x336f | 0x33c0 | 0x33c1 | 0x33c2 | 0x33c3
6418 | 0x33c4 | 0x33c5 | 0x33c6 | 0x33c7 | 0x33c8 | 0x33c9 | 0x33ca | 0x33cb | 0x33cc
6419 | 0x33cd | 0x33ce | 0x33cf | 0x34c0 | 0x34c1 | 0x34c2 | 0x34c3 | 0x34c4 | 0x34c5
6420 | 0x34c6 | 0x34c7 | 0x34c8 | 0x34c9 | 0x34ca | 0x34cb | 0x34cc | 0x34cd | 0x34ce
6421 | 0x34cf | 0x34e0 | 0x34e1 | 0x34e2 | 0x34e3 | 0x34e4 | 0x34e5 | 0x34e6 | 0x34e7
6422 | 0x34e8 | 0x34e9 | 0x34ea | 0x34eb | 0x34ec | 0x34ed | 0x34ee | 0x34ef | 0x35c0
6423 | 0x35c1 | 0x35c2 | 0x35c3 | 0x35c4 | 0x35c5 | 0x35c6 | 0x35c7 | 0x35c8 | 0x35c9
6424 | 0x35ca | 0x35cb | 0x35cc | 0x35cd | 0x35ce | 0x35cf | 0x35e0 | 0x35e1 | 0x35e2
6425 | 0x35e3 | 0x35e4 | 0x35e5 | 0x35e6 | 0x35e7 | 0x35e8 | 0x35e9 | 0x35ea | 0x35eb
6426 | 0x35ec | 0x35ed | 0x35ee | 0x35ef | 0x36c0 | 0x36c1 | 0x36c2 | 0x36c3 | 0x36c4
6427 | 0x36c5 | 0x36c6 | 0x36c7 | 0x36c8 | 0x36c9 | 0x36ca | 0x36cb | 0x36cc | 0x36cd
6428 | 0x36ce | 0x36cf | 0x36e0 | 0x36e1 | 0x36e2 | 0x36e3 | 0x36e4 | 0x36e5 | 0x36e6
6429 | 0x36e7 | 0x36e8 | 0x36e9 | 0x36ea | 0x36eb | 0x36ec | 0x36ed | 0x36ee | 0x36ef
6430 | 0x37c0 | 0x37c1 | 0x37c2 | 0x37c3 | 0x37c4 | 0x37c5 | 0x37c6 | 0x37c7 | 0x37c8
6431 | 0x37c9 | 0x37ca | 0x37cb | 0x37cc | 0x37cd | 0x37ce | 0x37cf | 0x37e0 | 0x37e1
6432 | 0x37e2 | 0x37e3 | 0x37e4 | 0x37e5 | 0x37e6 | 0x37e7 | 0x37e8 | 0x37e9 | 0x37ea
6433 | 0x37eb | 0x37ec | 0x37ed | 0x37ee | 0x37ef => {
6434 #[cfg(
6435 all(
6436 feature = "arm",
6437 any(
6438 feature = "v5t",
6439 feature = "v5te",
6440 feature = "v5tej",
6441 feature = "v6",
6442 feature = "v6k"
6443 )
6444 )
6445 )]
6446 if (ins & 0xfe100000) == 0xfc100000
6447 && let Some(ins) = parse_arm_ldc2_0(ins, pc, options)
6448 {
6449 return ins;
6450 }
6451 #[cfg(
6452 all(
6453 feature = "arm",
6454 feature = "vfp_v2",
6455 any(
6456 feature = "v5te",
6457 feature = "v5tej",
6458 feature = "v6",
6459 feature = "v6k"
6460 )
6461 )
6462 )]
6463 if (ins & 0xe100f00) == 0xc100a00
6464 && let Some(ins) = parse_arm_vldm_f32_0(ins, pc, options)
6465 {
6466 return ins;
6467 }
6468 #[cfg(feature = "arm")]
6469 if (ins & 0xe100000) == 0xc100000
6470 && let Some(ins) = parse_arm_ldc_0(ins, pc, options)
6471 {
6472 return ins;
6473 }
6474 }
6475 0x3050 | 0x3051 | 0x3052 | 0x3053 | 0x3054 | 0x3055 | 0x3056 | 0x3057 | 0x3058
6476 | 0x3059 | 0x305a | 0x305b | 0x305c | 0x305d | 0x305e | 0x305f | 0x3070 | 0x3071
6477 | 0x3072 | 0x3073 | 0x3074 | 0x3075 | 0x3076 | 0x3077 | 0x3078 | 0x3079 | 0x307a
6478 | 0x307b | 0x307c | 0x307d | 0x307e | 0x307f | 0x30d0 | 0x30d1 | 0x30d2 | 0x30d3
6479 | 0x30d4 | 0x30d5 | 0x30d6 | 0x30d7 | 0x30d8 | 0x30d9 | 0x30da | 0x30db | 0x30dc
6480 | 0x30dd | 0x30de | 0x30df | 0x30f0 | 0x30f1 | 0x30f2 | 0x30f3 | 0x30f4 | 0x30f5
6481 | 0x30f6 | 0x30f7 | 0x30f8 | 0x30f9 | 0x30fa | 0x30fb | 0x30fc | 0x30fd | 0x30fe
6482 | 0x30ff | 0x31d0 | 0x31d1 | 0x31d2 | 0x31d3 | 0x31d4 | 0x31d5 | 0x31d6 | 0x31d7
6483 | 0x31d8 | 0x31d9 | 0x31da | 0x31db | 0x31dc | 0x31dd | 0x31de | 0x31df | 0x31f0
6484 | 0x31f1 | 0x31f2 | 0x31f3 | 0x31f4 | 0x31f5 | 0x31f6 | 0x31f7 | 0x31f8 | 0x31f9
6485 | 0x31fa | 0x31fb | 0x31fc | 0x31fd | 0x31fe | 0x31ff | 0x3250 | 0x3251 | 0x3252
6486 | 0x3253 | 0x3254 | 0x3255 | 0x3256 | 0x3257 | 0x3258 | 0x3259 | 0x325a | 0x325b
6487 | 0x325c | 0x325d | 0x325e | 0x325f | 0x3270 | 0x3271 | 0x3272 | 0x3273 | 0x3274
6488 | 0x3275 | 0x3276 | 0x3277 | 0x3278 | 0x3279 | 0x327a | 0x327b | 0x327c | 0x327d
6489 | 0x327e | 0x327f | 0x32d0 | 0x32d1 | 0x32d2 | 0x32d3 | 0x32d4 | 0x32d5 | 0x32d6
6490 | 0x32d7 | 0x32d8 | 0x32d9 | 0x32da | 0x32db | 0x32dc | 0x32dd | 0x32de | 0x32df
6491 | 0x3350 | 0x3351 | 0x3352 | 0x3353 | 0x3354 | 0x3355 | 0x3356 | 0x3357 | 0x3358
6492 | 0x3359 | 0x335a | 0x335b | 0x335c | 0x335d | 0x335e | 0x335f | 0x3370 | 0x3371
6493 | 0x3372 | 0x3373 | 0x3374 | 0x3375 | 0x3376 | 0x3377 | 0x3378 | 0x3379 | 0x337a
6494 | 0x337b | 0x337c | 0x337d | 0x337e | 0x337f | 0x33d0 | 0x33d1 | 0x33d2 | 0x33d3
6495 | 0x33d4 | 0x33d5 | 0x33d6 | 0x33d7 | 0x33d8 | 0x33d9 | 0x33da | 0x33db | 0x33dc
6496 | 0x33dd | 0x33de | 0x33df | 0x34d0 | 0x34d1 | 0x34d2 | 0x34d3 | 0x34d4 | 0x34d5
6497 | 0x34d6 | 0x34d7 | 0x34d8 | 0x34d9 | 0x34da | 0x34db | 0x34dc | 0x34dd | 0x34de
6498 | 0x34df | 0x34f0 | 0x34f1 | 0x34f2 | 0x34f3 | 0x34f4 | 0x34f5 | 0x34f6 | 0x34f7
6499 | 0x34f8 | 0x34f9 | 0x34fa | 0x34fb | 0x34fc | 0x34fd | 0x34fe | 0x34ff | 0x35d0
6500 | 0x35d1 | 0x35d2 | 0x35d3 | 0x35d4 | 0x35d5 | 0x35d6 | 0x35d7 | 0x35d8 | 0x35d9
6501 | 0x35da | 0x35db | 0x35dc | 0x35dd | 0x35de | 0x35df | 0x35f0 | 0x35f1 | 0x35f2
6502 | 0x35f3 | 0x35f4 | 0x35f5 | 0x35f6 | 0x35f7 | 0x35f8 | 0x35f9 | 0x35fa | 0x35fb
6503 | 0x35fc | 0x35fd | 0x35fe | 0x35ff | 0x36d0 | 0x36d1 | 0x36d2 | 0x36d3 | 0x36d4
6504 | 0x36d5 | 0x36d6 | 0x36d7 | 0x36d8 | 0x36d9 | 0x36da | 0x36db | 0x36dc | 0x36dd
6505 | 0x36de | 0x36df | 0x36f0 | 0x36f1 | 0x36f2 | 0x36f3 | 0x36f4 | 0x36f5 | 0x36f6
6506 | 0x36f7 | 0x36f8 | 0x36f9 | 0x36fa | 0x36fb | 0x36fc | 0x36fd | 0x36fe | 0x36ff
6507 | 0x37d0 | 0x37d1 | 0x37d2 | 0x37d3 | 0x37d4 | 0x37d5 | 0x37d6 | 0x37d7 | 0x37d8
6508 | 0x37d9 | 0x37da | 0x37db | 0x37dc | 0x37dd | 0x37de | 0x37df | 0x37f0 | 0x37f1
6509 | 0x37f2 | 0x37f3 | 0x37f4 | 0x37f5 | 0x37f6 | 0x37f7 | 0x37f8 | 0x37f9 | 0x37fa
6510 | 0x37fb | 0x37fc | 0x37fd | 0x37fe | 0x37ff => {
6511 #[cfg(
6512 all(
6513 feature = "arm",
6514 any(
6515 feature = "v5t",
6516 feature = "v5te",
6517 feature = "v5tej",
6518 feature = "v6",
6519 feature = "v6k"
6520 )
6521 )
6522 )]
6523 if (ins & 0xfe100000) == 0xfc100000
6524 && let Some(ins) = parse_arm_ldc2_0(ins, pc, options)
6525 {
6526 return ins;
6527 }
6528 #[cfg(
6529 all(
6530 feature = "arm",
6531 feature = "vfp_v2",
6532 any(
6533 feature = "v5te",
6534 feature = "v5tej",
6535 feature = "v6",
6536 feature = "v6k"
6537 )
6538 )
6539 )]
6540 if (ins & 0xe100f00) == 0xc100b00
6541 && let Some(ins) = parse_arm_vldm_f64_0(ins, pc, options)
6542 {
6543 return ins;
6544 }
6545 #[cfg(feature = "arm")]
6546 if (ins & 0xe100000) == 0xc100000
6547 && let Some(ins) = parse_arm_ldc_0(ins, pc, options)
6548 {
6549 return ins;
6550 }
6551 }
6552 0x3100 | 0x3102 | 0x3104 | 0x3105 | 0x3106 | 0x3107 | 0x3108 | 0x3109 | 0x310a
6553 | 0x310b | 0x310c | 0x310d | 0x310e | 0x310f | 0x3120 | 0x3122 | 0x3124 | 0x3125
6554 | 0x3126 | 0x3127 | 0x3128 | 0x3129 | 0x312a | 0x312b | 0x312c | 0x312d | 0x312e
6555 | 0x312f => {
6556 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
6557 if (ins & 0xfff00000) == 0xfc400000
6558 && let Some(ins) = parse_arm_mcrr2_0(ins, pc, options)
6559 {
6560 return ins;
6561 }
6562 #[cfg(
6563 all(
6564 feature = "arm",
6565 any(
6566 feature = "v5te",
6567 feature = "v5tej",
6568 feature = "v6",
6569 feature = "v6k"
6570 )
6571 )
6572 )]
6573 if (ins & 0xff00000) == 0xc400000
6574 && let Some(ins) = parse_arm_mcrr_0(ins, pc, options)
6575 {
6576 return ins;
6577 }
6578 #[cfg(
6579 all(
6580 feature = "arm",
6581 any(
6582 feature = "v5t",
6583 feature = "v5te",
6584 feature = "v5tej",
6585 feature = "v6",
6586 feature = "v6k"
6587 )
6588 )
6589 )]
6590 if (ins & 0xfe100000) == 0xfc000000
6591 && let Some(ins) = parse_arm_stc2_0(ins, pc, options)
6592 {
6593 return ins;
6594 }
6595 #[cfg(
6596 all(
6597 feature = "arm",
6598 feature = "vfp_v2",
6599 any(
6600 feature = "v5te",
6601 feature = "v5tej",
6602 feature = "v6",
6603 feature = "v6k"
6604 )
6605 )
6606 )]
6607 if (ins & 0xe100f00) == 0xc000a00
6608 && let Some(ins) = parse_arm_vstm_f32_0(ins, pc, options)
6609 {
6610 return ins;
6611 }
6612 #[cfg(feature = "arm")]
6613 if (ins & 0xe100000) == 0xc000000
6614 && let Some(ins) = parse_arm_stc_0(ins, pc, options)
6615 {
6616 return ins;
6617 }
6618 }
6619 0x3101 | 0x3103 | 0x3121 | 0x3123 => {
6620 #[cfg(
6621 all(
6622 feature = "arm",
6623 feature = "vfp_v2",
6624 any(
6625 feature = "v5te",
6626 feature = "v5tej",
6627 feature = "v6",
6628 feature = "v6k"
6629 )
6630 )
6631 )]
6632 if (ins & 0xff00fd0) == 0xc400a10
6633 && let Some(ins) = parse_arm_vmov_f32_reg_dual_0(ins, pc, options)
6634 {
6635 return ins;
6636 }
6637 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
6638 if (ins & 0xfff00000) == 0xfc400000
6639 && let Some(ins) = parse_arm_mcrr2_0(ins, pc, options)
6640 {
6641 return ins;
6642 }
6643 #[cfg(
6644 all(
6645 feature = "arm",
6646 any(
6647 feature = "v5te",
6648 feature = "v5tej",
6649 feature = "v6",
6650 feature = "v6k"
6651 )
6652 )
6653 )]
6654 if (ins & 0xff00000) == 0xc400000
6655 && let Some(ins) = parse_arm_mcrr_0(ins, pc, options)
6656 {
6657 return ins;
6658 }
6659 #[cfg(
6660 all(
6661 feature = "arm",
6662 any(
6663 feature = "v5t",
6664 feature = "v5te",
6665 feature = "v5tej",
6666 feature = "v6",
6667 feature = "v6k"
6668 )
6669 )
6670 )]
6671 if (ins & 0xfe100000) == 0xfc000000
6672 && let Some(ins) = parse_arm_stc2_0(ins, pc, options)
6673 {
6674 return ins;
6675 }
6676 #[cfg(
6677 all(
6678 feature = "arm",
6679 feature = "vfp_v2",
6680 any(
6681 feature = "v5te",
6682 feature = "v5tej",
6683 feature = "v6",
6684 feature = "v6k"
6685 )
6686 )
6687 )]
6688 if (ins & 0xe100f00) == 0xc000a00
6689 && let Some(ins) = parse_arm_vstm_f32_0(ins, pc, options)
6690 {
6691 return ins;
6692 }
6693 #[cfg(feature = "arm")]
6694 if (ins & 0xe100000) == 0xc000000
6695 && let Some(ins) = parse_arm_stc_0(ins, pc, options)
6696 {
6697 return ins;
6698 }
6699 }
6700 0x3110 | 0x3112 | 0x3114 | 0x3115 | 0x3116 | 0x3117 | 0x3118 | 0x3119 | 0x311a
6701 | 0x311b | 0x311c | 0x311d | 0x311e | 0x311f | 0x3130 | 0x3132 | 0x3134 | 0x3135
6702 | 0x3136 | 0x3137 | 0x3138 | 0x3139 | 0x313a | 0x313b | 0x313c | 0x313d | 0x313e
6703 | 0x313f => {
6704 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
6705 if (ins & 0xfff00000) == 0xfc400000
6706 && let Some(ins) = parse_arm_mcrr2_0(ins, pc, options)
6707 {
6708 return ins;
6709 }
6710 #[cfg(
6711 all(
6712 feature = "arm",
6713 any(
6714 feature = "v5te",
6715 feature = "v5tej",
6716 feature = "v6",
6717 feature = "v6k"
6718 )
6719 )
6720 )]
6721 if (ins & 0xff00000) == 0xc400000
6722 && let Some(ins) = parse_arm_mcrr_0(ins, pc, options)
6723 {
6724 return ins;
6725 }
6726 #[cfg(
6727 all(
6728 feature = "arm",
6729 any(
6730 feature = "v5t",
6731 feature = "v5te",
6732 feature = "v5tej",
6733 feature = "v6",
6734 feature = "v6k"
6735 )
6736 )
6737 )]
6738 if (ins & 0xfe100000) == 0xfc000000
6739 && let Some(ins) = parse_arm_stc2_0(ins, pc, options)
6740 {
6741 return ins;
6742 }
6743 #[cfg(
6744 all(
6745 feature = "arm",
6746 feature = "vfp_v2",
6747 any(
6748 feature = "v5te",
6749 feature = "v5tej",
6750 feature = "v6",
6751 feature = "v6k"
6752 )
6753 )
6754 )]
6755 if (ins & 0xe100f00) == 0xc000b00
6756 && let Some(ins) = parse_arm_vstm_f64_0(ins, pc, options)
6757 {
6758 return ins;
6759 }
6760 #[cfg(feature = "arm")]
6761 if (ins & 0xe100000) == 0xc000000
6762 && let Some(ins) = parse_arm_stc_0(ins, pc, options)
6763 {
6764 return ins;
6765 }
6766 }
6767 0x3111 | 0x3113 | 0x3131 | 0x3133 => {
6768 #[cfg(
6769 all(
6770 feature = "arm",
6771 feature = "vfp_v2",
6772 any(
6773 feature = "v5te",
6774 feature = "v5tej",
6775 feature = "v6",
6776 feature = "v6k"
6777 )
6778 )
6779 )]
6780 if (ins & 0xff00fd0) == 0xc400b10
6781 && let Some(ins) = parse_arm_vmov_f64_reg_0(ins, pc, options)
6782 {
6783 return ins;
6784 }
6785 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
6786 if (ins & 0xfff00000) == 0xfc400000
6787 && let Some(ins) = parse_arm_mcrr2_0(ins, pc, options)
6788 {
6789 return ins;
6790 }
6791 #[cfg(
6792 all(
6793 feature = "arm",
6794 any(
6795 feature = "v5te",
6796 feature = "v5tej",
6797 feature = "v6",
6798 feature = "v6k"
6799 )
6800 )
6801 )]
6802 if (ins & 0xff00000) == 0xc400000
6803 && let Some(ins) = parse_arm_mcrr_0(ins, pc, options)
6804 {
6805 return ins;
6806 }
6807 #[cfg(
6808 all(
6809 feature = "arm",
6810 any(
6811 feature = "v5t",
6812 feature = "v5te",
6813 feature = "v5tej",
6814 feature = "v6",
6815 feature = "v6k"
6816 )
6817 )
6818 )]
6819 if (ins & 0xfe100000) == 0xfc000000
6820 && let Some(ins) = parse_arm_stc2_0(ins, pc, options)
6821 {
6822 return ins;
6823 }
6824 #[cfg(
6825 all(
6826 feature = "arm",
6827 feature = "vfp_v2",
6828 any(
6829 feature = "v5te",
6830 feature = "v5tej",
6831 feature = "v6",
6832 feature = "v6k"
6833 )
6834 )
6835 )]
6836 if (ins & 0xe100f00) == 0xc000b00
6837 && let Some(ins) = parse_arm_vstm_f64_0(ins, pc, options)
6838 {
6839 return ins;
6840 }
6841 #[cfg(feature = "arm")]
6842 if (ins & 0xe100000) == 0xc000000
6843 && let Some(ins) = parse_arm_stc_0(ins, pc, options)
6844 {
6845 return ins;
6846 }
6847 }
6848 0x3140 | 0x3142 | 0x3144 | 0x3145 | 0x3146 | 0x3147 | 0x3148 | 0x3149 | 0x314a
6849 | 0x314b | 0x314c | 0x314d | 0x314e | 0x314f | 0x3160 | 0x3162 | 0x3164 | 0x3165
6850 | 0x3166 | 0x3167 | 0x3168 | 0x3169 | 0x316a | 0x316b | 0x316c | 0x316d | 0x316e
6851 | 0x316f => {
6852 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
6853 if (ins & 0xfff00000) == 0xfc500000
6854 && let Some(ins) = parse_arm_mrrc2_0(ins, pc, options)
6855 {
6856 return ins;
6857 }
6858 #[cfg(
6859 all(
6860 feature = "arm",
6861 any(
6862 feature = "v5t",
6863 feature = "v5te",
6864 feature = "v5tej",
6865 feature = "v6",
6866 feature = "v6k"
6867 )
6868 )
6869 )]
6870 if (ins & 0xfe100000) == 0xfc100000
6871 && let Some(ins) = parse_arm_ldc2_0(ins, pc, options)
6872 {
6873 return ins;
6874 }
6875 #[cfg(
6876 all(
6877 feature = "arm",
6878 any(
6879 feature = "v5te",
6880 feature = "v5tej",
6881 feature = "v6",
6882 feature = "v6k"
6883 )
6884 )
6885 )]
6886 if (ins & 0xff00000) == 0xc500000
6887 && let Some(ins) = parse_arm_mrrc_0(ins, pc, options)
6888 {
6889 return ins;
6890 }
6891 #[cfg(
6892 all(
6893 feature = "arm",
6894 feature = "vfp_v2",
6895 any(
6896 feature = "v5te",
6897 feature = "v5tej",
6898 feature = "v6",
6899 feature = "v6k"
6900 )
6901 )
6902 )]
6903 if (ins & 0xe100f00) == 0xc100a00
6904 && let Some(ins) = parse_arm_vldm_f32_0(ins, pc, options)
6905 {
6906 return ins;
6907 }
6908 #[cfg(feature = "arm")]
6909 if (ins & 0xe100000) == 0xc100000
6910 && let Some(ins) = parse_arm_ldc_0(ins, pc, options)
6911 {
6912 return ins;
6913 }
6914 }
6915 0x3141 | 0x3143 | 0x3161 | 0x3163 => {
6916 #[cfg(
6917 all(
6918 feature = "arm",
6919 feature = "vfp_v2",
6920 any(
6921 feature = "v5te",
6922 feature = "v5tej",
6923 feature = "v6",
6924 feature = "v6k"
6925 )
6926 )
6927 )]
6928 if (ins & 0xff00fd0) == 0xc500a10
6929 && let Some(ins) = parse_arm_vmov_reg_f32_dual_0(ins, pc, options)
6930 {
6931 return ins;
6932 }
6933 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
6934 if (ins & 0xfff00000) == 0xfc500000
6935 && let Some(ins) = parse_arm_mrrc2_0(ins, pc, options)
6936 {
6937 return ins;
6938 }
6939 #[cfg(
6940 all(
6941 feature = "arm",
6942 any(
6943 feature = "v5t",
6944 feature = "v5te",
6945 feature = "v5tej",
6946 feature = "v6",
6947 feature = "v6k"
6948 )
6949 )
6950 )]
6951 if (ins & 0xfe100000) == 0xfc100000
6952 && let Some(ins) = parse_arm_ldc2_0(ins, pc, options)
6953 {
6954 return ins;
6955 }
6956 #[cfg(
6957 all(
6958 feature = "arm",
6959 any(
6960 feature = "v5te",
6961 feature = "v5tej",
6962 feature = "v6",
6963 feature = "v6k"
6964 )
6965 )
6966 )]
6967 if (ins & 0xff00000) == 0xc500000
6968 && let Some(ins) = parse_arm_mrrc_0(ins, pc, options)
6969 {
6970 return ins;
6971 }
6972 #[cfg(
6973 all(
6974 feature = "arm",
6975 feature = "vfp_v2",
6976 any(
6977 feature = "v5te",
6978 feature = "v5tej",
6979 feature = "v6",
6980 feature = "v6k"
6981 )
6982 )
6983 )]
6984 if (ins & 0xe100f00) == 0xc100a00
6985 && let Some(ins) = parse_arm_vldm_f32_0(ins, pc, options)
6986 {
6987 return ins;
6988 }
6989 #[cfg(feature = "arm")]
6990 if (ins & 0xe100000) == 0xc100000
6991 && let Some(ins) = parse_arm_ldc_0(ins, pc, options)
6992 {
6993 return ins;
6994 }
6995 }
6996 0x3150 | 0x3152 | 0x3154 | 0x3155 | 0x3156 | 0x3157 | 0x3158 | 0x3159 | 0x315a
6997 | 0x315b | 0x315c | 0x315d | 0x315e | 0x315f | 0x3170 | 0x3172 | 0x3174 | 0x3175
6998 | 0x3176 | 0x3177 | 0x3178 | 0x3179 | 0x317a | 0x317b | 0x317c | 0x317d | 0x317e
6999 | 0x317f => {
7000 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
7001 if (ins & 0xfff00000) == 0xfc500000
7002 && let Some(ins) = parse_arm_mrrc2_0(ins, pc, options)
7003 {
7004 return ins;
7005 }
7006 #[cfg(
7007 all(
7008 feature = "arm",
7009 any(
7010 feature = "v5t",
7011 feature = "v5te",
7012 feature = "v5tej",
7013 feature = "v6",
7014 feature = "v6k"
7015 )
7016 )
7017 )]
7018 if (ins & 0xfe100000) == 0xfc100000
7019 && let Some(ins) = parse_arm_ldc2_0(ins, pc, options)
7020 {
7021 return ins;
7022 }
7023 #[cfg(
7024 all(
7025 feature = "arm",
7026 any(
7027 feature = "v5te",
7028 feature = "v5tej",
7029 feature = "v6",
7030 feature = "v6k"
7031 )
7032 )
7033 )]
7034 if (ins & 0xff00000) == 0xc500000
7035 && let Some(ins) = parse_arm_mrrc_0(ins, pc, options)
7036 {
7037 return ins;
7038 }
7039 #[cfg(
7040 all(
7041 feature = "arm",
7042 feature = "vfp_v2",
7043 any(
7044 feature = "v5te",
7045 feature = "v5tej",
7046 feature = "v6",
7047 feature = "v6k"
7048 )
7049 )
7050 )]
7051 if (ins & 0xe100f00) == 0xc100b00
7052 && let Some(ins) = parse_arm_vldm_f64_0(ins, pc, options)
7053 {
7054 return ins;
7055 }
7056 #[cfg(feature = "arm")]
7057 if (ins & 0xe100000) == 0xc100000
7058 && let Some(ins) = parse_arm_ldc_0(ins, pc, options)
7059 {
7060 return ins;
7061 }
7062 }
7063 0x3151 | 0x3153 | 0x3171 | 0x3173 => {
7064 #[cfg(
7065 all(
7066 feature = "arm",
7067 feature = "vfp_v2",
7068 any(
7069 feature = "v5te",
7070 feature = "v5tej",
7071 feature = "v6",
7072 feature = "v6k"
7073 )
7074 )
7075 )]
7076 if (ins & 0xff00fd0) == 0xc500b10
7077 && let Some(ins) = parse_arm_vmov_reg_f64_0(ins, pc, options)
7078 {
7079 return ins;
7080 }
7081 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
7082 if (ins & 0xfff00000) == 0xfc500000
7083 && let Some(ins) = parse_arm_mrrc2_0(ins, pc, options)
7084 {
7085 return ins;
7086 }
7087 #[cfg(
7088 all(
7089 feature = "arm",
7090 any(
7091 feature = "v5t",
7092 feature = "v5te",
7093 feature = "v5tej",
7094 feature = "v6",
7095 feature = "v6k"
7096 )
7097 )
7098 )]
7099 if (ins & 0xfe100000) == 0xfc100000
7100 && let Some(ins) = parse_arm_ldc2_0(ins, pc, options)
7101 {
7102 return ins;
7103 }
7104 #[cfg(
7105 all(
7106 feature = "arm",
7107 any(
7108 feature = "v5te",
7109 feature = "v5tej",
7110 feature = "v6",
7111 feature = "v6k"
7112 )
7113 )
7114 )]
7115 if (ins & 0xff00000) == 0xc500000
7116 && let Some(ins) = parse_arm_mrrc_0(ins, pc, options)
7117 {
7118 return ins;
7119 }
7120 #[cfg(
7121 all(
7122 feature = "arm",
7123 feature = "vfp_v2",
7124 any(
7125 feature = "v5te",
7126 feature = "v5tej",
7127 feature = "v6",
7128 feature = "v6k"
7129 )
7130 )
7131 )]
7132 if (ins & 0xe100f00) == 0xc100b00
7133 && let Some(ins) = parse_arm_vldm_f64_0(ins, pc, options)
7134 {
7135 return ins;
7136 }
7137 #[cfg(feature = "arm")]
7138 if (ins & 0xe100000) == 0xc100000
7139 && let Some(ins) = parse_arm_ldc_0(ins, pc, options)
7140 {
7141 return ins;
7142 }
7143 }
7144 0x32e0 | 0x32e1 | 0x32e2 | 0x32e3 | 0x32e4 | 0x32e5 | 0x32e6 | 0x32e7 | 0x32e8
7145 | 0x32e9 | 0x32ea | 0x32eb | 0x32ec | 0x32ed | 0x32ee | 0x32ef | 0x33e0 | 0x33e1
7146 | 0x33e2 | 0x33e3 | 0x33e4 | 0x33e5 | 0x33e6 | 0x33e7 | 0x33e8 | 0x33e9 | 0x33ea
7147 | 0x33eb | 0x33ec | 0x33ed | 0x33ee | 0x33ef => {
7148 #[cfg(
7149 all(
7150 feature = "arm",
7151 feature = "vfp_v2",
7152 any(
7153 feature = "v5te",
7154 feature = "v5tej",
7155 feature = "v6",
7156 feature = "v6k"
7157 )
7158 )
7159 )]
7160 if (ins & 0xfbf0f00) == 0xcbd0a00
7161 && let Some(ins) = parse_arm_vpop_f32_0(ins, pc, options)
7162 {
7163 return ins;
7164 }
7165 #[cfg(
7166 all(
7167 feature = "arm",
7168 any(
7169 feature = "v5t",
7170 feature = "v5te",
7171 feature = "v5tej",
7172 feature = "v6",
7173 feature = "v6k"
7174 )
7175 )
7176 )]
7177 if (ins & 0xfe100000) == 0xfc100000
7178 && let Some(ins) = parse_arm_ldc2_0(ins, pc, options)
7179 {
7180 return ins;
7181 }
7182 #[cfg(
7183 all(
7184 feature = "arm",
7185 feature = "vfp_v2",
7186 any(
7187 feature = "v5te",
7188 feature = "v5tej",
7189 feature = "v6",
7190 feature = "v6k"
7191 )
7192 )
7193 )]
7194 if (ins & 0xe100f00) == 0xc100a00
7195 && let Some(ins) = parse_arm_vldm_f32_0(ins, pc, options)
7196 {
7197 return ins;
7198 }
7199 #[cfg(feature = "arm")]
7200 if (ins & 0xe100000) == 0xc100000
7201 && let Some(ins) = parse_arm_ldc_0(ins, pc, options)
7202 {
7203 return ins;
7204 }
7205 }
7206 0x32f0 | 0x32f1 | 0x32f2 | 0x32f3 | 0x32f4 | 0x32f5 | 0x32f6 | 0x32f7 | 0x32f8
7207 | 0x32f9 | 0x32fa | 0x32fb | 0x32fc | 0x32fd | 0x32fe | 0x32ff | 0x33f0 | 0x33f1
7208 | 0x33f2 | 0x33f3 | 0x33f4 | 0x33f5 | 0x33f6 | 0x33f7 | 0x33f8 | 0x33f9 | 0x33fa
7209 | 0x33fb | 0x33fc | 0x33fd | 0x33fe | 0x33ff => {
7210 #[cfg(
7211 all(
7212 feature = "arm",
7213 feature = "vfp_v2",
7214 any(
7215 feature = "v5te",
7216 feature = "v5tej",
7217 feature = "v6",
7218 feature = "v6k"
7219 )
7220 )
7221 )]
7222 if (ins & 0xfbf0f00) == 0xcbd0b00
7223 && let Some(ins) = parse_arm_vpop_f64_0(ins, pc, options)
7224 {
7225 return ins;
7226 }
7227 #[cfg(
7228 all(
7229 feature = "arm",
7230 any(
7231 feature = "v5t",
7232 feature = "v5te",
7233 feature = "v5tej",
7234 feature = "v6",
7235 feature = "v6k"
7236 )
7237 )
7238 )]
7239 if (ins & 0xfe100000) == 0xfc100000
7240 && let Some(ins) = parse_arm_ldc2_0(ins, pc, options)
7241 {
7242 return ins;
7243 }
7244 #[cfg(
7245 all(
7246 feature = "arm",
7247 feature = "vfp_v2",
7248 any(
7249 feature = "v5te",
7250 feature = "v5tej",
7251 feature = "v6",
7252 feature = "v6k"
7253 )
7254 )
7255 )]
7256 if (ins & 0xe100f00) == 0xc100b00
7257 && let Some(ins) = parse_arm_vldm_f64_0(ins, pc, options)
7258 {
7259 return ins;
7260 }
7261 #[cfg(feature = "arm")]
7262 if (ins & 0xe100000) == 0xc100000
7263 && let Some(ins) = parse_arm_ldc_0(ins, pc, options)
7264 {
7265 return ins;
7266 }
7267 }
7268 0x3400 | 0x3401 | 0x3402 | 0x3403 | 0x3404 | 0x3405 | 0x3406 | 0x3407 | 0x3408
7269 | 0x3409 | 0x340a | 0x340b | 0x340c | 0x340d | 0x340e | 0x340f | 0x3420 | 0x3421
7270 | 0x3422 | 0x3423 | 0x3424 | 0x3425 | 0x3426 | 0x3427 | 0x3428 | 0x3429 | 0x342a
7271 | 0x342b | 0x342c | 0x342d | 0x342e | 0x342f | 0x3500 | 0x3501 | 0x3502 | 0x3503
7272 | 0x3504 | 0x3505 | 0x3506 | 0x3507 | 0x3508 | 0x3509 | 0x350a | 0x350b | 0x350c
7273 | 0x350d | 0x350e | 0x350f | 0x3520 | 0x3521 | 0x3522 | 0x3523 | 0x3524 | 0x3525
7274 | 0x3526 | 0x3527 | 0x3528 | 0x3529 | 0x352a | 0x352b | 0x352c | 0x352d | 0x352e
7275 | 0x352f | 0x3600 | 0x3601 | 0x3602 | 0x3603 | 0x3604 | 0x3605 | 0x3606 | 0x3607
7276 | 0x3608 | 0x3609 | 0x360a | 0x360b | 0x360c | 0x360d | 0x360e | 0x360f | 0x3620
7277 | 0x3621 | 0x3622 | 0x3623 | 0x3624 | 0x3625 | 0x3626 | 0x3627 | 0x3628 | 0x3629
7278 | 0x362a | 0x362b | 0x362c | 0x362d | 0x362e | 0x362f | 0x3700 | 0x3701 | 0x3702
7279 | 0x3703 | 0x3704 | 0x3705 | 0x3706 | 0x3707 | 0x3708 | 0x3709 | 0x370a | 0x370b
7280 | 0x370c | 0x370d | 0x370e | 0x370f | 0x3720 | 0x3721 | 0x3722 | 0x3723 | 0x3724
7281 | 0x3725 | 0x3726 | 0x3727 | 0x3728 | 0x3729 | 0x372a | 0x372b | 0x372c | 0x372d
7282 | 0x372e | 0x372f => {
7283 #[cfg(
7284 all(
7285 feature = "arm",
7286 feature = "vfp_v2",
7287 any(
7288 feature = "v5te",
7289 feature = "v5tej",
7290 feature = "v6",
7291 feature = "v6k"
7292 )
7293 )
7294 )]
7295 if (ins & 0xf300f00) == 0xd000a00
7296 && let Some(ins) = parse_arm_vstr_f32_0(ins, pc, options)
7297 {
7298 return ins;
7299 }
7300 #[cfg(
7301 all(
7302 feature = "arm",
7303 any(
7304 feature = "v5t",
7305 feature = "v5te",
7306 feature = "v5tej",
7307 feature = "v6",
7308 feature = "v6k"
7309 )
7310 )
7311 )]
7312 if (ins & 0xfe100000) == 0xfc000000
7313 && let Some(ins) = parse_arm_stc2_0(ins, pc, options)
7314 {
7315 return ins;
7316 }
7317 #[cfg(
7318 all(
7319 feature = "arm",
7320 feature = "vfp_v2",
7321 any(
7322 feature = "v5te",
7323 feature = "v5tej",
7324 feature = "v6",
7325 feature = "v6k"
7326 )
7327 )
7328 )]
7329 if (ins & 0xe100f00) == 0xc000a00
7330 && let Some(ins) = parse_arm_vstm_f32_0(ins, pc, options)
7331 {
7332 return ins;
7333 }
7334 #[cfg(feature = "arm")]
7335 if (ins & 0xe100000) == 0xc000000
7336 && let Some(ins) = parse_arm_stc_0(ins, pc, options)
7337 {
7338 return ins;
7339 }
7340 }
7341 0x3410 | 0x3411 | 0x3412 | 0x3413 | 0x3414 | 0x3415 | 0x3416 | 0x3417 | 0x3418
7342 | 0x3419 | 0x341a | 0x341b | 0x341c | 0x341d | 0x341e | 0x341f | 0x3430 | 0x3431
7343 | 0x3432 | 0x3433 | 0x3434 | 0x3435 | 0x3436 | 0x3437 | 0x3438 | 0x3439 | 0x343a
7344 | 0x343b | 0x343c | 0x343d | 0x343e | 0x343f | 0x3510 | 0x3511 | 0x3512 | 0x3513
7345 | 0x3514 | 0x3515 | 0x3516 | 0x3517 | 0x3518 | 0x3519 | 0x351a | 0x351b | 0x351c
7346 | 0x351d | 0x351e | 0x351f | 0x3530 | 0x3531 | 0x3532 | 0x3533 | 0x3534 | 0x3535
7347 | 0x3536 | 0x3537 | 0x3538 | 0x3539 | 0x353a | 0x353b | 0x353c | 0x353d | 0x353e
7348 | 0x353f | 0x3610 | 0x3611 | 0x3612 | 0x3613 | 0x3614 | 0x3615 | 0x3616 | 0x3617
7349 | 0x3618 | 0x3619 | 0x361a | 0x361b | 0x361c | 0x361d | 0x361e | 0x361f | 0x3630
7350 | 0x3631 | 0x3632 | 0x3633 | 0x3634 | 0x3635 | 0x3636 | 0x3637 | 0x3638 | 0x3639
7351 | 0x363a | 0x363b | 0x363c | 0x363d | 0x363e | 0x363f | 0x3710 | 0x3711 | 0x3712
7352 | 0x3713 | 0x3714 | 0x3715 | 0x3716 | 0x3717 | 0x3718 | 0x3719 | 0x371a | 0x371b
7353 | 0x371c | 0x371d | 0x371e | 0x371f | 0x3730 | 0x3731 | 0x3732 | 0x3733 | 0x3734
7354 | 0x3735 | 0x3736 | 0x3737 | 0x3738 | 0x3739 | 0x373a | 0x373b | 0x373c | 0x373d
7355 | 0x373e | 0x373f => {
7356 #[cfg(
7357 all(
7358 feature = "arm",
7359 feature = "vfp_v2",
7360 any(
7361 feature = "v5te",
7362 feature = "v5tej",
7363 feature = "v6",
7364 feature = "v6k"
7365 )
7366 )
7367 )]
7368 if (ins & 0xf300f00) == 0xd000b00
7369 && let Some(ins) = parse_arm_vstr_f64_0(ins, pc, options)
7370 {
7371 return ins;
7372 }
7373 #[cfg(
7374 all(
7375 feature = "arm",
7376 any(
7377 feature = "v5t",
7378 feature = "v5te",
7379 feature = "v5tej",
7380 feature = "v6",
7381 feature = "v6k"
7382 )
7383 )
7384 )]
7385 if (ins & 0xfe100000) == 0xfc000000
7386 && let Some(ins) = parse_arm_stc2_0(ins, pc, options)
7387 {
7388 return ins;
7389 }
7390 #[cfg(
7391 all(
7392 feature = "arm",
7393 feature = "vfp_v2",
7394 any(
7395 feature = "v5te",
7396 feature = "v5tej",
7397 feature = "v6",
7398 feature = "v6k"
7399 )
7400 )
7401 )]
7402 if (ins & 0xe100f00) == 0xc000b00
7403 && let Some(ins) = parse_arm_vstm_f64_0(ins, pc, options)
7404 {
7405 return ins;
7406 }
7407 #[cfg(feature = "arm")]
7408 if (ins & 0xe100000) == 0xc000000
7409 && let Some(ins) = parse_arm_stc_0(ins, pc, options)
7410 {
7411 return ins;
7412 }
7413 }
7414 0x3440 | 0x3441 | 0x3442 | 0x3443 | 0x3444 | 0x3445 | 0x3446 | 0x3447 | 0x3448
7415 | 0x3449 | 0x344a | 0x344b | 0x344c | 0x344d | 0x344e | 0x344f | 0x3460 | 0x3461
7416 | 0x3462 | 0x3463 | 0x3464 | 0x3465 | 0x3466 | 0x3467 | 0x3468 | 0x3469 | 0x346a
7417 | 0x346b | 0x346c | 0x346d | 0x346e | 0x346f | 0x3540 | 0x3541 | 0x3542 | 0x3543
7418 | 0x3544 | 0x3545 | 0x3546 | 0x3547 | 0x3548 | 0x3549 | 0x354a | 0x354b | 0x354c
7419 | 0x354d | 0x354e | 0x354f | 0x3560 | 0x3561 | 0x3562 | 0x3563 | 0x3564 | 0x3565
7420 | 0x3566 | 0x3567 | 0x3568 | 0x3569 | 0x356a | 0x356b | 0x356c | 0x356d | 0x356e
7421 | 0x356f | 0x3640 | 0x3641 | 0x3642 | 0x3643 | 0x3644 | 0x3645 | 0x3646 | 0x3647
7422 | 0x3648 | 0x3649 | 0x364a | 0x364b | 0x364c | 0x364d | 0x364e | 0x364f | 0x3660
7423 | 0x3661 | 0x3662 | 0x3663 | 0x3664 | 0x3665 | 0x3666 | 0x3667 | 0x3668 | 0x3669
7424 | 0x366a | 0x366b | 0x366c | 0x366d | 0x366e | 0x366f | 0x3740 | 0x3741 | 0x3742
7425 | 0x3743 | 0x3744 | 0x3745 | 0x3746 | 0x3747 | 0x3748 | 0x3749 | 0x374a | 0x374b
7426 | 0x374c | 0x374d | 0x374e | 0x374f | 0x3760 | 0x3761 | 0x3762 | 0x3763 | 0x3764
7427 | 0x3765 | 0x3766 | 0x3767 | 0x3768 | 0x3769 | 0x376a | 0x376b | 0x376c | 0x376d
7428 | 0x376e | 0x376f => {
7429 #[cfg(
7430 all(
7431 feature = "arm",
7432 feature = "vfp_v2",
7433 any(
7434 feature = "v5te",
7435 feature = "v5tej",
7436 feature = "v6",
7437 feature = "v6k"
7438 )
7439 )
7440 )]
7441 if (ins & 0xf300f00) == 0xd100a00
7442 && let Some(ins) = parse_arm_vldr_f32_0(ins, pc, options)
7443 {
7444 return ins;
7445 }
7446 #[cfg(
7447 all(
7448 feature = "arm",
7449 any(
7450 feature = "v5t",
7451 feature = "v5te",
7452 feature = "v5tej",
7453 feature = "v6",
7454 feature = "v6k"
7455 )
7456 )
7457 )]
7458 if (ins & 0xfe100000) == 0xfc100000
7459 && let Some(ins) = parse_arm_ldc2_0(ins, pc, options)
7460 {
7461 return ins;
7462 }
7463 #[cfg(
7464 all(
7465 feature = "arm",
7466 feature = "vfp_v2",
7467 any(
7468 feature = "v5te",
7469 feature = "v5tej",
7470 feature = "v6",
7471 feature = "v6k"
7472 )
7473 )
7474 )]
7475 if (ins & 0xe100f00) == 0xc100a00
7476 && let Some(ins) = parse_arm_vldm_f32_0(ins, pc, options)
7477 {
7478 return ins;
7479 }
7480 #[cfg(feature = "arm")]
7481 if (ins & 0xe100000) == 0xc100000
7482 && let Some(ins) = parse_arm_ldc_0(ins, pc, options)
7483 {
7484 return ins;
7485 }
7486 }
7487 0x3450 | 0x3451 | 0x3452 | 0x3453 | 0x3454 | 0x3455 | 0x3456 | 0x3457 | 0x3458
7488 | 0x3459 | 0x345a | 0x345b | 0x345c | 0x345d | 0x345e | 0x345f | 0x3470 | 0x3471
7489 | 0x3472 | 0x3473 | 0x3474 | 0x3475 | 0x3476 | 0x3477 | 0x3478 | 0x3479 | 0x347a
7490 | 0x347b | 0x347c | 0x347d | 0x347e | 0x347f | 0x3550 | 0x3551 | 0x3552 | 0x3553
7491 | 0x3554 | 0x3555 | 0x3556 | 0x3557 | 0x3558 | 0x3559 | 0x355a | 0x355b | 0x355c
7492 | 0x355d | 0x355e | 0x355f | 0x3570 | 0x3571 | 0x3572 | 0x3573 | 0x3574 | 0x3575
7493 | 0x3576 | 0x3577 | 0x3578 | 0x3579 | 0x357a | 0x357b | 0x357c | 0x357d | 0x357e
7494 | 0x357f | 0x3650 | 0x3651 | 0x3652 | 0x3653 | 0x3654 | 0x3655 | 0x3656 | 0x3657
7495 | 0x3658 | 0x3659 | 0x365a | 0x365b | 0x365c | 0x365d | 0x365e | 0x365f | 0x3670
7496 | 0x3671 | 0x3672 | 0x3673 | 0x3674 | 0x3675 | 0x3676 | 0x3677 | 0x3678 | 0x3679
7497 | 0x367a | 0x367b | 0x367c | 0x367d | 0x367e | 0x367f | 0x3750 | 0x3751 | 0x3752
7498 | 0x3753 | 0x3754 | 0x3755 | 0x3756 | 0x3757 | 0x3758 | 0x3759 | 0x375a | 0x375b
7499 | 0x375c | 0x375d | 0x375e | 0x375f | 0x3770 | 0x3771 | 0x3772 | 0x3773 | 0x3774
7500 | 0x3775 | 0x3776 | 0x3777 | 0x3778 | 0x3779 | 0x377a | 0x377b | 0x377c | 0x377d
7501 | 0x377e | 0x377f => {
7502 #[cfg(
7503 all(
7504 feature = "arm",
7505 feature = "vfp_v2",
7506 any(
7507 feature = "v5te",
7508 feature = "v5tej",
7509 feature = "v6",
7510 feature = "v6k"
7511 )
7512 )
7513 )]
7514 if (ins & 0xf300f00) == 0xd100b00
7515 && let Some(ins) = parse_arm_vldr_f64_0(ins, pc, options)
7516 {
7517 return ins;
7518 }
7519 #[cfg(
7520 all(
7521 feature = "arm",
7522 any(
7523 feature = "v5t",
7524 feature = "v5te",
7525 feature = "v5tej",
7526 feature = "v6",
7527 feature = "v6k"
7528 )
7529 )
7530 )]
7531 if (ins & 0xfe100000) == 0xfc100000
7532 && let Some(ins) = parse_arm_ldc2_0(ins, pc, options)
7533 {
7534 return ins;
7535 }
7536 #[cfg(
7537 all(
7538 feature = "arm",
7539 feature = "vfp_v2",
7540 any(
7541 feature = "v5te",
7542 feature = "v5tej",
7543 feature = "v6",
7544 feature = "v6k"
7545 )
7546 )
7547 )]
7548 if (ins & 0xe100f00) == 0xc100b00
7549 && let Some(ins) = parse_arm_vldm_f64_0(ins, pc, options)
7550 {
7551 return ins;
7552 }
7553 #[cfg(feature = "arm")]
7554 if (ins & 0xe100000) == 0xc100000
7555 && let Some(ins) = parse_arm_ldc_0(ins, pc, options)
7556 {
7557 return ins;
7558 }
7559 }
7560 0x34a0 | 0x34a1 | 0x34a2 | 0x34a3 | 0x34a4 | 0x34a5 | 0x34a6 | 0x34a7 | 0x34a8
7561 | 0x34a9 | 0x34aa | 0x34ab | 0x34ac | 0x34ad | 0x34ae | 0x34af | 0x35a0 | 0x35a1
7562 | 0x35a2 | 0x35a3 | 0x35a4 | 0x35a5 | 0x35a6 | 0x35a7 | 0x35a8 | 0x35a9 | 0x35aa
7563 | 0x35ab | 0x35ac | 0x35ad | 0x35ae | 0x35af => {
7564 #[cfg(
7565 all(
7566 feature = "arm",
7567 feature = "vfp_v2",
7568 any(
7569 feature = "v5te",
7570 feature = "v5tej",
7571 feature = "v6",
7572 feature = "v6k"
7573 )
7574 )
7575 )]
7576 if (ins & 0xfbf0f00) == 0xd2d0a00
7577 && let Some(ins) = parse_arm_vpush_f32_0(ins, pc, options)
7578 {
7579 return ins;
7580 }
7581 #[cfg(
7582 all(
7583 feature = "arm",
7584 any(
7585 feature = "v5t",
7586 feature = "v5te",
7587 feature = "v5tej",
7588 feature = "v6",
7589 feature = "v6k"
7590 )
7591 )
7592 )]
7593 if (ins & 0xfe100000) == 0xfc000000
7594 && let Some(ins) = parse_arm_stc2_0(ins, pc, options)
7595 {
7596 return ins;
7597 }
7598 #[cfg(
7599 all(
7600 feature = "arm",
7601 feature = "vfp_v2",
7602 any(
7603 feature = "v5te",
7604 feature = "v5tej",
7605 feature = "v6",
7606 feature = "v6k"
7607 )
7608 )
7609 )]
7610 if (ins & 0xe100f00) == 0xc000a00
7611 && let Some(ins) = parse_arm_vstm_f32_0(ins, pc, options)
7612 {
7613 return ins;
7614 }
7615 #[cfg(feature = "arm")]
7616 if (ins & 0xe100000) == 0xc000000
7617 && let Some(ins) = parse_arm_stc_0(ins, pc, options)
7618 {
7619 return ins;
7620 }
7621 }
7622 0x34b0 | 0x34b1 | 0x34b2 | 0x34b3 | 0x34b4 | 0x34b5 | 0x34b6 | 0x34b7 | 0x34b8
7623 | 0x34b9 | 0x34ba | 0x34bb | 0x34bc | 0x34bd | 0x34be | 0x34bf | 0x35b0 | 0x35b1
7624 | 0x35b2 | 0x35b3 | 0x35b4 | 0x35b5 | 0x35b6 | 0x35b7 | 0x35b8 | 0x35b9 | 0x35ba
7625 | 0x35bb | 0x35bc | 0x35bd | 0x35be | 0x35bf => {
7626 #[cfg(
7627 all(
7628 feature = "arm",
7629 feature = "vfp_v2",
7630 any(
7631 feature = "v5te",
7632 feature = "v5tej",
7633 feature = "v6",
7634 feature = "v6k"
7635 )
7636 )
7637 )]
7638 if (ins & 0xfbf0f00) == 0xd2d0b00
7639 && let Some(ins) = parse_arm_vpush_f64_0(ins, pc, options)
7640 {
7641 return ins;
7642 }
7643 #[cfg(
7644 all(
7645 feature = "arm",
7646 any(
7647 feature = "v5t",
7648 feature = "v5te",
7649 feature = "v5tej",
7650 feature = "v6",
7651 feature = "v6k"
7652 )
7653 )
7654 )]
7655 if (ins & 0xfe100000) == 0xfc000000
7656 && let Some(ins) = parse_arm_stc2_0(ins, pc, options)
7657 {
7658 return ins;
7659 }
7660 #[cfg(
7661 all(
7662 feature = "arm",
7663 feature = "vfp_v2",
7664 any(
7665 feature = "v5te",
7666 feature = "v5tej",
7667 feature = "v6",
7668 feature = "v6k"
7669 )
7670 )
7671 )]
7672 if (ins & 0xe100f00) == 0xc000b00
7673 && let Some(ins) = parse_arm_vstm_f64_0(ins, pc, options)
7674 {
7675 return ins;
7676 }
7677 #[cfg(feature = "arm")]
7678 if (ins & 0xe100000) == 0xc000000
7679 && let Some(ins) = parse_arm_stc_0(ins, pc, options)
7680 {
7681 return ins;
7682 }
7683 }
7684 0x3800 | 0x3802 | 0x3808 | 0x380a | 0x3820 | 0x3822 | 0x3828 | 0x382a | 0x3900
7685 | 0x3902 | 0x3908 | 0x390a | 0x3920 | 0x3922 | 0x3928 | 0x392a => {
7686 #[cfg(
7687 all(
7688 feature = "arm",
7689 feature = "vfp_v2",
7690 any(
7691 feature = "v5te",
7692 feature = "v5tej",
7693 feature = "v6",
7694 feature = "v6k"
7695 )
7696 )
7697 )]
7698 if (ins & 0xfb00f50) == 0xe000a00
7699 && let Some(ins) = parse_arm_vmla_f32_0(ins, pc, options)
7700 {
7701 return ins;
7702 }
7703 #[cfg(
7704 all(
7705 feature = "arm",
7706 any(
7707 feature = "v5t",
7708 feature = "v5te",
7709 feature = "v5tej",
7710 feature = "v6",
7711 feature = "v6k"
7712 )
7713 )
7714 )]
7715 if (ins & 0xff000010) == 0xfe000000
7716 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
7717 {
7718 return ins;
7719 }
7720 #[cfg(feature = "arm")]
7721 if (ins & 0xf000010) == 0xe000000
7722 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
7723 {
7724 return ins;
7725 }
7726 }
7727 0x3801 | 0x3803 | 0x3805 | 0x3807 | 0x3809 | 0x380b | 0x380d | 0x380f | 0x3821
7728 | 0x3823 | 0x3825 | 0x3827 | 0x3829 | 0x382b | 0x382d | 0x382f => {
7729 #[cfg(
7730 all(
7731 feature = "arm",
7732 feature = "vfp_v2",
7733 any(
7734 feature = "v5te",
7735 feature = "v5tej",
7736 feature = "v6",
7737 feature = "v6k"
7738 )
7739 )
7740 )]
7741 if (ins & 0xff00f10) == 0xe000a10
7742 && let Some(ins) = parse_arm_vmov_f32_reg_0(ins, pc, options)
7743 {
7744 return ins;
7745 }
7746 #[cfg(
7747 all(
7748 feature = "arm",
7749 any(
7750 feature = "v5t",
7751 feature = "v5te",
7752 feature = "v5tej",
7753 feature = "v6",
7754 feature = "v6k"
7755 )
7756 )
7757 )]
7758 if (ins & 0xff100010) == 0xfe000010
7759 && let Some(ins) = parse_arm_mcr2_0(ins, pc, options)
7760 {
7761 return ins;
7762 }
7763 #[cfg(feature = "arm")]
7764 if (ins & 0xf100010) == 0xe000010
7765 && let Some(ins) = parse_arm_mcr_0(ins, pc, options)
7766 {
7767 return ins;
7768 }
7769 }
7770 0x3804 | 0x3806 | 0x380c | 0x380e | 0x3824 | 0x3826 | 0x382c | 0x382e | 0x3904
7771 | 0x3906 | 0x390c | 0x390e | 0x3924 | 0x3926 | 0x392c | 0x392e => {
7772 #[cfg(
7773 all(
7774 feature = "arm",
7775 feature = "vfp_v2",
7776 any(
7777 feature = "v5te",
7778 feature = "v5tej",
7779 feature = "v6",
7780 feature = "v6k"
7781 )
7782 )
7783 )]
7784 if (ins & 0xfb00f50) == 0xe000a40
7785 && let Some(ins) = parse_arm_vmls_f32_0(ins, pc, options)
7786 {
7787 return ins;
7788 }
7789 #[cfg(
7790 all(
7791 feature = "arm",
7792 any(
7793 feature = "v5t",
7794 feature = "v5te",
7795 feature = "v5tej",
7796 feature = "v6",
7797 feature = "v6k"
7798 )
7799 )
7800 )]
7801 if (ins & 0xff000010) == 0xfe000000
7802 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
7803 {
7804 return ins;
7805 }
7806 #[cfg(feature = "arm")]
7807 if (ins & 0xf000010) == 0xe000000
7808 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
7809 {
7810 return ins;
7811 }
7812 }
7813 0x3810 | 0x3812 | 0x3818 | 0x381a | 0x3830 | 0x3832 | 0x3838 | 0x383a | 0x3910
7814 | 0x3912 | 0x3918 | 0x391a | 0x3930 | 0x3932 | 0x3938 | 0x393a => {
7815 #[cfg(
7816 all(
7817 feature = "arm",
7818 feature = "vfp_v2",
7819 any(
7820 feature = "v5te",
7821 feature = "v5tej",
7822 feature = "v6",
7823 feature = "v6k"
7824 )
7825 )
7826 )]
7827 if (ins & 0xfb00f50) == 0xe000b00
7828 && let Some(ins) = parse_arm_vmla_f64_0(ins, pc, options)
7829 {
7830 return ins;
7831 }
7832 #[cfg(
7833 all(
7834 feature = "arm",
7835 any(
7836 feature = "v5t",
7837 feature = "v5te",
7838 feature = "v5tej",
7839 feature = "v6",
7840 feature = "v6k"
7841 )
7842 )
7843 )]
7844 if (ins & 0xff000010) == 0xfe000000
7845 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
7846 {
7847 return ins;
7848 }
7849 #[cfg(feature = "arm")]
7850 if (ins & 0xf000010) == 0xe000000
7851 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
7852 {
7853 return ins;
7854 }
7855 }
7856 0x3811 | 0x3819 | 0x3831 | 0x3839 | 0x3891 | 0x3899 | 0x38b1 | 0x38b9 => {
7857 #[cfg(
7858 all(
7859 feature = "arm",
7860 feature = "vfp_v2",
7861 any(
7862 feature = "v5te",
7863 feature = "v5tej",
7864 feature = "v6",
7865 feature = "v6k"
7866 )
7867 )
7868 )]
7869 if (ins & 0xfd00f70) == 0xe000b10
7870 && let Some(ins) = parse_arm_vmov_32_reg_0(ins, pc, options)
7871 {
7872 return ins;
7873 }
7874 #[cfg(
7875 all(
7876 feature = "arm",
7877 any(
7878 feature = "v5t",
7879 feature = "v5te",
7880 feature = "v5tej",
7881 feature = "v6",
7882 feature = "v6k"
7883 )
7884 )
7885 )]
7886 if (ins & 0xff100010) == 0xfe000010
7887 && let Some(ins) = parse_arm_mcr2_0(ins, pc, options)
7888 {
7889 return ins;
7890 }
7891 #[cfg(feature = "arm")]
7892 if (ins & 0xf100010) == 0xe000010
7893 && let Some(ins) = parse_arm_mcr_0(ins, pc, options)
7894 {
7895 return ins;
7896 }
7897 }
7898 0x3813 | 0x3815 | 0x3817 | 0x381b | 0x381d | 0x381f | 0x3833 | 0x3835 | 0x3837
7899 | 0x383b | 0x383d | 0x383f | 0x3881 | 0x3883 | 0x3885 | 0x3887 | 0x3889 | 0x388b
7900 | 0x388d | 0x388f | 0x3893 | 0x3895 | 0x3897 | 0x389b | 0x389d | 0x389f | 0x38a1
7901 | 0x38a3 | 0x38a5 | 0x38a7 | 0x38a9 | 0x38ab | 0x38ad | 0x38af | 0x38b3 | 0x38b5
7902 | 0x38b7 | 0x38bb | 0x38bd | 0x38bf | 0x3901 | 0x3903 | 0x3905 | 0x3907 | 0x3909
7903 | 0x390b | 0x390d | 0x390f | 0x3911 | 0x3913 | 0x3915 | 0x3917 | 0x3919 | 0x391b
7904 | 0x391d | 0x391f | 0x3921 | 0x3923 | 0x3925 | 0x3927 | 0x3929 | 0x392b | 0x392d
7905 | 0x392f | 0x3931 | 0x3933 | 0x3935 | 0x3937 | 0x3939 | 0x393b | 0x393d | 0x393f
7906 | 0x3981 | 0x3983 | 0x3985 | 0x3987 | 0x3989 | 0x398b | 0x398d | 0x398f | 0x3991
7907 | 0x3993 | 0x3995 | 0x3997 | 0x3999 | 0x399b | 0x399d | 0x399f | 0x39a1 | 0x39a3
7908 | 0x39a5 | 0x39a7 | 0x39a9 | 0x39ab | 0x39ad | 0x39af | 0x39b1 | 0x39b3 | 0x39b5
7909 | 0x39b7 | 0x39b9 | 0x39bb | 0x39bd | 0x39bf | 0x3a01 | 0x3a03 | 0x3a05 | 0x3a07
7910 | 0x3a09 | 0x3a0b | 0x3a0d | 0x3a0f | 0x3a11 | 0x3a13 | 0x3a15 | 0x3a17 | 0x3a19
7911 | 0x3a1b | 0x3a1d | 0x3a1f | 0x3a21 | 0x3a23 | 0x3a25 | 0x3a27 | 0x3a29 | 0x3a2b
7912 | 0x3a2d | 0x3a2f | 0x3a31 | 0x3a33 | 0x3a35 | 0x3a37 | 0x3a39 | 0x3a3b | 0x3a3d
7913 | 0x3a3f | 0x3a81 | 0x3a83 | 0x3a85 | 0x3a87 | 0x3a89 | 0x3a8b | 0x3a8d | 0x3a8f
7914 | 0x3a91 | 0x3a93 | 0x3a95 | 0x3a97 | 0x3a99 | 0x3a9b | 0x3a9d | 0x3a9f | 0x3aa1
7915 | 0x3aa3 | 0x3aa5 | 0x3aa7 | 0x3aa9 | 0x3aab | 0x3aad | 0x3aaf | 0x3ab1 | 0x3ab3
7916 | 0x3ab5 | 0x3ab7 | 0x3ab9 | 0x3abb | 0x3abd | 0x3abf | 0x3b01 | 0x3b03 | 0x3b05
7917 | 0x3b07 | 0x3b09 | 0x3b0b | 0x3b0d | 0x3b0f | 0x3b11 | 0x3b13 | 0x3b15 | 0x3b17
7918 | 0x3b19 | 0x3b1b | 0x3b1d | 0x3b1f | 0x3b21 | 0x3b23 | 0x3b25 | 0x3b27 | 0x3b29
7919 | 0x3b2b | 0x3b2d | 0x3b2f | 0x3b31 | 0x3b33 | 0x3b35 | 0x3b37 | 0x3b39 | 0x3b3b
7920 | 0x3b3d | 0x3b3f | 0x3b91 | 0x3b93 | 0x3b95 | 0x3b97 | 0x3b99 | 0x3b9b | 0x3b9d
7921 | 0x3b9f | 0x3ba1 | 0x3ba3 | 0x3ba5 | 0x3ba7 | 0x3ba9 | 0x3bab | 0x3bad | 0x3baf
7922 | 0x3bb1 | 0x3bb3 | 0x3bb5 | 0x3bb7 | 0x3bb9 | 0x3bbb | 0x3bbd | 0x3bbf => {
7923 #[cfg(
7924 all(
7925 feature = "arm",
7926 any(
7927 feature = "v5t",
7928 feature = "v5te",
7929 feature = "v5tej",
7930 feature = "v6",
7931 feature = "v6k"
7932 )
7933 )
7934 )]
7935 if (ins & 0xff100010) == 0xfe000010
7936 && let Some(ins) = parse_arm_mcr2_0(ins, pc, options)
7937 {
7938 return ins;
7939 }
7940 #[cfg(feature = "arm")]
7941 if (ins & 0xf100010) == 0xe000010
7942 && let Some(ins) = parse_arm_mcr_0(ins, pc, options)
7943 {
7944 return ins;
7945 }
7946 }
7947 0x3814 | 0x3816 | 0x381c | 0x381e | 0x3834 | 0x3836 | 0x383c | 0x383e | 0x3914
7948 | 0x3916 | 0x391c | 0x391e | 0x3934 | 0x3936 | 0x393c | 0x393e => {
7949 #[cfg(
7950 all(
7951 feature = "arm",
7952 feature = "vfp_v2",
7953 any(
7954 feature = "v5te",
7955 feature = "v5tej",
7956 feature = "v6",
7957 feature = "v6k"
7958 )
7959 )
7960 )]
7961 if (ins & 0xfb00f50) == 0xe000b40
7962 && let Some(ins) = parse_arm_vmls_f64_0(ins, pc, options)
7963 {
7964 return ins;
7965 }
7966 #[cfg(
7967 all(
7968 feature = "arm",
7969 any(
7970 feature = "v5t",
7971 feature = "v5te",
7972 feature = "v5tej",
7973 feature = "v6",
7974 feature = "v6k"
7975 )
7976 )
7977 )]
7978 if (ins & 0xff000010) == 0xfe000000
7979 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
7980 {
7981 return ins;
7982 }
7983 #[cfg(feature = "arm")]
7984 if (ins & 0xf000010) == 0xe000000
7985 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
7986 {
7987 return ins;
7988 }
7989 }
7990 0x3840 | 0x3842 | 0x3848 | 0x384a | 0x3860 | 0x3862 | 0x3868 | 0x386a | 0x3940
7991 | 0x3942 | 0x3948 | 0x394a | 0x3960 | 0x3962 | 0x3968 | 0x396a => {
7992 #[cfg(
7993 all(
7994 feature = "arm",
7995 feature = "vfp_v2",
7996 any(
7997 feature = "v5te",
7998 feature = "v5tej",
7999 feature = "v6",
8000 feature = "v6k"
8001 )
8002 )
8003 )]
8004 if (ins & 0xfb00f50) == 0xe100a00
8005 && let Some(ins) = parse_arm_vnmls_f32_0(ins, pc, options)
8006 {
8007 return ins;
8008 }
8009 #[cfg(
8010 all(
8011 feature = "arm",
8012 any(
8013 feature = "v5t",
8014 feature = "v5te",
8015 feature = "v5tej",
8016 feature = "v6",
8017 feature = "v6k"
8018 )
8019 )
8020 )]
8021 if (ins & 0xff000010) == 0xfe000000
8022 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
8023 {
8024 return ins;
8025 }
8026 #[cfg(feature = "arm")]
8027 if (ins & 0xf000010) == 0xe000000
8028 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
8029 {
8030 return ins;
8031 }
8032 }
8033 0x3841 | 0x3843 | 0x3845 | 0x3847 | 0x3849 | 0x384b | 0x384d | 0x384f | 0x3861
8034 | 0x3863 | 0x3865 | 0x3867 | 0x3869 | 0x386b | 0x386d | 0x386f => {
8035 #[cfg(
8036 all(
8037 feature = "arm",
8038 feature = "vfp_v2",
8039 any(
8040 feature = "v5te",
8041 feature = "v5tej",
8042 feature = "v6",
8043 feature = "v6k"
8044 )
8045 )
8046 )]
8047 if (ins & 0xff00f10) == 0xe100a10
8048 && let Some(ins) = parse_arm_vmov_reg_f32_0(ins, pc, options)
8049 {
8050 return ins;
8051 }
8052 #[cfg(
8053 all(
8054 feature = "arm",
8055 any(
8056 feature = "v5t",
8057 feature = "v5te",
8058 feature = "v5tej",
8059 feature = "v6",
8060 feature = "v6k"
8061 )
8062 )
8063 )]
8064 if (ins & 0xff100010) == 0xfe100010
8065 && let Some(ins) = parse_arm_mrc2_0(ins, pc, options)
8066 {
8067 return ins;
8068 }
8069 #[cfg(feature = "arm")]
8070 if (ins & 0xf100010) == 0xe100010
8071 && let Some(ins) = parse_arm_mrc_0(ins, pc, options)
8072 {
8073 return ins;
8074 }
8075 }
8076 0x3844 | 0x3846 | 0x384c | 0x384e | 0x3864 | 0x3866 | 0x386c | 0x386e | 0x3944
8077 | 0x3946 | 0x394c | 0x394e | 0x3964 | 0x3966 | 0x396c | 0x396e => {
8078 #[cfg(
8079 all(
8080 feature = "arm",
8081 feature = "vfp_v2",
8082 any(
8083 feature = "v5te",
8084 feature = "v5tej",
8085 feature = "v6",
8086 feature = "v6k"
8087 )
8088 )
8089 )]
8090 if (ins & 0xfb00f50) == 0xe100a40
8091 && let Some(ins) = parse_arm_vnmla_f32_0(ins, pc, options)
8092 {
8093 return ins;
8094 }
8095 #[cfg(
8096 all(
8097 feature = "arm",
8098 any(
8099 feature = "v5t",
8100 feature = "v5te",
8101 feature = "v5tej",
8102 feature = "v6",
8103 feature = "v6k"
8104 )
8105 )
8106 )]
8107 if (ins & 0xff000010) == 0xfe000000
8108 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
8109 {
8110 return ins;
8111 }
8112 #[cfg(feature = "arm")]
8113 if (ins & 0xf000010) == 0xe000000
8114 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
8115 {
8116 return ins;
8117 }
8118 }
8119 0x3850 | 0x3852 | 0x3858 | 0x385a | 0x3870 | 0x3872 | 0x3878 | 0x387a | 0x3950
8120 | 0x3952 | 0x3958 | 0x395a | 0x3970 | 0x3972 | 0x3978 | 0x397a => {
8121 #[cfg(
8122 all(
8123 feature = "arm",
8124 feature = "vfp_v2",
8125 any(
8126 feature = "v5te",
8127 feature = "v5tej",
8128 feature = "v6",
8129 feature = "v6k"
8130 )
8131 )
8132 )]
8133 if (ins & 0xfb00f50) == 0xe100b00
8134 && let Some(ins) = parse_arm_vnmls_f64_0(ins, pc, options)
8135 {
8136 return ins;
8137 }
8138 #[cfg(
8139 all(
8140 feature = "arm",
8141 any(
8142 feature = "v5t",
8143 feature = "v5te",
8144 feature = "v5tej",
8145 feature = "v6",
8146 feature = "v6k"
8147 )
8148 )
8149 )]
8150 if (ins & 0xff000010) == 0xfe000000
8151 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
8152 {
8153 return ins;
8154 }
8155 #[cfg(feature = "arm")]
8156 if (ins & 0xf000010) == 0xe000000
8157 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
8158 {
8159 return ins;
8160 }
8161 }
8162 0x3851 | 0x3859 | 0x3871 | 0x3879 | 0x38d1 | 0x38d9 | 0x38f1 | 0x38f9 => {
8163 #[cfg(
8164 all(
8165 feature = "arm",
8166 feature = "vfp_v2",
8167 any(
8168 feature = "v5te",
8169 feature = "v5tej",
8170 feature = "v6",
8171 feature = "v6k"
8172 )
8173 )
8174 )]
8175 if (ins & 0xfd00f70) == 0xe100b10
8176 && let Some(ins) = parse_arm_vmov_reg_32_0(ins, pc, options)
8177 {
8178 return ins;
8179 }
8180 #[cfg(
8181 all(
8182 feature = "arm",
8183 any(
8184 feature = "v5t",
8185 feature = "v5te",
8186 feature = "v5tej",
8187 feature = "v6",
8188 feature = "v6k"
8189 )
8190 )
8191 )]
8192 if (ins & 0xff100010) == 0xfe100010
8193 && let Some(ins) = parse_arm_mrc2_0(ins, pc, options)
8194 {
8195 return ins;
8196 }
8197 #[cfg(feature = "arm")]
8198 if (ins & 0xf100010) == 0xe100010
8199 && let Some(ins) = parse_arm_mrc_0(ins, pc, options)
8200 {
8201 return ins;
8202 }
8203 }
8204 0x3853 | 0x3855 | 0x3857 | 0x385b | 0x385d | 0x385f | 0x3873 | 0x3875 | 0x3877
8205 | 0x387b | 0x387d | 0x387f | 0x38c1 | 0x38c3 | 0x38c5 | 0x38c7 | 0x38c9 | 0x38cb
8206 | 0x38cd | 0x38cf | 0x38d3 | 0x38d5 | 0x38d7 | 0x38db | 0x38dd | 0x38df | 0x38e1
8207 | 0x38e3 | 0x38e5 | 0x38e7 | 0x38e9 | 0x38eb | 0x38ed | 0x38ef | 0x38f3 | 0x38f5
8208 | 0x38f7 | 0x38fb | 0x38fd | 0x38ff | 0x3941 | 0x3943 | 0x3945 | 0x3947 | 0x3949
8209 | 0x394b | 0x394d | 0x394f | 0x3951 | 0x3953 | 0x3955 | 0x3957 | 0x3959 | 0x395b
8210 | 0x395d | 0x395f | 0x3961 | 0x3963 | 0x3965 | 0x3967 | 0x3969 | 0x396b | 0x396d
8211 | 0x396f | 0x3971 | 0x3973 | 0x3975 | 0x3977 | 0x3979 | 0x397b | 0x397d | 0x397f
8212 | 0x39c1 | 0x39c3 | 0x39c5 | 0x39c7 | 0x39c9 | 0x39cb | 0x39cd | 0x39cf | 0x39d1
8213 | 0x39d3 | 0x39d5 | 0x39d7 | 0x39d9 | 0x39db | 0x39dd | 0x39df | 0x39e1 | 0x39e3
8214 | 0x39e5 | 0x39e7 | 0x39e9 | 0x39eb | 0x39ed | 0x39ef | 0x39f1 | 0x39f3 | 0x39f5
8215 | 0x39f7 | 0x39f9 | 0x39fb | 0x39fd | 0x39ff | 0x3a41 | 0x3a43 | 0x3a45 | 0x3a47
8216 | 0x3a49 | 0x3a4b | 0x3a4d | 0x3a4f | 0x3a51 | 0x3a53 | 0x3a55 | 0x3a57 | 0x3a59
8217 | 0x3a5b | 0x3a5d | 0x3a5f | 0x3a61 | 0x3a63 | 0x3a65 | 0x3a67 | 0x3a69 | 0x3a6b
8218 | 0x3a6d | 0x3a6f | 0x3a71 | 0x3a73 | 0x3a75 | 0x3a77 | 0x3a79 | 0x3a7b | 0x3a7d
8219 | 0x3a7f | 0x3ac1 | 0x3ac3 | 0x3ac5 | 0x3ac7 | 0x3ac9 | 0x3acb | 0x3acd | 0x3acf
8220 | 0x3ad1 | 0x3ad3 | 0x3ad5 | 0x3ad7 | 0x3ad9 | 0x3adb | 0x3add | 0x3adf | 0x3ae1
8221 | 0x3ae3 | 0x3ae5 | 0x3ae7 | 0x3ae9 | 0x3aeb | 0x3aed | 0x3aef | 0x3af1 | 0x3af3
8222 | 0x3af5 | 0x3af7 | 0x3af9 | 0x3afb | 0x3afd | 0x3aff | 0x3b41 | 0x3b43 | 0x3b45
8223 | 0x3b47 | 0x3b49 | 0x3b4b | 0x3b4d | 0x3b4f | 0x3b51 | 0x3b53 | 0x3b55 | 0x3b57
8224 | 0x3b59 | 0x3b5b | 0x3b5d | 0x3b5f | 0x3b61 | 0x3b63 | 0x3b65 | 0x3b67 | 0x3b69
8225 | 0x3b6b | 0x3b6d | 0x3b6f | 0x3b71 | 0x3b73 | 0x3b75 | 0x3b77 | 0x3b79 | 0x3b7b
8226 | 0x3b7d | 0x3b7f | 0x3bd1 | 0x3bd3 | 0x3bd5 | 0x3bd7 | 0x3bd9 | 0x3bdb | 0x3bdd
8227 | 0x3bdf | 0x3be1 | 0x3be3 | 0x3be5 | 0x3be7 | 0x3be9 | 0x3beb | 0x3bed | 0x3bef
8228 | 0x3bf1 | 0x3bf3 | 0x3bf5 | 0x3bf7 | 0x3bf9 | 0x3bfb | 0x3bfd | 0x3bff => {
8229 #[cfg(
8230 all(
8231 feature = "arm",
8232 any(
8233 feature = "v5t",
8234 feature = "v5te",
8235 feature = "v5tej",
8236 feature = "v6",
8237 feature = "v6k"
8238 )
8239 )
8240 )]
8241 if (ins & 0xff100010) == 0xfe100010
8242 && let Some(ins) = parse_arm_mrc2_0(ins, pc, options)
8243 {
8244 return ins;
8245 }
8246 #[cfg(feature = "arm")]
8247 if (ins & 0xf100010) == 0xe100010
8248 && let Some(ins) = parse_arm_mrc_0(ins, pc, options)
8249 {
8250 return ins;
8251 }
8252 }
8253 0x3854 | 0x3856 | 0x385c | 0x385e | 0x3874 | 0x3876 | 0x387c | 0x387e | 0x3954
8254 | 0x3956 | 0x395c | 0x395e | 0x3974 | 0x3976 | 0x397c | 0x397e => {
8255 #[cfg(
8256 all(
8257 feature = "arm",
8258 feature = "vfp_v2",
8259 any(
8260 feature = "v5te",
8261 feature = "v5tej",
8262 feature = "v6",
8263 feature = "v6k"
8264 )
8265 )
8266 )]
8267 if (ins & 0xfb00f50) == 0xe100b40
8268 && let Some(ins) = parse_arm_vnmla_f64_0(ins, pc, options)
8269 {
8270 return ins;
8271 }
8272 #[cfg(
8273 all(
8274 feature = "arm",
8275 any(
8276 feature = "v5t",
8277 feature = "v5te",
8278 feature = "v5tej",
8279 feature = "v6",
8280 feature = "v6k"
8281 )
8282 )
8283 )]
8284 if (ins & 0xff000010) == 0xfe000000
8285 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
8286 {
8287 return ins;
8288 }
8289 #[cfg(feature = "arm")]
8290 if (ins & 0xf000010) == 0xe000000
8291 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
8292 {
8293 return ins;
8294 }
8295 }
8296 0x3880 | 0x3882 | 0x3888 | 0x388a | 0x38a0 | 0x38a2 | 0x38a8 | 0x38aa | 0x3980
8297 | 0x3982 | 0x3988 | 0x398a | 0x39a0 | 0x39a2 | 0x39a8 | 0x39aa => {
8298 #[cfg(
8299 all(
8300 feature = "arm",
8301 feature = "vfp_v2",
8302 any(
8303 feature = "v5te",
8304 feature = "v5tej",
8305 feature = "v6",
8306 feature = "v6k"
8307 )
8308 )
8309 )]
8310 if (ins & 0xfb00f50) == 0xe200a00
8311 && let Some(ins) = parse_arm_vmul_f32_0(ins, pc, options)
8312 {
8313 return ins;
8314 }
8315 #[cfg(
8316 all(
8317 feature = "arm",
8318 any(
8319 feature = "v5t",
8320 feature = "v5te",
8321 feature = "v5tej",
8322 feature = "v6",
8323 feature = "v6k"
8324 )
8325 )
8326 )]
8327 if (ins & 0xff000010) == 0xfe000000
8328 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
8329 {
8330 return ins;
8331 }
8332 #[cfg(feature = "arm")]
8333 if (ins & 0xf000010) == 0xe000000
8334 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
8335 {
8336 return ins;
8337 }
8338 }
8339 0x3884 | 0x3886 | 0x388c | 0x388e | 0x38a4 | 0x38a6 | 0x38ac | 0x38ae | 0x3984
8340 | 0x3986 | 0x398c | 0x398e | 0x39a4 | 0x39a6 | 0x39ac | 0x39ae => {
8341 #[cfg(
8342 all(
8343 feature = "arm",
8344 feature = "vfp_v2",
8345 any(
8346 feature = "v5te",
8347 feature = "v5tej",
8348 feature = "v6",
8349 feature = "v6k"
8350 )
8351 )
8352 )]
8353 if (ins & 0xfb00f50) == 0xe200a40
8354 && let Some(ins) = parse_arm_vnmul_f32_0(ins, pc, options)
8355 {
8356 return ins;
8357 }
8358 #[cfg(
8359 all(
8360 feature = "arm",
8361 any(
8362 feature = "v5t",
8363 feature = "v5te",
8364 feature = "v5tej",
8365 feature = "v6",
8366 feature = "v6k"
8367 )
8368 )
8369 )]
8370 if (ins & 0xff000010) == 0xfe000000
8371 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
8372 {
8373 return ins;
8374 }
8375 #[cfg(feature = "arm")]
8376 if (ins & 0xf000010) == 0xe000000
8377 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
8378 {
8379 return ins;
8380 }
8381 }
8382 0x3890 | 0x3892 | 0x3898 | 0x389a | 0x38b0 | 0x38b2 | 0x38b8 | 0x38ba | 0x3990
8383 | 0x3992 | 0x3998 | 0x399a | 0x39b0 | 0x39b2 | 0x39b8 | 0x39ba => {
8384 #[cfg(
8385 all(
8386 feature = "arm",
8387 feature = "vfp_v2",
8388 any(
8389 feature = "v5te",
8390 feature = "v5tej",
8391 feature = "v6",
8392 feature = "v6k"
8393 )
8394 )
8395 )]
8396 if (ins & 0xfb00f50) == 0xe200b00
8397 && let Some(ins) = parse_arm_vmul_f64_0(ins, pc, options)
8398 {
8399 return ins;
8400 }
8401 #[cfg(
8402 all(
8403 feature = "arm",
8404 any(
8405 feature = "v5t",
8406 feature = "v5te",
8407 feature = "v5tej",
8408 feature = "v6",
8409 feature = "v6k"
8410 )
8411 )
8412 )]
8413 if (ins & 0xff000010) == 0xfe000000
8414 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
8415 {
8416 return ins;
8417 }
8418 #[cfg(feature = "arm")]
8419 if (ins & 0xf000010) == 0xe000000
8420 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
8421 {
8422 return ins;
8423 }
8424 }
8425 0x3894 | 0x3896 | 0x389c | 0x389e | 0x38b4 | 0x38b6 | 0x38bc | 0x38be | 0x3994
8426 | 0x3996 | 0x399c | 0x399e | 0x39b4 | 0x39b6 | 0x39bc | 0x39be => {
8427 #[cfg(
8428 all(
8429 feature = "arm",
8430 feature = "vfp_v2",
8431 any(
8432 feature = "v5te",
8433 feature = "v5tej",
8434 feature = "v6",
8435 feature = "v6k"
8436 )
8437 )
8438 )]
8439 if (ins & 0xfb00f50) == 0xe200b40
8440 && let Some(ins) = parse_arm_vnmul_f64_0(ins, pc, options)
8441 {
8442 return ins;
8443 }
8444 #[cfg(
8445 all(
8446 feature = "arm",
8447 any(
8448 feature = "v5t",
8449 feature = "v5te",
8450 feature = "v5tej",
8451 feature = "v6",
8452 feature = "v6k"
8453 )
8454 )
8455 )]
8456 if (ins & 0xff000010) == 0xfe000000
8457 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
8458 {
8459 return ins;
8460 }
8461 #[cfg(feature = "arm")]
8462 if (ins & 0xf000010) == 0xe000000
8463 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
8464 {
8465 return ins;
8466 }
8467 }
8468 0x38c0 | 0x38c2 | 0x38c8 | 0x38ca | 0x38e0 | 0x38e2 | 0x38e8 | 0x38ea | 0x39c0
8469 | 0x39c2 | 0x39c8 | 0x39ca | 0x39e0 | 0x39e2 | 0x39e8 | 0x39ea => {
8470 #[cfg(
8471 all(
8472 feature = "arm",
8473 feature = "vfp_v2",
8474 any(
8475 feature = "v5te",
8476 feature = "v5tej",
8477 feature = "v6",
8478 feature = "v6k"
8479 )
8480 )
8481 )]
8482 if (ins & 0xfb00f50) == 0xe300a00
8483 && let Some(ins) = parse_arm_vadd_f32_0(ins, pc, options)
8484 {
8485 return ins;
8486 }
8487 #[cfg(
8488 all(
8489 feature = "arm",
8490 any(
8491 feature = "v5t",
8492 feature = "v5te",
8493 feature = "v5tej",
8494 feature = "v6",
8495 feature = "v6k"
8496 )
8497 )
8498 )]
8499 if (ins & 0xff000010) == 0xfe000000
8500 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
8501 {
8502 return ins;
8503 }
8504 #[cfg(feature = "arm")]
8505 if (ins & 0xf000010) == 0xe000000
8506 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
8507 {
8508 return ins;
8509 }
8510 }
8511 0x38c4 | 0x38c6 | 0x38cc | 0x38ce | 0x38e4 | 0x38e6 | 0x38ec | 0x38ee | 0x39c4
8512 | 0x39c6 | 0x39cc | 0x39ce | 0x39e4 | 0x39e6 | 0x39ec | 0x39ee => {
8513 #[cfg(
8514 all(
8515 feature = "arm",
8516 feature = "vfp_v2",
8517 any(
8518 feature = "v5te",
8519 feature = "v5tej",
8520 feature = "v6",
8521 feature = "v6k"
8522 )
8523 )
8524 )]
8525 if (ins & 0xfb00f50) == 0xe300a40
8526 && let Some(ins) = parse_arm_vsub_f32_0(ins, pc, options)
8527 {
8528 return ins;
8529 }
8530 #[cfg(
8531 all(
8532 feature = "arm",
8533 any(
8534 feature = "v5t",
8535 feature = "v5te",
8536 feature = "v5tej",
8537 feature = "v6",
8538 feature = "v6k"
8539 )
8540 )
8541 )]
8542 if (ins & 0xff000010) == 0xfe000000
8543 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
8544 {
8545 return ins;
8546 }
8547 #[cfg(feature = "arm")]
8548 if (ins & 0xf000010) == 0xe000000
8549 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
8550 {
8551 return ins;
8552 }
8553 }
8554 0x38d0 | 0x38d2 | 0x38d8 | 0x38da | 0x38f0 | 0x38f2 | 0x38f8 | 0x38fa | 0x39d0
8555 | 0x39d2 | 0x39d8 | 0x39da | 0x39f0 | 0x39f2 | 0x39f8 | 0x39fa => {
8556 #[cfg(
8557 all(
8558 feature = "arm",
8559 feature = "vfp_v2",
8560 any(
8561 feature = "v5te",
8562 feature = "v5tej",
8563 feature = "v6",
8564 feature = "v6k"
8565 )
8566 )
8567 )]
8568 if (ins & 0xfb00f50) == 0xe300b00
8569 && let Some(ins) = parse_arm_vadd_f64_0(ins, pc, options)
8570 {
8571 return ins;
8572 }
8573 #[cfg(
8574 all(
8575 feature = "arm",
8576 any(
8577 feature = "v5t",
8578 feature = "v5te",
8579 feature = "v5tej",
8580 feature = "v6",
8581 feature = "v6k"
8582 )
8583 )
8584 )]
8585 if (ins & 0xff000010) == 0xfe000000
8586 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
8587 {
8588 return ins;
8589 }
8590 #[cfg(feature = "arm")]
8591 if (ins & 0xf000010) == 0xe000000
8592 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
8593 {
8594 return ins;
8595 }
8596 }
8597 0x38d4 | 0x38d6 | 0x38dc | 0x38de | 0x38f4 | 0x38f6 | 0x38fc | 0x38fe | 0x39d4
8598 | 0x39d6 | 0x39dc | 0x39de | 0x39f4 | 0x39f6 | 0x39fc | 0x39fe => {
8599 #[cfg(
8600 all(
8601 feature = "arm",
8602 feature = "vfp_v2",
8603 any(
8604 feature = "v5te",
8605 feature = "v5tej",
8606 feature = "v6",
8607 feature = "v6k"
8608 )
8609 )
8610 )]
8611 if (ins & 0xfb00f50) == 0xe300b40
8612 && let Some(ins) = parse_arm_vsub_f64_0(ins, pc, options)
8613 {
8614 return ins;
8615 }
8616 #[cfg(
8617 all(
8618 feature = "arm",
8619 any(
8620 feature = "v5t",
8621 feature = "v5te",
8622 feature = "v5tej",
8623 feature = "v6",
8624 feature = "v6k"
8625 )
8626 )
8627 )]
8628 if (ins & 0xff000010) == 0xfe000000
8629 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
8630 {
8631 return ins;
8632 }
8633 #[cfg(feature = "arm")]
8634 if (ins & 0xf000010) == 0xe000000
8635 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
8636 {
8637 return ins;
8638 }
8639 }
8640 0x3a00 | 0x3a02 | 0x3a08 | 0x3a0a | 0x3a20 | 0x3a22 | 0x3a28 | 0x3a2a | 0x3b00
8641 | 0x3b02 | 0x3b08 | 0x3b0a | 0x3b20 | 0x3b22 | 0x3b28 | 0x3b2a => {
8642 #[cfg(
8643 all(
8644 feature = "arm",
8645 feature = "vfp_v2",
8646 any(
8647 feature = "v5te",
8648 feature = "v5tej",
8649 feature = "v6",
8650 feature = "v6k"
8651 )
8652 )
8653 )]
8654 if (ins & 0xfb00f50) == 0xe800a00
8655 && let Some(ins) = parse_arm_vdiv_f32_0(ins, pc, options)
8656 {
8657 return ins;
8658 }
8659 #[cfg(
8660 all(
8661 feature = "arm",
8662 any(
8663 feature = "v5t",
8664 feature = "v5te",
8665 feature = "v5tej",
8666 feature = "v6",
8667 feature = "v6k"
8668 )
8669 )
8670 )]
8671 if (ins & 0xff000010) == 0xfe000000
8672 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
8673 {
8674 return ins;
8675 }
8676 #[cfg(feature = "arm")]
8677 if (ins & 0xf000010) == 0xe000000
8678 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
8679 {
8680 return ins;
8681 }
8682 }
8683 0x3a04 | 0x3a06 | 0x3a0c | 0x3a0e | 0x3a14 | 0x3a16 | 0x3a1c | 0x3a1e | 0x3a24
8684 | 0x3a26 | 0x3a2c | 0x3a2e | 0x3a34 | 0x3a36 | 0x3a3c | 0x3a3e | 0x3a40 | 0x3a42
8685 | 0x3a44 | 0x3a46 | 0x3a48 | 0x3a4a | 0x3a4c | 0x3a4e | 0x3a50 | 0x3a52 | 0x3a54
8686 | 0x3a56 | 0x3a58 | 0x3a5a | 0x3a5c | 0x3a5e | 0x3a60 | 0x3a62 | 0x3a64 | 0x3a66
8687 | 0x3a68 | 0x3a6a | 0x3a6c | 0x3a6e | 0x3a70 | 0x3a72 | 0x3a74 | 0x3a76 | 0x3a78
8688 | 0x3a7a | 0x3a7c | 0x3a7e | 0x3a80 | 0x3a82 | 0x3a84 | 0x3a86 | 0x3a88 | 0x3a8a
8689 | 0x3a8c | 0x3a8e | 0x3a90 | 0x3a92 | 0x3a94 | 0x3a96 | 0x3a98 | 0x3a9a | 0x3a9c
8690 | 0x3a9e | 0x3aa0 | 0x3aa2 | 0x3aa4 | 0x3aa6 | 0x3aa8 | 0x3aaa | 0x3aac | 0x3aae
8691 | 0x3ab0 | 0x3ab2 | 0x3ab4 | 0x3ab6 | 0x3ab8 | 0x3aba | 0x3abc | 0x3abe | 0x3ac0
8692 | 0x3ac2 | 0x3ac8 | 0x3aca | 0x3ad0 | 0x3ad2 | 0x3ad8 | 0x3ada | 0x3ae0 | 0x3ae2
8693 | 0x3ae8 | 0x3aea | 0x3af0 | 0x3af2 | 0x3af8 | 0x3afa | 0x3b04 | 0x3b06 | 0x3b0c
8694 | 0x3b0e | 0x3b14 | 0x3b16 | 0x3b1c | 0x3b1e | 0x3b24 | 0x3b26 | 0x3b2c | 0x3b2e
8695 | 0x3b34 | 0x3b36 | 0x3b3c | 0x3b3e | 0x3b40 | 0x3b42 | 0x3b44 | 0x3b46 | 0x3b48
8696 | 0x3b4a | 0x3b4c | 0x3b4e | 0x3b50 | 0x3b52 | 0x3b54 | 0x3b56 | 0x3b58 | 0x3b5a
8697 | 0x3b5c | 0x3b5e | 0x3b60 | 0x3b62 | 0x3b64 | 0x3b66 | 0x3b68 | 0x3b6a | 0x3b6c
8698 | 0x3b6e | 0x3b70 | 0x3b72 | 0x3b74 | 0x3b76 | 0x3b78 | 0x3b7a | 0x3b7c | 0x3b7e
8699 | 0x3b80 | 0x3b82 | 0x3b84 | 0x3b86 | 0x3b88 | 0x3b8a | 0x3b8c | 0x3b8e | 0x3b90
8700 | 0x3b92 | 0x3b94 | 0x3b96 | 0x3b98 | 0x3b9a | 0x3b9c | 0x3b9e | 0x3ba0 | 0x3ba2
8701 | 0x3ba4 | 0x3ba6 | 0x3ba8 | 0x3baa | 0x3bac | 0x3bae | 0x3bb0 | 0x3bb2 | 0x3bb4
8702 | 0x3bb6 | 0x3bb8 | 0x3bba | 0x3bbc | 0x3bbe | 0x3bc0 | 0x3bc2 | 0x3bc8 | 0x3bca
8703 | 0x3bd0 | 0x3bd2 | 0x3bd8 | 0x3bda | 0x3be0 | 0x3be2 | 0x3be8 | 0x3bea | 0x3bf0
8704 | 0x3bf2 | 0x3bf8 | 0x3bfa => {
8705 #[cfg(
8706 all(
8707 feature = "arm",
8708 any(
8709 feature = "v5t",
8710 feature = "v5te",
8711 feature = "v5tej",
8712 feature = "v6",
8713 feature = "v6k"
8714 )
8715 )
8716 )]
8717 if (ins & 0xff000010) == 0xfe000000
8718 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
8719 {
8720 return ins;
8721 }
8722 #[cfg(feature = "arm")]
8723 if (ins & 0xf000010) == 0xe000000
8724 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
8725 {
8726 return ins;
8727 }
8728 }
8729 0x3a10 | 0x3a12 | 0x3a18 | 0x3a1a | 0x3a30 | 0x3a32 | 0x3a38 | 0x3a3a | 0x3b10
8730 | 0x3b12 | 0x3b18 | 0x3b1a | 0x3b30 | 0x3b32 | 0x3b38 | 0x3b3a => {
8731 #[cfg(
8732 all(
8733 feature = "arm",
8734 feature = "vfp_v2",
8735 any(
8736 feature = "v5te",
8737 feature = "v5tej",
8738 feature = "v6",
8739 feature = "v6k"
8740 )
8741 )
8742 )]
8743 if (ins & 0xfb00f50) == 0xe800b00
8744 && let Some(ins) = parse_arm_vdiv_f64_0(ins, pc, options)
8745 {
8746 return ins;
8747 }
8748 #[cfg(
8749 all(
8750 feature = "arm",
8751 any(
8752 feature = "v5t",
8753 feature = "v5te",
8754 feature = "v5tej",
8755 feature = "v6",
8756 feature = "v6k"
8757 )
8758 )
8759 )]
8760 if (ins & 0xff000010) == 0xfe000000
8761 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
8762 {
8763 return ins;
8764 }
8765 #[cfg(feature = "arm")]
8766 if (ins & 0xf000010) == 0xe000000
8767 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
8768 {
8769 return ins;
8770 }
8771 }
8772 0x3ac4 | 0x3ac6 | 0x3bc4 | 0x3bc6 => {
8773 #[cfg(
8774 all(
8775 feature = "arm",
8776 feature = "vfp_v2",
8777 any(
8778 feature = "v5te",
8779 feature = "v5tej",
8780 feature = "v6",
8781 feature = "v6k"
8782 )
8783 )
8784 )]
8785 if (ins & 0xfbf0fd0) == 0xeb00a40
8786 && let Some(ins) = parse_arm_vmov_f32_0(ins, pc, options)
8787 {
8788 return ins;
8789 }
8790 #[cfg(
8791 all(
8792 feature = "arm",
8793 feature = "vfp_v2",
8794 any(
8795 feature = "v5te",
8796 feature = "v5tej",
8797 feature = "v6",
8798 feature = "v6k"
8799 )
8800 )
8801 )]
8802 if (ins & 0xfbf0fd0) == 0xeb10a40
8803 && let Some(ins) = parse_arm_vneg_f32_0(ins, pc, options)
8804 {
8805 return ins;
8806 }
8807 #[cfg(
8808 all(
8809 feature = "arm",
8810 feature = "vfp_v2",
8811 any(
8812 feature = "v5te",
8813 feature = "v5tej",
8814 feature = "v6",
8815 feature = "v6k"
8816 )
8817 )
8818 )]
8819 if (ins & 0xfbe0f50) == 0xeb40a40
8820 && let Some(ins) = parse_arm_vcmp_f32_0(ins, pc, options)
8821 {
8822 return ins;
8823 }
8824 #[cfg(
8825 all(
8826 feature = "arm",
8827 any(
8828 feature = "v5t",
8829 feature = "v5te",
8830 feature = "v5tej",
8831 feature = "v6",
8832 feature = "v6k"
8833 )
8834 )
8835 )]
8836 if (ins & 0xff000010) == 0xfe000000
8837 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
8838 {
8839 return ins;
8840 }
8841 #[cfg(feature = "arm")]
8842 if (ins & 0xf000010) == 0xe000000
8843 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
8844 {
8845 return ins;
8846 }
8847 }
8848 0x3acc | 0x3ace | 0x3bcc | 0x3bce => {
8849 #[cfg(
8850 all(
8851 feature = "arm",
8852 feature = "vfp_v2",
8853 any(
8854 feature = "v5te",
8855 feature = "v5tej",
8856 feature = "v6",
8857 feature = "v6k"
8858 )
8859 )
8860 )]
8861 if (ins & 0xfbf0fd0) == 0xeb00ac0
8862 && let Some(ins) = parse_arm_vabs_f32_0(ins, pc, options)
8863 {
8864 return ins;
8865 }
8866 #[cfg(
8867 all(
8868 feature = "arm",
8869 feature = "vfp_v2",
8870 any(
8871 feature = "v5te",
8872 feature = "v5tej",
8873 feature = "v6",
8874 feature = "v6k"
8875 )
8876 )
8877 )]
8878 if (ins & 0xfbf0fd0) == 0xeb70ac0
8879 && let Some(ins) = parse_arm_vcvt_f64_f32_0(ins, pc, options)
8880 {
8881 return ins;
8882 }
8883 #[cfg(
8884 all(
8885 feature = "arm",
8886 feature = "vfp_v2",
8887 any(
8888 feature = "v5te",
8889 feature = "v5tej",
8890 feature = "v6",
8891 feature = "v6k"
8892 )
8893 )
8894 )]
8895 if (ins & 0xfbf0fd0) == 0xeb10ac0
8896 && let Some(ins) = parse_arm_vsqrt_f32_0(ins, pc, options)
8897 {
8898 return ins;
8899 }
8900 #[cfg(
8901 all(
8902 feature = "arm",
8903 feature = "vfp_v2",
8904 any(
8905 feature = "v5te",
8906 feature = "v5tej",
8907 feature = "v6",
8908 feature = "v6k"
8909 )
8910 )
8911 )]
8912 if (ins & 0xfbe0f50) == 0xeb40a40
8913 && let Some(ins) = parse_arm_vcmp_f32_0(ins, pc, options)
8914 {
8915 return ins;
8916 }
8917 #[cfg(
8918 all(
8919 feature = "arm",
8920 any(
8921 feature = "v5t",
8922 feature = "v5te",
8923 feature = "v5tej",
8924 feature = "v6",
8925 feature = "v6k"
8926 )
8927 )
8928 )]
8929 if (ins & 0xff000010) == 0xfe000000
8930 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
8931 {
8932 return ins;
8933 }
8934 #[cfg(feature = "arm")]
8935 if (ins & 0xf000010) == 0xe000000
8936 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
8937 {
8938 return ins;
8939 }
8940 }
8941 0x3ad4 | 0x3ad6 | 0x3bd4 | 0x3bd6 => {
8942 #[cfg(
8943 all(
8944 feature = "arm",
8945 feature = "vfp_v2",
8946 any(
8947 feature = "v5te",
8948 feature = "v5tej",
8949 feature = "v6",
8950 feature = "v6k"
8951 )
8952 )
8953 )]
8954 if (ins & 0xfbf0fd0) == 0xeb00b40
8955 && let Some(ins) = parse_arm_vmov_f64_0(ins, pc, options)
8956 {
8957 return ins;
8958 }
8959 #[cfg(
8960 all(
8961 feature = "arm",
8962 feature = "vfp_v2",
8963 any(
8964 feature = "v5te",
8965 feature = "v5tej",
8966 feature = "v6",
8967 feature = "v6k"
8968 )
8969 )
8970 )]
8971 if (ins & 0xfbf0fd0) == 0xeb10b40
8972 && let Some(ins) = parse_arm_vneg_f64_0(ins, pc, options)
8973 {
8974 return ins;
8975 }
8976 #[cfg(
8977 all(
8978 feature = "arm",
8979 feature = "vfp_v2",
8980 any(
8981 feature = "v5te",
8982 feature = "v5tej",
8983 feature = "v6",
8984 feature = "v6k"
8985 )
8986 )
8987 )]
8988 if (ins & 0xfbe0f50) == 0xeb40b40
8989 && let Some(ins) = parse_arm_vcmp_f64_0(ins, pc, options)
8990 {
8991 return ins;
8992 }
8993 #[cfg(
8994 all(
8995 feature = "arm",
8996 any(
8997 feature = "v5t",
8998 feature = "v5te",
8999 feature = "v5tej",
9000 feature = "v6",
9001 feature = "v6k"
9002 )
9003 )
9004 )]
9005 if (ins & 0xff000010) == 0xfe000000
9006 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
9007 {
9008 return ins;
9009 }
9010 #[cfg(feature = "arm")]
9011 if (ins & 0xf000010) == 0xe000000
9012 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
9013 {
9014 return ins;
9015 }
9016 }
9017 0x3adc | 0x3ade | 0x3bdc | 0x3bde => {
9018 #[cfg(
9019 all(
9020 feature = "arm",
9021 feature = "vfp_v2",
9022 any(
9023 feature = "v5te",
9024 feature = "v5tej",
9025 feature = "v6",
9026 feature = "v6k"
9027 )
9028 )
9029 )]
9030 if (ins & 0xfbf0fd0) == 0xeb00bc0
9031 && let Some(ins) = parse_arm_vabs_f64_0(ins, pc, options)
9032 {
9033 return ins;
9034 }
9035 #[cfg(
9036 all(
9037 feature = "arm",
9038 feature = "vfp_v2",
9039 any(
9040 feature = "v5te",
9041 feature = "v5tej",
9042 feature = "v6",
9043 feature = "v6k"
9044 )
9045 )
9046 )]
9047 if (ins & 0xfbf0fd0) == 0xeb70bc0
9048 && let Some(ins) = parse_arm_vcvt_f32_f64_0(ins, pc, options)
9049 {
9050 return ins;
9051 }
9052 #[cfg(
9053 all(
9054 feature = "arm",
9055 feature = "vfp_v2",
9056 any(
9057 feature = "v5te",
9058 feature = "v5tej",
9059 feature = "v6",
9060 feature = "v6k"
9061 )
9062 )
9063 )]
9064 if (ins & 0xfbf0fd0) == 0xeb10bc0
9065 && let Some(ins) = parse_arm_vsqrt_f64_0(ins, pc, options)
9066 {
9067 return ins;
9068 }
9069 #[cfg(
9070 all(
9071 feature = "arm",
9072 feature = "vfp_v2",
9073 any(
9074 feature = "v5te",
9075 feature = "v5tej",
9076 feature = "v6",
9077 feature = "v6k"
9078 )
9079 )
9080 )]
9081 if (ins & 0xfbe0f50) == 0xeb40b40
9082 && let Some(ins) = parse_arm_vcmp_f64_0(ins, pc, options)
9083 {
9084 return ins;
9085 }
9086 #[cfg(
9087 all(
9088 feature = "arm",
9089 any(
9090 feature = "v5t",
9091 feature = "v5te",
9092 feature = "v5tej",
9093 feature = "v6",
9094 feature = "v6k"
9095 )
9096 )
9097 )]
9098 if (ins & 0xff000010) == 0xfe000000
9099 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
9100 {
9101 return ins;
9102 }
9103 #[cfg(feature = "arm")]
9104 if (ins & 0xf000010) == 0xe000000
9105 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
9106 {
9107 return ins;
9108 }
9109 }
9110 0x3ae4 | 0x3ae6 | 0x3be4 | 0x3be6 => {
9111 #[cfg(
9112 all(
9113 feature = "arm",
9114 feature = "vfp_v2",
9115 any(
9116 feature = "v5te",
9117 feature = "v5tej",
9118 feature = "v6",
9119 feature = "v6k"
9120 )
9121 )
9122 )]
9123 if (ins & 0xfbc0fd0) == 0xeb80a40
9124 && let Some(ins) = parse_arm_vcvt_f32_u32_0(ins, pc, options)
9125 {
9126 return ins;
9127 }
9128 #[cfg(
9129 all(
9130 feature = "arm",
9131 feature = "vfp_v2",
9132 any(
9133 feature = "v5te",
9134 feature = "v5tej",
9135 feature = "v6",
9136 feature = "v6k"
9137 )
9138 )
9139 )]
9140 if (ins & 0xfbd0f50) == 0xebd0a40
9141 && let Some(ins) = parse_arm_vcvt_s32_f32_0(ins, pc, options)
9142 {
9143 return ins;
9144 }
9145 #[cfg(
9146 all(
9147 feature = "arm",
9148 feature = "vfp_v2",
9149 any(
9150 feature = "v5te",
9151 feature = "v5tej",
9152 feature = "v6",
9153 feature = "v6k"
9154 )
9155 )
9156 )]
9157 if (ins & 0xfbd0f50) == 0xebc0a40
9158 && let Some(ins) = parse_arm_vcvt_u32_f32_0(ins, pc, options)
9159 {
9160 return ins;
9161 }
9162 #[cfg(
9163 all(
9164 feature = "arm",
9165 any(
9166 feature = "v5t",
9167 feature = "v5te",
9168 feature = "v5tej",
9169 feature = "v6",
9170 feature = "v6k"
9171 )
9172 )
9173 )]
9174 if (ins & 0xff000010) == 0xfe000000
9175 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
9176 {
9177 return ins;
9178 }
9179 #[cfg(feature = "arm")]
9180 if (ins & 0xf000010) == 0xe000000
9181 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
9182 {
9183 return ins;
9184 }
9185 }
9186 0x3aec | 0x3aee | 0x3bec | 0x3bee => {
9187 #[cfg(
9188 all(
9189 feature = "arm",
9190 feature = "vfp_v2",
9191 any(
9192 feature = "v5te",
9193 feature = "v5tej",
9194 feature = "v6",
9195 feature = "v6k"
9196 )
9197 )
9198 )]
9199 if (ins & 0xfbc0fd0) == 0xeb80ac0
9200 && let Some(ins) = parse_arm_vcvt_f32_s32_0(ins, pc, options)
9201 {
9202 return ins;
9203 }
9204 #[cfg(
9205 all(
9206 feature = "arm",
9207 feature = "vfp_v2",
9208 any(
9209 feature = "v5te",
9210 feature = "v5tej",
9211 feature = "v6",
9212 feature = "v6k"
9213 )
9214 )
9215 )]
9216 if (ins & 0xfbd0f50) == 0xebd0a40
9217 && let Some(ins) = parse_arm_vcvt_s32_f32_0(ins, pc, options)
9218 {
9219 return ins;
9220 }
9221 #[cfg(
9222 all(
9223 feature = "arm",
9224 feature = "vfp_v2",
9225 any(
9226 feature = "v5te",
9227 feature = "v5tej",
9228 feature = "v6",
9229 feature = "v6k"
9230 )
9231 )
9232 )]
9233 if (ins & 0xfbd0f50) == 0xebc0a40
9234 && let Some(ins) = parse_arm_vcvt_u32_f32_0(ins, pc, options)
9235 {
9236 return ins;
9237 }
9238 #[cfg(
9239 all(
9240 feature = "arm",
9241 any(
9242 feature = "v5t",
9243 feature = "v5te",
9244 feature = "v5tej",
9245 feature = "v6",
9246 feature = "v6k"
9247 )
9248 )
9249 )]
9250 if (ins & 0xff000010) == 0xfe000000
9251 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
9252 {
9253 return ins;
9254 }
9255 #[cfg(feature = "arm")]
9256 if (ins & 0xf000010) == 0xe000000
9257 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
9258 {
9259 return ins;
9260 }
9261 }
9262 0x3af4 | 0x3af6 | 0x3bf4 | 0x3bf6 => {
9263 #[cfg(
9264 all(
9265 feature = "arm",
9266 feature = "vfp_v2",
9267 any(
9268 feature = "v5te",
9269 feature = "v5tej",
9270 feature = "v6",
9271 feature = "v6k"
9272 )
9273 )
9274 )]
9275 if (ins & 0xfbc0fd0) == 0xeb80b40
9276 && let Some(ins) = parse_arm_vcvt_f64_u32_0(ins, pc, options)
9277 {
9278 return ins;
9279 }
9280 #[cfg(
9281 all(
9282 feature = "arm",
9283 feature = "vfp_v2",
9284 any(
9285 feature = "v5te",
9286 feature = "v5tej",
9287 feature = "v6",
9288 feature = "v6k"
9289 )
9290 )
9291 )]
9292 if (ins & 0xfbd0f50) == 0xebd0b40
9293 && let Some(ins) = parse_arm_vcvt_s32_f64_0(ins, pc, options)
9294 {
9295 return ins;
9296 }
9297 #[cfg(
9298 all(
9299 feature = "arm",
9300 feature = "vfp_v2",
9301 any(
9302 feature = "v5te",
9303 feature = "v5tej",
9304 feature = "v6",
9305 feature = "v6k"
9306 )
9307 )
9308 )]
9309 if (ins & 0xfbd0f50) == 0xebc0b40
9310 && let Some(ins) = parse_arm_vcvt_u32_f64_0(ins, pc, options)
9311 {
9312 return ins;
9313 }
9314 #[cfg(
9315 all(
9316 feature = "arm",
9317 any(
9318 feature = "v5t",
9319 feature = "v5te",
9320 feature = "v5tej",
9321 feature = "v6",
9322 feature = "v6k"
9323 )
9324 )
9325 )]
9326 if (ins & 0xff000010) == 0xfe000000
9327 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
9328 {
9329 return ins;
9330 }
9331 #[cfg(feature = "arm")]
9332 if (ins & 0xf000010) == 0xe000000
9333 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
9334 {
9335 return ins;
9336 }
9337 }
9338 0x3afc | 0x3afe | 0x3bfc | 0x3bfe => {
9339 #[cfg(
9340 all(
9341 feature = "arm",
9342 feature = "vfp_v2",
9343 any(
9344 feature = "v5te",
9345 feature = "v5tej",
9346 feature = "v6",
9347 feature = "v6k"
9348 )
9349 )
9350 )]
9351 if (ins & 0xfbc0fd0) == 0xeb80bc0
9352 && let Some(ins) = parse_arm_vcvt_f64_s32_0(ins, pc, options)
9353 {
9354 return ins;
9355 }
9356 #[cfg(
9357 all(
9358 feature = "arm",
9359 feature = "vfp_v2",
9360 any(
9361 feature = "v5te",
9362 feature = "v5tej",
9363 feature = "v6",
9364 feature = "v6k"
9365 )
9366 )
9367 )]
9368 if (ins & 0xfbd0f50) == 0xebd0b40
9369 && let Some(ins) = parse_arm_vcvt_s32_f64_0(ins, pc, options)
9370 {
9371 return ins;
9372 }
9373 #[cfg(
9374 all(
9375 feature = "arm",
9376 feature = "vfp_v2",
9377 any(
9378 feature = "v5te",
9379 feature = "v5tej",
9380 feature = "v6",
9381 feature = "v6k"
9382 )
9383 )
9384 )]
9385 if (ins & 0xfbd0f50) == 0xebc0b40
9386 && let Some(ins) = parse_arm_vcvt_u32_f64_0(ins, pc, options)
9387 {
9388 return ins;
9389 }
9390 #[cfg(
9391 all(
9392 feature = "arm",
9393 any(
9394 feature = "v5t",
9395 feature = "v5te",
9396 feature = "v5tej",
9397 feature = "v6",
9398 feature = "v6k"
9399 )
9400 )
9401 )]
9402 if (ins & 0xff000010) == 0xfe000000
9403 && let Some(ins) = parse_arm_cdp2_0(ins, pc, options)
9404 {
9405 return ins;
9406 }
9407 #[cfg(feature = "arm")]
9408 if (ins & 0xf000010) == 0xe000000
9409 && let Some(ins) = parse_arm_cdp_0(ins, pc, options)
9410 {
9411 return ins;
9412 }
9413 }
9414 0x3b81 | 0x3b83 | 0x3b85 | 0x3b87 | 0x3b89 | 0x3b8b | 0x3b8d | 0x3b8f => {
9415 #[cfg(
9416 all(
9417 feature = "arm",
9418 feature = "vfp_v2",
9419 any(
9420 feature = "v5te",
9421 feature = "v5tej",
9422 feature = "v6",
9423 feature = "v6k"
9424 )
9425 )
9426 )]
9427 if (ins & 0xfff0f10) == 0xee10a10
9428 && let Some(ins) = parse_arm_vmsr_0(ins, pc, options)
9429 {
9430 return ins;
9431 }
9432 #[cfg(
9433 all(
9434 feature = "arm",
9435 any(
9436 feature = "v5t",
9437 feature = "v5te",
9438 feature = "v5tej",
9439 feature = "v6",
9440 feature = "v6k"
9441 )
9442 )
9443 )]
9444 if (ins & 0xff100010) == 0xfe000010
9445 && let Some(ins) = parse_arm_mcr2_0(ins, pc, options)
9446 {
9447 return ins;
9448 }
9449 #[cfg(feature = "arm")]
9450 if (ins & 0xf100010) == 0xe000010
9451 && let Some(ins) = parse_arm_mcr_0(ins, pc, options)
9452 {
9453 return ins;
9454 }
9455 }
9456 0x3bc1 | 0x3bc3 | 0x3bc5 | 0x3bc7 | 0x3bc9 | 0x3bcb | 0x3bcd | 0x3bcf => {
9457 #[cfg(
9458 all(
9459 feature = "arm",
9460 feature = "vfp_v2",
9461 any(
9462 feature = "v5te",
9463 feature = "v5tej",
9464 feature = "v6",
9465 feature = "v6k"
9466 )
9467 )
9468 )]
9469 if (ins & 0xfff0f10) == 0xef10a10
9470 && let Some(ins) = parse_arm_vmrs_0(ins, pc, options)
9471 {
9472 return ins;
9473 }
9474 #[cfg(
9475 all(
9476 feature = "arm",
9477 any(
9478 feature = "v5t",
9479 feature = "v5te",
9480 feature = "v5tej",
9481 feature = "v6",
9482 feature = "v6k"
9483 )
9484 )
9485 )]
9486 if (ins & 0xff100010) == 0xfe100010
9487 && let Some(ins) = parse_arm_mrc2_0(ins, pc, options)
9488 {
9489 return ins;
9490 }
9491 #[cfg(feature = "arm")]
9492 if (ins & 0xf100010) == 0xe100010
9493 && let Some(ins) = parse_arm_mrc_0(ins, pc, options)
9494 {
9495 return ins;
9496 }
9497 }
9498 0x3c00 | 0x3c01 | 0x3c02 | 0x3c03 | 0x3c04 | 0x3c05 | 0x3c06 | 0x3c07 | 0x3c08
9499 | 0x3c09 | 0x3c0a | 0x3c0b | 0x3c0c | 0x3c0d | 0x3c0e | 0x3c0f | 0x3c10 | 0x3c11
9500 | 0x3c12 | 0x3c13 | 0x3c14 | 0x3c15 | 0x3c16 | 0x3c17 | 0x3c18 | 0x3c19 | 0x3c1a
9501 | 0x3c1b | 0x3c1c | 0x3c1d | 0x3c1e | 0x3c1f | 0x3c20 | 0x3c21 | 0x3c22 | 0x3c23
9502 | 0x3c24 | 0x3c25 | 0x3c26 | 0x3c27 | 0x3c28 | 0x3c29 | 0x3c2a | 0x3c2b | 0x3c2c
9503 | 0x3c2d | 0x3c2e | 0x3c2f | 0x3c30 | 0x3c31 | 0x3c32 | 0x3c33 | 0x3c34 | 0x3c35
9504 | 0x3c36 | 0x3c37 | 0x3c38 | 0x3c39 | 0x3c3a | 0x3c3b | 0x3c3c | 0x3c3d | 0x3c3e
9505 | 0x3c3f | 0x3c40 | 0x3c41 | 0x3c42 | 0x3c43 | 0x3c44 | 0x3c45 | 0x3c46 | 0x3c47
9506 | 0x3c48 | 0x3c49 | 0x3c4a | 0x3c4b | 0x3c4c | 0x3c4d | 0x3c4e | 0x3c4f | 0x3c50
9507 | 0x3c51 | 0x3c52 | 0x3c53 | 0x3c54 | 0x3c55 | 0x3c56 | 0x3c57 | 0x3c58 | 0x3c59
9508 | 0x3c5a | 0x3c5b | 0x3c5c | 0x3c5d | 0x3c5e | 0x3c5f | 0x3c60 | 0x3c61 | 0x3c62
9509 | 0x3c63 | 0x3c64 | 0x3c65 | 0x3c66 | 0x3c67 | 0x3c68 | 0x3c69 | 0x3c6a | 0x3c6b
9510 | 0x3c6c | 0x3c6d | 0x3c6e | 0x3c6f | 0x3c70 | 0x3c71 | 0x3c72 | 0x3c73 | 0x3c74
9511 | 0x3c75 | 0x3c76 | 0x3c77 | 0x3c78 | 0x3c79 | 0x3c7a | 0x3c7b | 0x3c7c | 0x3c7d
9512 | 0x3c7e | 0x3c7f | 0x3c80 | 0x3c81 | 0x3c82 | 0x3c83 | 0x3c84 | 0x3c85 | 0x3c86
9513 | 0x3c87 | 0x3c88 | 0x3c89 | 0x3c8a | 0x3c8b | 0x3c8c | 0x3c8d | 0x3c8e | 0x3c8f
9514 | 0x3c90 | 0x3c91 | 0x3c92 | 0x3c93 | 0x3c94 | 0x3c95 | 0x3c96 | 0x3c97 | 0x3c98
9515 | 0x3c99 | 0x3c9a | 0x3c9b | 0x3c9c | 0x3c9d | 0x3c9e | 0x3c9f | 0x3ca0 | 0x3ca1
9516 | 0x3ca2 | 0x3ca3 | 0x3ca4 | 0x3ca5 | 0x3ca6 | 0x3ca7 | 0x3ca8 | 0x3ca9 | 0x3caa
9517 | 0x3cab | 0x3cac | 0x3cad | 0x3cae | 0x3caf | 0x3cb0 | 0x3cb1 | 0x3cb2 | 0x3cb3
9518 | 0x3cb4 | 0x3cb5 | 0x3cb6 | 0x3cb7 | 0x3cb8 | 0x3cb9 | 0x3cba | 0x3cbb | 0x3cbc
9519 | 0x3cbd | 0x3cbe | 0x3cbf | 0x3cc0 | 0x3cc1 | 0x3cc2 | 0x3cc3 | 0x3cc4 | 0x3cc5
9520 | 0x3cc6 | 0x3cc7 | 0x3cc8 | 0x3cc9 | 0x3cca | 0x3ccb | 0x3ccc | 0x3ccd | 0x3cce
9521 | 0x3ccf | 0x3cd0 | 0x3cd1 | 0x3cd2 | 0x3cd3 | 0x3cd4 | 0x3cd5 | 0x3cd6 | 0x3cd7
9522 | 0x3cd8 | 0x3cd9 | 0x3cda | 0x3cdb | 0x3cdc | 0x3cdd | 0x3cde | 0x3cdf | 0x3ce0
9523 | 0x3ce1 | 0x3ce2 | 0x3ce3 | 0x3ce4 | 0x3ce5 | 0x3ce6 | 0x3ce7 | 0x3ce8 | 0x3ce9
9524 | 0x3cea | 0x3ceb | 0x3cec | 0x3ced | 0x3cee | 0x3cef | 0x3cf0 | 0x3cf1 | 0x3cf2
9525 | 0x3cf3 | 0x3cf4 | 0x3cf5 | 0x3cf6 | 0x3cf7 | 0x3cf8 | 0x3cf9 | 0x3cfa | 0x3cfb
9526 | 0x3cfc | 0x3cfd | 0x3cfe | 0x3cff | 0x3d00 | 0x3d01 | 0x3d02 | 0x3d03 | 0x3d04
9527 | 0x3d05 | 0x3d06 | 0x3d07 | 0x3d08 | 0x3d09 | 0x3d0a | 0x3d0b | 0x3d0c | 0x3d0d
9528 | 0x3d0e | 0x3d0f | 0x3d10 | 0x3d11 | 0x3d12 | 0x3d13 | 0x3d14 | 0x3d15 | 0x3d16
9529 | 0x3d17 | 0x3d18 | 0x3d19 | 0x3d1a | 0x3d1b | 0x3d1c | 0x3d1d | 0x3d1e | 0x3d1f
9530 | 0x3d20 | 0x3d21 | 0x3d22 | 0x3d23 | 0x3d24 | 0x3d25 | 0x3d26 | 0x3d27 | 0x3d28
9531 | 0x3d29 | 0x3d2a | 0x3d2b | 0x3d2c | 0x3d2d | 0x3d2e | 0x3d2f | 0x3d30 | 0x3d31
9532 | 0x3d32 | 0x3d33 | 0x3d34 | 0x3d35 | 0x3d36 | 0x3d37 | 0x3d38 | 0x3d39 | 0x3d3a
9533 | 0x3d3b | 0x3d3c | 0x3d3d | 0x3d3e | 0x3d3f | 0x3d40 | 0x3d41 | 0x3d42 | 0x3d43
9534 | 0x3d44 | 0x3d45 | 0x3d46 | 0x3d47 | 0x3d48 | 0x3d49 | 0x3d4a | 0x3d4b | 0x3d4c
9535 | 0x3d4d | 0x3d4e | 0x3d4f | 0x3d50 | 0x3d51 | 0x3d52 | 0x3d53 | 0x3d54 | 0x3d55
9536 | 0x3d56 | 0x3d57 | 0x3d58 | 0x3d59 | 0x3d5a | 0x3d5b | 0x3d5c | 0x3d5d | 0x3d5e
9537 | 0x3d5f | 0x3d60 | 0x3d61 | 0x3d62 | 0x3d63 | 0x3d64 | 0x3d65 | 0x3d66 | 0x3d67
9538 | 0x3d68 | 0x3d69 | 0x3d6a | 0x3d6b | 0x3d6c | 0x3d6d | 0x3d6e | 0x3d6f | 0x3d70
9539 | 0x3d71 | 0x3d72 | 0x3d73 | 0x3d74 | 0x3d75 | 0x3d76 | 0x3d77 | 0x3d78 | 0x3d79
9540 | 0x3d7a | 0x3d7b | 0x3d7c | 0x3d7d | 0x3d7e | 0x3d7f | 0x3d80 | 0x3d81 | 0x3d82
9541 | 0x3d83 | 0x3d84 | 0x3d85 | 0x3d86 | 0x3d87 | 0x3d88 | 0x3d89 | 0x3d8a | 0x3d8b
9542 | 0x3d8c | 0x3d8d | 0x3d8e | 0x3d8f | 0x3d90 | 0x3d91 | 0x3d92 | 0x3d93 | 0x3d94
9543 | 0x3d95 | 0x3d96 | 0x3d97 | 0x3d98 | 0x3d99 | 0x3d9a | 0x3d9b | 0x3d9c | 0x3d9d
9544 | 0x3d9e | 0x3d9f | 0x3da0 | 0x3da1 | 0x3da2 | 0x3da3 | 0x3da4 | 0x3da5 | 0x3da6
9545 | 0x3da7 | 0x3da8 | 0x3da9 | 0x3daa | 0x3dab | 0x3dac | 0x3dad | 0x3dae | 0x3daf
9546 | 0x3db0 | 0x3db1 | 0x3db2 | 0x3db3 | 0x3db4 | 0x3db5 | 0x3db6 | 0x3db7 | 0x3db8
9547 | 0x3db9 | 0x3dba | 0x3dbb | 0x3dbc | 0x3dbd | 0x3dbe | 0x3dbf | 0x3dc0 | 0x3dc1
9548 | 0x3dc2 | 0x3dc3 | 0x3dc4 | 0x3dc5 | 0x3dc6 | 0x3dc7 | 0x3dc8 | 0x3dc9 | 0x3dca
9549 | 0x3dcb | 0x3dcc | 0x3dcd | 0x3dce | 0x3dcf | 0x3dd0 | 0x3dd1 | 0x3dd2 | 0x3dd3
9550 | 0x3dd4 | 0x3dd5 | 0x3dd6 | 0x3dd7 | 0x3dd8 | 0x3dd9 | 0x3dda | 0x3ddb | 0x3ddc
9551 | 0x3ddd | 0x3dde | 0x3ddf | 0x3de0 | 0x3de1 | 0x3de2 | 0x3de3 | 0x3de4 | 0x3de5
9552 | 0x3de6 | 0x3de7 | 0x3de8 | 0x3de9 | 0x3dea | 0x3deb | 0x3dec | 0x3ded | 0x3dee
9553 | 0x3def | 0x3df0 | 0x3df1 | 0x3df2 | 0x3df3 | 0x3df4 | 0x3df5 | 0x3df6 | 0x3df7
9554 | 0x3df8 | 0x3df9 | 0x3dfa | 0x3dfb | 0x3dfc | 0x3dfd | 0x3dfe | 0x3dff | 0x3e00
9555 | 0x3e01 | 0x3e02 | 0x3e03 | 0x3e04 | 0x3e05 | 0x3e06 | 0x3e07 | 0x3e08 | 0x3e09
9556 | 0x3e0a | 0x3e0b | 0x3e0c | 0x3e0d | 0x3e0e | 0x3e0f | 0x3e10 | 0x3e11 | 0x3e12
9557 | 0x3e13 | 0x3e14 | 0x3e15 | 0x3e16 | 0x3e17 | 0x3e18 | 0x3e19 | 0x3e1a | 0x3e1b
9558 | 0x3e1c | 0x3e1d | 0x3e1e | 0x3e1f | 0x3e20 | 0x3e21 | 0x3e22 | 0x3e23 | 0x3e24
9559 | 0x3e25 | 0x3e26 | 0x3e27 | 0x3e28 | 0x3e29 | 0x3e2a | 0x3e2b | 0x3e2c | 0x3e2d
9560 | 0x3e2e | 0x3e2f | 0x3e30 | 0x3e31 | 0x3e32 | 0x3e33 | 0x3e34 | 0x3e35 | 0x3e36
9561 | 0x3e37 | 0x3e38 | 0x3e39 | 0x3e3a | 0x3e3b | 0x3e3c | 0x3e3d | 0x3e3e | 0x3e3f
9562 | 0x3e40 | 0x3e41 | 0x3e42 | 0x3e43 | 0x3e44 | 0x3e45 | 0x3e46 | 0x3e47 | 0x3e48
9563 | 0x3e49 | 0x3e4a | 0x3e4b | 0x3e4c | 0x3e4d | 0x3e4e | 0x3e4f | 0x3e50 | 0x3e51
9564 | 0x3e52 | 0x3e53 | 0x3e54 | 0x3e55 | 0x3e56 | 0x3e57 | 0x3e58 | 0x3e59 | 0x3e5a
9565 | 0x3e5b | 0x3e5c | 0x3e5d | 0x3e5e | 0x3e5f | 0x3e60 | 0x3e61 | 0x3e62 | 0x3e63
9566 | 0x3e64 | 0x3e65 | 0x3e66 | 0x3e67 | 0x3e68 | 0x3e69 | 0x3e6a | 0x3e6b | 0x3e6c
9567 | 0x3e6d | 0x3e6e | 0x3e6f | 0x3e70 | 0x3e71 | 0x3e72 | 0x3e73 | 0x3e74 | 0x3e75
9568 | 0x3e76 | 0x3e77 | 0x3e78 | 0x3e79 | 0x3e7a | 0x3e7b | 0x3e7c | 0x3e7d | 0x3e7e
9569 | 0x3e7f | 0x3e80 | 0x3e81 | 0x3e82 | 0x3e83 | 0x3e84 | 0x3e85 | 0x3e86 | 0x3e87
9570 | 0x3e88 | 0x3e89 | 0x3e8a | 0x3e8b | 0x3e8c | 0x3e8d | 0x3e8e | 0x3e8f | 0x3e90
9571 | 0x3e91 | 0x3e92 | 0x3e93 | 0x3e94 | 0x3e95 | 0x3e96 | 0x3e97 | 0x3e98 | 0x3e99
9572 | 0x3e9a | 0x3e9b | 0x3e9c | 0x3e9d | 0x3e9e | 0x3e9f | 0x3ea0 | 0x3ea1 | 0x3ea2
9573 | 0x3ea3 | 0x3ea4 | 0x3ea5 | 0x3ea6 | 0x3ea7 | 0x3ea8 | 0x3ea9 | 0x3eaa | 0x3eab
9574 | 0x3eac | 0x3ead | 0x3eae | 0x3eaf | 0x3eb0 | 0x3eb1 | 0x3eb2 | 0x3eb3 | 0x3eb4
9575 | 0x3eb5 | 0x3eb6 | 0x3eb7 | 0x3eb8 | 0x3eb9 | 0x3eba | 0x3ebb | 0x3ebc | 0x3ebd
9576 | 0x3ebe | 0x3ebf | 0x3ec0 | 0x3ec1 | 0x3ec2 | 0x3ec3 | 0x3ec4 | 0x3ec5 | 0x3ec6
9577 | 0x3ec7 | 0x3ec8 | 0x3ec9 | 0x3eca | 0x3ecb | 0x3ecc | 0x3ecd | 0x3ece | 0x3ecf
9578 | 0x3ed0 | 0x3ed1 | 0x3ed2 | 0x3ed3 | 0x3ed4 | 0x3ed5 | 0x3ed6 | 0x3ed7 | 0x3ed8
9579 | 0x3ed9 | 0x3eda | 0x3edb | 0x3edc | 0x3edd | 0x3ede | 0x3edf | 0x3ee0 | 0x3ee1
9580 | 0x3ee2 | 0x3ee3 | 0x3ee4 | 0x3ee5 | 0x3ee6 | 0x3ee7 | 0x3ee8 | 0x3ee9 | 0x3eea
9581 | 0x3eeb | 0x3eec | 0x3eed | 0x3eee | 0x3eef | 0x3ef0 | 0x3ef1 | 0x3ef2 | 0x3ef3
9582 | 0x3ef4 | 0x3ef5 | 0x3ef6 | 0x3ef7 | 0x3ef8 | 0x3ef9 | 0x3efa | 0x3efb | 0x3efc
9583 | 0x3efd | 0x3efe | 0x3eff | 0x3f00 | 0x3f01 | 0x3f02 | 0x3f03 | 0x3f04 | 0x3f05
9584 | 0x3f06 | 0x3f07 | 0x3f08 | 0x3f09 | 0x3f0a | 0x3f0b | 0x3f0c | 0x3f0d | 0x3f0e
9585 | 0x3f0f | 0x3f10 | 0x3f11 | 0x3f12 | 0x3f13 | 0x3f14 | 0x3f15 | 0x3f16 | 0x3f17
9586 | 0x3f18 | 0x3f19 | 0x3f1a | 0x3f1b | 0x3f1c | 0x3f1d | 0x3f1e | 0x3f1f | 0x3f20
9587 | 0x3f21 | 0x3f22 | 0x3f23 | 0x3f24 | 0x3f25 | 0x3f26 | 0x3f27 | 0x3f28 | 0x3f29
9588 | 0x3f2a | 0x3f2b | 0x3f2c | 0x3f2d | 0x3f2e | 0x3f2f | 0x3f30 | 0x3f31 | 0x3f32
9589 | 0x3f33 | 0x3f34 | 0x3f35 | 0x3f36 | 0x3f37 | 0x3f38 | 0x3f39 | 0x3f3a | 0x3f3b
9590 | 0x3f3c | 0x3f3d | 0x3f3e | 0x3f3f | 0x3f40 | 0x3f41 | 0x3f42 | 0x3f43 | 0x3f44
9591 | 0x3f45 | 0x3f46 | 0x3f47 | 0x3f48 | 0x3f49 | 0x3f4a | 0x3f4b | 0x3f4c | 0x3f4d
9592 | 0x3f4e | 0x3f4f | 0x3f50 | 0x3f51 | 0x3f52 | 0x3f53 | 0x3f54 | 0x3f55 | 0x3f56
9593 | 0x3f57 | 0x3f58 | 0x3f59 | 0x3f5a | 0x3f5b | 0x3f5c | 0x3f5d | 0x3f5e | 0x3f5f
9594 | 0x3f60 | 0x3f61 | 0x3f62 | 0x3f63 | 0x3f64 | 0x3f65 | 0x3f66 | 0x3f67 | 0x3f68
9595 | 0x3f69 | 0x3f6a | 0x3f6b | 0x3f6c | 0x3f6d | 0x3f6e | 0x3f6f | 0x3f70 | 0x3f71
9596 | 0x3f72 | 0x3f73 | 0x3f74 | 0x3f75 | 0x3f76 | 0x3f77 | 0x3f78 | 0x3f79 | 0x3f7a
9597 | 0x3f7b | 0x3f7c | 0x3f7d | 0x3f7e | 0x3f7f | 0x3f80 | 0x3f81 | 0x3f82 | 0x3f83
9598 | 0x3f84 | 0x3f85 | 0x3f86 | 0x3f87 | 0x3f88 | 0x3f89 | 0x3f8a | 0x3f8b | 0x3f8c
9599 | 0x3f8d | 0x3f8e | 0x3f8f | 0x3f90 | 0x3f91 | 0x3f92 | 0x3f93 | 0x3f94 | 0x3f95
9600 | 0x3f96 | 0x3f97 | 0x3f98 | 0x3f99 | 0x3f9a | 0x3f9b | 0x3f9c | 0x3f9d | 0x3f9e
9601 | 0x3f9f | 0x3fa0 | 0x3fa1 | 0x3fa2 | 0x3fa3 | 0x3fa4 | 0x3fa5 | 0x3fa6 | 0x3fa7
9602 | 0x3fa8 | 0x3fa9 | 0x3faa | 0x3fab | 0x3fac | 0x3fad | 0x3fae | 0x3faf | 0x3fb0
9603 | 0x3fb1 | 0x3fb2 | 0x3fb3 | 0x3fb4 | 0x3fb5 | 0x3fb6 | 0x3fb7 | 0x3fb8 | 0x3fb9
9604 | 0x3fba | 0x3fbb | 0x3fbc | 0x3fbd | 0x3fbe | 0x3fbf | 0x3fc0 | 0x3fc1 | 0x3fc2
9605 | 0x3fc3 | 0x3fc4 | 0x3fc5 | 0x3fc6 | 0x3fc7 | 0x3fc8 | 0x3fc9 | 0x3fca | 0x3fcb
9606 | 0x3fcc | 0x3fcd | 0x3fce | 0x3fcf | 0x3fd0 | 0x3fd1 | 0x3fd2 | 0x3fd3 | 0x3fd4
9607 | 0x3fd5 | 0x3fd6 | 0x3fd7 | 0x3fd8 | 0x3fd9 | 0x3fda | 0x3fdb | 0x3fdc | 0x3fdd
9608 | 0x3fde | 0x3fdf | 0x3fe0 | 0x3fe1 | 0x3fe2 | 0x3fe3 | 0x3fe4 | 0x3fe5 | 0x3fe6
9609 | 0x3fe7 | 0x3fe8 | 0x3fe9 | 0x3fea | 0x3feb | 0x3fec | 0x3fed | 0x3fee | 0x3fef
9610 | 0x3ff0 | 0x3ff1 | 0x3ff2 | 0x3ff3 | 0x3ff4 | 0x3ff5 | 0x3ff6 | 0x3ff7 | 0x3ff8
9611 | 0x3ff9 | 0x3ffa | 0x3ffb | 0x3ffc | 0x3ffd | 0x3ffe | 0x3fff => {
9612 #[cfg(feature = "arm")]
9613 if let Some(ins) = parse_arm_svc_0(ins, pc, options) {
9614 return ins;
9615 }
9616 }
9617 _ => unreachable!(),
9618 }
9619 Ins::Illegal
9620}
9621#[cfg(feature = "thumb")]
9622pub fn parse_thumb(ins: u32, pc: u32, options: &Options) -> (Ins, u32) {
9623 match (((ins) & 0xffc0) >> 6) {
9624 0x0 => {
9625 #[cfg(feature = "thumb")]
9626 if (ins & 0xffc0) == 0x0
9627 && let Some(ins) = parse_thumb_mov_2(ins, pc, options)
9628 {
9629 return ins;
9630 }
9631 #[cfg(feature = "thumb")]
9632 if (ins & 0xf800) == 0x0
9633 && let Some(ins) = parse_thumb_lsl_0(ins, pc, options)
9634 {
9635 return ins;
9636 }
9637 }
9638 0x1 | 0x2 | 0x3 | 0x4 | 0x5 | 0x6 | 0x7 | 0x8 | 0x9 | 0xa | 0xb | 0xc | 0xd | 0xe
9639 | 0xf | 0x10 | 0x11 | 0x12 | 0x13 | 0x14 | 0x15 | 0x16 | 0x17 | 0x18 | 0x19
9640 | 0x1a | 0x1b | 0x1c | 0x1d | 0x1e | 0x1f => {
9641 #[cfg(feature = "thumb")]
9642 if let Some(ins) = parse_thumb_lsl_0(ins, pc, options) {
9643 return ins;
9644 }
9645 }
9646 0x20 | 0x21 | 0x22 | 0x23 | 0x24 | 0x25 | 0x26 | 0x27 | 0x28 | 0x29 | 0x2a | 0x2b
9647 | 0x2c | 0x2d | 0x2e | 0x2f | 0x30 | 0x31 | 0x32 | 0x33 | 0x34 | 0x35 | 0x36
9648 | 0x37 | 0x38 | 0x39 | 0x3a | 0x3b | 0x3c | 0x3d | 0x3e | 0x3f => {
9649 #[cfg(feature = "thumb")]
9650 if let Some(ins) = parse_thumb_lsr_0(ins, pc, options) {
9651 return ins;
9652 }
9653 }
9654 0x40 | 0x41 | 0x42 | 0x43 | 0x44 | 0x45 | 0x46 | 0x47 | 0x48 | 0x49 | 0x4a | 0x4b
9655 | 0x4c | 0x4d | 0x4e | 0x4f | 0x50 | 0x51 | 0x52 | 0x53 | 0x54 | 0x55 | 0x56
9656 | 0x57 | 0x58 | 0x59 | 0x5a | 0x5b | 0x5c | 0x5d | 0x5e | 0x5f => {
9657 #[cfg(feature = "thumb")]
9658 if let Some(ins) = parse_thumb_asr_0(ins, pc, options) {
9659 return ins;
9660 }
9661 }
9662 0x60 | 0x61 | 0x62 | 0x63 | 0x64 | 0x65 | 0x66 | 0x67 => {
9663 #[cfg(feature = "thumb")]
9664 if let Some(ins) = parse_thumb_add_2(ins, pc, options) {
9665 return ins;
9666 }
9667 }
9668 0x68 | 0x69 | 0x6a | 0x6b | 0x6c | 0x6d | 0x6e | 0x6f => {
9669 #[cfg(feature = "thumb")]
9670 if let Some(ins) = parse_thumb_sub_2(ins, pc, options) {
9671 return ins;
9672 }
9673 }
9674 0x70 => {
9675 #[cfg(feature = "thumb")]
9676 if (ins & 0xffc0) == 0x1c00
9677 && let Some(ins) = parse_thumb_mov_3(ins, pc, options)
9678 {
9679 return ins;
9680 }
9681 #[cfg(feature = "thumb")]
9682 if (ins & 0xfe00) == 0x1c00
9683 && let Some(ins) = parse_thumb_add_0(ins, pc, options)
9684 {
9685 return ins;
9686 }
9687 }
9688 0x71 | 0x72 | 0x73 | 0x74 | 0x75 | 0x76 | 0x77 => {
9689 #[cfg(feature = "thumb")]
9690 if let Some(ins) = parse_thumb_add_0(ins, pc, options) {
9691 return ins;
9692 }
9693 }
9694 0x78 | 0x79 | 0x7a | 0x7b | 0x7c | 0x7d | 0x7e | 0x7f => {
9695 #[cfg(feature = "thumb")]
9696 if let Some(ins) = parse_thumb_sub_0(ins, pc, options) {
9697 return ins;
9698 }
9699 }
9700 0x80 | 0x81 | 0x82 | 0x83 | 0x84 | 0x85 | 0x86 | 0x87 | 0x88 | 0x89 | 0x8a | 0x8b
9701 | 0x8c | 0x8d | 0x8e | 0x8f | 0x90 | 0x91 | 0x92 | 0x93 | 0x94 | 0x95 | 0x96
9702 | 0x97 | 0x98 | 0x99 | 0x9a | 0x9b | 0x9c | 0x9d | 0x9e | 0x9f => {
9703 #[cfg(feature = "thumb")]
9704 if let Some(ins) = parse_thumb_mov_0(ins, pc, options) {
9705 return ins;
9706 }
9707 }
9708 0xa0 | 0xa1 | 0xa2 | 0xa3 | 0xa4 | 0xa5 | 0xa6 | 0xa7 | 0xa8 | 0xa9 | 0xaa | 0xab
9709 | 0xac | 0xad | 0xae | 0xaf | 0xb0 | 0xb1 | 0xb2 | 0xb3 | 0xb4 | 0xb5 | 0xb6
9710 | 0xb7 | 0xb8 | 0xb9 | 0xba | 0xbb | 0xbc | 0xbd | 0xbe | 0xbf => {
9711 #[cfg(feature = "thumb")]
9712 if let Some(ins) = parse_thumb_cmp_0(ins, pc, options) {
9713 return ins;
9714 }
9715 }
9716 0xc0 | 0xc1 | 0xc2 | 0xc3 | 0xc4 | 0xc5 | 0xc6 | 0xc7 | 0xc8 | 0xc9 | 0xca | 0xcb
9717 | 0xcc | 0xcd | 0xce | 0xcf | 0xd0 | 0xd1 | 0xd2 | 0xd3 | 0xd4 | 0xd5 | 0xd6
9718 | 0xd7 | 0xd8 | 0xd9 | 0xda | 0xdb | 0xdc | 0xdd | 0xde | 0xdf => {
9719 #[cfg(feature = "thumb")]
9720 if let Some(ins) = parse_thumb_add_1(ins, pc, options) {
9721 return ins;
9722 }
9723 }
9724 0xe0 | 0xe1 | 0xe2 | 0xe3 | 0xe4 | 0xe5 | 0xe6 | 0xe7 | 0xe8 | 0xe9 | 0xea | 0xeb
9725 | 0xec | 0xed | 0xee | 0xef | 0xf0 | 0xf1 | 0xf2 | 0xf3 | 0xf4 | 0xf5 | 0xf6
9726 | 0xf7 | 0xf8 | 0xf9 | 0xfa | 0xfb | 0xfc | 0xfd | 0xfe | 0xff => {
9727 #[cfg(feature = "thumb")]
9728 if let Some(ins) = parse_thumb_sub_1(ins, pc, options) {
9729 return ins;
9730 }
9731 }
9732 0x100 => {
9733 #[cfg(feature = "thumb")]
9734 if let Some(ins) = parse_thumb_and_0(ins, pc, options) {
9735 return ins;
9736 }
9737 }
9738 0x101 => {
9739 #[cfg(feature = "thumb")]
9740 if let Some(ins) = parse_thumb_eor_0(ins, pc, options) {
9741 return ins;
9742 }
9743 }
9744 0x102 => {
9745 #[cfg(feature = "thumb")]
9746 if let Some(ins) = parse_thumb_lsl_1(ins, pc, options) {
9747 return ins;
9748 }
9749 }
9750 0x103 => {
9751 #[cfg(feature = "thumb")]
9752 if let Some(ins) = parse_thumb_lsr_1(ins, pc, options) {
9753 return ins;
9754 }
9755 }
9756 0x104 => {
9757 #[cfg(feature = "thumb")]
9758 if let Some(ins) = parse_thumb_asr_1(ins, pc, options) {
9759 return ins;
9760 }
9761 }
9762 0x105 => {
9763 #[cfg(feature = "thumb")]
9764 if let Some(ins) = parse_thumb_adc_0(ins, pc, options) {
9765 return ins;
9766 }
9767 }
9768 0x106 => {
9769 #[cfg(feature = "thumb")]
9770 if let Some(ins) = parse_thumb_sbc_0(ins, pc, options) {
9771 return ins;
9772 }
9773 }
9774 0x107 => {
9775 #[cfg(feature = "thumb")]
9776 if let Some(ins) = parse_thumb_ror_0(ins, pc, options) {
9777 return ins;
9778 }
9779 }
9780 0x108 => {
9781 #[cfg(feature = "thumb")]
9782 if let Some(ins) = parse_thumb_tst_0(ins, pc, options) {
9783 return ins;
9784 }
9785 }
9786 0x109 => {
9787 #[cfg(feature = "thumb")]
9788 if (ins & 0xffc0) == 0x4240
9789 && let Some(ins) = parse_thumb_neg_0(ins, pc, options)
9790 {
9791 return ins;
9792 }
9793 #[cfg(feature = "thumb")]
9794 if (ins & 0xffc0) == 0x4240
9795 && let Some(ins) = parse_thumb_rsb_0(ins, pc, options)
9796 {
9797 return ins;
9798 }
9799 }
9800 0x10a => {
9801 #[cfg(feature = "thumb")]
9802 if let Some(ins) = parse_thumb_cmp_1(ins, pc, options) {
9803 return ins;
9804 }
9805 }
9806 0x10b => {
9807 #[cfg(feature = "thumb")]
9808 if let Some(ins) = parse_thumb_cmn_0(ins, pc, options) {
9809 return ins;
9810 }
9811 }
9812 0x10c => {
9813 #[cfg(feature = "thumb")]
9814 if let Some(ins) = parse_thumb_orr_0(ins, pc, options) {
9815 return ins;
9816 }
9817 }
9818 0x10d => {
9819 #[cfg(feature = "thumb")]
9820 if let Some(ins) = parse_thumb_mul_0(ins, pc, options) {
9821 return ins;
9822 }
9823 }
9824 0x10e => {
9825 #[cfg(feature = "thumb")]
9826 if let Some(ins) = parse_thumb_bic_0(ins, pc, options) {
9827 return ins;
9828 }
9829 }
9830 0x10f => {
9831 #[cfg(feature = "thumb")]
9832 if let Some(ins) = parse_thumb_mvn_0(ins, pc, options) {
9833 return ins;
9834 }
9835 }
9836 0x110 => {
9837 #[cfg(feature = "thumb")]
9838 if let Some(ins) = parse_thumb_add_3(ins, pc, options) {
9839 return ins;
9840 }
9841 }
9842 0x111 => {
9843 #[cfg(feature = "thumb")]
9844 if (ins & 0xff78) == 0x4468
9845 && let Some(ins) = parse_thumb_add_6(ins, pc, options)
9846 {
9847 return ins;
9848 }
9849 #[cfg(feature = "thumb")]
9850 if (ins & 0xff00) == 0x4400
9851 && let Some(ins) = parse_thumb_add_3(ins, pc, options)
9852 {
9853 return ins;
9854 }
9855 }
9856 0x112 => {
9857 #[cfg(feature = "thumb")]
9858 if (ins & 0xff87) == 0x4485
9859 && let Some(ins) = parse_thumb_add_7(ins, pc, options)
9860 {
9861 return ins;
9862 }
9863 #[cfg(feature = "thumb")]
9864 if (ins & 0xff00) == 0x4400
9865 && let Some(ins) = parse_thumb_add_3(ins, pc, options)
9866 {
9867 return ins;
9868 }
9869 }
9870 0x113 => {
9871 #[cfg(feature = "thumb")]
9872 if (ins & 0xff78) == 0x4468
9873 && let Some(ins) = parse_thumb_add_6(ins, pc, options)
9874 {
9875 return ins;
9876 }
9877 #[cfg(feature = "thumb")]
9878 if (ins & 0xff87) == 0x4485
9879 && let Some(ins) = parse_thumb_add_7(ins, pc, options)
9880 {
9881 return ins;
9882 }
9883 #[cfg(feature = "thumb")]
9884 if (ins & 0xff00) == 0x4400
9885 && let Some(ins) = parse_thumb_add_3(ins, pc, options)
9886 {
9887 return ins;
9888 }
9889 }
9890 0x114 | 0x115 | 0x116 | 0x117 => {
9891 #[cfg(feature = "thumb")]
9892 if let Some(ins) = parse_thumb_cmp_2(ins, pc, options) {
9893 return ins;
9894 }
9895 }
9896 0x118 | 0x119 | 0x11a | 0x11b => {
9897 #[cfg(feature = "thumb")]
9898 if let Some(ins) = parse_thumb_mov_1(ins, pc, options) {
9899 return ins;
9900 }
9901 }
9902 0x11c | 0x11d => {
9903 #[cfg(feature = "thumb")]
9904 if let Some(ins) = parse_thumb_bx_0(ins, pc, options) {
9905 return ins;
9906 }
9907 }
9908 0x11e | 0x11f => {
9909 #[cfg(
9910 all(
9911 feature = "thumb",
9912 any(
9913 feature = "v5t",
9914 feature = "v5te",
9915 feature = "v5tej",
9916 feature = "v6",
9917 feature = "v6k"
9918 )
9919 )
9920 )]
9921 if let Some(ins) = parse_thumb_blx_1(ins, pc, options) {
9922 return ins;
9923 }
9924 }
9925 0x120 | 0x121 | 0x122 | 0x123 | 0x124 | 0x125 | 0x126 | 0x127 | 0x128 | 0x129
9926 | 0x12a | 0x12b | 0x12c | 0x12d | 0x12e | 0x12f | 0x130 | 0x131 | 0x132 | 0x133
9927 | 0x134 | 0x135 | 0x136 | 0x137 | 0x138 | 0x139 | 0x13a | 0x13b | 0x13c | 0x13d
9928 | 0x13e | 0x13f => {
9929 #[cfg(feature = "thumb")]
9930 if let Some(ins) = parse_thumb_ldr_2(ins, pc, options) {
9931 return ins;
9932 }
9933 }
9934 0x140 | 0x141 | 0x142 | 0x143 | 0x144 | 0x145 | 0x146 | 0x147 => {
9935 #[cfg(feature = "thumb")]
9936 if let Some(ins) = parse_thumb_str_2(ins, pc, options) {
9937 return ins;
9938 }
9939 }
9940 0x148 | 0x149 | 0x14a | 0x14b | 0x14c | 0x14d | 0x14e | 0x14f => {
9941 #[cfg(feature = "thumb")]
9942 if let Some(ins) = parse_thumb_strh_1(ins, pc, options) {
9943 return ins;
9944 }
9945 }
9946 0x150 | 0x151 | 0x152 | 0x153 | 0x154 | 0x155 | 0x156 | 0x157 => {
9947 #[cfg(feature = "thumb")]
9948 if let Some(ins) = parse_thumb_strb_1(ins, pc, options) {
9949 return ins;
9950 }
9951 }
9952 0x158 | 0x159 | 0x15a | 0x15b | 0x15c | 0x15d | 0x15e | 0x15f => {
9953 #[cfg(feature = "thumb")]
9954 if let Some(ins) = parse_thumb_ldrsb_0(ins, pc, options) {
9955 return ins;
9956 }
9957 }
9958 0x160 | 0x161 | 0x162 | 0x163 | 0x164 | 0x165 | 0x166 | 0x167 => {
9959 #[cfg(feature = "thumb")]
9960 if let Some(ins) = parse_thumb_ldr_3(ins, pc, options) {
9961 return ins;
9962 }
9963 }
9964 0x168 | 0x169 | 0x16a | 0x16b | 0x16c | 0x16d | 0x16e | 0x16f => {
9965 #[cfg(feature = "thumb")]
9966 if let Some(ins) = parse_thumb_ldrh_1(ins, pc, options) {
9967 return ins;
9968 }
9969 }
9970 0x170 | 0x171 | 0x172 | 0x173 | 0x174 | 0x175 | 0x176 | 0x177 => {
9971 #[cfg(feature = "thumb")]
9972 if let Some(ins) = parse_thumb_ldrb_1(ins, pc, options) {
9973 return ins;
9974 }
9975 }
9976 0x178 | 0x179 | 0x17a | 0x17b | 0x17c | 0x17d | 0x17e | 0x17f => {
9977 #[cfg(feature = "thumb")]
9978 if let Some(ins) = parse_thumb_ldrsh_0(ins, pc, options) {
9979 return ins;
9980 }
9981 }
9982 0x180 | 0x181 | 0x182 | 0x183 | 0x184 | 0x185 | 0x186 | 0x187 | 0x188 | 0x189
9983 | 0x18a | 0x18b | 0x18c | 0x18d | 0x18e | 0x18f | 0x190 | 0x191 | 0x192 | 0x193
9984 | 0x194 | 0x195 | 0x196 | 0x197 | 0x198 | 0x199 | 0x19a | 0x19b | 0x19c | 0x19d
9985 | 0x19e | 0x19f => {
9986 #[cfg(feature = "thumb")]
9987 if let Some(ins) = parse_thumb_str_0(ins, pc, options) {
9988 return ins;
9989 }
9990 }
9991 0x1a0 | 0x1a1 | 0x1a2 | 0x1a3 | 0x1a4 | 0x1a5 | 0x1a6 | 0x1a7 | 0x1a8 | 0x1a9
9992 | 0x1aa | 0x1ab | 0x1ac | 0x1ad | 0x1ae | 0x1af | 0x1b0 | 0x1b1 | 0x1b2 | 0x1b3
9993 | 0x1b4 | 0x1b5 | 0x1b6 | 0x1b7 | 0x1b8 | 0x1b9 | 0x1ba | 0x1bb | 0x1bc | 0x1bd
9994 | 0x1be | 0x1bf => {
9995 #[cfg(feature = "thumb")]
9996 if let Some(ins) = parse_thumb_ldr_0(ins, pc, options) {
9997 return ins;
9998 }
9999 }
10000 0x1c0 | 0x1c1 | 0x1c2 | 0x1c3 | 0x1c4 | 0x1c5 | 0x1c6 | 0x1c7 | 0x1c8 | 0x1c9
10001 | 0x1ca | 0x1cb | 0x1cc | 0x1cd | 0x1ce | 0x1cf | 0x1d0 | 0x1d1 | 0x1d2 | 0x1d3
10002 | 0x1d4 | 0x1d5 | 0x1d6 | 0x1d7 | 0x1d8 | 0x1d9 | 0x1da | 0x1db | 0x1dc | 0x1dd
10003 | 0x1de | 0x1df => {
10004 #[cfg(feature = "thumb")]
10005 if let Some(ins) = parse_thumb_strb_0(ins, pc, options) {
10006 return ins;
10007 }
10008 }
10009 0x1e0 | 0x1e1 | 0x1e2 | 0x1e3 | 0x1e4 | 0x1e5 | 0x1e6 | 0x1e7 | 0x1e8 | 0x1e9
10010 | 0x1ea | 0x1eb | 0x1ec | 0x1ed | 0x1ee | 0x1ef | 0x1f0 | 0x1f1 | 0x1f2 | 0x1f3
10011 | 0x1f4 | 0x1f5 | 0x1f6 | 0x1f7 | 0x1f8 | 0x1f9 | 0x1fa | 0x1fb | 0x1fc | 0x1fd
10012 | 0x1fe | 0x1ff => {
10013 #[cfg(feature = "thumb")]
10014 if let Some(ins) = parse_thumb_ldrb_0(ins, pc, options) {
10015 return ins;
10016 }
10017 }
10018 0x200 | 0x201 | 0x202 | 0x203 | 0x204 | 0x205 | 0x206 | 0x207 | 0x208 | 0x209
10019 | 0x20a | 0x20b | 0x20c | 0x20d | 0x20e | 0x20f | 0x210 | 0x211 | 0x212 | 0x213
10020 | 0x214 | 0x215 | 0x216 | 0x217 | 0x218 | 0x219 | 0x21a | 0x21b | 0x21c | 0x21d
10021 | 0x21e | 0x21f => {
10022 #[cfg(feature = "thumb")]
10023 if let Some(ins) = parse_thumb_strh_0(ins, pc, options) {
10024 return ins;
10025 }
10026 }
10027 0x220 | 0x221 | 0x222 | 0x223 | 0x224 | 0x225 | 0x226 | 0x227 | 0x228 | 0x229
10028 | 0x22a | 0x22b | 0x22c | 0x22d | 0x22e | 0x22f | 0x230 | 0x231 | 0x232 | 0x233
10029 | 0x234 | 0x235 | 0x236 | 0x237 | 0x238 | 0x239 | 0x23a | 0x23b | 0x23c | 0x23d
10030 | 0x23e | 0x23f => {
10031 #[cfg(feature = "thumb")]
10032 if let Some(ins) = parse_thumb_ldrh_0(ins, pc, options) {
10033 return ins;
10034 }
10035 }
10036 0x240 | 0x241 | 0x242 | 0x243 | 0x244 | 0x245 | 0x246 | 0x247 | 0x248 | 0x249
10037 | 0x24a | 0x24b | 0x24c | 0x24d | 0x24e | 0x24f | 0x250 | 0x251 | 0x252 | 0x253
10038 | 0x254 | 0x255 | 0x256 | 0x257 | 0x258 | 0x259 | 0x25a | 0x25b | 0x25c | 0x25d
10039 | 0x25e | 0x25f => {
10040 #[cfg(feature = "thumb")]
10041 if let Some(ins) = parse_thumb_str_1(ins, pc, options) {
10042 return ins;
10043 }
10044 }
10045 0x260 | 0x261 | 0x262 | 0x263 | 0x264 | 0x265 | 0x266 | 0x267 | 0x268 | 0x269
10046 | 0x26a | 0x26b | 0x26c | 0x26d | 0x26e | 0x26f | 0x270 | 0x271 | 0x272 | 0x273
10047 | 0x274 | 0x275 | 0x276 | 0x277 | 0x278 | 0x279 | 0x27a | 0x27b | 0x27c | 0x27d
10048 | 0x27e | 0x27f => {
10049 #[cfg(feature = "thumb")]
10050 if let Some(ins) = parse_thumb_ldr_1(ins, pc, options) {
10051 return ins;
10052 }
10053 }
10054 0x280 | 0x281 | 0x282 | 0x283 | 0x284 | 0x285 | 0x286 | 0x287 | 0x288 | 0x289
10055 | 0x28a | 0x28b | 0x28c | 0x28d | 0x28e | 0x28f | 0x290 | 0x291 | 0x292 | 0x293
10056 | 0x294 | 0x295 | 0x296 | 0x297 | 0x298 | 0x299 | 0x29a | 0x29b | 0x29c | 0x29d
10057 | 0x29e | 0x29f => {
10058 #[cfg(feature = "thumb")]
10059 if let Some(ins) = parse_thumb_add_8(ins, pc, options) {
10060 return ins;
10061 }
10062 }
10063 0x2a0 | 0x2a1 | 0x2a2 | 0x2a3 | 0x2a4 | 0x2a5 | 0x2a6 | 0x2a7 | 0x2a8 | 0x2a9
10064 | 0x2aa | 0x2ab | 0x2ac | 0x2ad | 0x2ae | 0x2af | 0x2b0 | 0x2b1 | 0x2b2 | 0x2b3
10065 | 0x2b4 | 0x2b5 | 0x2b6 | 0x2b7 | 0x2b8 | 0x2b9 | 0x2ba | 0x2bb | 0x2bc | 0x2bd
10066 | 0x2be | 0x2bf => {
10067 #[cfg(feature = "thumb")]
10068 if let Some(ins) = parse_thumb_add_4(ins, pc, options) {
10069 return ins;
10070 }
10071 }
10072 0x2c0 | 0x2c1 => {
10073 #[cfg(feature = "thumb")]
10074 if let Some(ins) = parse_thumb_add_5(ins, pc, options) {
10075 return ins;
10076 }
10077 }
10078 0x2c2 | 0x2c3 => {
10079 #[cfg(feature = "thumb")]
10080 if let Some(ins) = parse_thumb_sub_3(ins, pc, options) {
10081 return ins;
10082 }
10083 }
10084 0x2c4 | 0x2c5 | 0x2c6 | 0x2c7 | 0x2cc | 0x2cd | 0x2ce | 0x2cf | 0x2d8 | 0x2da
10085 | 0x2db | 0x2dc | 0x2dd | 0x2de | 0x2df | 0x2e0 | 0x2e1 | 0x2e2 | 0x2e3 | 0x2e4
10086 | 0x2e5 | 0x2e6 | 0x2e7 | 0x2ea | 0x2ec | 0x2ed | 0x2ee | 0x2ef | 0x2fc | 0x2fd
10087 | 0x2fe | 0x2ff | 0x3a0 | 0x3a1 | 0x3a2 | 0x3a3 | 0x3a4 | 0x3a5 | 0x3a6 | 0x3a7
10088 | 0x3a8 | 0x3a9 | 0x3aa | 0x3ab | 0x3ac | 0x3ad | 0x3ae | 0x3af | 0x3b0 | 0x3b1
10089 | 0x3b2 | 0x3b3 | 0x3b4 | 0x3b5 | 0x3b6 | 0x3b7 | 0x3b8 | 0x3b9 | 0x3ba | 0x3bb
10090 | 0x3bc | 0x3bd | 0x3be | 0x3bf | 0x3e0 | 0x3e1 | 0x3e2 | 0x3e3 | 0x3e4 | 0x3e5
10091 | 0x3e6 | 0x3e7 | 0x3e8 | 0x3e9 | 0x3ea | 0x3eb | 0x3ec | 0x3ed | 0x3ee | 0x3ef
10092 | 0x3f0 | 0x3f1 | 0x3f2 | 0x3f3 | 0x3f4 | 0x3f5 | 0x3f6 | 0x3f7 | 0x3f8 | 0x3f9
10093 | 0x3fa | 0x3fb | 0x3fc | 0x3fd | 0x3fe | 0x3ff => {}
10094 0x2c8 => {
10095 #[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
10096 if let Some(ins) = parse_thumb_sxth_0(ins, pc, options) {
10097 return ins;
10098 }
10099 }
10100 0x2c9 => {
10101 #[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
10102 if let Some(ins) = parse_thumb_sxtb_0(ins, pc, options) {
10103 return ins;
10104 }
10105 }
10106 0x2ca => {
10107 #[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
10108 if let Some(ins) = parse_thumb_uxth_0(ins, pc, options) {
10109 return ins;
10110 }
10111 }
10112 0x2cb => {
10113 #[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
10114 if let Some(ins) = parse_thumb_uxtb_0(ins, pc, options) {
10115 return ins;
10116 }
10117 }
10118 0x2d0 | 0x2d1 | 0x2d2 | 0x2d3 | 0x2d4 | 0x2d5 | 0x2d6 | 0x2d7 => {
10119 #[cfg(feature = "thumb")]
10120 if let Some(ins) = parse_thumb_push_0(ins, pc, options) {
10121 return ins;
10122 }
10123 }
10124 0x2d9 => {
10125 #[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
10126 if (ins & 0xffe8) == 0xb660
10127 && let Some(ins) = parse_thumb_cps_0(ins, pc, options)
10128 {
10129 return ins;
10130 }
10131 #[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
10132 if (ins & 0xffe0) == 0xb640
10133 && let Some(ins) = parse_thumb_setend_0(ins, pc, options)
10134 {
10135 return ins;
10136 }
10137 }
10138 0x2e8 => {
10139 #[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
10140 if let Some(ins) = parse_thumb_rev_0(ins, pc, options) {
10141 return ins;
10142 }
10143 }
10144 0x2e9 => {
10145 #[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
10146 if let Some(ins) = parse_thumb_rev16_0(ins, pc, options) {
10147 return ins;
10148 }
10149 }
10150 0x2eb => {
10151 #[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
10152 if let Some(ins) = parse_thumb_revsh_0(ins, pc, options) {
10153 return ins;
10154 }
10155 }
10156 0x2f0 | 0x2f1 | 0x2f2 | 0x2f3 | 0x2f4 | 0x2f5 | 0x2f6 | 0x2f7 => {
10157 #[cfg(feature = "thumb")]
10158 if let Some(ins) = parse_thumb_pop_0(ins, pc, options) {
10159 return ins;
10160 }
10161 }
10162 0x2f8 | 0x2f9 | 0x2fa | 0x2fb => {
10163 #[cfg(
10164 all(
10165 feature = "thumb",
10166 any(
10167 feature = "v5t",
10168 feature = "v5te",
10169 feature = "v5tej",
10170 feature = "v6",
10171 feature = "v6k"
10172 )
10173 )
10174 )]
10175 if let Some(ins) = parse_thumb_bkpt_0(ins, pc, options) {
10176 return ins;
10177 }
10178 }
10179 0x300 | 0x301 | 0x302 | 0x303 | 0x304 | 0x305 | 0x306 | 0x307 | 0x308 | 0x309
10180 | 0x30a | 0x30b | 0x30c | 0x30d | 0x30e | 0x30f | 0x310 | 0x311 | 0x312 | 0x313
10181 | 0x314 | 0x315 | 0x316 | 0x317 | 0x318 | 0x319 | 0x31a | 0x31b | 0x31c | 0x31d
10182 | 0x31e | 0x31f => {
10183 #[cfg(feature = "thumb")]
10184 if let Some(ins) = parse_thumb_stm_0(ins, pc, options) {
10185 return ins;
10186 }
10187 }
10188 0x320 | 0x321 | 0x322 | 0x323 | 0x324 | 0x325 | 0x326 | 0x327 | 0x328 | 0x329
10189 | 0x32a | 0x32b | 0x32c | 0x32d | 0x32e | 0x32f | 0x330 | 0x331 | 0x332 | 0x333
10190 | 0x334 | 0x335 | 0x336 | 0x337 | 0x338 | 0x339 | 0x33a | 0x33b | 0x33c | 0x33d
10191 | 0x33e | 0x33f => {
10192 #[cfg(feature = "thumb")]
10193 if let Some(ins) = parse_thumb_ldm_0(ins, pc, options) {
10194 return ins;
10195 }
10196 }
10197 0x340 | 0x341 | 0x342 | 0x343 | 0x344 | 0x345 | 0x346 | 0x347 | 0x348 | 0x349
10198 | 0x34a | 0x34b | 0x34c | 0x34d | 0x34e | 0x34f | 0x350 | 0x351 | 0x352 | 0x353
10199 | 0x354 | 0x355 | 0x356 | 0x357 | 0x358 | 0x359 | 0x35a | 0x35b | 0x35c | 0x35d
10200 | 0x35e | 0x35f | 0x360 | 0x361 | 0x362 | 0x363 | 0x364 | 0x365 | 0x366 | 0x367
10201 | 0x368 | 0x369 | 0x36a | 0x36b | 0x36c | 0x36d | 0x36e | 0x36f | 0x370 | 0x371
10202 | 0x372 | 0x373 | 0x374 | 0x375 | 0x376 | 0x377 => {
10203 #[cfg(feature = "thumb")]
10204 if let Some(ins) = parse_thumb_b_0(ins, pc, options) {
10205 return ins;
10206 }
10207 }
10208 0x378 | 0x379 | 0x37a | 0x37b => {
10209 #[cfg(feature = "thumb")]
10210 if (ins & 0xff00) == 0xde00
10211 && let Some(ins) = parse_thumb_udf_0(ins, pc, options)
10212 {
10213 return ins;
10214 }
10215 #[cfg(feature = "thumb")]
10216 if (ins & 0xf000) == 0xd000
10217 && let Some(ins) = parse_thumb_b_0(ins, pc, options)
10218 {
10219 return ins;
10220 }
10221 }
10222 0x37c | 0x37d | 0x37e | 0x37f => {
10223 #[cfg(feature = "thumb")]
10224 if (ins & 0xff00) == 0xdf00
10225 && let Some(ins) = parse_thumb_svc_0(ins, pc, options)
10226 {
10227 return ins;
10228 }
10229 #[cfg(feature = "thumb")]
10230 if (ins & 0xf000) == 0xd000
10231 && let Some(ins) = parse_thumb_b_0(ins, pc, options)
10232 {
10233 return ins;
10234 }
10235 }
10236 0x380 | 0x381 | 0x382 | 0x383 | 0x384 | 0x385 | 0x386 | 0x387 | 0x388 | 0x389
10237 | 0x38a | 0x38b | 0x38c | 0x38d | 0x38e | 0x38f | 0x390 | 0x391 | 0x392 | 0x393
10238 | 0x394 | 0x395 | 0x396 | 0x397 | 0x398 | 0x399 | 0x39a | 0x39b | 0x39c | 0x39d
10239 | 0x39e | 0x39f => {
10240 #[cfg(feature = "thumb")]
10241 if let Some(ins) = parse_thumb_b_1(ins, pc, options) {
10242 return ins;
10243 }
10244 }
10245 0x3c0 | 0x3c1 | 0x3c2 | 0x3c3 | 0x3c4 | 0x3c5 | 0x3c6 | 0x3c7 | 0x3c8 | 0x3c9
10246 | 0x3ca | 0x3cb | 0x3cc | 0x3cd | 0x3ce | 0x3cf | 0x3d0 | 0x3d1 | 0x3d2 | 0x3d3
10247 | 0x3d4 | 0x3d5 | 0x3d6 | 0x3d7 | 0x3d8 | 0x3d9 | 0x3da | 0x3db | 0x3dc | 0x3dd
10248 | 0x3de | 0x3df => {
10249 #[cfg(feature = "thumb")]
10250 if (ins & 0xd000f800) == 0xd000f000
10251 && let Some(ins) = parse_thumb_bl_0(ins, pc, options)
10252 {
10253 return ins;
10254 }
10255 #[cfg(
10256 all(
10257 feature = "thumb",
10258 any(
10259 feature = "v5t",
10260 feature = "v5te",
10261 feature = "v5tej",
10262 feature = "v6",
10263 feature = "v6k"
10264 )
10265 )
10266 )]
10267 if (ins & 0xd000f800) == 0xc000f000
10268 && let Some(ins) = parse_thumb_blx_0(ins, pc, options)
10269 {
10270 return ins;
10271 }
10272 }
10273 _ => unreachable!(),
10274 }
10275 (Ins::Illegal, 2)
10276}
10277#[cfg(feature = "arm")]
10278pub fn parse_arm_with_discriminant(
10279 ins: u32,
10280 discriminant: u16,
10281 pc: u32,
10282 options: &Options,
10283) -> Ins {
10284 match discriminant {
10285 0 => {
10286 #[cfg(feature = "arm")]
10287 if let Some(ins) = parse_arm_adc_0(ins, pc, options) {
10288 return ins;
10289 }
10290 }
10291 1 => {
10292 #[cfg(feature = "arm")]
10293 if let Some(ins) = parse_arm_add_0(ins, pc, options) {
10294 return ins;
10295 }
10296 }
10297 2 => {
10298 #[cfg(feature = "arm")]
10299 if let Some(ins) = parse_arm_and_0(ins, pc, options) {
10300 return ins;
10301 }
10302 }
10303 3 => {
10304 #[cfg(feature = "arm")]
10305 if let Some(ins) = parse_arm_asr_0(ins, pc, options) {
10306 return ins;
10307 }
10308 }
10309 4 => {
10310 #[cfg(feature = "arm")]
10311 if let Some(ins) = parse_arm_b_0(ins, pc, options) {
10312 return ins;
10313 }
10314 }
10315 5 => {
10316 #[cfg(feature = "arm")]
10317 if let Some(ins) = parse_arm_bic_0(ins, pc, options) {
10318 return ins;
10319 }
10320 }
10321 #[cfg(
10322 any(
10323 feature = "v5t",
10324 feature = "v5te",
10325 feature = "v5tej",
10326 feature = "v6",
10327 feature = "v6k"
10328 )
10329 )]
10330 6 => {
10331 #[cfg(
10332 all(
10333 feature = "arm",
10334 any(
10335 feature = "v5t",
10336 feature = "v5te",
10337 feature = "v5tej",
10338 feature = "v6",
10339 feature = "v6k"
10340 )
10341 )
10342 )]
10343 if let Some(ins) = parse_arm_bkpt_0(ins, pc, options) {
10344 return ins;
10345 }
10346 }
10347 7 => {
10348 #[cfg(feature = "arm")]
10349 if let Some(ins) = parse_arm_bl_0(ins, pc, options) {
10350 return ins;
10351 }
10352 }
10353 #[cfg(
10354 any(
10355 feature = "v5t",
10356 feature = "v5te",
10357 feature = "v5tej",
10358 feature = "v6",
10359 feature = "v6k"
10360 )
10361 )]
10362 8 => {
10363 #[cfg(
10364 all(
10365 feature = "arm",
10366 any(
10367 feature = "v5t",
10368 feature = "v5te",
10369 feature = "v5tej",
10370 feature = "v6",
10371 feature = "v6k"
10372 )
10373 )
10374 )]
10375 if (ins & 0xff000f0) == 0x1200030
10376 && let Some(ins) = parse_arm_blx_1(ins, pc, options)
10377 {
10378 return ins;
10379 }
10380 #[cfg(
10381 all(
10382 feature = "arm",
10383 any(
10384 feature = "v5t",
10385 feature = "v5te",
10386 feature = "v5tej",
10387 feature = "v6",
10388 feature = "v6k"
10389 )
10390 )
10391 )]
10392 if (ins & 0xfe000000) == 0xfa000000
10393 && let Some(ins) = parse_arm_blx_0(ins, pc, options)
10394 {
10395 return ins;
10396 }
10397 }
10398 #[cfg(
10399 any(
10400 feature = "v4t",
10401 feature = "v5t",
10402 feature = "v5te",
10403 feature = "v5tej",
10404 feature = "v6",
10405 feature = "v6k"
10406 )
10407 )]
10408 9 => {
10409 #[cfg(
10410 all(
10411 feature = "arm",
10412 any(
10413 feature = "v4t",
10414 feature = "v5t",
10415 feature = "v5te",
10416 feature = "v5tej",
10417 feature = "v6",
10418 feature = "v6k"
10419 )
10420 )
10421 )]
10422 if let Some(ins) = parse_arm_bx_0(ins, pc, options) {
10423 return ins;
10424 }
10425 }
10426 #[cfg(
10427 all(feature = "arm", any(feature = "v5tej", feature = "v6", feature = "v6k"))
10428 )]
10429 10 => {
10430 #[cfg(
10431 all(
10432 feature = "arm",
10433 any(feature = "v5tej", feature = "v6", feature = "v6k")
10434 )
10435 )]
10436 if let Some(ins) = parse_arm_bxj_0(ins, pc, options) {
10437 return ins;
10438 }
10439 }
10440 #[cfg(feature = "arm")]
10441 11 => {
10442 #[cfg(feature = "arm")]
10443 if let Some(ins) = parse_arm_cdp_0(ins, pc, options) {
10444 return ins;
10445 }
10446 }
10447 #[cfg(
10448 all(
10449 feature = "arm",
10450 any(
10451 feature = "v5t",
10452 feature = "v5te",
10453 feature = "v5tej",
10454 feature = "v6",
10455 feature = "v6k"
10456 )
10457 )
10458 )]
10459 12 => {
10460 #[cfg(
10461 all(
10462 feature = "arm",
10463 any(
10464 feature = "v5t",
10465 feature = "v5te",
10466 feature = "v5tej",
10467 feature = "v6",
10468 feature = "v6k"
10469 )
10470 )
10471 )]
10472 if let Some(ins) = parse_arm_cdp2_0(ins, pc, options) {
10473 return ins;
10474 }
10475 }
10476 #[cfg(all(feature = "arm", feature = "v6k"))]
10477 13 => {
10478 #[cfg(all(feature = "arm", feature = "v6k"))]
10479 if let Some(ins) = parse_arm_clrex_0(ins, pc, options) {
10480 return ins;
10481 }
10482 }
10483 #[cfg(
10484 all(
10485 feature = "arm",
10486 any(
10487 feature = "v5t",
10488 feature = "v5te",
10489 feature = "v5tej",
10490 feature = "v6",
10491 feature = "v6k"
10492 )
10493 )
10494 )]
10495 14 => {
10496 #[cfg(
10497 all(
10498 feature = "arm",
10499 any(
10500 feature = "v5t",
10501 feature = "v5te",
10502 feature = "v5tej",
10503 feature = "v6",
10504 feature = "v6k"
10505 )
10506 )
10507 )]
10508 if let Some(ins) = parse_arm_clz_0(ins, pc, options) {
10509 return ins;
10510 }
10511 }
10512 15 => {
10513 #[cfg(feature = "arm")]
10514 if let Some(ins) = parse_arm_cmn_0(ins, pc, options) {
10515 return ins;
10516 }
10517 }
10518 16 => {
10519 #[cfg(feature = "arm")]
10520 if let Some(ins) = parse_arm_cmp_0(ins, pc, options) {
10521 return ins;
10522 }
10523 }
10524 #[cfg(any(feature = "v6", feature = "v6k"))]
10525 17 => {
10526 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
10527 if let Some(ins) = parse_arm_cps_0(ins, pc, options) {
10528 return ins;
10529 }
10530 }
10531 #[cfg(feature = "arm")]
10532 18 => {
10533 #[cfg(feature = "arm")]
10534 if let Some(ins) = parse_arm_csdb_0(ins, pc, options) {
10535 return ins;
10536 }
10537 }
10538 #[cfg(all(feature = "arm", feature = "v6k"))]
10539 19 => {
10540 #[cfg(all(feature = "arm", feature = "v6k"))]
10541 if let Some(ins) = parse_arm_dbg_0(ins, pc, options) {
10542 return ins;
10543 }
10544 }
10545 20 => {
10546 #[cfg(feature = "arm")]
10547 if let Some(ins) = parse_arm_eor_0(ins, pc, options) {
10548 return ins;
10549 }
10550 }
10551 #[cfg(feature = "arm")]
10552 21 => {
10553 #[cfg(feature = "arm")]
10554 if let Some(ins) = parse_arm_ldc_0(ins, pc, options) {
10555 return ins;
10556 }
10557 }
10558 #[cfg(
10559 all(
10560 feature = "arm",
10561 any(
10562 feature = "v5t",
10563 feature = "v5te",
10564 feature = "v5tej",
10565 feature = "v6",
10566 feature = "v6k"
10567 )
10568 )
10569 )]
10570 22 => {
10571 #[cfg(
10572 all(
10573 feature = "arm",
10574 any(
10575 feature = "v5t",
10576 feature = "v5te",
10577 feature = "v5tej",
10578 feature = "v6",
10579 feature = "v6k"
10580 )
10581 )
10582 )]
10583 if let Some(ins) = parse_arm_ldc2_0(ins, pc, options) {
10584 return ins;
10585 }
10586 }
10587 23 => {
10588 #[cfg(feature = "arm")]
10589 if (ins & 0xe708000) == 0x8500000
10590 && let Some(ins) = parse_arm_ldm_1(ins, pc, options)
10591 {
10592 return ins;
10593 }
10594 #[cfg(feature = "arm")]
10595 if (ins & 0xe508000) == 0x8508000
10596 && let Some(ins) = parse_arm_ldm_2(ins, pc, options)
10597 {
10598 return ins;
10599 }
10600 #[cfg(feature = "arm")]
10601 if (ins & 0xe500000) == 0x8100000
10602 && let Some(ins) = parse_arm_ldm_0(ins, pc, options)
10603 {
10604 return ins;
10605 }
10606 }
10607 24 => {
10608 #[cfg(feature = "arm")]
10609 if let Some(ins) = parse_arm_ldr_0(ins, pc, options) {
10610 return ins;
10611 }
10612 }
10613 25 => {
10614 #[cfg(feature = "arm")]
10615 if let Some(ins) = parse_arm_ldrb_0(ins, pc, options) {
10616 return ins;
10617 }
10618 }
10619 #[cfg(feature = "arm")]
10620 26 => {
10621 #[cfg(feature = "arm")]
10622 if let Some(ins) = parse_arm_ldrbt_0(ins, pc, options) {
10623 return ins;
10624 }
10625 }
10626 #[cfg(
10627 all(
10628 feature = "arm",
10629 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
10630 )
10631 )]
10632 27 => {
10633 #[cfg(
10634 all(
10635 feature = "arm",
10636 any(
10637 feature = "v5te",
10638 feature = "v5tej",
10639 feature = "v6",
10640 feature = "v6k"
10641 )
10642 )
10643 )]
10644 if (ins & 0xe5f00f0) == 0x4f00d0
10645 && let Some(ins) = parse_arm_ldrd_1(ins, pc, options)
10646 {
10647 return ins;
10648 }
10649 #[cfg(
10650 all(
10651 feature = "arm",
10652 any(
10653 feature = "v5te",
10654 feature = "v5tej",
10655 feature = "v6",
10656 feature = "v6k"
10657 )
10658 )
10659 )]
10660 if (ins & 0xe1000f0) == 0xd0
10661 && let Some(ins) = parse_arm_ldrd_0(ins, pc, options)
10662 {
10663 return ins;
10664 }
10665 }
10666 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
10667 28 => {
10668 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
10669 if let Some(ins) = parse_arm_ldrex_0(ins, pc, options) {
10670 return ins;
10671 }
10672 }
10673 #[cfg(all(feature = "arm", feature = "v6k"))]
10674 29 => {
10675 #[cfg(all(feature = "arm", feature = "v6k"))]
10676 if let Some(ins) = parse_arm_ldrexb_0(ins, pc, options) {
10677 return ins;
10678 }
10679 }
10680 #[cfg(all(feature = "arm", feature = "v6k"))]
10681 30 => {
10682 #[cfg(all(feature = "arm", feature = "v6k"))]
10683 if let Some(ins) = parse_arm_ldrexd_0(ins, pc, options) {
10684 return ins;
10685 }
10686 }
10687 #[cfg(all(feature = "arm", feature = "v6k"))]
10688 31 => {
10689 #[cfg(all(feature = "arm", feature = "v6k"))]
10690 if let Some(ins) = parse_arm_ldrexh_0(ins, pc, options) {
10691 return ins;
10692 }
10693 }
10694 32 => {
10695 #[cfg(feature = "arm")]
10696 if let Some(ins) = parse_arm_ldrh_0(ins, pc, options) {
10697 return ins;
10698 }
10699 }
10700 33 => {
10701 #[cfg(feature = "arm")]
10702 if let Some(ins) = parse_arm_ldrsb_0(ins, pc, options) {
10703 return ins;
10704 }
10705 }
10706 34 => {
10707 #[cfg(feature = "arm")]
10708 if let Some(ins) = parse_arm_ldrsh_0(ins, pc, options) {
10709 return ins;
10710 }
10711 }
10712 #[cfg(feature = "arm")]
10713 35 => {
10714 #[cfg(feature = "arm")]
10715 if let Some(ins) = parse_arm_ldrt_0(ins, pc, options) {
10716 return ins;
10717 }
10718 }
10719 36 => {
10720 #[cfg(feature = "arm")]
10721 if let Some(ins) = parse_arm_lsl_0(ins, pc, options) {
10722 return ins;
10723 }
10724 }
10725 37 => {
10726 #[cfg(feature = "arm")]
10727 if let Some(ins) = parse_arm_lsr_0(ins, pc, options) {
10728 return ins;
10729 }
10730 }
10731 #[cfg(feature = "arm")]
10732 38 => {
10733 #[cfg(feature = "arm")]
10734 if let Some(ins) = parse_arm_mcr_0(ins, pc, options) {
10735 return ins;
10736 }
10737 }
10738 #[cfg(
10739 all(
10740 feature = "arm",
10741 any(
10742 feature = "v5t",
10743 feature = "v5te",
10744 feature = "v5tej",
10745 feature = "v6",
10746 feature = "v6k"
10747 )
10748 )
10749 )]
10750 39 => {
10751 #[cfg(
10752 all(
10753 feature = "arm",
10754 any(
10755 feature = "v5t",
10756 feature = "v5te",
10757 feature = "v5tej",
10758 feature = "v6",
10759 feature = "v6k"
10760 )
10761 )
10762 )]
10763 if let Some(ins) = parse_arm_mcr2_0(ins, pc, options) {
10764 return ins;
10765 }
10766 }
10767 #[cfg(
10768 all(
10769 feature = "arm",
10770 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
10771 )
10772 )]
10773 40 => {
10774 #[cfg(
10775 all(
10776 feature = "arm",
10777 any(
10778 feature = "v5te",
10779 feature = "v5tej",
10780 feature = "v6",
10781 feature = "v6k"
10782 )
10783 )
10784 )]
10785 if let Some(ins) = parse_arm_mcrr_0(ins, pc, options) {
10786 return ins;
10787 }
10788 }
10789 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
10790 41 => {
10791 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
10792 if let Some(ins) = parse_arm_mcrr2_0(ins, pc, options) {
10793 return ins;
10794 }
10795 }
10796 #[cfg(feature = "arm")]
10797 42 => {
10798 #[cfg(feature = "arm")]
10799 if let Some(ins) = parse_arm_mla_0(ins, pc, options) {
10800 return ins;
10801 }
10802 }
10803 43 => {
10804 #[cfg(feature = "arm")]
10805 if (ins & 0xfe00ff0) == 0x1a00000
10806 && let Some(ins) = parse_arm_mov_1(ins, pc, options)
10807 {
10808 return ins;
10809 }
10810 #[cfg(feature = "arm")]
10811 if (ins & 0xfe00000) == 0x3a00000
10812 && let Some(ins) = parse_arm_mov_0(ins, pc, options)
10813 {
10814 return ins;
10815 }
10816 #[cfg(feature = "arm")]
10817 if (ins & 0xde00000) == 0x1a00000
10818 && let Some(ins) = parse_arm_mov_2(ins, pc, options)
10819 {
10820 return ins;
10821 }
10822 }
10823 #[cfg(feature = "arm")]
10824 44 => {
10825 #[cfg(feature = "arm")]
10826 if let Some(ins) = parse_arm_mrc_0(ins, pc, options) {
10827 return ins;
10828 }
10829 }
10830 #[cfg(
10831 all(
10832 feature = "arm",
10833 any(
10834 feature = "v5t",
10835 feature = "v5te",
10836 feature = "v5tej",
10837 feature = "v6",
10838 feature = "v6k"
10839 )
10840 )
10841 )]
10842 45 => {
10843 #[cfg(
10844 all(
10845 feature = "arm",
10846 any(
10847 feature = "v5t",
10848 feature = "v5te",
10849 feature = "v5tej",
10850 feature = "v6",
10851 feature = "v6k"
10852 )
10853 )
10854 )]
10855 if let Some(ins) = parse_arm_mrc2_0(ins, pc, options) {
10856 return ins;
10857 }
10858 }
10859 #[cfg(
10860 all(
10861 feature = "arm",
10862 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
10863 )
10864 )]
10865 46 => {
10866 #[cfg(
10867 all(
10868 feature = "arm",
10869 any(
10870 feature = "v5te",
10871 feature = "v5tej",
10872 feature = "v6",
10873 feature = "v6k"
10874 )
10875 )
10876 )]
10877 if let Some(ins) = parse_arm_mrrc_0(ins, pc, options) {
10878 return ins;
10879 }
10880 }
10881 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
10882 47 => {
10883 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
10884 if let Some(ins) = parse_arm_mrrc2_0(ins, pc, options) {
10885 return ins;
10886 }
10887 }
10888 #[cfg(feature = "arm")]
10889 48 => {
10890 #[cfg(feature = "arm")]
10891 if let Some(ins) = parse_arm_mrs_0(ins, pc, options) {
10892 return ins;
10893 }
10894 }
10895 #[cfg(feature = "arm")]
10896 49 => {
10897 #[cfg(feature = "arm")]
10898 if let Some(ins) = parse_arm_msr_0(ins, pc, options) {
10899 return ins;
10900 }
10901 }
10902 50 => {
10903 #[cfg(feature = "arm")]
10904 if let Some(ins) = parse_arm_mul_0(ins, pc, options) {
10905 return ins;
10906 }
10907 }
10908 51 => {
10909 #[cfg(feature = "arm")]
10910 if let Some(ins) = parse_arm_mvn_0(ins, pc, options) {
10911 return ins;
10912 }
10913 }
10914 #[cfg(all(feature = "arm", feature = "v6k"))]
10915 53 => {
10916 #[cfg(all(feature = "arm", feature = "v6k"))]
10917 if let Some(ins) = parse_arm_nop_0(ins, pc, options) {
10918 return ins;
10919 }
10920 }
10921 54 => {
10922 #[cfg(feature = "arm")]
10923 if let Some(ins) = parse_arm_orr_0(ins, pc, options) {
10924 return ins;
10925 }
10926 }
10927 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
10928 55 => {
10929 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
10930 if let Some(ins) = parse_arm_pkhbt_0(ins, pc, options) {
10931 return ins;
10932 }
10933 }
10934 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
10935 56 => {
10936 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
10937 if let Some(ins) = parse_arm_pkhtb_0(ins, pc, options) {
10938 return ins;
10939 }
10940 }
10941 #[cfg(
10942 all(
10943 feature = "arm",
10944 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
10945 )
10946 )]
10947 57 => {
10948 #[cfg(
10949 all(
10950 feature = "arm",
10951 any(
10952 feature = "v5te",
10953 feature = "v5tej",
10954 feature = "v6",
10955 feature = "v6k"
10956 )
10957 )
10958 )]
10959 if let Some(ins) = parse_arm_pld_0(ins, pc, options) {
10960 return ins;
10961 }
10962 }
10963 58 => {
10964 #[cfg(feature = "arm")]
10965 if (ins & 0xfff0fff) == 0x49d0004
10966 && let Some(ins) = parse_arm_pop_1(ins, pc, options)
10967 {
10968 return ins;
10969 }
10970 #[cfg(feature = "arm")]
10971 if (ins & 0xfff0000) == 0x8bd0000
10972 && let Some(ins) = parse_arm_pop_0(ins, pc, options)
10973 {
10974 return ins;
10975 }
10976 }
10977 59 => {
10978 #[cfg(feature = "arm")]
10979 if (ins & 0xfff0fff) == 0x52d0004
10980 && let Some(ins) = parse_arm_push_1(ins, pc, options)
10981 {
10982 return ins;
10983 }
10984 #[cfg(feature = "arm")]
10985 if (ins & 0xfff0000) == 0x92d0000
10986 && let Some(ins) = parse_arm_push_0(ins, pc, options)
10987 {
10988 return ins;
10989 }
10990 }
10991 #[cfg(
10992 all(
10993 feature = "arm",
10994 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
10995 )
10996 )]
10997 60 => {
10998 #[cfg(
10999 all(
11000 feature = "arm",
11001 any(
11002 feature = "v5te",
11003 feature = "v5tej",
11004 feature = "v6",
11005 feature = "v6k"
11006 )
11007 )
11008 )]
11009 if let Some(ins) = parse_arm_qadd_0(ins, pc, options) {
11010 return ins;
11011 }
11012 }
11013 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11014 61 => {
11015 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11016 if let Some(ins) = parse_arm_qadd16_0(ins, pc, options) {
11017 return ins;
11018 }
11019 }
11020 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11021 62 => {
11022 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11023 if let Some(ins) = parse_arm_qadd8_0(ins, pc, options) {
11024 return ins;
11025 }
11026 }
11027 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11028 63 => {
11029 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11030 if let Some(ins) = parse_arm_qasx_0(ins, pc, options) {
11031 return ins;
11032 }
11033 }
11034 #[cfg(
11035 all(
11036 feature = "arm",
11037 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
11038 )
11039 )]
11040 64 => {
11041 #[cfg(
11042 all(
11043 feature = "arm",
11044 any(
11045 feature = "v5te",
11046 feature = "v5tej",
11047 feature = "v6",
11048 feature = "v6k"
11049 )
11050 )
11051 )]
11052 if let Some(ins) = parse_arm_qdadd_0(ins, pc, options) {
11053 return ins;
11054 }
11055 }
11056 #[cfg(
11057 all(
11058 feature = "arm",
11059 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
11060 )
11061 )]
11062 65 => {
11063 #[cfg(
11064 all(
11065 feature = "arm",
11066 any(
11067 feature = "v5te",
11068 feature = "v5tej",
11069 feature = "v6",
11070 feature = "v6k"
11071 )
11072 )
11073 )]
11074 if let Some(ins) = parse_arm_qdsub_0(ins, pc, options) {
11075 return ins;
11076 }
11077 }
11078 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11079 66 => {
11080 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11081 if let Some(ins) = parse_arm_qsax_0(ins, pc, options) {
11082 return ins;
11083 }
11084 }
11085 #[cfg(
11086 all(
11087 feature = "arm",
11088 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
11089 )
11090 )]
11091 67 => {
11092 #[cfg(
11093 all(
11094 feature = "arm",
11095 any(
11096 feature = "v5te",
11097 feature = "v5tej",
11098 feature = "v6",
11099 feature = "v6k"
11100 )
11101 )
11102 )]
11103 if let Some(ins) = parse_arm_qsub_0(ins, pc, options) {
11104 return ins;
11105 }
11106 }
11107 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11108 68 => {
11109 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11110 if let Some(ins) = parse_arm_qsub16_0(ins, pc, options) {
11111 return ins;
11112 }
11113 }
11114 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11115 69 => {
11116 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11117 if let Some(ins) = parse_arm_qsub8_0(ins, pc, options) {
11118 return ins;
11119 }
11120 }
11121 #[cfg(any(feature = "v6", feature = "v6k"))]
11122 70 => {
11123 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11124 if let Some(ins) = parse_arm_rev_0(ins, pc, options) {
11125 return ins;
11126 }
11127 }
11128 #[cfg(any(feature = "v6", feature = "v6k"))]
11129 71 => {
11130 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11131 if let Some(ins) = parse_arm_rev16_0(ins, pc, options) {
11132 return ins;
11133 }
11134 }
11135 #[cfg(any(feature = "v6", feature = "v6k"))]
11136 72 => {
11137 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11138 if let Some(ins) = parse_arm_revsh_0(ins, pc, options) {
11139 return ins;
11140 }
11141 }
11142 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11143 73 => {
11144 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11145 if let Some(ins) = parse_arm_rfe_0(ins, pc, options) {
11146 return ins;
11147 }
11148 }
11149 74 => {
11150 #[cfg(feature = "arm")]
11151 if let Some(ins) = parse_arm_ror_0(ins, pc, options) {
11152 return ins;
11153 }
11154 }
11155 #[cfg(feature = "arm")]
11156 75 => {
11157 #[cfg(feature = "arm")]
11158 if let Some(ins) = parse_arm_rrx_0(ins, pc, options) {
11159 return ins;
11160 }
11161 }
11162 76 => {
11163 #[cfg(feature = "arm")]
11164 if let Some(ins) = parse_arm_rsb_0(ins, pc, options) {
11165 return ins;
11166 }
11167 }
11168 #[cfg(feature = "arm")]
11169 77 => {
11170 #[cfg(feature = "arm")]
11171 if let Some(ins) = parse_arm_rsc_0(ins, pc, options) {
11172 return ins;
11173 }
11174 }
11175 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11176 78 => {
11177 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11178 if let Some(ins) = parse_arm_sadd16_0(ins, pc, options) {
11179 return ins;
11180 }
11181 }
11182 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11183 79 => {
11184 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11185 if let Some(ins) = parse_arm_sadd8_0(ins, pc, options) {
11186 return ins;
11187 }
11188 }
11189 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11190 80 => {
11191 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11192 if let Some(ins) = parse_arm_sasx_0(ins, pc, options) {
11193 return ins;
11194 }
11195 }
11196 81 => {
11197 #[cfg(feature = "arm")]
11198 if let Some(ins) = parse_arm_sbc_0(ins, pc, options) {
11199 return ins;
11200 }
11201 }
11202 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11203 82 => {
11204 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11205 if let Some(ins) = parse_arm_sel_0(ins, pc, options) {
11206 return ins;
11207 }
11208 }
11209 #[cfg(any(feature = "v6", feature = "v6k"))]
11210 83 => {
11211 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11212 if let Some(ins) = parse_arm_setend_0(ins, pc, options) {
11213 return ins;
11214 }
11215 }
11216 #[cfg(all(feature = "arm", feature = "v6k"))]
11217 84 => {
11218 #[cfg(all(feature = "arm", feature = "v6k"))]
11219 if let Some(ins) = parse_arm_sev_0(ins, pc, options) {
11220 return ins;
11221 }
11222 }
11223 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11224 85 => {
11225 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11226 if let Some(ins) = parse_arm_shadd16_0(ins, pc, options) {
11227 return ins;
11228 }
11229 }
11230 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11231 86 => {
11232 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11233 if let Some(ins) = parse_arm_shadd8_0(ins, pc, options) {
11234 return ins;
11235 }
11236 }
11237 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11238 87 => {
11239 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11240 if let Some(ins) = parse_arm_shasx_0(ins, pc, options) {
11241 return ins;
11242 }
11243 }
11244 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11245 88 => {
11246 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11247 if let Some(ins) = parse_arm_shsax_0(ins, pc, options) {
11248 return ins;
11249 }
11250 }
11251 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11252 89 => {
11253 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11254 if let Some(ins) = parse_arm_shsub16_0(ins, pc, options) {
11255 return ins;
11256 }
11257 }
11258 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11259 90 => {
11260 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11261 if let Some(ins) = parse_arm_shsub8_0(ins, pc, options) {
11262 return ins;
11263 }
11264 }
11265 #[cfg(
11266 all(
11267 feature = "arm",
11268 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
11269 )
11270 )]
11271 91 => {
11272 #[cfg(
11273 all(
11274 feature = "arm",
11275 any(
11276 feature = "v5te",
11277 feature = "v5tej",
11278 feature = "v6",
11279 feature = "v6k"
11280 )
11281 )
11282 )]
11283 if let Some(ins) = parse_arm_smla_0(ins, pc, options) {
11284 return ins;
11285 }
11286 }
11287 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11288 92 => {
11289 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11290 if let Some(ins) = parse_arm_smlad_0(ins, pc, options) {
11291 return ins;
11292 }
11293 }
11294 #[cfg(feature = "arm")]
11295 93 => {
11296 #[cfg(feature = "arm")]
11297 if let Some(ins) = parse_arm_smlal_0(ins, pc, options) {
11298 return ins;
11299 }
11300 }
11301 #[cfg(
11302 all(
11303 feature = "arm",
11304 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
11305 )
11306 )]
11307 94 => {
11308 #[cfg(
11309 all(
11310 feature = "arm",
11311 any(
11312 feature = "v5te",
11313 feature = "v5tej",
11314 feature = "v6",
11315 feature = "v6k"
11316 )
11317 )
11318 )]
11319 if let Some(ins) = parse_arm_smlal_half_0(ins, pc, options) {
11320 return ins;
11321 }
11322 }
11323 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11324 95 => {
11325 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11326 if let Some(ins) = parse_arm_smlald_0(ins, pc, options) {
11327 return ins;
11328 }
11329 }
11330 #[cfg(
11331 all(
11332 feature = "arm",
11333 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
11334 )
11335 )]
11336 96 => {
11337 #[cfg(
11338 all(
11339 feature = "arm",
11340 any(
11341 feature = "v5te",
11342 feature = "v5tej",
11343 feature = "v6",
11344 feature = "v6k"
11345 )
11346 )
11347 )]
11348 if let Some(ins) = parse_arm_smlaw_0(ins, pc, options) {
11349 return ins;
11350 }
11351 }
11352 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11353 97 => {
11354 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11355 if let Some(ins) = parse_arm_smlsd_0(ins, pc, options) {
11356 return ins;
11357 }
11358 }
11359 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11360 98 => {
11361 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11362 if let Some(ins) = parse_arm_smlsld_0(ins, pc, options) {
11363 return ins;
11364 }
11365 }
11366 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11367 99 => {
11368 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11369 if let Some(ins) = parse_arm_smmla_0(ins, pc, options) {
11370 return ins;
11371 }
11372 }
11373 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11374 100 => {
11375 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11376 if let Some(ins) = parse_arm_smmls_0(ins, pc, options) {
11377 return ins;
11378 }
11379 }
11380 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11381 101 => {
11382 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11383 if let Some(ins) = parse_arm_smmul_0(ins, pc, options) {
11384 return ins;
11385 }
11386 }
11387 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11388 102 => {
11389 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11390 if let Some(ins) = parse_arm_smuad_0(ins, pc, options) {
11391 return ins;
11392 }
11393 }
11394 #[cfg(
11395 all(
11396 feature = "arm",
11397 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
11398 )
11399 )]
11400 103 => {
11401 #[cfg(
11402 all(
11403 feature = "arm",
11404 any(
11405 feature = "v5te",
11406 feature = "v5tej",
11407 feature = "v6",
11408 feature = "v6k"
11409 )
11410 )
11411 )]
11412 if let Some(ins) = parse_arm_smul_0(ins, pc, options) {
11413 return ins;
11414 }
11415 }
11416 #[cfg(feature = "arm")]
11417 104 => {
11418 #[cfg(feature = "arm")]
11419 if let Some(ins) = parse_arm_smull_0(ins, pc, options) {
11420 return ins;
11421 }
11422 }
11423 #[cfg(
11424 all(
11425 feature = "arm",
11426 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
11427 )
11428 )]
11429 105 => {
11430 #[cfg(
11431 all(
11432 feature = "arm",
11433 any(
11434 feature = "v5te",
11435 feature = "v5tej",
11436 feature = "v6",
11437 feature = "v6k"
11438 )
11439 )
11440 )]
11441 if let Some(ins) = parse_arm_smulw_0(ins, pc, options) {
11442 return ins;
11443 }
11444 }
11445 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11446 106 => {
11447 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11448 if let Some(ins) = parse_arm_smusd_0(ins, pc, options) {
11449 return ins;
11450 }
11451 }
11452 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11453 107 => {
11454 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11455 if let Some(ins) = parse_arm_srs_0(ins, pc, options) {
11456 return ins;
11457 }
11458 }
11459 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11460 108 => {
11461 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11462 if let Some(ins) = parse_arm_ssat_0(ins, pc, options) {
11463 return ins;
11464 }
11465 }
11466 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11467 109 => {
11468 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11469 if let Some(ins) = parse_arm_ssat16_0(ins, pc, options) {
11470 return ins;
11471 }
11472 }
11473 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11474 110 => {
11475 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11476 if let Some(ins) = parse_arm_ssax_0(ins, pc, options) {
11477 return ins;
11478 }
11479 }
11480 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11481 111 => {
11482 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11483 if let Some(ins) = parse_arm_ssub16_0(ins, pc, options) {
11484 return ins;
11485 }
11486 }
11487 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11488 112 => {
11489 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11490 if let Some(ins) = parse_arm_ssub8_0(ins, pc, options) {
11491 return ins;
11492 }
11493 }
11494 #[cfg(feature = "arm")]
11495 113 => {
11496 #[cfg(feature = "arm")]
11497 if let Some(ins) = parse_arm_stc_0(ins, pc, options) {
11498 return ins;
11499 }
11500 }
11501 #[cfg(
11502 all(
11503 feature = "arm",
11504 any(
11505 feature = "v5t",
11506 feature = "v5te",
11507 feature = "v5tej",
11508 feature = "v6",
11509 feature = "v6k"
11510 )
11511 )
11512 )]
11513 114 => {
11514 #[cfg(
11515 all(
11516 feature = "arm",
11517 any(
11518 feature = "v5t",
11519 feature = "v5te",
11520 feature = "v5tej",
11521 feature = "v6",
11522 feature = "v6k"
11523 )
11524 )
11525 )]
11526 if let Some(ins) = parse_arm_stc2_0(ins, pc, options) {
11527 return ins;
11528 }
11529 }
11530 115 => {
11531 #[cfg(feature = "arm")]
11532 if let Some(ins) = parse_arm_stm_0(ins, pc, options) {
11533 return ins;
11534 }
11535 }
11536 116 => {
11537 #[cfg(feature = "arm")]
11538 if let Some(ins) = parse_arm_str_0(ins, pc, options) {
11539 return ins;
11540 }
11541 }
11542 117 => {
11543 #[cfg(feature = "arm")]
11544 if let Some(ins) = parse_arm_strb_0(ins, pc, options) {
11545 return ins;
11546 }
11547 }
11548 #[cfg(feature = "arm")]
11549 118 => {
11550 #[cfg(feature = "arm")]
11551 if let Some(ins) = parse_arm_strbt_0(ins, pc, options) {
11552 return ins;
11553 }
11554 }
11555 #[cfg(
11556 all(
11557 feature = "arm",
11558 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
11559 )
11560 )]
11561 119 => {
11562 #[cfg(
11563 all(
11564 feature = "arm",
11565 any(
11566 feature = "v5te",
11567 feature = "v5tej",
11568 feature = "v6",
11569 feature = "v6k"
11570 )
11571 )
11572 )]
11573 if let Some(ins) = parse_arm_strd_0(ins, pc, options) {
11574 return ins;
11575 }
11576 }
11577 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11578 120 => {
11579 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11580 if let Some(ins) = parse_arm_strex_0(ins, pc, options) {
11581 return ins;
11582 }
11583 }
11584 #[cfg(all(feature = "arm", feature = "v6k"))]
11585 121 => {
11586 #[cfg(all(feature = "arm", feature = "v6k"))]
11587 if let Some(ins) = parse_arm_strexb_0(ins, pc, options) {
11588 return ins;
11589 }
11590 }
11591 #[cfg(all(feature = "arm", feature = "v6k"))]
11592 122 => {
11593 #[cfg(all(feature = "arm", feature = "v6k"))]
11594 if let Some(ins) = parse_arm_strexd_0(ins, pc, options) {
11595 return ins;
11596 }
11597 }
11598 #[cfg(all(feature = "arm", feature = "v6k"))]
11599 123 => {
11600 #[cfg(all(feature = "arm", feature = "v6k"))]
11601 if let Some(ins) = parse_arm_strexh_0(ins, pc, options) {
11602 return ins;
11603 }
11604 }
11605 124 => {
11606 #[cfg(feature = "arm")]
11607 if let Some(ins) = parse_arm_strh_0(ins, pc, options) {
11608 return ins;
11609 }
11610 }
11611 #[cfg(feature = "arm")]
11612 125 => {
11613 #[cfg(feature = "arm")]
11614 if let Some(ins) = parse_arm_strt_0(ins, pc, options) {
11615 return ins;
11616 }
11617 }
11618 126 => {
11619 #[cfg(feature = "arm")]
11620 if let Some(ins) = parse_arm_sub_0(ins, pc, options) {
11621 return ins;
11622 }
11623 }
11624 127 => {
11625 #[cfg(feature = "arm")]
11626 if let Some(ins) = parse_arm_svc_0(ins, pc, options) {
11627 return ins;
11628 }
11629 }
11630 #[cfg(feature = "arm")]
11631 128 => {
11632 #[cfg(feature = "arm")]
11633 if let Some(ins) = parse_arm_swp_0(ins, pc, options) {
11634 return ins;
11635 }
11636 }
11637 #[cfg(feature = "arm")]
11638 129 => {
11639 #[cfg(feature = "arm")]
11640 if let Some(ins) = parse_arm_swpb_0(ins, pc, options) {
11641 return ins;
11642 }
11643 }
11644 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11645 130 => {
11646 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11647 if let Some(ins) = parse_arm_sxtab_0(ins, pc, options) {
11648 return ins;
11649 }
11650 }
11651 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11652 131 => {
11653 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11654 if let Some(ins) = parse_arm_sxtab16_0(ins, pc, options) {
11655 return ins;
11656 }
11657 }
11658 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11659 132 => {
11660 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11661 if let Some(ins) = parse_arm_sxtah_0(ins, pc, options) {
11662 return ins;
11663 }
11664 }
11665 #[cfg(any(feature = "v6", feature = "v6k"))]
11666 133 => {
11667 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11668 if let Some(ins) = parse_arm_sxtb_0(ins, pc, options) {
11669 return ins;
11670 }
11671 }
11672 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11673 134 => {
11674 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11675 if let Some(ins) = parse_arm_sxtb16_0(ins, pc, options) {
11676 return ins;
11677 }
11678 }
11679 #[cfg(any(feature = "v6", feature = "v6k"))]
11680 135 => {
11681 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11682 if let Some(ins) = parse_arm_sxth_0(ins, pc, options) {
11683 return ins;
11684 }
11685 }
11686 #[cfg(feature = "arm")]
11687 136 => {
11688 #[cfg(feature = "arm")]
11689 if let Some(ins) = parse_arm_teq_0(ins, pc, options) {
11690 return ins;
11691 }
11692 }
11693 137 => {
11694 #[cfg(feature = "arm")]
11695 if let Some(ins) = parse_arm_tst_0(ins, pc, options) {
11696 return ins;
11697 }
11698 }
11699 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11700 138 => {
11701 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11702 if let Some(ins) = parse_arm_uadd16_0(ins, pc, options) {
11703 return ins;
11704 }
11705 }
11706 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11707 139 => {
11708 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11709 if let Some(ins) = parse_arm_uadd8_0(ins, pc, options) {
11710 return ins;
11711 }
11712 }
11713 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11714 140 => {
11715 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11716 if let Some(ins) = parse_arm_uasx_0(ins, pc, options) {
11717 return ins;
11718 }
11719 }
11720 #[cfg(
11721 any(
11722 feature = "v4t",
11723 feature = "v5t",
11724 feature = "v5te",
11725 feature = "v5tej",
11726 feature = "v6",
11727 feature = "v6k"
11728 )
11729 )]
11730 141 => {
11731 #[cfg(
11732 all(
11733 feature = "arm",
11734 any(
11735 feature = "v4t",
11736 feature = "v5t",
11737 feature = "v5te",
11738 feature = "v5tej",
11739 feature = "v6",
11740 feature = "v6k"
11741 )
11742 )
11743 )]
11744 if let Some(ins) = parse_arm_udf_0(ins, pc, options) {
11745 return ins;
11746 }
11747 }
11748 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11749 142 => {
11750 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11751 if let Some(ins) = parse_arm_uhadd16_0(ins, pc, options) {
11752 return ins;
11753 }
11754 }
11755 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11756 143 => {
11757 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11758 if let Some(ins) = parse_arm_uhadd8_0(ins, pc, options) {
11759 return ins;
11760 }
11761 }
11762 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11763 144 => {
11764 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11765 if let Some(ins) = parse_arm_uhasx_0(ins, pc, options) {
11766 return ins;
11767 }
11768 }
11769 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11770 145 => {
11771 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11772 if let Some(ins) = parse_arm_uhsax_0(ins, pc, options) {
11773 return ins;
11774 }
11775 }
11776 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11777 146 => {
11778 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11779 if let Some(ins) = parse_arm_uhsub16_0(ins, pc, options) {
11780 return ins;
11781 }
11782 }
11783 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11784 147 => {
11785 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11786 if let Some(ins) = parse_arm_uhsub8_0(ins, pc, options) {
11787 return ins;
11788 }
11789 }
11790 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11791 148 => {
11792 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11793 if let Some(ins) = parse_arm_umaal_0(ins, pc, options) {
11794 return ins;
11795 }
11796 }
11797 #[cfg(feature = "arm")]
11798 149 => {
11799 #[cfg(feature = "arm")]
11800 if let Some(ins) = parse_arm_umlal_0(ins, pc, options) {
11801 return ins;
11802 }
11803 }
11804 #[cfg(feature = "arm")]
11805 150 => {
11806 #[cfg(feature = "arm")]
11807 if let Some(ins) = parse_arm_umull_0(ins, pc, options) {
11808 return ins;
11809 }
11810 }
11811 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11812 151 => {
11813 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11814 if let Some(ins) = parse_arm_uqadd16_0(ins, pc, options) {
11815 return ins;
11816 }
11817 }
11818 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11819 152 => {
11820 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11821 if let Some(ins) = parse_arm_uqadd8_0(ins, pc, options) {
11822 return ins;
11823 }
11824 }
11825 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11826 153 => {
11827 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11828 if let Some(ins) = parse_arm_uqasx_0(ins, pc, options) {
11829 return ins;
11830 }
11831 }
11832 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11833 154 => {
11834 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11835 if let Some(ins) = parse_arm_uqsax_0(ins, pc, options) {
11836 return ins;
11837 }
11838 }
11839 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11840 155 => {
11841 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11842 if let Some(ins) = parse_arm_uqsub16_0(ins, pc, options) {
11843 return ins;
11844 }
11845 }
11846 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11847 156 => {
11848 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11849 if let Some(ins) = parse_arm_uqsub8_0(ins, pc, options) {
11850 return ins;
11851 }
11852 }
11853 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11854 157 => {
11855 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11856 if let Some(ins) = parse_arm_usad8_0(ins, pc, options) {
11857 return ins;
11858 }
11859 }
11860 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11861 158 => {
11862 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11863 if let Some(ins) = parse_arm_usada8_0(ins, pc, options) {
11864 return ins;
11865 }
11866 }
11867 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11868 159 => {
11869 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11870 if let Some(ins) = parse_arm_usat_0(ins, pc, options) {
11871 return ins;
11872 }
11873 }
11874 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11875 160 => {
11876 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11877 if let Some(ins) = parse_arm_usat16_0(ins, pc, options) {
11878 return ins;
11879 }
11880 }
11881 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11882 161 => {
11883 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11884 if let Some(ins) = parse_arm_usax_0(ins, pc, options) {
11885 return ins;
11886 }
11887 }
11888 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11889 162 => {
11890 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11891 if let Some(ins) = parse_arm_usub16_0(ins, pc, options) {
11892 return ins;
11893 }
11894 }
11895 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11896 163 => {
11897 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11898 if let Some(ins) = parse_arm_usub8_0(ins, pc, options) {
11899 return ins;
11900 }
11901 }
11902 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11903 164 => {
11904 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11905 if let Some(ins) = parse_arm_uxtab_0(ins, pc, options) {
11906 return ins;
11907 }
11908 }
11909 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11910 165 => {
11911 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11912 if let Some(ins) = parse_arm_uxtab16_0(ins, pc, options) {
11913 return ins;
11914 }
11915 }
11916 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11917 166 => {
11918 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11919 if let Some(ins) = parse_arm_uxtah_0(ins, pc, options) {
11920 return ins;
11921 }
11922 }
11923 #[cfg(any(feature = "v6", feature = "v6k"))]
11924 167 => {
11925 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11926 if let Some(ins) = parse_arm_uxtb_0(ins, pc, options) {
11927 return ins;
11928 }
11929 }
11930 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11931 168 => {
11932 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11933 if let Some(ins) = parse_arm_uxtb16_0(ins, pc, options) {
11934 return ins;
11935 }
11936 }
11937 #[cfg(any(feature = "v6", feature = "v6k"))]
11938 169 => {
11939 #[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
11940 if let Some(ins) = parse_arm_uxth_0(ins, pc, options) {
11941 return ins;
11942 }
11943 }
11944 #[cfg(
11945 all(
11946 feature = "arm",
11947 feature = "vfp_v2",
11948 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
11949 )
11950 )]
11951 170 => {
11952 #[cfg(
11953 all(
11954 feature = "arm",
11955 feature = "vfp_v2",
11956 any(
11957 feature = "v5te",
11958 feature = "v5tej",
11959 feature = "v6",
11960 feature = "v6k"
11961 )
11962 )
11963 )]
11964 if let Some(ins) = parse_arm_vabs_f32_0(ins, pc, options) {
11965 return ins;
11966 }
11967 }
11968 #[cfg(
11969 all(
11970 feature = "arm",
11971 feature = "vfp_v2",
11972 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
11973 )
11974 )]
11975 171 => {
11976 #[cfg(
11977 all(
11978 feature = "arm",
11979 feature = "vfp_v2",
11980 any(
11981 feature = "v5te",
11982 feature = "v5tej",
11983 feature = "v6",
11984 feature = "v6k"
11985 )
11986 )
11987 )]
11988 if let Some(ins) = parse_arm_vabs_f64_0(ins, pc, options) {
11989 return ins;
11990 }
11991 }
11992 #[cfg(
11993 all(
11994 feature = "arm",
11995 feature = "vfp_v2",
11996 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
11997 )
11998 )]
11999 172 => {
12000 #[cfg(
12001 all(
12002 feature = "arm",
12003 feature = "vfp_v2",
12004 any(
12005 feature = "v5te",
12006 feature = "v5tej",
12007 feature = "v6",
12008 feature = "v6k"
12009 )
12010 )
12011 )]
12012 if let Some(ins) = parse_arm_vadd_f32_0(ins, pc, options) {
12013 return ins;
12014 }
12015 }
12016 #[cfg(
12017 all(
12018 feature = "arm",
12019 feature = "vfp_v2",
12020 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12021 )
12022 )]
12023 173 => {
12024 #[cfg(
12025 all(
12026 feature = "arm",
12027 feature = "vfp_v2",
12028 any(
12029 feature = "v5te",
12030 feature = "v5tej",
12031 feature = "v6",
12032 feature = "v6k"
12033 )
12034 )
12035 )]
12036 if let Some(ins) = parse_arm_vadd_f64_0(ins, pc, options) {
12037 return ins;
12038 }
12039 }
12040 #[cfg(
12041 all(
12042 feature = "arm",
12043 feature = "vfp_v2",
12044 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12045 )
12046 )]
12047 174 => {
12048 #[cfg(
12049 all(
12050 feature = "arm",
12051 feature = "vfp_v2",
12052 any(
12053 feature = "v5te",
12054 feature = "v5tej",
12055 feature = "v6",
12056 feature = "v6k"
12057 )
12058 )
12059 )]
12060 if let Some(ins) = parse_arm_vcmp_f32_0(ins, pc, options) {
12061 return ins;
12062 }
12063 }
12064 #[cfg(
12065 all(
12066 feature = "arm",
12067 feature = "vfp_v2",
12068 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12069 )
12070 )]
12071 175 => {
12072 #[cfg(
12073 all(
12074 feature = "arm",
12075 feature = "vfp_v2",
12076 any(
12077 feature = "v5te",
12078 feature = "v5tej",
12079 feature = "v6",
12080 feature = "v6k"
12081 )
12082 )
12083 )]
12084 if let Some(ins) = parse_arm_vcmp_f64_0(ins, pc, options) {
12085 return ins;
12086 }
12087 }
12088 #[cfg(
12089 all(
12090 feature = "arm",
12091 feature = "vfp_v2",
12092 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12093 )
12094 )]
12095 176 => {
12096 #[cfg(
12097 all(
12098 feature = "arm",
12099 feature = "vfp_v2",
12100 any(
12101 feature = "v5te",
12102 feature = "v5tej",
12103 feature = "v6",
12104 feature = "v6k"
12105 )
12106 )
12107 )]
12108 if let Some(ins) = parse_arm_vcvt_f32_f64_0(ins, pc, options) {
12109 return ins;
12110 }
12111 }
12112 #[cfg(
12113 all(
12114 feature = "arm",
12115 feature = "vfp_v2",
12116 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12117 )
12118 )]
12119 177 => {
12120 #[cfg(
12121 all(
12122 feature = "arm",
12123 feature = "vfp_v2",
12124 any(
12125 feature = "v5te",
12126 feature = "v5tej",
12127 feature = "v6",
12128 feature = "v6k"
12129 )
12130 )
12131 )]
12132 if let Some(ins) = parse_arm_vcvt_f32_s32_0(ins, pc, options) {
12133 return ins;
12134 }
12135 }
12136 #[cfg(
12137 all(
12138 feature = "arm",
12139 feature = "vfp_v2",
12140 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12141 )
12142 )]
12143 178 => {
12144 #[cfg(
12145 all(
12146 feature = "arm",
12147 feature = "vfp_v2",
12148 any(
12149 feature = "v5te",
12150 feature = "v5tej",
12151 feature = "v6",
12152 feature = "v6k"
12153 )
12154 )
12155 )]
12156 if let Some(ins) = parse_arm_vcvt_f32_u32_0(ins, pc, options) {
12157 return ins;
12158 }
12159 }
12160 #[cfg(
12161 all(
12162 feature = "arm",
12163 feature = "vfp_v2",
12164 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12165 )
12166 )]
12167 179 => {
12168 #[cfg(
12169 all(
12170 feature = "arm",
12171 feature = "vfp_v2",
12172 any(
12173 feature = "v5te",
12174 feature = "v5tej",
12175 feature = "v6",
12176 feature = "v6k"
12177 )
12178 )
12179 )]
12180 if let Some(ins) = parse_arm_vcvt_f64_f32_0(ins, pc, options) {
12181 return ins;
12182 }
12183 }
12184 #[cfg(
12185 all(
12186 feature = "arm",
12187 feature = "vfp_v2",
12188 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12189 )
12190 )]
12191 180 => {
12192 #[cfg(
12193 all(
12194 feature = "arm",
12195 feature = "vfp_v2",
12196 any(
12197 feature = "v5te",
12198 feature = "v5tej",
12199 feature = "v6",
12200 feature = "v6k"
12201 )
12202 )
12203 )]
12204 if let Some(ins) = parse_arm_vcvt_f64_s32_0(ins, pc, options) {
12205 return ins;
12206 }
12207 }
12208 #[cfg(
12209 all(
12210 feature = "arm",
12211 feature = "vfp_v2",
12212 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12213 )
12214 )]
12215 181 => {
12216 #[cfg(
12217 all(
12218 feature = "arm",
12219 feature = "vfp_v2",
12220 any(
12221 feature = "v5te",
12222 feature = "v5tej",
12223 feature = "v6",
12224 feature = "v6k"
12225 )
12226 )
12227 )]
12228 if let Some(ins) = parse_arm_vcvt_f64_u32_0(ins, pc, options) {
12229 return ins;
12230 }
12231 }
12232 #[cfg(
12233 all(
12234 feature = "arm",
12235 feature = "vfp_v2",
12236 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12237 )
12238 )]
12239 182 => {
12240 #[cfg(
12241 all(
12242 feature = "arm",
12243 feature = "vfp_v2",
12244 any(
12245 feature = "v5te",
12246 feature = "v5tej",
12247 feature = "v6",
12248 feature = "v6k"
12249 )
12250 )
12251 )]
12252 if let Some(ins) = parse_arm_vcvt_s32_f32_0(ins, pc, options) {
12253 return ins;
12254 }
12255 }
12256 #[cfg(
12257 all(
12258 feature = "arm",
12259 feature = "vfp_v2",
12260 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12261 )
12262 )]
12263 183 => {
12264 #[cfg(
12265 all(
12266 feature = "arm",
12267 feature = "vfp_v2",
12268 any(
12269 feature = "v5te",
12270 feature = "v5tej",
12271 feature = "v6",
12272 feature = "v6k"
12273 )
12274 )
12275 )]
12276 if let Some(ins) = parse_arm_vcvt_s32_f64_0(ins, pc, options) {
12277 return ins;
12278 }
12279 }
12280 #[cfg(
12281 all(
12282 feature = "arm",
12283 feature = "vfp_v2",
12284 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12285 )
12286 )]
12287 184 => {
12288 #[cfg(
12289 all(
12290 feature = "arm",
12291 feature = "vfp_v2",
12292 any(
12293 feature = "v5te",
12294 feature = "v5tej",
12295 feature = "v6",
12296 feature = "v6k"
12297 )
12298 )
12299 )]
12300 if let Some(ins) = parse_arm_vcvt_u32_f32_0(ins, pc, options) {
12301 return ins;
12302 }
12303 }
12304 #[cfg(
12305 all(
12306 feature = "arm",
12307 feature = "vfp_v2",
12308 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12309 )
12310 )]
12311 185 => {
12312 #[cfg(
12313 all(
12314 feature = "arm",
12315 feature = "vfp_v2",
12316 any(
12317 feature = "v5te",
12318 feature = "v5tej",
12319 feature = "v6",
12320 feature = "v6k"
12321 )
12322 )
12323 )]
12324 if let Some(ins) = parse_arm_vcvt_u32_f64_0(ins, pc, options) {
12325 return ins;
12326 }
12327 }
12328 #[cfg(
12329 all(
12330 feature = "arm",
12331 feature = "vfp_v2",
12332 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12333 )
12334 )]
12335 186 => {
12336 #[cfg(
12337 all(
12338 feature = "arm",
12339 feature = "vfp_v2",
12340 any(
12341 feature = "v5te",
12342 feature = "v5tej",
12343 feature = "v6",
12344 feature = "v6k"
12345 )
12346 )
12347 )]
12348 if let Some(ins) = parse_arm_vdiv_f32_0(ins, pc, options) {
12349 return ins;
12350 }
12351 }
12352 #[cfg(
12353 all(
12354 feature = "arm",
12355 feature = "vfp_v2",
12356 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12357 )
12358 )]
12359 187 => {
12360 #[cfg(
12361 all(
12362 feature = "arm",
12363 feature = "vfp_v2",
12364 any(
12365 feature = "v5te",
12366 feature = "v5tej",
12367 feature = "v6",
12368 feature = "v6k"
12369 )
12370 )
12371 )]
12372 if let Some(ins) = parse_arm_vdiv_f64_0(ins, pc, options) {
12373 return ins;
12374 }
12375 }
12376 #[cfg(
12377 all(
12378 feature = "arm",
12379 feature = "vfp_v2",
12380 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12381 )
12382 )]
12383 188 => {
12384 #[cfg(
12385 all(
12386 feature = "arm",
12387 feature = "vfp_v2",
12388 any(
12389 feature = "v5te",
12390 feature = "v5tej",
12391 feature = "v6",
12392 feature = "v6k"
12393 )
12394 )
12395 )]
12396 if let Some(ins) = parse_arm_vldm_f32_0(ins, pc, options) {
12397 return ins;
12398 }
12399 }
12400 #[cfg(
12401 all(
12402 feature = "arm",
12403 feature = "vfp_v2",
12404 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12405 )
12406 )]
12407 189 => {
12408 #[cfg(
12409 all(
12410 feature = "arm",
12411 feature = "vfp_v2",
12412 any(
12413 feature = "v5te",
12414 feature = "v5tej",
12415 feature = "v6",
12416 feature = "v6k"
12417 )
12418 )
12419 )]
12420 if let Some(ins) = parse_arm_vldm_f64_0(ins, pc, options) {
12421 return ins;
12422 }
12423 }
12424 #[cfg(
12425 all(
12426 feature = "arm",
12427 feature = "vfp_v2",
12428 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12429 )
12430 )]
12431 190 => {
12432 #[cfg(
12433 all(
12434 feature = "arm",
12435 feature = "vfp_v2",
12436 any(
12437 feature = "v5te",
12438 feature = "v5tej",
12439 feature = "v6",
12440 feature = "v6k"
12441 )
12442 )
12443 )]
12444 if let Some(ins) = parse_arm_vldr_f32_0(ins, pc, options) {
12445 return ins;
12446 }
12447 }
12448 #[cfg(
12449 all(
12450 feature = "arm",
12451 feature = "vfp_v2",
12452 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12453 )
12454 )]
12455 191 => {
12456 #[cfg(
12457 all(
12458 feature = "arm",
12459 feature = "vfp_v2",
12460 any(
12461 feature = "v5te",
12462 feature = "v5tej",
12463 feature = "v6",
12464 feature = "v6k"
12465 )
12466 )
12467 )]
12468 if let Some(ins) = parse_arm_vldr_f64_0(ins, pc, options) {
12469 return ins;
12470 }
12471 }
12472 #[cfg(
12473 all(
12474 feature = "arm",
12475 feature = "vfp_v2",
12476 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12477 )
12478 )]
12479 192 => {
12480 #[cfg(
12481 all(
12482 feature = "arm",
12483 feature = "vfp_v2",
12484 any(
12485 feature = "v5te",
12486 feature = "v5tej",
12487 feature = "v6",
12488 feature = "v6k"
12489 )
12490 )
12491 )]
12492 if let Some(ins) = parse_arm_vmla_f32_0(ins, pc, options) {
12493 return ins;
12494 }
12495 }
12496 #[cfg(
12497 all(
12498 feature = "arm",
12499 feature = "vfp_v2",
12500 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12501 )
12502 )]
12503 193 => {
12504 #[cfg(
12505 all(
12506 feature = "arm",
12507 feature = "vfp_v2",
12508 any(
12509 feature = "v5te",
12510 feature = "v5tej",
12511 feature = "v6",
12512 feature = "v6k"
12513 )
12514 )
12515 )]
12516 if let Some(ins) = parse_arm_vmla_f64_0(ins, pc, options) {
12517 return ins;
12518 }
12519 }
12520 #[cfg(
12521 all(
12522 feature = "arm",
12523 feature = "vfp_v2",
12524 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12525 )
12526 )]
12527 194 => {
12528 #[cfg(
12529 all(
12530 feature = "arm",
12531 feature = "vfp_v2",
12532 any(
12533 feature = "v5te",
12534 feature = "v5tej",
12535 feature = "v6",
12536 feature = "v6k"
12537 )
12538 )
12539 )]
12540 if let Some(ins) = parse_arm_vmls_f32_0(ins, pc, options) {
12541 return ins;
12542 }
12543 }
12544 #[cfg(
12545 all(
12546 feature = "arm",
12547 feature = "vfp_v2",
12548 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12549 )
12550 )]
12551 195 => {
12552 #[cfg(
12553 all(
12554 feature = "arm",
12555 feature = "vfp_v2",
12556 any(
12557 feature = "v5te",
12558 feature = "v5tej",
12559 feature = "v6",
12560 feature = "v6k"
12561 )
12562 )
12563 )]
12564 if let Some(ins) = parse_arm_vmls_f64_0(ins, pc, options) {
12565 return ins;
12566 }
12567 }
12568 #[cfg(
12569 all(
12570 feature = "arm",
12571 feature = "vfp_v2",
12572 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12573 )
12574 )]
12575 196 => {
12576 #[cfg(
12577 all(
12578 feature = "arm",
12579 feature = "vfp_v2",
12580 any(
12581 feature = "v5te",
12582 feature = "v5tej",
12583 feature = "v6",
12584 feature = "v6k"
12585 )
12586 )
12587 )]
12588 if let Some(ins) = parse_arm_vmov_32_reg_0(ins, pc, options) {
12589 return ins;
12590 }
12591 }
12592 #[cfg(
12593 all(
12594 feature = "arm",
12595 feature = "vfp_v2",
12596 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12597 )
12598 )]
12599 197 => {
12600 #[cfg(
12601 all(
12602 feature = "arm",
12603 feature = "vfp_v2",
12604 any(
12605 feature = "v5te",
12606 feature = "v5tej",
12607 feature = "v6",
12608 feature = "v6k"
12609 )
12610 )
12611 )]
12612 if let Some(ins) = parse_arm_vmov_f32_0(ins, pc, options) {
12613 return ins;
12614 }
12615 }
12616 #[cfg(
12617 all(
12618 feature = "arm",
12619 feature = "vfp_v2",
12620 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12621 )
12622 )]
12623 198 => {
12624 #[cfg(
12625 all(
12626 feature = "arm",
12627 feature = "vfp_v2",
12628 any(
12629 feature = "v5te",
12630 feature = "v5tej",
12631 feature = "v6",
12632 feature = "v6k"
12633 )
12634 )
12635 )]
12636 if let Some(ins) = parse_arm_vmov_f32_reg_0(ins, pc, options) {
12637 return ins;
12638 }
12639 }
12640 #[cfg(
12641 all(
12642 feature = "arm",
12643 feature = "vfp_v2",
12644 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12645 )
12646 )]
12647 199 => {
12648 #[cfg(
12649 all(
12650 feature = "arm",
12651 feature = "vfp_v2",
12652 any(
12653 feature = "v5te",
12654 feature = "v5tej",
12655 feature = "v6",
12656 feature = "v6k"
12657 )
12658 )
12659 )]
12660 if let Some(ins) = parse_arm_vmov_f64_0(ins, pc, options) {
12661 return ins;
12662 }
12663 }
12664 #[cfg(
12665 all(
12666 feature = "arm",
12667 feature = "vfp_v2",
12668 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12669 )
12670 )]
12671 200 => {
12672 #[cfg(
12673 all(
12674 feature = "arm",
12675 feature = "vfp_v2",
12676 any(
12677 feature = "v5te",
12678 feature = "v5tej",
12679 feature = "v6",
12680 feature = "v6k"
12681 )
12682 )
12683 )]
12684 if let Some(ins) = parse_arm_vmov_reg_32_0(ins, pc, options) {
12685 return ins;
12686 }
12687 }
12688 #[cfg(
12689 all(
12690 feature = "arm",
12691 feature = "vfp_v2",
12692 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12693 )
12694 )]
12695 201 => {
12696 #[cfg(
12697 all(
12698 feature = "arm",
12699 feature = "vfp_v2",
12700 any(
12701 feature = "v5te",
12702 feature = "v5tej",
12703 feature = "v6",
12704 feature = "v6k"
12705 )
12706 )
12707 )]
12708 if let Some(ins) = parse_arm_vmov_reg_f32_0(ins, pc, options) {
12709 return ins;
12710 }
12711 }
12712 #[cfg(
12713 all(
12714 feature = "arm",
12715 feature = "vfp_v2",
12716 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12717 )
12718 )]
12719 202 => {
12720 #[cfg(
12721 all(
12722 feature = "arm",
12723 feature = "vfp_v2",
12724 any(
12725 feature = "v5te",
12726 feature = "v5tej",
12727 feature = "v6",
12728 feature = "v6k"
12729 )
12730 )
12731 )]
12732 if let Some(ins) = parse_arm_vmov_reg_f32_dual_0(ins, pc, options) {
12733 return ins;
12734 }
12735 }
12736 #[cfg(
12737 all(
12738 feature = "arm",
12739 feature = "vfp_v2",
12740 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12741 )
12742 )]
12743 203 => {
12744 #[cfg(
12745 all(
12746 feature = "arm",
12747 feature = "vfp_v2",
12748 any(
12749 feature = "v5te",
12750 feature = "v5tej",
12751 feature = "v6",
12752 feature = "v6k"
12753 )
12754 )
12755 )]
12756 if let Some(ins) = parse_arm_vmov_f32_reg_dual_0(ins, pc, options) {
12757 return ins;
12758 }
12759 }
12760 #[cfg(
12761 all(
12762 feature = "arm",
12763 feature = "vfp_v2",
12764 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12765 )
12766 )]
12767 204 => {
12768 #[cfg(
12769 all(
12770 feature = "arm",
12771 feature = "vfp_v2",
12772 any(
12773 feature = "v5te",
12774 feature = "v5tej",
12775 feature = "v6",
12776 feature = "v6k"
12777 )
12778 )
12779 )]
12780 if let Some(ins) = parse_arm_vmov_reg_f64_0(ins, pc, options) {
12781 return ins;
12782 }
12783 }
12784 #[cfg(
12785 all(
12786 feature = "arm",
12787 feature = "vfp_v2",
12788 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12789 )
12790 )]
12791 205 => {
12792 #[cfg(
12793 all(
12794 feature = "arm",
12795 feature = "vfp_v2",
12796 any(
12797 feature = "v5te",
12798 feature = "v5tej",
12799 feature = "v6",
12800 feature = "v6k"
12801 )
12802 )
12803 )]
12804 if let Some(ins) = parse_arm_vmov_f64_reg_0(ins, pc, options) {
12805 return ins;
12806 }
12807 }
12808 #[cfg(
12809 all(
12810 feature = "arm",
12811 feature = "vfp_v2",
12812 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12813 )
12814 )]
12815 206 => {
12816 #[cfg(
12817 all(
12818 feature = "arm",
12819 feature = "vfp_v2",
12820 any(
12821 feature = "v5te",
12822 feature = "v5tej",
12823 feature = "v6",
12824 feature = "v6k"
12825 )
12826 )
12827 )]
12828 if let Some(ins) = parse_arm_vmrs_0(ins, pc, options) {
12829 return ins;
12830 }
12831 }
12832 #[cfg(
12833 all(
12834 feature = "arm",
12835 feature = "vfp_v2",
12836 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12837 )
12838 )]
12839 207 => {
12840 #[cfg(
12841 all(
12842 feature = "arm",
12843 feature = "vfp_v2",
12844 any(
12845 feature = "v5te",
12846 feature = "v5tej",
12847 feature = "v6",
12848 feature = "v6k"
12849 )
12850 )
12851 )]
12852 if let Some(ins) = parse_arm_vmsr_0(ins, pc, options) {
12853 return ins;
12854 }
12855 }
12856 #[cfg(
12857 all(
12858 feature = "arm",
12859 feature = "vfp_v2",
12860 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12861 )
12862 )]
12863 208 => {
12864 #[cfg(
12865 all(
12866 feature = "arm",
12867 feature = "vfp_v2",
12868 any(
12869 feature = "v5te",
12870 feature = "v5tej",
12871 feature = "v6",
12872 feature = "v6k"
12873 )
12874 )
12875 )]
12876 if let Some(ins) = parse_arm_vmul_f32_0(ins, pc, options) {
12877 return ins;
12878 }
12879 }
12880 #[cfg(
12881 all(
12882 feature = "arm",
12883 feature = "vfp_v2",
12884 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12885 )
12886 )]
12887 209 => {
12888 #[cfg(
12889 all(
12890 feature = "arm",
12891 feature = "vfp_v2",
12892 any(
12893 feature = "v5te",
12894 feature = "v5tej",
12895 feature = "v6",
12896 feature = "v6k"
12897 )
12898 )
12899 )]
12900 if let Some(ins) = parse_arm_vmul_f64_0(ins, pc, options) {
12901 return ins;
12902 }
12903 }
12904 #[cfg(
12905 all(
12906 feature = "arm",
12907 feature = "vfp_v2",
12908 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12909 )
12910 )]
12911 210 => {
12912 #[cfg(
12913 all(
12914 feature = "arm",
12915 feature = "vfp_v2",
12916 any(
12917 feature = "v5te",
12918 feature = "v5tej",
12919 feature = "v6",
12920 feature = "v6k"
12921 )
12922 )
12923 )]
12924 if let Some(ins) = parse_arm_vneg_f32_0(ins, pc, options) {
12925 return ins;
12926 }
12927 }
12928 #[cfg(
12929 all(
12930 feature = "arm",
12931 feature = "vfp_v2",
12932 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12933 )
12934 )]
12935 211 => {
12936 #[cfg(
12937 all(
12938 feature = "arm",
12939 feature = "vfp_v2",
12940 any(
12941 feature = "v5te",
12942 feature = "v5tej",
12943 feature = "v6",
12944 feature = "v6k"
12945 )
12946 )
12947 )]
12948 if let Some(ins) = parse_arm_vneg_f64_0(ins, pc, options) {
12949 return ins;
12950 }
12951 }
12952 #[cfg(
12953 all(
12954 feature = "arm",
12955 feature = "vfp_v2",
12956 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12957 )
12958 )]
12959 212 => {
12960 #[cfg(
12961 all(
12962 feature = "arm",
12963 feature = "vfp_v2",
12964 any(
12965 feature = "v5te",
12966 feature = "v5tej",
12967 feature = "v6",
12968 feature = "v6k"
12969 )
12970 )
12971 )]
12972 if let Some(ins) = parse_arm_vnmla_f32_0(ins, pc, options) {
12973 return ins;
12974 }
12975 }
12976 #[cfg(
12977 all(
12978 feature = "arm",
12979 feature = "vfp_v2",
12980 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
12981 )
12982 )]
12983 213 => {
12984 #[cfg(
12985 all(
12986 feature = "arm",
12987 feature = "vfp_v2",
12988 any(
12989 feature = "v5te",
12990 feature = "v5tej",
12991 feature = "v6",
12992 feature = "v6k"
12993 )
12994 )
12995 )]
12996 if let Some(ins) = parse_arm_vnmla_f64_0(ins, pc, options) {
12997 return ins;
12998 }
12999 }
13000 #[cfg(
13001 all(
13002 feature = "arm",
13003 feature = "vfp_v2",
13004 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
13005 )
13006 )]
13007 214 => {
13008 #[cfg(
13009 all(
13010 feature = "arm",
13011 feature = "vfp_v2",
13012 any(
13013 feature = "v5te",
13014 feature = "v5tej",
13015 feature = "v6",
13016 feature = "v6k"
13017 )
13018 )
13019 )]
13020 if let Some(ins) = parse_arm_vnmls_f32_0(ins, pc, options) {
13021 return ins;
13022 }
13023 }
13024 #[cfg(
13025 all(
13026 feature = "arm",
13027 feature = "vfp_v2",
13028 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
13029 )
13030 )]
13031 215 => {
13032 #[cfg(
13033 all(
13034 feature = "arm",
13035 feature = "vfp_v2",
13036 any(
13037 feature = "v5te",
13038 feature = "v5tej",
13039 feature = "v6",
13040 feature = "v6k"
13041 )
13042 )
13043 )]
13044 if let Some(ins) = parse_arm_vnmls_f64_0(ins, pc, options) {
13045 return ins;
13046 }
13047 }
13048 #[cfg(
13049 all(
13050 feature = "arm",
13051 feature = "vfp_v2",
13052 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
13053 )
13054 )]
13055 216 => {
13056 #[cfg(
13057 all(
13058 feature = "arm",
13059 feature = "vfp_v2",
13060 any(
13061 feature = "v5te",
13062 feature = "v5tej",
13063 feature = "v6",
13064 feature = "v6k"
13065 )
13066 )
13067 )]
13068 if let Some(ins) = parse_arm_vnmul_f32_0(ins, pc, options) {
13069 return ins;
13070 }
13071 }
13072 #[cfg(
13073 all(
13074 feature = "arm",
13075 feature = "vfp_v2",
13076 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
13077 )
13078 )]
13079 217 => {
13080 #[cfg(
13081 all(
13082 feature = "arm",
13083 feature = "vfp_v2",
13084 any(
13085 feature = "v5te",
13086 feature = "v5tej",
13087 feature = "v6",
13088 feature = "v6k"
13089 )
13090 )
13091 )]
13092 if let Some(ins) = parse_arm_vnmul_f64_0(ins, pc, options) {
13093 return ins;
13094 }
13095 }
13096 #[cfg(
13097 all(
13098 feature = "arm",
13099 feature = "vfp_v2",
13100 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
13101 )
13102 )]
13103 218 => {
13104 #[cfg(
13105 all(
13106 feature = "arm",
13107 feature = "vfp_v2",
13108 any(
13109 feature = "v5te",
13110 feature = "v5tej",
13111 feature = "v6",
13112 feature = "v6k"
13113 )
13114 )
13115 )]
13116 if let Some(ins) = parse_arm_vpop_f32_0(ins, pc, options) {
13117 return ins;
13118 }
13119 }
13120 #[cfg(
13121 all(
13122 feature = "arm",
13123 feature = "vfp_v2",
13124 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
13125 )
13126 )]
13127 219 => {
13128 #[cfg(
13129 all(
13130 feature = "arm",
13131 feature = "vfp_v2",
13132 any(
13133 feature = "v5te",
13134 feature = "v5tej",
13135 feature = "v6",
13136 feature = "v6k"
13137 )
13138 )
13139 )]
13140 if let Some(ins) = parse_arm_vpop_f64_0(ins, pc, options) {
13141 return ins;
13142 }
13143 }
13144 #[cfg(
13145 all(
13146 feature = "arm",
13147 feature = "vfp_v2",
13148 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
13149 )
13150 )]
13151 220 => {
13152 #[cfg(
13153 all(
13154 feature = "arm",
13155 feature = "vfp_v2",
13156 any(
13157 feature = "v5te",
13158 feature = "v5tej",
13159 feature = "v6",
13160 feature = "v6k"
13161 )
13162 )
13163 )]
13164 if let Some(ins) = parse_arm_vpush_f32_0(ins, pc, options) {
13165 return ins;
13166 }
13167 }
13168 #[cfg(
13169 all(
13170 feature = "arm",
13171 feature = "vfp_v2",
13172 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
13173 )
13174 )]
13175 221 => {
13176 #[cfg(
13177 all(
13178 feature = "arm",
13179 feature = "vfp_v2",
13180 any(
13181 feature = "v5te",
13182 feature = "v5tej",
13183 feature = "v6",
13184 feature = "v6k"
13185 )
13186 )
13187 )]
13188 if let Some(ins) = parse_arm_vpush_f64_0(ins, pc, options) {
13189 return ins;
13190 }
13191 }
13192 #[cfg(
13193 all(
13194 feature = "arm",
13195 feature = "vfp_v2",
13196 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
13197 )
13198 )]
13199 222 => {
13200 #[cfg(
13201 all(
13202 feature = "arm",
13203 feature = "vfp_v2",
13204 any(
13205 feature = "v5te",
13206 feature = "v5tej",
13207 feature = "v6",
13208 feature = "v6k"
13209 )
13210 )
13211 )]
13212 if let Some(ins) = parse_arm_vsqrt_f32_0(ins, pc, options) {
13213 return ins;
13214 }
13215 }
13216 #[cfg(
13217 all(
13218 feature = "arm",
13219 feature = "vfp_v2",
13220 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
13221 )
13222 )]
13223 223 => {
13224 #[cfg(
13225 all(
13226 feature = "arm",
13227 feature = "vfp_v2",
13228 any(
13229 feature = "v5te",
13230 feature = "v5tej",
13231 feature = "v6",
13232 feature = "v6k"
13233 )
13234 )
13235 )]
13236 if let Some(ins) = parse_arm_vsqrt_f64_0(ins, pc, options) {
13237 return ins;
13238 }
13239 }
13240 #[cfg(
13241 all(
13242 feature = "arm",
13243 feature = "vfp_v2",
13244 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
13245 )
13246 )]
13247 224 => {
13248 #[cfg(
13249 all(
13250 feature = "arm",
13251 feature = "vfp_v2",
13252 any(
13253 feature = "v5te",
13254 feature = "v5tej",
13255 feature = "v6",
13256 feature = "v6k"
13257 )
13258 )
13259 )]
13260 if let Some(ins) = parse_arm_vstm_f32_0(ins, pc, options) {
13261 return ins;
13262 }
13263 }
13264 #[cfg(
13265 all(
13266 feature = "arm",
13267 feature = "vfp_v2",
13268 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
13269 )
13270 )]
13271 225 => {
13272 #[cfg(
13273 all(
13274 feature = "arm",
13275 feature = "vfp_v2",
13276 any(
13277 feature = "v5te",
13278 feature = "v5tej",
13279 feature = "v6",
13280 feature = "v6k"
13281 )
13282 )
13283 )]
13284 if let Some(ins) = parse_arm_vstm_f64_0(ins, pc, options) {
13285 return ins;
13286 }
13287 }
13288 #[cfg(
13289 all(
13290 feature = "arm",
13291 feature = "vfp_v2",
13292 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
13293 )
13294 )]
13295 226 => {
13296 #[cfg(
13297 all(
13298 feature = "arm",
13299 feature = "vfp_v2",
13300 any(
13301 feature = "v5te",
13302 feature = "v5tej",
13303 feature = "v6",
13304 feature = "v6k"
13305 )
13306 )
13307 )]
13308 if let Some(ins) = parse_arm_vstr_f32_0(ins, pc, options) {
13309 return ins;
13310 }
13311 }
13312 #[cfg(
13313 all(
13314 feature = "arm",
13315 feature = "vfp_v2",
13316 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
13317 )
13318 )]
13319 227 => {
13320 #[cfg(
13321 all(
13322 feature = "arm",
13323 feature = "vfp_v2",
13324 any(
13325 feature = "v5te",
13326 feature = "v5tej",
13327 feature = "v6",
13328 feature = "v6k"
13329 )
13330 )
13331 )]
13332 if let Some(ins) = parse_arm_vstr_f64_0(ins, pc, options) {
13333 return ins;
13334 }
13335 }
13336 #[cfg(
13337 all(
13338 feature = "arm",
13339 feature = "vfp_v2",
13340 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
13341 )
13342 )]
13343 228 => {
13344 #[cfg(
13345 all(
13346 feature = "arm",
13347 feature = "vfp_v2",
13348 any(
13349 feature = "v5te",
13350 feature = "v5tej",
13351 feature = "v6",
13352 feature = "v6k"
13353 )
13354 )
13355 )]
13356 if let Some(ins) = parse_arm_vsub_f32_0(ins, pc, options) {
13357 return ins;
13358 }
13359 }
13360 #[cfg(
13361 all(
13362 feature = "arm",
13363 feature = "vfp_v2",
13364 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
13365 )
13366 )]
13367 229 => {
13368 #[cfg(
13369 all(
13370 feature = "arm",
13371 feature = "vfp_v2",
13372 any(
13373 feature = "v5te",
13374 feature = "v5tej",
13375 feature = "v6",
13376 feature = "v6k"
13377 )
13378 )
13379 )]
13380 if let Some(ins) = parse_arm_vsub_f64_0(ins, pc, options) {
13381 return ins;
13382 }
13383 }
13384 #[cfg(all(feature = "arm", feature = "v6k"))]
13385 230 => {
13386 #[cfg(all(feature = "arm", feature = "v6k"))]
13387 if let Some(ins) = parse_arm_wfe_0(ins, pc, options) {
13388 return ins;
13389 }
13390 }
13391 #[cfg(all(feature = "arm", feature = "v6k"))]
13392 231 => {
13393 #[cfg(all(feature = "arm", feature = "v6k"))]
13394 if let Some(ins) = parse_arm_wfi_0(ins, pc, options) {
13395 return ins;
13396 }
13397 }
13398 #[cfg(all(feature = "arm", feature = "v6k"))]
13399 232 => {
13400 #[cfg(all(feature = "arm", feature = "v6k"))]
13401 if let Some(ins) = parse_arm_yield_0(ins, pc, options) {
13402 return ins;
13403 }
13404 }
13405 233 => return Ins::Byte(ins as u8),
13406 234 => return Ins::HalfWord(ins as u16),
13407 235 => return Ins::Word(ins),
13408 _ => {}
13409 };
13410 Ins::Illegal
13411}
13412#[cfg(feature = "thumb")]
13413pub fn parse_thumb_with_discriminant(
13414 ins: u32,
13415 discriminant: u16,
13416 pc: u32,
13417 options: &Options,
13418) -> Ins {
13419 match discriminant {
13420 0 => {
13421 #[cfg(feature = "thumb")]
13422 if let Some(ins) = parse_thumb_adc_0(ins, pc, options)
13423 .map(|(ins, _size)| ins)
13424 {
13425 return ins;
13426 }
13427 }
13428 1 => {
13429 #[cfg(feature = "thumb")]
13430 if (ins & 0xff78) == 0x4468
13431 && let Some(ins) = parse_thumb_add_6(ins, pc, options)
13432 .map(|(ins, _size)| ins)
13433 {
13434 return ins;
13435 }
13436 #[cfg(feature = "thumb")]
13437 if (ins & 0xff87) == 0x4485
13438 && let Some(ins) = parse_thumb_add_7(ins, pc, options)
13439 .map(|(ins, _size)| ins)
13440 {
13441 return ins;
13442 }
13443 #[cfg(feature = "thumb")]
13444 if (ins & 0xff80) == 0xb000
13445 && let Some(ins) = parse_thumb_add_5(ins, pc, options)
13446 .map(|(ins, _size)| ins)
13447 {
13448 return ins;
13449 }
13450 #[cfg(feature = "thumb")]
13451 if (ins & 0xff00) == 0x4400
13452 && let Some(ins) = parse_thumb_add_3(ins, pc, options)
13453 .map(|(ins, _size)| ins)
13454 {
13455 return ins;
13456 }
13457 #[cfg(feature = "thumb")]
13458 if (ins & 0xfe00) == 0x1c00
13459 && let Some(ins) = parse_thumb_add_0(ins, pc, options)
13460 .map(|(ins, _size)| ins)
13461 {
13462 return ins;
13463 }
13464 #[cfg(feature = "thumb")]
13465 if (ins & 0xfe00) == 0x1800
13466 && let Some(ins) = parse_thumb_add_2(ins, pc, options)
13467 .map(|(ins, _size)| ins)
13468 {
13469 return ins;
13470 }
13471 #[cfg(feature = "thumb")]
13472 if (ins & 0xf800) == 0x3000
13473 && let Some(ins) = parse_thumb_add_1(ins, pc, options)
13474 .map(|(ins, _size)| ins)
13475 {
13476 return ins;
13477 }
13478 #[cfg(feature = "thumb")]
13479 if (ins & 0xf800) == 0xa800
13480 && let Some(ins) = parse_thumb_add_4(ins, pc, options)
13481 .map(|(ins, _size)| ins)
13482 {
13483 return ins;
13484 }
13485 #[cfg(feature = "thumb")]
13486 if (ins & 0xf800) == 0xa000
13487 && let Some(ins) = parse_thumb_add_8(ins, pc, options)
13488 .map(|(ins, _size)| ins)
13489 {
13490 return ins;
13491 }
13492 }
13493 2 => {
13494 #[cfg(feature = "thumb")]
13495 if let Some(ins) = parse_thumb_and_0(ins, pc, options)
13496 .map(|(ins, _size)| ins)
13497 {
13498 return ins;
13499 }
13500 }
13501 3 => {
13502 #[cfg(feature = "thumb")]
13503 if (ins & 0xffc0) == 0x4100
13504 && let Some(ins) = parse_thumb_asr_1(ins, pc, options)
13505 .map(|(ins, _size)| ins)
13506 {
13507 return ins;
13508 }
13509 #[cfg(feature = "thumb")]
13510 if (ins & 0xf800) == 0x1000
13511 && let Some(ins) = parse_thumb_asr_0(ins, pc, options)
13512 .map(|(ins, _size)| ins)
13513 {
13514 return ins;
13515 }
13516 }
13517 4 => {
13518 #[cfg(feature = "thumb")]
13519 if (ins & 0xf800) == 0xe000
13520 && let Some(ins) = parse_thumb_b_1(ins, pc, options)
13521 .map(|(ins, _size)| ins)
13522 {
13523 return ins;
13524 }
13525 #[cfg(feature = "thumb")]
13526 if (ins & 0xf000) == 0xd000
13527 && let Some(ins) = parse_thumb_b_0(ins, pc, options)
13528 .map(|(ins, _size)| ins)
13529 {
13530 return ins;
13531 }
13532 }
13533 5 => {
13534 #[cfg(feature = "thumb")]
13535 if let Some(ins) = parse_thumb_bic_0(ins, pc, options)
13536 .map(|(ins, _size)| ins)
13537 {
13538 return ins;
13539 }
13540 }
13541 #[cfg(
13542 any(
13543 feature = "v5t",
13544 feature = "v5te",
13545 feature = "v5tej",
13546 feature = "v6",
13547 feature = "v6k"
13548 )
13549 )]
13550 6 => {
13551 #[cfg(
13552 all(
13553 feature = "thumb",
13554 any(
13555 feature = "v5t",
13556 feature = "v5te",
13557 feature = "v5tej",
13558 feature = "v6",
13559 feature = "v6k"
13560 )
13561 )
13562 )]
13563 if let Some(ins) = parse_thumb_bkpt_0(ins, pc, options)
13564 .map(|(ins, _size)| ins)
13565 {
13566 return ins;
13567 }
13568 }
13569 7 => {
13570 #[cfg(feature = "thumb")]
13571 if let Some(ins) = parse_thumb_bl_0(ins, pc, options).map(|(ins, _size)| ins)
13572 {
13573 return ins;
13574 }
13575 }
13576 #[cfg(
13577 any(
13578 feature = "v5t",
13579 feature = "v5te",
13580 feature = "v5tej",
13581 feature = "v6",
13582 feature = "v6k"
13583 )
13584 )]
13585 8 => {
13586 #[cfg(
13587 all(
13588 feature = "thumb",
13589 any(
13590 feature = "v5t",
13591 feature = "v5te",
13592 feature = "v5tej",
13593 feature = "v6",
13594 feature = "v6k"
13595 )
13596 )
13597 )]
13598 if (ins & 0xff87) == 0x4780
13599 && let Some(ins) = parse_thumb_blx_1(ins, pc, options)
13600 .map(|(ins, _size)| ins)
13601 {
13602 return ins;
13603 }
13604 #[cfg(
13605 all(
13606 feature = "thumb",
13607 any(
13608 feature = "v5t",
13609 feature = "v5te",
13610 feature = "v5tej",
13611 feature = "v6",
13612 feature = "v6k"
13613 )
13614 )
13615 )]
13616 if (ins & 0xd000f800) == 0xc000f000
13617 && let Some(ins) = parse_thumb_blx_0(ins, pc, options)
13618 .map(|(ins, _size)| ins)
13619 {
13620 return ins;
13621 }
13622 }
13623 #[cfg(
13624 any(
13625 feature = "v4t",
13626 feature = "v5t",
13627 feature = "v5te",
13628 feature = "v5tej",
13629 feature = "v6",
13630 feature = "v6k"
13631 )
13632 )]
13633 9 => {
13634 #[cfg(feature = "thumb")]
13635 if let Some(ins) = parse_thumb_bx_0(ins, pc, options).map(|(ins, _size)| ins)
13636 {
13637 return ins;
13638 }
13639 }
13640 15 => {
13641 #[cfg(feature = "thumb")]
13642 if let Some(ins) = parse_thumb_cmn_0(ins, pc, options)
13643 .map(|(ins, _size)| ins)
13644 {
13645 return ins;
13646 }
13647 }
13648 16 => {
13649 #[cfg(feature = "thumb")]
13650 if (ins & 0xffc0) == 0x4280
13651 && let Some(ins) = parse_thumb_cmp_1(ins, pc, options)
13652 .map(|(ins, _size)| ins)
13653 {
13654 return ins;
13655 }
13656 #[cfg(feature = "thumb")]
13657 if (ins & 0xff00) == 0x4500
13658 && let Some(ins) = parse_thumb_cmp_2(ins, pc, options)
13659 .map(|(ins, _size)| ins)
13660 {
13661 return ins;
13662 }
13663 #[cfg(feature = "thumb")]
13664 if (ins & 0xf800) == 0x2800
13665 && let Some(ins) = parse_thumb_cmp_0(ins, pc, options)
13666 .map(|(ins, _size)| ins)
13667 {
13668 return ins;
13669 }
13670 }
13671 #[cfg(any(feature = "v6", feature = "v6k"))]
13672 17 => {
13673 #[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
13674 if let Some(ins) = parse_thumb_cps_0(ins, pc, options)
13675 .map(|(ins, _size)| ins)
13676 {
13677 return ins;
13678 }
13679 }
13680 20 => {
13681 #[cfg(feature = "thumb")]
13682 if let Some(ins) = parse_thumb_eor_0(ins, pc, options)
13683 .map(|(ins, _size)| ins)
13684 {
13685 return ins;
13686 }
13687 }
13688 23 => {
13689 #[cfg(feature = "thumb")]
13690 if let Some(ins) = parse_thumb_ldm_0(ins, pc, options)
13691 .map(|(ins, _size)| ins)
13692 {
13693 return ins;
13694 }
13695 }
13696 24 => {
13697 #[cfg(feature = "thumb")]
13698 if (ins & 0xfe00) == 0x5800
13699 && let Some(ins) = parse_thumb_ldr_3(ins, pc, options)
13700 .map(|(ins, _size)| ins)
13701 {
13702 return ins;
13703 }
13704 #[cfg(feature = "thumb")]
13705 if (ins & 0xf800) == 0x6800
13706 && let Some(ins) = parse_thumb_ldr_0(ins, pc, options)
13707 .map(|(ins, _size)| ins)
13708 {
13709 return ins;
13710 }
13711 #[cfg(feature = "thumb")]
13712 if (ins & 0xf800) == 0x9800
13713 && let Some(ins) = parse_thumb_ldr_1(ins, pc, options)
13714 .map(|(ins, _size)| ins)
13715 {
13716 return ins;
13717 }
13718 #[cfg(feature = "thumb")]
13719 if (ins & 0xf800) == 0x4800
13720 && let Some(ins) = parse_thumb_ldr_2(ins, pc, options)
13721 .map(|(ins, _size)| ins)
13722 {
13723 return ins;
13724 }
13725 }
13726 25 => {
13727 #[cfg(feature = "thumb")]
13728 if (ins & 0xfe00) == 0x5c00
13729 && let Some(ins) = parse_thumb_ldrb_1(ins, pc, options)
13730 .map(|(ins, _size)| ins)
13731 {
13732 return ins;
13733 }
13734 #[cfg(feature = "thumb")]
13735 if (ins & 0xf800) == 0x7800
13736 && let Some(ins) = parse_thumb_ldrb_0(ins, pc, options)
13737 .map(|(ins, _size)| ins)
13738 {
13739 return ins;
13740 }
13741 }
13742 32 => {
13743 #[cfg(feature = "thumb")]
13744 if (ins & 0xfe00) == 0x5a00
13745 && let Some(ins) = parse_thumb_ldrh_1(ins, pc, options)
13746 .map(|(ins, _size)| ins)
13747 {
13748 return ins;
13749 }
13750 #[cfg(feature = "thumb")]
13751 if (ins & 0xf800) == 0x8800
13752 && let Some(ins) = parse_thumb_ldrh_0(ins, pc, options)
13753 .map(|(ins, _size)| ins)
13754 {
13755 return ins;
13756 }
13757 }
13758 33 => {
13759 #[cfg(feature = "thumb")]
13760 if let Some(ins) = parse_thumb_ldrsb_0(ins, pc, options)
13761 .map(|(ins, _size)| ins)
13762 {
13763 return ins;
13764 }
13765 }
13766 34 => {
13767 #[cfg(feature = "thumb")]
13768 if let Some(ins) = parse_thumb_ldrsh_0(ins, pc, options)
13769 .map(|(ins, _size)| ins)
13770 {
13771 return ins;
13772 }
13773 }
13774 36 => {
13775 #[cfg(feature = "thumb")]
13776 if (ins & 0xffc0) == 0x4080
13777 && let Some(ins) = parse_thumb_lsl_1(ins, pc, options)
13778 .map(|(ins, _size)| ins)
13779 {
13780 return ins;
13781 }
13782 #[cfg(feature = "thumb")]
13783 if (ins & 0xf800) == 0x0
13784 && let Some(ins) = parse_thumb_lsl_0(ins, pc, options)
13785 .map(|(ins, _size)| ins)
13786 {
13787 return ins;
13788 }
13789 }
13790 37 => {
13791 #[cfg(feature = "thumb")]
13792 if (ins & 0xffc0) == 0x40c0
13793 && let Some(ins) = parse_thumb_lsr_1(ins, pc, options)
13794 .map(|(ins, _size)| ins)
13795 {
13796 return ins;
13797 }
13798 #[cfg(feature = "thumb")]
13799 if (ins & 0xf800) == 0x800
13800 && let Some(ins) = parse_thumb_lsr_0(ins, pc, options)
13801 .map(|(ins, _size)| ins)
13802 {
13803 return ins;
13804 }
13805 }
13806 43 => {
13807 #[cfg(feature = "thumb")]
13808 if (ins & 0xffc0) == 0x0
13809 && let Some(ins) = parse_thumb_mov_2(ins, pc, options)
13810 .map(|(ins, _size)| ins)
13811 {
13812 return ins;
13813 }
13814 #[cfg(feature = "thumb")]
13815 if (ins & 0xffc0) == 0x1c00
13816 && let Some(ins) = parse_thumb_mov_3(ins, pc, options)
13817 .map(|(ins, _size)| ins)
13818 {
13819 return ins;
13820 }
13821 #[cfg(feature = "thumb")]
13822 if (ins & 0xff00) == 0x4600
13823 && let Some(ins) = parse_thumb_mov_1(ins, pc, options)
13824 .map(|(ins, _size)| ins)
13825 {
13826 return ins;
13827 }
13828 #[cfg(feature = "thumb")]
13829 if (ins & 0xf800) == 0x2000
13830 && let Some(ins) = parse_thumb_mov_0(ins, pc, options)
13831 .map(|(ins, _size)| ins)
13832 {
13833 return ins;
13834 }
13835 }
13836 50 => {
13837 #[cfg(feature = "thumb")]
13838 if let Some(ins) = parse_thumb_mul_0(ins, pc, options)
13839 .map(|(ins, _size)| ins)
13840 {
13841 return ins;
13842 }
13843 }
13844 51 => {
13845 #[cfg(feature = "thumb")]
13846 if let Some(ins) = parse_thumb_mvn_0(ins, pc, options)
13847 .map(|(ins, _size)| ins)
13848 {
13849 return ins;
13850 }
13851 }
13852 #[cfg(feature = "thumb")]
13853 52 => {
13854 #[cfg(feature = "thumb")]
13855 if let Some(ins) = parse_thumb_neg_0(ins, pc, options)
13856 .map(|(ins, _size)| ins)
13857 {
13858 return ins;
13859 }
13860 }
13861 54 => {
13862 #[cfg(feature = "thumb")]
13863 if let Some(ins) = parse_thumb_orr_0(ins, pc, options)
13864 .map(|(ins, _size)| ins)
13865 {
13866 return ins;
13867 }
13868 }
13869 58 => {
13870 #[cfg(feature = "thumb")]
13871 if let Some(ins) = parse_thumb_pop_0(ins, pc, options)
13872 .map(|(ins, _size)| ins)
13873 {
13874 return ins;
13875 }
13876 }
13877 59 => {
13878 #[cfg(feature = "thumb")]
13879 if let Some(ins) = parse_thumb_push_0(ins, pc, options)
13880 .map(|(ins, _size)| ins)
13881 {
13882 return ins;
13883 }
13884 }
13885 #[cfg(any(feature = "v6", feature = "v6k"))]
13886 70 => {
13887 #[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
13888 if let Some(ins) = parse_thumb_rev_0(ins, pc, options)
13889 .map(|(ins, _size)| ins)
13890 {
13891 return ins;
13892 }
13893 }
13894 #[cfg(any(feature = "v6", feature = "v6k"))]
13895 71 => {
13896 #[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
13897 if let Some(ins) = parse_thumb_rev16_0(ins, pc, options)
13898 .map(|(ins, _size)| ins)
13899 {
13900 return ins;
13901 }
13902 }
13903 #[cfg(any(feature = "v6", feature = "v6k"))]
13904 72 => {
13905 #[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
13906 if let Some(ins) = parse_thumb_revsh_0(ins, pc, options)
13907 .map(|(ins, _size)| ins)
13908 {
13909 return ins;
13910 }
13911 }
13912 74 => {
13913 #[cfg(feature = "thumb")]
13914 if let Some(ins) = parse_thumb_ror_0(ins, pc, options)
13915 .map(|(ins, _size)| ins)
13916 {
13917 return ins;
13918 }
13919 }
13920 76 => {
13921 #[cfg(feature = "thumb")]
13922 if let Some(ins) = parse_thumb_rsb_0(ins, pc, options)
13923 .map(|(ins, _size)| ins)
13924 {
13925 return ins;
13926 }
13927 }
13928 81 => {
13929 #[cfg(feature = "thumb")]
13930 if let Some(ins) = parse_thumb_sbc_0(ins, pc, options)
13931 .map(|(ins, _size)| ins)
13932 {
13933 return ins;
13934 }
13935 }
13936 #[cfg(any(feature = "v6", feature = "v6k"))]
13937 83 => {
13938 #[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
13939 if let Some(ins) = parse_thumb_setend_0(ins, pc, options)
13940 .map(|(ins, _size)| ins)
13941 {
13942 return ins;
13943 }
13944 }
13945 115 => {
13946 #[cfg(feature = "thumb")]
13947 if let Some(ins) = parse_thumb_stm_0(ins, pc, options)
13948 .map(|(ins, _size)| ins)
13949 {
13950 return ins;
13951 }
13952 }
13953 116 => {
13954 #[cfg(feature = "thumb")]
13955 if (ins & 0xfe00) == 0x5000
13956 && let Some(ins) = parse_thumb_str_2(ins, pc, options)
13957 .map(|(ins, _size)| ins)
13958 {
13959 return ins;
13960 }
13961 #[cfg(feature = "thumb")]
13962 if (ins & 0xf800) == 0x6000
13963 && let Some(ins) = parse_thumb_str_0(ins, pc, options)
13964 .map(|(ins, _size)| ins)
13965 {
13966 return ins;
13967 }
13968 #[cfg(feature = "thumb")]
13969 if (ins & 0xf800) == 0x9000
13970 && let Some(ins) = parse_thumb_str_1(ins, pc, options)
13971 .map(|(ins, _size)| ins)
13972 {
13973 return ins;
13974 }
13975 }
13976 117 => {
13977 #[cfg(feature = "thumb")]
13978 if (ins & 0xfe00) == 0x5400
13979 && let Some(ins) = parse_thumb_strb_1(ins, pc, options)
13980 .map(|(ins, _size)| ins)
13981 {
13982 return ins;
13983 }
13984 #[cfg(feature = "thumb")]
13985 if (ins & 0xf800) == 0x7000
13986 && let Some(ins) = parse_thumb_strb_0(ins, pc, options)
13987 .map(|(ins, _size)| ins)
13988 {
13989 return ins;
13990 }
13991 }
13992 124 => {
13993 #[cfg(feature = "thumb")]
13994 if (ins & 0xfe00) == 0x5200
13995 && let Some(ins) = parse_thumb_strh_1(ins, pc, options)
13996 .map(|(ins, _size)| ins)
13997 {
13998 return ins;
13999 }
14000 #[cfg(feature = "thumb")]
14001 if (ins & 0xf800) == 0x8000
14002 && let Some(ins) = parse_thumb_strh_0(ins, pc, options)
14003 .map(|(ins, _size)| ins)
14004 {
14005 return ins;
14006 }
14007 }
14008 126 => {
14009 #[cfg(feature = "thumb")]
14010 if (ins & 0xff80) == 0xb080
14011 && let Some(ins) = parse_thumb_sub_3(ins, pc, options)
14012 .map(|(ins, _size)| ins)
14013 {
14014 return ins;
14015 }
14016 #[cfg(feature = "thumb")]
14017 if (ins & 0xfe00) == 0x1e00
14018 && let Some(ins) = parse_thumb_sub_0(ins, pc, options)
14019 .map(|(ins, _size)| ins)
14020 {
14021 return ins;
14022 }
14023 #[cfg(feature = "thumb")]
14024 if (ins & 0xfe00) == 0x1a00
14025 && let Some(ins) = parse_thumb_sub_2(ins, pc, options)
14026 .map(|(ins, _size)| ins)
14027 {
14028 return ins;
14029 }
14030 #[cfg(feature = "thumb")]
14031 if (ins & 0xf800) == 0x3800
14032 && let Some(ins) = parse_thumb_sub_1(ins, pc, options)
14033 .map(|(ins, _size)| ins)
14034 {
14035 return ins;
14036 }
14037 }
14038 127 => {
14039 #[cfg(feature = "thumb")]
14040 if let Some(ins) = parse_thumb_svc_0(ins, pc, options)
14041 .map(|(ins, _size)| ins)
14042 {
14043 return ins;
14044 }
14045 }
14046 #[cfg(any(feature = "v6", feature = "v6k"))]
14047 133 => {
14048 #[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
14049 if let Some(ins) = parse_thumb_sxtb_0(ins, pc, options)
14050 .map(|(ins, _size)| ins)
14051 {
14052 return ins;
14053 }
14054 }
14055 #[cfg(any(feature = "v6", feature = "v6k"))]
14056 135 => {
14057 #[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
14058 if let Some(ins) = parse_thumb_sxth_0(ins, pc, options)
14059 .map(|(ins, _size)| ins)
14060 {
14061 return ins;
14062 }
14063 }
14064 137 => {
14065 #[cfg(feature = "thumb")]
14066 if let Some(ins) = parse_thumb_tst_0(ins, pc, options)
14067 .map(|(ins, _size)| ins)
14068 {
14069 return ins;
14070 }
14071 }
14072 #[cfg(
14073 any(
14074 feature = "v4t",
14075 feature = "v5t",
14076 feature = "v5te",
14077 feature = "v5tej",
14078 feature = "v6",
14079 feature = "v6k"
14080 )
14081 )]
14082 141 => {
14083 #[cfg(feature = "thumb")]
14084 if let Some(ins) = parse_thumb_udf_0(ins, pc, options)
14085 .map(|(ins, _size)| ins)
14086 {
14087 return ins;
14088 }
14089 }
14090 #[cfg(any(feature = "v6", feature = "v6k"))]
14091 167 => {
14092 #[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
14093 if let Some(ins) = parse_thumb_uxtb_0(ins, pc, options)
14094 .map(|(ins, _size)| ins)
14095 {
14096 return ins;
14097 }
14098 }
14099 #[cfg(any(feature = "v6", feature = "v6k"))]
14100 169 => {
14101 #[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
14102 if let Some(ins) = parse_thumb_uxth_0(ins, pc, options)
14103 .map(|(ins, _size)| ins)
14104 {
14105 return ins;
14106 }
14107 }
14108 233 => return Ins::Byte(ins as u8),
14109 234 => return Ins::HalfWord(ins as u16),
14110 235 => return Ins::Word(ins),
14111 _ => {}
14112 };
14113 Ins::Illegal
14114}
14115#[cfg(feature = "arm")]
14116fn parse_arm_adc_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
14117 if value & 0xf0000000 == 0xf0000000 {
14118 return Some(Ins::Illegal);
14119 }
14120 let s = (((value) >> 20) & 0x1) != 0;
14121 let thumb = false;
14122 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
14123 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
14124 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
14125 let Some(op2) = Op2::parse(value, pc) else {
14126 return Some(Ins::Illegal);
14127 };
14128 Some(Ins::Adc {
14129 s,
14130 thumb,
14131 cond,
14132 rd,
14133 rn,
14134 op2,
14135 })
14136}
14137#[cfg(feature = "thumb")]
14138fn parse_thumb_adc_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
14139 const VERSIONS: Versions = Versions::of(
14140 &[
14141 #[cfg(feature = "v4t")]
14142 Version::V4T,
14143 #[cfg(feature = "v5t")]
14144 Version::V5T,
14145 #[cfg(feature = "v5te")]
14146 Version::V5Te,
14147 #[cfg(feature = "v5tej")]
14148 Version::V5Tej,
14149 #[cfg(feature = "v6")]
14150 Version::V6,
14151 #[cfg(feature = "v6k")]
14152 Version::V6K,
14153 ],
14154 );
14155 if !VERSIONS.has(options.version) {
14156 return None;
14157 }
14158 let s = (1) != 0;
14159 let thumb = (1) != 0;
14160 let cond = Cond::default();
14161 let rd = Reg::parse((value) & 0x7, pc);
14162 let rn = Reg::parse((value) & 0x7, pc);
14163 let op2 = Op2::ShiftImm(ShiftImm {
14164 rm: Reg::parse(((value) >> 3) & 0x7, pc),
14165 shift_op: ShiftOp::default(),
14166 imm: 0,
14167 });
14168 Some((
14169 Ins::Adc {
14170 s,
14171 thumb,
14172 cond,
14173 rd,
14174 rn,
14175 op2,
14176 },
14177 2,
14178 ))
14179}
14180#[cfg(feature = "arm")]
14181fn parse_arm_add_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
14182 if value & 0xf0000000 == 0xf0000000 {
14183 return Some(Ins::Illegal);
14184 }
14185 let s = (((value) >> 20) & 0x1) != 0;
14186 let thumb = false;
14187 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
14188 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
14189 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
14190 let Some(op2) = Op2::parse(value, pc) else {
14191 return Some(Ins::Illegal);
14192 };
14193 Some(Ins::Add {
14194 s,
14195 thumb,
14196 cond,
14197 rd,
14198 rn,
14199 op2,
14200 })
14201}
14202#[cfg(feature = "thumb")]
14203fn parse_thumb_add_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
14204 const VERSIONS: Versions = Versions::of(
14205 &[
14206 #[cfg(feature = "v4t")]
14207 Version::V4T,
14208 #[cfg(feature = "v5t")]
14209 Version::V5T,
14210 #[cfg(feature = "v5te")]
14211 Version::V5Te,
14212 #[cfg(feature = "v5tej")]
14213 Version::V5Tej,
14214 #[cfg(feature = "v6")]
14215 Version::V6,
14216 #[cfg(feature = "v6k")]
14217 Version::V6K,
14218 ],
14219 );
14220 if !VERSIONS.has(options.version) {
14221 return None;
14222 }
14223 let s = (1) != 0;
14224 let thumb = (1) != 0;
14225 let cond = Cond::default();
14226 let rd = Reg::parse((value) & 0x7, pc);
14227 let rn = Reg::parse(((value) >> 3) & 0x7, pc);
14228 let op2 = Op2::Imm(((value) >> 6) & 0x7);
14229 Some((
14230 Ins::Add {
14231 s,
14232 thumb,
14233 cond,
14234 rd,
14235 rn,
14236 op2,
14237 },
14238 2,
14239 ))
14240}
14241#[cfg(feature = "thumb")]
14242fn parse_thumb_add_1(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
14243 const VERSIONS: Versions = Versions::of(
14244 &[
14245 #[cfg(feature = "v4t")]
14246 Version::V4T,
14247 #[cfg(feature = "v5t")]
14248 Version::V5T,
14249 #[cfg(feature = "v5te")]
14250 Version::V5Te,
14251 #[cfg(feature = "v5tej")]
14252 Version::V5Tej,
14253 #[cfg(feature = "v6")]
14254 Version::V6,
14255 #[cfg(feature = "v6k")]
14256 Version::V6K,
14257 ],
14258 );
14259 if !VERSIONS.has(options.version) {
14260 return None;
14261 }
14262 let s = (1) != 0;
14263 let thumb = (1) != 0;
14264 let cond = Cond::default();
14265 let rd = Reg::parse(((value) >> 8) & 0x7, pc);
14266 let rn = Reg::parse(((value) >> 8) & 0x7, pc);
14267 let op2 = Op2::Imm((value) & 0xff);
14268 Some((
14269 Ins::Add {
14270 s,
14271 thumb,
14272 cond,
14273 rd,
14274 rn,
14275 op2,
14276 },
14277 2,
14278 ))
14279}
14280#[cfg(feature = "thumb")]
14281fn parse_thumb_add_2(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
14282 const VERSIONS: Versions = Versions::of(
14283 &[
14284 #[cfg(feature = "v4t")]
14285 Version::V4T,
14286 #[cfg(feature = "v5t")]
14287 Version::V5T,
14288 #[cfg(feature = "v5te")]
14289 Version::V5Te,
14290 #[cfg(feature = "v5tej")]
14291 Version::V5Tej,
14292 #[cfg(feature = "v6")]
14293 Version::V6,
14294 #[cfg(feature = "v6k")]
14295 Version::V6K,
14296 ],
14297 );
14298 if !VERSIONS.has(options.version) {
14299 return None;
14300 }
14301 let s = (1) != 0;
14302 let thumb = (1) != 0;
14303 let cond = Cond::default();
14304 let rd = Reg::parse((value) & 0x7, pc);
14305 let rn = Reg::parse(((value) >> 3) & 0x7, pc);
14306 let op2 = Op2::ShiftImm(ShiftImm {
14307 rm: Reg::parse(((value) >> 6) & 0x7, pc),
14308 shift_op: ShiftOp::default(),
14309 imm: 0,
14310 });
14311 Some((
14312 Ins::Add {
14313 s,
14314 thumb,
14315 cond,
14316 rd,
14317 rn,
14318 op2,
14319 },
14320 2,
14321 ))
14322}
14323#[cfg(feature = "thumb")]
14324fn parse_thumb_add_3(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
14325 const VERSIONS: Versions = Versions::of(
14326 &[
14327 #[cfg(feature = "v4t")]
14328 Version::V4T,
14329 #[cfg(feature = "v5t")]
14330 Version::V5T,
14331 #[cfg(feature = "v5te")]
14332 Version::V5Te,
14333 #[cfg(feature = "v5tej")]
14334 Version::V5Tej,
14335 #[cfg(feature = "v6")]
14336 Version::V6,
14337 #[cfg(feature = "v6k")]
14338 Version::V6K,
14339 ],
14340 );
14341 if !VERSIONS.has(options.version) {
14342 return None;
14343 }
14344 let s = false;
14345 let thumb = (1) != 0;
14346 let cond = Cond::default();
14347 let rd = Reg::parse(((((value) >> 7) & 0x1) << 3) | ((value) & 0x7), pc);
14348 let rn = Reg::parse(((((value) >> 7) & 0x1) << 3) | ((value) & 0x7), pc);
14349 let op2 = Op2::ShiftImm(ShiftImm {
14350 rm: Reg::parse(((value) >> 3) & 0xf, pc),
14351 shift_op: ShiftOp::default(),
14352 imm: 0,
14353 });
14354 Some((
14355 Ins::Add {
14356 s,
14357 thumb,
14358 cond,
14359 rd,
14360 rn,
14361 op2,
14362 },
14363 2,
14364 ))
14365}
14366#[cfg(feature = "thumb")]
14367fn parse_thumb_add_4(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
14368 const VERSIONS: Versions = Versions::of(
14369 &[
14370 #[cfg(feature = "v4t")]
14371 Version::V4T,
14372 #[cfg(feature = "v5t")]
14373 Version::V5T,
14374 #[cfg(feature = "v5te")]
14375 Version::V5Te,
14376 #[cfg(feature = "v5tej")]
14377 Version::V5Tej,
14378 #[cfg(feature = "v6")]
14379 Version::V6,
14380 #[cfg(feature = "v6k")]
14381 Version::V6K,
14382 ],
14383 );
14384 if !VERSIONS.has(options.version) {
14385 return None;
14386 }
14387 let s = false;
14388 let thumb = (1) != 0;
14389 let cond = Cond::default();
14390 let rd = Reg::parse(((value) >> 8) & 0x7, pc);
14391 let rn = Reg::parse(13, pc);
14392 let op2 = Op2::Imm(((value) & 0xff) << 2);
14393 Some((
14394 Ins::Add {
14395 s,
14396 thumb,
14397 cond,
14398 rd,
14399 rn,
14400 op2,
14401 },
14402 2,
14403 ))
14404}
14405#[cfg(feature = "thumb")]
14406fn parse_thumb_add_5(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
14407 const VERSIONS: Versions = Versions::of(
14408 &[
14409 #[cfg(feature = "v4t")]
14410 Version::V4T,
14411 #[cfg(feature = "v5t")]
14412 Version::V5T,
14413 #[cfg(feature = "v5te")]
14414 Version::V5Te,
14415 #[cfg(feature = "v5tej")]
14416 Version::V5Tej,
14417 #[cfg(feature = "v6")]
14418 Version::V6,
14419 #[cfg(feature = "v6k")]
14420 Version::V6K,
14421 ],
14422 );
14423 if !VERSIONS.has(options.version) {
14424 return None;
14425 }
14426 let s = false;
14427 let thumb = (1) != 0;
14428 let cond = Cond::default();
14429 let rd = Reg::parse(13, pc);
14430 let rn = Reg::parse(13, pc);
14431 let op2 = Op2::Imm(((value) & 0x7f) << 2);
14432 Some((
14433 Ins::Add {
14434 s,
14435 thumb,
14436 cond,
14437 rd,
14438 rn,
14439 op2,
14440 },
14441 2,
14442 ))
14443}
14444#[cfg(feature = "thumb")]
14445fn parse_thumb_add_6(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
14446 const VERSIONS: Versions = Versions::of(
14447 &[
14448 #[cfg(feature = "v4t")]
14449 Version::V4T,
14450 #[cfg(feature = "v5t")]
14451 Version::V5T,
14452 #[cfg(feature = "v5te")]
14453 Version::V5Te,
14454 #[cfg(feature = "v5tej")]
14455 Version::V5Tej,
14456 #[cfg(feature = "v6")]
14457 Version::V6,
14458 #[cfg(feature = "v6k")]
14459 Version::V6K,
14460 ],
14461 );
14462 if !VERSIONS.has(options.version) {
14463 return None;
14464 }
14465 let s = false;
14466 let thumb = (1) != 0;
14467 let cond = Cond::default();
14468 let rd = Reg::parse(((((value) >> 7) & 0x1) << 3) | ((value) & 0x7), pc);
14469 let rn = Reg::parse(13, pc);
14470 let op2 = Op2::ShiftImm(ShiftImm {
14471 rm: Reg::parse(((((value) >> 7) & 0x1) << 3) | ((value) & 0x7), pc),
14472 shift_op: ShiftOp::default(),
14473 imm: 0,
14474 });
14475 Some((
14476 Ins::Add {
14477 s,
14478 thumb,
14479 cond,
14480 rd,
14481 rn,
14482 op2,
14483 },
14484 2,
14485 ))
14486}
14487#[cfg(feature = "thumb")]
14488fn parse_thumb_add_7(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
14489 const VERSIONS: Versions = Versions::of(
14490 &[
14491 #[cfg(feature = "v4t")]
14492 Version::V4T,
14493 #[cfg(feature = "v5t")]
14494 Version::V5T,
14495 #[cfg(feature = "v5te")]
14496 Version::V5Te,
14497 #[cfg(feature = "v5tej")]
14498 Version::V5Tej,
14499 #[cfg(feature = "v6")]
14500 Version::V6,
14501 #[cfg(feature = "v6k")]
14502 Version::V6K,
14503 ],
14504 );
14505 if !VERSIONS.has(options.version) {
14506 return None;
14507 }
14508 let s = false;
14509 let thumb = (1) != 0;
14510 let cond = Cond::default();
14511 let rd = Reg::parse(13, pc);
14512 let rn = Reg::parse(13, pc);
14513 let op2 = Op2::ShiftImm(ShiftImm {
14514 rm: Reg::parse(((value) >> 3) & 0xf, pc),
14515 shift_op: ShiftOp::default(),
14516 imm: 0,
14517 });
14518 Some((
14519 Ins::Add {
14520 s,
14521 thumb,
14522 cond,
14523 rd,
14524 rn,
14525 op2,
14526 },
14527 2,
14528 ))
14529}
14530#[cfg(feature = "thumb")]
14531fn parse_thumb_add_8(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
14532 const VERSIONS: Versions = Versions::of(
14533 &[
14534 #[cfg(feature = "v4t")]
14535 Version::V4T,
14536 #[cfg(feature = "v5t")]
14537 Version::V5T,
14538 #[cfg(feature = "v5te")]
14539 Version::V5Te,
14540 #[cfg(feature = "v5tej")]
14541 Version::V5Tej,
14542 #[cfg(feature = "v6")]
14543 Version::V6,
14544 #[cfg(feature = "v6k")]
14545 Version::V6K,
14546 ],
14547 );
14548 if !VERSIONS.has(options.version) {
14549 return None;
14550 }
14551 let s = false;
14552 let thumb = (1) != 0;
14553 let cond = Cond::default();
14554 let rd = Reg::parse(((value) >> 8) & 0x7, pc);
14555 let rn = Reg::parse(15, pc);
14556 let op2 = Op2::Imm(((value) & 0xff) << 2);
14557 Some((
14558 Ins::Add {
14559 s,
14560 thumb,
14561 cond,
14562 rd,
14563 rn,
14564 op2,
14565 },
14566 2,
14567 ))
14568}
14569#[cfg(feature = "arm")]
14570fn parse_arm_and_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
14571 if value & 0xf0000000 == 0xf0000000 {
14572 return Some(Ins::Illegal);
14573 }
14574 let s = (((value) >> 20) & 0x1) != 0;
14575 let thumb = false;
14576 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
14577 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
14578 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
14579 let Some(op2) = Op2::parse(value, pc) else {
14580 return Some(Ins::Illegal);
14581 };
14582 Some(Ins::And {
14583 s,
14584 thumb,
14585 cond,
14586 rd,
14587 rn,
14588 op2,
14589 })
14590}
14591#[cfg(feature = "thumb")]
14592fn parse_thumb_and_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
14593 const VERSIONS: Versions = Versions::of(
14594 &[
14595 #[cfg(feature = "v4t")]
14596 Version::V4T,
14597 #[cfg(feature = "v5t")]
14598 Version::V5T,
14599 #[cfg(feature = "v5te")]
14600 Version::V5Te,
14601 #[cfg(feature = "v5tej")]
14602 Version::V5Tej,
14603 #[cfg(feature = "v6")]
14604 Version::V6,
14605 #[cfg(feature = "v6k")]
14606 Version::V6K,
14607 ],
14608 );
14609 if !VERSIONS.has(options.version) {
14610 return None;
14611 }
14612 let s = (1) != 0;
14613 let thumb = (1) != 0;
14614 let cond = Cond::default();
14615 let rd = Reg::parse((value) & 0x7, pc);
14616 let rn = Reg::parse((value) & 0x7, pc);
14617 let op2 = Op2::ShiftImm(ShiftImm {
14618 rm: Reg::parse(((value) >> 3) & 0x7, pc),
14619 shift_op: ShiftOp::default(),
14620 imm: 0,
14621 });
14622 Some((
14623 Ins::And {
14624 s,
14625 thumb,
14626 cond,
14627 rd,
14628 rn,
14629 op2,
14630 },
14631 2,
14632 ))
14633}
14634#[cfg(feature = "arm")]
14635fn parse_arm_asr_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
14636 if !options.ual {
14637 return None;
14638 }
14639 if value & 0xf0000000 == 0xf0000000 {
14640 return Some(Ins::Illegal);
14641 }
14642 let s = (((value) >> 20) & 0x1) != 0;
14643 let thumb = false;
14644 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
14645 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
14646 let rn = Reg::parse((value) & 0xf, pc);
14647 let Some(op2) = Op2Shift::parse(value, pc) else {
14648 return Some(Ins::Illegal);
14649 };
14650 Some(Ins::Asr {
14651 s,
14652 thumb,
14653 cond,
14654 rd,
14655 rn,
14656 op2,
14657 })
14658}
14659#[cfg(feature = "thumb")]
14660fn parse_thumb_asr_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
14661 const VERSIONS: Versions = Versions::of(
14662 &[
14663 #[cfg(feature = "v4t")]
14664 Version::V4T,
14665 #[cfg(feature = "v5t")]
14666 Version::V5T,
14667 #[cfg(feature = "v5te")]
14668 Version::V5Te,
14669 #[cfg(feature = "v5tej")]
14670 Version::V5Tej,
14671 #[cfg(feature = "v6")]
14672 Version::V6,
14673 #[cfg(feature = "v6k")]
14674 Version::V6K,
14675 ],
14676 );
14677 if !VERSIONS.has(options.version) {
14678 return None;
14679 }
14680 let s = (1) != 0;
14681 let thumb = (1) != 0;
14682 let cond = Cond::default();
14683 let rd = Reg::parse((value) & 0x7, pc);
14684 let rn = Reg::parse(((value) >> 3) & 0x7, pc);
14685 let op2 = Op2Shift::Imm(
14686 if (((value) >> 6) & 0x1f) != 0 { (((value) >> 6) & 0x1f) } else { 32 },
14687 );
14688 Some((
14689 Ins::Asr {
14690 s,
14691 thumb,
14692 cond,
14693 rd,
14694 rn,
14695 op2,
14696 },
14697 2,
14698 ))
14699}
14700#[cfg(feature = "thumb")]
14701fn parse_thumb_asr_1(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
14702 const VERSIONS: Versions = Versions::of(
14703 &[
14704 #[cfg(feature = "v4t")]
14705 Version::V4T,
14706 #[cfg(feature = "v5t")]
14707 Version::V5T,
14708 #[cfg(feature = "v5te")]
14709 Version::V5Te,
14710 #[cfg(feature = "v5tej")]
14711 Version::V5Tej,
14712 #[cfg(feature = "v6")]
14713 Version::V6,
14714 #[cfg(feature = "v6k")]
14715 Version::V6K,
14716 ],
14717 );
14718 if !VERSIONS.has(options.version) {
14719 return None;
14720 }
14721 let s = (1) != 0;
14722 let thumb = (1) != 0;
14723 let cond = Cond::default();
14724 let rd = Reg::parse((value) & 0x7, pc);
14725 let rn = Reg::parse((value) & 0x7, pc);
14726 let op2 = Op2Shift::Reg(Reg::parse(((value) >> 3) & 0x7, pc));
14727 Some((
14728 Ins::Asr {
14729 s,
14730 thumb,
14731 cond,
14732 rd,
14733 rn,
14734 op2,
14735 },
14736 2,
14737 ))
14738}
14739#[cfg(feature = "arm")]
14740fn parse_arm_b_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
14741 if value & 0xf0000000 == 0xf0000000 {
14742 return Some(Ins::Illegal);
14743 }
14744 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
14745 let target = BranchTarget::parse(
14746 ((((((value) & 0xffffff) << 2) as i32) << 6 >> 6) as u32).wrapping_add(8),
14747 pc,
14748 );
14749 Some(Ins::B { cond, target })
14750}
14751#[cfg(feature = "thumb")]
14752fn parse_thumb_b_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
14753 const VERSIONS: Versions = Versions::of(
14754 &[
14755 #[cfg(feature = "v4t")]
14756 Version::V4T,
14757 #[cfg(feature = "v5t")]
14758 Version::V5T,
14759 #[cfg(feature = "v5te")]
14760 Version::V5Te,
14761 #[cfg(feature = "v5tej")]
14762 Version::V5Tej,
14763 #[cfg(feature = "v6")]
14764 Version::V6,
14765 #[cfg(feature = "v6k")]
14766 Version::V6K,
14767 ],
14768 );
14769 if !VERSIONS.has(options.version) {
14770 return None;
14771 }
14772 if value & 0xf00 == 0xf00 {
14773 return Some((Ins::Illegal, 2));
14774 }
14775 let cond = Cond::parse(((value) >> 8) & 0xf, pc);
14776 let target = BranchTarget::parse(
14777 ((((((value) & 0xff) << 1) as i32) << 23 >> 23) as u32).wrapping_add(4),
14778 pc,
14779 );
14780 Some((Ins::B { cond, target }, 2))
14781}
14782#[cfg(feature = "thumb")]
14783fn parse_thumb_b_1(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
14784 const VERSIONS: Versions = Versions::of(
14785 &[
14786 #[cfg(feature = "v4t")]
14787 Version::V4T,
14788 #[cfg(feature = "v5t")]
14789 Version::V5T,
14790 #[cfg(feature = "v5te")]
14791 Version::V5Te,
14792 #[cfg(feature = "v5tej")]
14793 Version::V5Tej,
14794 #[cfg(feature = "v6")]
14795 Version::V6,
14796 #[cfg(feature = "v6k")]
14797 Version::V6K,
14798 ],
14799 );
14800 if !VERSIONS.has(options.version) {
14801 return None;
14802 }
14803 let cond = Cond::default();
14804 let target = BranchTarget::parse(
14805 ((((((value) & 0x7ff) << 1) as i32) << 20 >> 20) as u32).wrapping_add(4),
14806 pc,
14807 );
14808 Some((Ins::B { cond, target }, 2))
14809}
14810#[cfg(feature = "arm")]
14811fn parse_arm_bic_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
14812 if value & 0xf0000000 == 0xf0000000 {
14813 return Some(Ins::Illegal);
14814 }
14815 let s = (((value) >> 20) & 0x1) != 0;
14816 let thumb = false;
14817 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
14818 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
14819 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
14820 let Some(op2) = Op2::parse(value, pc) else {
14821 return Some(Ins::Illegal);
14822 };
14823 Some(Ins::Bic {
14824 s,
14825 thumb,
14826 cond,
14827 rd,
14828 rn,
14829 op2,
14830 })
14831}
14832#[cfg(feature = "thumb")]
14833fn parse_thumb_bic_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
14834 const VERSIONS: Versions = Versions::of(
14835 &[
14836 #[cfg(feature = "v4t")]
14837 Version::V4T,
14838 #[cfg(feature = "v5t")]
14839 Version::V5T,
14840 #[cfg(feature = "v5te")]
14841 Version::V5Te,
14842 #[cfg(feature = "v5tej")]
14843 Version::V5Tej,
14844 #[cfg(feature = "v6")]
14845 Version::V6,
14846 #[cfg(feature = "v6k")]
14847 Version::V6K,
14848 ],
14849 );
14850 if !VERSIONS.has(options.version) {
14851 return None;
14852 }
14853 let s = (1) != 0;
14854 let thumb = (1) != 0;
14855 let cond = Cond::default();
14856 let rd = Reg::parse((value) & 0x7, pc);
14857 let rn = Reg::parse((value) & 0x7, pc);
14858 let op2 = Op2::ShiftImm(ShiftImm {
14859 rm: Reg::parse(((value) >> 3) & 0x7, pc),
14860 shift_op: ShiftOp::default(),
14861 imm: 0,
14862 });
14863 Some((
14864 Ins::Bic {
14865 s,
14866 thumb,
14867 cond,
14868 rd,
14869 rn,
14870 op2,
14871 },
14872 2,
14873 ))
14874}
14875#[cfg(
14876 all(
14877 feature = "arm",
14878 any(
14879 feature = "v5t",
14880 feature = "v5te",
14881 feature = "v5tej",
14882 feature = "v6",
14883 feature = "v6k"
14884 )
14885 )
14886)]
14887fn parse_arm_bkpt_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
14888 const VERSIONS: Versions = Versions::of(
14889 &[
14890 #[cfg(feature = "v5t")]
14891 Version::V5T,
14892 #[cfg(feature = "v5te")]
14893 Version::V5Te,
14894 #[cfg(feature = "v5tej")]
14895 Version::V5Tej,
14896 #[cfg(feature = "v6")]
14897 Version::V6,
14898 #[cfg(feature = "v6k")]
14899 Version::V6K,
14900 ],
14901 );
14902 if !VERSIONS.has(options.version) {
14903 return None;
14904 }
14905 let imm = ((((value) >> 8) & 0xfff) << 4) | ((value) & 0xf);
14906 Some(Ins::Bkpt { imm })
14907}
14908#[cfg(
14909 all(
14910 feature = "thumb",
14911 any(
14912 feature = "v5t",
14913 feature = "v5te",
14914 feature = "v5tej",
14915 feature = "v6",
14916 feature = "v6k"
14917 )
14918 )
14919)]
14920fn parse_thumb_bkpt_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
14921 const VERSIONS: Versions = Versions::of(
14922 &[
14923 #[cfg(feature = "v5t")]
14924 Version::V5T,
14925 #[cfg(feature = "v5te")]
14926 Version::V5Te,
14927 #[cfg(feature = "v5tej")]
14928 Version::V5Tej,
14929 #[cfg(feature = "v6")]
14930 Version::V6,
14931 #[cfg(feature = "v6k")]
14932 Version::V6K,
14933 ],
14934 );
14935 if !VERSIONS.has(options.version) {
14936 return None;
14937 }
14938 let imm = (value) & 0xff;
14939 Some((Ins::Bkpt { imm }, 2))
14940}
14941#[cfg(feature = "arm")]
14942fn parse_arm_bl_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
14943 if value & 0xf0000000 == 0xf0000000 {
14944 return Some(Ins::Illegal);
14945 }
14946 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
14947 let target = BranchTarget::parse(
14948 ((((((value) & 0xffffff) << 2) as i32) << 6 >> 6) as u32).wrapping_add(8),
14949 pc,
14950 );
14951 Some(Ins::Bl { cond, target })
14952}
14953#[cfg(feature = "thumb")]
14954fn parse_thumb_bl_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
14955 const VERSIONS: Versions = Versions::of(
14956 &[
14957 #[cfg(feature = "v4t")]
14958 Version::V4T,
14959 #[cfg(feature = "v5t")]
14960 Version::V5T,
14961 #[cfg(feature = "v5te")]
14962 Version::V5Te,
14963 #[cfg(feature = "v5tej")]
14964 Version::V5Tej,
14965 #[cfg(feature = "v6")]
14966 Version::V6,
14967 #[cfg(feature = "v6k")]
14968 Version::V6K,
14969 ],
14970 );
14971 if !VERSIONS.has(options.version) {
14972 return None;
14973 }
14974 let cond = Cond::default();
14975 let target = BranchTarget::parse(
14976 (((((((value) & 0x7ff) << 12) | ((((value) >> 16) & 0x7ff) << 1)) as i32) << 9
14977 >> 9) as u32)
14978 .wrapping_add(4),
14979 pc,
14980 );
14981 Some((Ins::Bl { cond, target }, 4))
14982}
14983#[cfg(
14984 all(
14985 feature = "arm",
14986 any(
14987 feature = "v5t",
14988 feature = "v5te",
14989 feature = "v5tej",
14990 feature = "v6",
14991 feature = "v6k"
14992 )
14993 )
14994)]
14995fn parse_arm_blx_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
14996 const VERSIONS: Versions = Versions::of(
14997 &[
14998 #[cfg(feature = "v5t")]
14999 Version::V5T,
15000 #[cfg(feature = "v5te")]
15001 Version::V5Te,
15002 #[cfg(feature = "v5tej")]
15003 Version::V5Tej,
15004 #[cfg(feature = "v6")]
15005 Version::V6,
15006 #[cfg(feature = "v6k")]
15007 Version::V6K,
15008 ],
15009 );
15010 if !VERSIONS.has(options.version) {
15011 return None;
15012 }
15013 let cond = Cond::default();
15014 let target = BlxTarget::Direct(
15015 BranchTarget::parse(
15016 (((((((value) & 0xffffff) << 2) | ((((value) >> 24) & 0x1) << 1)) as i32)
15017 << 6 >> 6) as u32)
15018 .wrapping_add(8),
15019 pc,
15020 ),
15021 );
15022 Some(Ins::Blx { cond, target })
15023}
15024#[cfg(
15025 all(
15026 feature = "arm",
15027 any(
15028 feature = "v5t",
15029 feature = "v5te",
15030 feature = "v5tej",
15031 feature = "v6",
15032 feature = "v6k"
15033 )
15034 )
15035)]
15036fn parse_arm_blx_1(value: u32, pc: u32, options: &Options) -> Option<Ins> {
15037 const VERSIONS: Versions = Versions::of(
15038 &[
15039 #[cfg(feature = "v5t")]
15040 Version::V5T,
15041 #[cfg(feature = "v5te")]
15042 Version::V5Te,
15043 #[cfg(feature = "v5tej")]
15044 Version::V5Tej,
15045 #[cfg(feature = "v6")]
15046 Version::V6,
15047 #[cfg(feature = "v6k")]
15048 Version::V6K,
15049 ],
15050 );
15051 if !VERSIONS.has(options.version) {
15052 return None;
15053 }
15054 if (((value) >> 8) & 0xfff) != 0xfff {
15055 return Some(Ins::Illegal);
15056 }
15057 if value & 0xf0000000 == 0xf0000000 {
15058 return Some(Ins::Illegal);
15059 }
15060 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
15061 let target = BlxTarget::Indirect(Reg::parse((value) & 0xf, pc));
15062 Some(Ins::Blx { cond, target })
15063}
15064#[cfg(
15065 all(
15066 feature = "thumb",
15067 any(
15068 feature = "v5t",
15069 feature = "v5te",
15070 feature = "v5tej",
15071 feature = "v6",
15072 feature = "v6k"
15073 )
15074 )
15075)]
15076fn parse_thumb_blx_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
15077 const VERSIONS: Versions = Versions::of(
15078 &[
15079 #[cfg(feature = "v5t")]
15080 Version::V5T,
15081 #[cfg(feature = "v5te")]
15082 Version::V5Te,
15083 #[cfg(feature = "v5tej")]
15084 Version::V5Tej,
15085 #[cfg(feature = "v6")]
15086 Version::V6,
15087 #[cfg(feature = "v6k")]
15088 Version::V6K,
15089 ],
15090 );
15091 if !VERSIONS.has(options.version) {
15092 return None;
15093 }
15094 let cond = Cond::default();
15095 let target = BlxTarget::Direct(
15096 BranchTarget::parse(
15097 (((((((value) & 0x7ff) << 12) | ((((value) >> 17) & 0x3ff) << 2)) as i32)
15098 << 9 >> 9) as u32)
15099 .wrapping_add(4),
15100 pc,
15101 ),
15102 );
15103 Some((Ins::Blx { cond, target }, 4))
15104}
15105#[cfg(
15106 all(
15107 feature = "thumb",
15108 any(
15109 feature = "v5t",
15110 feature = "v5te",
15111 feature = "v5tej",
15112 feature = "v6",
15113 feature = "v6k"
15114 )
15115 )
15116)]
15117fn parse_thumb_blx_1(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
15118 const VERSIONS: Versions = Versions::of(
15119 &[
15120 #[cfg(feature = "v5t")]
15121 Version::V5T,
15122 #[cfg(feature = "v5te")]
15123 Version::V5Te,
15124 #[cfg(feature = "v5tej")]
15125 Version::V5Tej,
15126 #[cfg(feature = "v6")]
15127 Version::V6,
15128 #[cfg(feature = "v6k")]
15129 Version::V6K,
15130 ],
15131 );
15132 if !VERSIONS.has(options.version) {
15133 return None;
15134 }
15135 let cond = Cond::default();
15136 let target = BlxTarget::Indirect(Reg::parse(((value) >> 3) & 0xf, pc));
15137 Some((Ins::Blx { cond, target }, 2))
15138}
15139#[cfg(
15140 all(
15141 feature = "arm",
15142 any(
15143 feature = "v4t",
15144 feature = "v5t",
15145 feature = "v5te",
15146 feature = "v5tej",
15147 feature = "v6",
15148 feature = "v6k"
15149 )
15150 )
15151)]
15152fn parse_arm_bx_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
15153 const VERSIONS: Versions = Versions::of(
15154 &[
15155 #[cfg(feature = "v4t")]
15156 Version::V4T,
15157 #[cfg(feature = "v5t")]
15158 Version::V5T,
15159 #[cfg(feature = "v5te")]
15160 Version::V5Te,
15161 #[cfg(feature = "v5tej")]
15162 Version::V5Tej,
15163 #[cfg(feature = "v6")]
15164 Version::V6,
15165 #[cfg(feature = "v6k")]
15166 Version::V6K,
15167 ],
15168 );
15169 if !VERSIONS.has(options.version) {
15170 return None;
15171 }
15172 if (((value) >> 8) & 0xfff) != 0xfff {
15173 return Some(Ins::Illegal);
15174 }
15175 if value & 0xf0000000 == 0xf0000000 {
15176 return Some(Ins::Illegal);
15177 }
15178 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
15179 let rm = Reg::parse((value) & 0xf, pc);
15180 Some(Ins::Bx { cond, rm })
15181}
15182#[cfg(feature = "thumb")]
15183fn parse_thumb_bx_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
15184 const VERSIONS: Versions = Versions::of(
15185 &[
15186 #[cfg(feature = "v4t")]
15187 Version::V4T,
15188 #[cfg(feature = "v5t")]
15189 Version::V5T,
15190 #[cfg(feature = "v5te")]
15191 Version::V5Te,
15192 #[cfg(feature = "v5tej")]
15193 Version::V5Tej,
15194 #[cfg(feature = "v6")]
15195 Version::V6,
15196 #[cfg(feature = "v6k")]
15197 Version::V6K,
15198 ],
15199 );
15200 if !VERSIONS.has(options.version) {
15201 return None;
15202 }
15203 let cond = Cond::default();
15204 let rm = Reg::parse(((value) >> 3) & 0xf, pc);
15205 Some((Ins::Bx { cond, rm }, 2))
15206}
15207#[cfg(all(feature = "arm", any(feature = "v5tej", feature = "v6", feature = "v6k")))]
15208fn parse_arm_bxj_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
15209 const VERSIONS: Versions = Versions::of(
15210 &[
15211 #[cfg(feature = "v5tej")]
15212 Version::V5Tej,
15213 #[cfg(feature = "v6")]
15214 Version::V6,
15215 #[cfg(feature = "v6k")]
15216 Version::V6K,
15217 ],
15218 );
15219 if !VERSIONS.has(options.version) {
15220 return None;
15221 }
15222 if (((value) >> 8) & 0xfff) != 0xfff {
15223 return Some(Ins::Illegal);
15224 }
15225 if value & 0xf0000000 == 0xf0000000 {
15226 return Some(Ins::Illegal);
15227 }
15228 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
15229 let rm = Reg::parse((value) & 0xf, pc);
15230 Some(Ins::Bxj { cond, rm })
15231}
15232#[cfg(feature = "arm")]
15233fn parse_arm_cdp_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
15234 if value & 0xf0000000 == 0xf0000000 {
15235 return Some(Ins::Illegal);
15236 }
15237 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
15238 let coproc = Coproc::parse(((value) >> 8) & 0xf, pc);
15239 let opc1 = ((value) >> 20) & 0xf;
15240 let crd = CoReg::parse(((value) >> 12) & 0xf, pc);
15241 let crn = CoReg::parse(((value) >> 16) & 0xf, pc);
15242 let crm = CoReg::parse((value) & 0xf, pc);
15243 let opc2 = ((value) >> 5) & 0x7;
15244 Some(Ins::Cdp {
15245 cond,
15246 coproc,
15247 opc1,
15248 crd,
15249 crn,
15250 crm,
15251 opc2,
15252 })
15253}
15254#[cfg(
15255 all(
15256 feature = "arm",
15257 any(
15258 feature = "v5t",
15259 feature = "v5te",
15260 feature = "v5tej",
15261 feature = "v6",
15262 feature = "v6k"
15263 )
15264 )
15265)]
15266fn parse_arm_cdp2_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
15267 const VERSIONS: Versions = Versions::of(
15268 &[
15269 #[cfg(feature = "v5t")]
15270 Version::V5T,
15271 #[cfg(feature = "v5te")]
15272 Version::V5Te,
15273 #[cfg(feature = "v5tej")]
15274 Version::V5Tej,
15275 #[cfg(feature = "v6")]
15276 Version::V6,
15277 #[cfg(feature = "v6k")]
15278 Version::V6K,
15279 ],
15280 );
15281 if !VERSIONS.has(options.version) {
15282 return None;
15283 }
15284 let coproc = Coproc::parse(((value) >> 8) & 0xf, pc);
15285 let opc1 = ((value) >> 20) & 0xf;
15286 let crd = CoReg::parse(((value) >> 12) & 0xf, pc);
15287 let crn = CoReg::parse(((value) >> 16) & 0xf, pc);
15288 let crm = CoReg::parse((value) & 0xf, pc);
15289 let opc2 = ((value) >> 5) & 0x7;
15290 Some(Ins::Cdp2 {
15291 coproc,
15292 opc1,
15293 crd,
15294 crn,
15295 crm,
15296 opc2,
15297 })
15298}
15299#[cfg(all(feature = "arm", feature = "v6k"))]
15300fn parse_arm_clrex_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
15301 const VERSIONS: Versions = Versions::of(&[#[cfg(feature = "v6k")] Version::V6K]);
15302 if !VERSIONS.has(options.version) {
15303 return None;
15304 }
15305 if value & 0xfff0f != 0xff00f {
15306 return Some(Ins::Illegal);
15307 }
15308 Some(Ins::Clrex {})
15309}
15310#[cfg(
15311 all(
15312 feature = "arm",
15313 any(
15314 feature = "v5t",
15315 feature = "v5te",
15316 feature = "v5tej",
15317 feature = "v6",
15318 feature = "v6k"
15319 )
15320 )
15321)]
15322fn parse_arm_clz_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
15323 const VERSIONS: Versions = Versions::of(
15324 &[
15325 #[cfg(feature = "v5t")]
15326 Version::V5T,
15327 #[cfg(feature = "v5te")]
15328 Version::V5Te,
15329 #[cfg(feature = "v5tej")]
15330 Version::V5Tej,
15331 #[cfg(feature = "v6")]
15332 Version::V6,
15333 #[cfg(feature = "v6k")]
15334 Version::V6K,
15335 ],
15336 );
15337 if !VERSIONS.has(options.version) {
15338 return None;
15339 }
15340 if value & 0xf0f00 != 0xf0f00 {
15341 return Some(Ins::Illegal);
15342 }
15343 if value & 0xf0000000 == 0xf0000000 {
15344 return Some(Ins::Illegal);
15345 }
15346 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
15347 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
15348 let rm = Reg::parse((value) & 0xf, pc);
15349 Some(Ins::Clz { cond, rd, rm })
15350}
15351#[cfg(feature = "arm")]
15352fn parse_arm_cmn_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
15353 if value & 0xf000 != 0 {
15354 return Some(Ins::Illegal);
15355 }
15356 if value & 0xf0000000 == 0xf0000000 {
15357 return Some(Ins::Illegal);
15358 }
15359 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
15360 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
15361 let Some(op2) = Op2::parse(value, pc) else {
15362 return Some(Ins::Illegal);
15363 };
15364 Some(Ins::Cmn { cond, rn, op2 })
15365}
15366#[cfg(feature = "thumb")]
15367fn parse_thumb_cmn_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
15368 const VERSIONS: Versions = Versions::of(
15369 &[
15370 #[cfg(feature = "v4t")]
15371 Version::V4T,
15372 #[cfg(feature = "v5t")]
15373 Version::V5T,
15374 #[cfg(feature = "v5te")]
15375 Version::V5Te,
15376 #[cfg(feature = "v5tej")]
15377 Version::V5Tej,
15378 #[cfg(feature = "v6")]
15379 Version::V6,
15380 #[cfg(feature = "v6k")]
15381 Version::V6K,
15382 ],
15383 );
15384 if !VERSIONS.has(options.version) {
15385 return None;
15386 }
15387 let cond = Cond::default();
15388 let rn = Reg::parse((value) & 0x7, pc);
15389 let op2 = Op2::ShiftImm(ShiftImm {
15390 rm: Reg::parse(((value) >> 3) & 0x7, pc),
15391 shift_op: ShiftOp::default(),
15392 imm: 0,
15393 });
15394 Some((Ins::Cmn { cond, rn, op2 }, 2))
15395}
15396#[cfg(feature = "arm")]
15397fn parse_arm_cmp_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
15398 if value & 0xf000 != 0 {
15399 return Some(Ins::Illegal);
15400 }
15401 if value & 0xf0000000 == 0xf0000000 {
15402 return Some(Ins::Illegal);
15403 }
15404 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
15405 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
15406 let Some(op2) = Op2::parse(value, pc) else {
15407 return Some(Ins::Illegal);
15408 };
15409 Some(Ins::Cmp { cond, rn, op2 })
15410}
15411#[cfg(feature = "thumb")]
15412fn parse_thumb_cmp_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
15413 const VERSIONS: Versions = Versions::of(
15414 &[
15415 #[cfg(feature = "v4t")]
15416 Version::V4T,
15417 #[cfg(feature = "v5t")]
15418 Version::V5T,
15419 #[cfg(feature = "v5te")]
15420 Version::V5Te,
15421 #[cfg(feature = "v5tej")]
15422 Version::V5Tej,
15423 #[cfg(feature = "v6")]
15424 Version::V6,
15425 #[cfg(feature = "v6k")]
15426 Version::V6K,
15427 ],
15428 );
15429 if !VERSIONS.has(options.version) {
15430 return None;
15431 }
15432 let cond = Cond::default();
15433 let rn = Reg::parse(((value) >> 8) & 0x7, pc);
15434 let op2 = Op2::Imm((value) & 0xff);
15435 Some((Ins::Cmp { cond, rn, op2 }, 2))
15436}
15437#[cfg(feature = "thumb")]
15438fn parse_thumb_cmp_1(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
15439 const VERSIONS: Versions = Versions::of(
15440 &[
15441 #[cfg(feature = "v4t")]
15442 Version::V4T,
15443 #[cfg(feature = "v5t")]
15444 Version::V5T,
15445 #[cfg(feature = "v5te")]
15446 Version::V5Te,
15447 #[cfg(feature = "v5tej")]
15448 Version::V5Tej,
15449 #[cfg(feature = "v6")]
15450 Version::V6,
15451 #[cfg(feature = "v6k")]
15452 Version::V6K,
15453 ],
15454 );
15455 if !VERSIONS.has(options.version) {
15456 return None;
15457 }
15458 let cond = Cond::default();
15459 let rn = Reg::parse((value) & 0x7, pc);
15460 let op2 = Op2::ShiftImm(ShiftImm {
15461 rm: Reg::parse(((value) >> 3) & 0x7, pc),
15462 shift_op: ShiftOp::default(),
15463 imm: 0,
15464 });
15465 Some((Ins::Cmp { cond, rn, op2 }, 2))
15466}
15467#[cfg(feature = "thumb")]
15468fn parse_thumb_cmp_2(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
15469 const VERSIONS: Versions = Versions::of(
15470 &[
15471 #[cfg(feature = "v4t")]
15472 Version::V4T,
15473 #[cfg(feature = "v5t")]
15474 Version::V5T,
15475 #[cfg(feature = "v5te")]
15476 Version::V5Te,
15477 #[cfg(feature = "v5tej")]
15478 Version::V5Tej,
15479 #[cfg(feature = "v6")]
15480 Version::V6,
15481 #[cfg(feature = "v6k")]
15482 Version::V6K,
15483 ],
15484 );
15485 if !VERSIONS.has(options.version) {
15486 return None;
15487 }
15488 let cond = Cond::default();
15489 let rn = Reg::parse(((((value) >> 7) & 0x1) << 3) | ((value) & 0x7), pc);
15490 let op2 = Op2::ShiftImm(ShiftImm {
15491 rm: Reg::parse(((value) >> 3) & 0xf, pc),
15492 shift_op: ShiftOp::default(),
15493 imm: 0,
15494 });
15495 Some((Ins::Cmp { cond, rn, op2 }, 2))
15496}
15497#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
15498fn parse_arm_cps_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
15499 const VERSIONS: Versions = Versions::of(
15500 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
15501 );
15502 if !VERSIONS.has(options.version) {
15503 return None;
15504 }
15505 if value & 0xfe00 != 0 {
15506 return Some(Ins::Illegal);
15507 }
15508 let Some(effect) = CpsEffect::parse(((value) >> 18) & 0x3, pc) else {
15509 return Some(Ins::Illegal);
15510 };
15511 let aif = AifFlags::parse(((value) >> 6) & 0x7, pc);
15512 let mode = (value) & 0x1f;
15513 Some(Ins::Cps { effect, aif, mode })
15514}
15515#[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
15516fn parse_thumb_cps_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
15517 const VERSIONS: Versions = Versions::of(
15518 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
15519 );
15520 if !VERSIONS.has(options.version) {
15521 return None;
15522 }
15523 let Some(effect) = CpsEffect::parse(((value) >> 4) & 0x3, pc) else {
15524 return Some((Ins::Illegal, 2));
15525 };
15526 let aif = AifFlags::parse((value) & 0x7, pc);
15527 let mode = 0;
15528 Some((Ins::Cps { effect, aif, mode }, 2))
15529}
15530#[cfg(feature = "arm")]
15531fn parse_arm_csdb_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
15532 if value & 0xff00 != 0xf000 {
15533 return Some(Ins::Illegal);
15534 }
15535 if value & 0xf0000000 == 0xf0000000 {
15536 return Some(Ins::Illegal);
15537 }
15538 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
15539 Some(Ins::Csdb { cond })
15540}
15541#[cfg(all(feature = "arm", feature = "v6k"))]
15542fn parse_arm_dbg_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
15543 const VERSIONS: Versions = Versions::of(&[#[cfg(feature = "v6k")] Version::V6K]);
15544 if !VERSIONS.has(options.version) {
15545 return None;
15546 }
15547 if value & 0xff00 != 0xf000 {
15548 return Some(Ins::Illegal);
15549 }
15550 if value & 0xf0000000 == 0xf0000000 {
15551 return Some(Ins::Illegal);
15552 }
15553 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
15554 let option = (value) & 0xf;
15555 Some(Ins::Dbg { cond, option })
15556}
15557#[cfg(feature = "arm")]
15558fn parse_arm_eor_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
15559 if value & 0xf0000000 == 0xf0000000 {
15560 return Some(Ins::Illegal);
15561 }
15562 let s = (((value) >> 20) & 0x1) != 0;
15563 let thumb = false;
15564 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
15565 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
15566 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
15567 let Some(op2) = Op2::parse(value, pc) else {
15568 return Some(Ins::Illegal);
15569 };
15570 Some(Ins::Eor {
15571 s,
15572 thumb,
15573 cond,
15574 rd,
15575 rn,
15576 op2,
15577 })
15578}
15579#[cfg(feature = "thumb")]
15580fn parse_thumb_eor_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
15581 const VERSIONS: Versions = Versions::of(
15582 &[
15583 #[cfg(feature = "v4t")]
15584 Version::V4T,
15585 #[cfg(feature = "v5t")]
15586 Version::V5T,
15587 #[cfg(feature = "v5te")]
15588 Version::V5Te,
15589 #[cfg(feature = "v5tej")]
15590 Version::V5Tej,
15591 #[cfg(feature = "v6")]
15592 Version::V6,
15593 #[cfg(feature = "v6k")]
15594 Version::V6K,
15595 ],
15596 );
15597 if !VERSIONS.has(options.version) {
15598 return None;
15599 }
15600 let s = (1) != 0;
15601 let thumb = (1) != 0;
15602 let cond = Cond::default();
15603 let rd = Reg::parse((value) & 0x7, pc);
15604 let rn = Reg::parse((value) & 0x7, pc);
15605 let op2 = Op2::ShiftImm(ShiftImm {
15606 rm: Reg::parse(((value) >> 3) & 0x7, pc),
15607 shift_op: ShiftOp::default(),
15608 imm: 0,
15609 });
15610 Some((
15611 Ins::Eor {
15612 s,
15613 thumb,
15614 cond,
15615 rd,
15616 rn,
15617 op2,
15618 },
15619 2,
15620 ))
15621}
15622#[cfg(feature = "arm")]
15623fn parse_arm_ldc_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
15624 if value & 0xf0000000 == 0xf0000000 {
15625 return Some(Ins::Illegal);
15626 }
15627 let l = (((value) >> 22) & 0x1) != 0;
15628 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
15629 let coproc = Coproc::parse(((value) >> 8) & 0xf, pc);
15630 let crd = CoReg::parse(((value) >> 12) & 0xf, pc);
15631 let Some(dest) = AddrLdcStc::parse(value, pc) else {
15632 return Some(Ins::Illegal);
15633 };
15634 Some(Ins::Ldc {
15635 l,
15636 cond,
15637 coproc,
15638 crd,
15639 dest,
15640 })
15641}
15642#[cfg(
15643 all(
15644 feature = "arm",
15645 any(
15646 feature = "v5t",
15647 feature = "v5te",
15648 feature = "v5tej",
15649 feature = "v6",
15650 feature = "v6k"
15651 )
15652 )
15653)]
15654fn parse_arm_ldc2_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
15655 const VERSIONS: Versions = Versions::of(
15656 &[
15657 #[cfg(feature = "v5t")]
15658 Version::V5T,
15659 #[cfg(feature = "v5te")]
15660 Version::V5Te,
15661 #[cfg(feature = "v5tej")]
15662 Version::V5Tej,
15663 #[cfg(feature = "v6")]
15664 Version::V6,
15665 #[cfg(feature = "v6k")]
15666 Version::V6K,
15667 ],
15668 );
15669 if !VERSIONS.has(options.version) {
15670 return None;
15671 }
15672 let l = (((value) >> 22) & 0x1) != 0;
15673 let coproc = Coproc::parse(((value) >> 8) & 0xf, pc);
15674 let crd = CoReg::parse(((value) >> 12) & 0xf, pc);
15675 let Some(dest) = AddrLdcStc::parse(value, pc) else {
15676 return Some(Ins::Illegal);
15677 };
15678 Some(Ins::Ldc2 { l, coproc, crd, dest })
15679}
15680#[cfg(feature = "arm")]
15681fn parse_arm_ldm_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
15682 if value & 0xffff == 0 {
15683 return Some(Ins::Illegal);
15684 }
15685 if value & 0xf0000000 == 0xf0000000 {
15686 return Some(Ins::Illegal);
15687 }
15688 let mode = LdmStmMode::parse(((value) >> 23) & 0x3, pc);
15689 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
15690 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
15691 let writeback = (((value) >> 21) & 0x1) != 0;
15692 let regs = RegList::parse((value) & 0xffff);
15693 let user_mode = (0) != 0;
15694 Some(Ins::Ldm {
15695 mode,
15696 cond,
15697 rn,
15698 writeback,
15699 regs,
15700 user_mode,
15701 })
15702}
15703#[cfg(feature = "arm")]
15704fn parse_arm_ldm_1(value: u32, pc: u32, options: &Options) -> Option<Ins> {
15705 if value & 0xffff == 0 {
15706 return Some(Ins::Illegal);
15707 }
15708 if value & 0xf0000000 == 0xf0000000 {
15709 return Some(Ins::Illegal);
15710 }
15711 let mode = LdmStmMode::parse(((value) >> 23) & 0x3, pc);
15712 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
15713 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
15714 let writeback = (0) != 0;
15715 let regs = RegList::parse((value) & 0x7fff);
15716 let user_mode = (1) != 0;
15717 Some(Ins::Ldm {
15718 mode,
15719 cond,
15720 rn,
15721 writeback,
15722 regs,
15723 user_mode,
15724 })
15725}
15726#[cfg(feature = "arm")]
15727fn parse_arm_ldm_2(value: u32, pc: u32, options: &Options) -> Option<Ins> {
15728 if value & 0xf0000000 == 0xf0000000 {
15729 return Some(Ins::Illegal);
15730 }
15731 let mode = LdmStmMode::parse(((value) >> 23) & 0x3, pc);
15732 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
15733 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
15734 let writeback = (((value) >> 21) & 0x1) != 0;
15735 let regs = RegList::parse((value) & 0xffff);
15736 let user_mode = (1) != 0;
15737 Some(Ins::Ldm {
15738 mode,
15739 cond,
15740 rn,
15741 writeback,
15742 regs,
15743 user_mode,
15744 })
15745}
15746#[cfg(feature = "thumb")]
15747fn parse_thumb_ldm_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
15748 const VERSIONS: Versions = Versions::of(
15749 &[
15750 #[cfg(feature = "v4t")]
15751 Version::V4T,
15752 #[cfg(feature = "v5t")]
15753 Version::V5T,
15754 #[cfg(feature = "v5te")]
15755 Version::V5Te,
15756 #[cfg(feature = "v5tej")]
15757 Version::V5Tej,
15758 #[cfg(feature = "v6")]
15759 Version::V6,
15760 #[cfg(feature = "v6k")]
15761 Version::V6K,
15762 ],
15763 );
15764 if !VERSIONS.has(options.version) {
15765 return None;
15766 }
15767 if value & 0xff == 0 {
15768 return Some((Ins::Illegal, 2));
15769 }
15770 let mode = LdmStmMode::default();
15771 let cond = Cond::default();
15772 let rn = Reg::parse(((value) >> 8) & 0x7, pc);
15773 let writeback = ((!((value) & 0xff) >> (((value) >> 8) & 0x7)) & 1) != 0;
15774 let regs = RegList::parse((value) & 0xff);
15775 let user_mode = (0) != 0;
15776 Some((
15777 Ins::Ldm {
15778 mode,
15779 cond,
15780 rn,
15781 writeback,
15782 regs,
15783 user_mode,
15784 },
15785 2,
15786 ))
15787}
15788#[cfg(feature = "arm")]
15789fn parse_arm_ldr_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
15790 if value & 0xf0000000 == 0xf0000000 {
15791 return Some(Ins::Illegal);
15792 }
15793 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
15794 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
15795 let Some(addr) = AddrLdrStr::parse(value, pc) else {
15796 return Some(Ins::Illegal);
15797 };
15798 Some(Ins::Ldr { cond, rd, addr })
15799}
15800#[cfg(feature = "thumb")]
15801fn parse_thumb_ldr_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
15802 const VERSIONS: Versions = Versions::of(
15803 &[
15804 #[cfg(feature = "v4t")]
15805 Version::V4T,
15806 #[cfg(feature = "v5t")]
15807 Version::V5T,
15808 #[cfg(feature = "v5te")]
15809 Version::V5Te,
15810 #[cfg(feature = "v5tej")]
15811 Version::V5Tej,
15812 #[cfg(feature = "v6")]
15813 Version::V6,
15814 #[cfg(feature = "v6k")]
15815 Version::V6K,
15816 ],
15817 );
15818 if !VERSIONS.has(options.version) {
15819 return None;
15820 }
15821 let cond = Cond::default();
15822 let rd = Reg::parse((value) & 0x7, pc);
15823 let addr = AddrLdrStr::Pre {
15824 rn: Reg::parse(((value) >> 3) & 0x7, pc),
15825 offset: LdrStrOffset::Imm(((((value) >> 6) & 0x1f) << 2) as i32),
15826 writeback: false,
15827 };
15828 Some((Ins::Ldr { cond, rd, addr }, 2))
15829}
15830#[cfg(feature = "thumb")]
15831fn parse_thumb_ldr_1(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
15832 const VERSIONS: Versions = Versions::of(
15833 &[
15834 #[cfg(feature = "v4t")]
15835 Version::V4T,
15836 #[cfg(feature = "v5t")]
15837 Version::V5T,
15838 #[cfg(feature = "v5te")]
15839 Version::V5Te,
15840 #[cfg(feature = "v5tej")]
15841 Version::V5Tej,
15842 #[cfg(feature = "v6")]
15843 Version::V6,
15844 #[cfg(feature = "v6k")]
15845 Version::V6K,
15846 ],
15847 );
15848 if !VERSIONS.has(options.version) {
15849 return None;
15850 }
15851 let cond = Cond::default();
15852 let rd = Reg::parse(((value) >> 8) & 0x7, pc);
15853 let addr = AddrLdrStr::Pre {
15854 rn: Reg::parse(13, pc),
15855 offset: LdrStrOffset::Imm((((value) & 0xff) << 2) as i32),
15856 writeback: false,
15857 };
15858 Some((Ins::Ldr { cond, rd, addr }, 2))
15859}
15860#[cfg(feature = "thumb")]
15861fn parse_thumb_ldr_2(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
15862 const VERSIONS: Versions = Versions::of(
15863 &[
15864 #[cfg(feature = "v4t")]
15865 Version::V4T,
15866 #[cfg(feature = "v5t")]
15867 Version::V5T,
15868 #[cfg(feature = "v5te")]
15869 Version::V5Te,
15870 #[cfg(feature = "v5tej")]
15871 Version::V5Tej,
15872 #[cfg(feature = "v6")]
15873 Version::V6,
15874 #[cfg(feature = "v6k")]
15875 Version::V6K,
15876 ],
15877 );
15878 if !VERSIONS.has(options.version) {
15879 return None;
15880 }
15881 let cond = Cond::default();
15882 let rd = Reg::parse(((value) >> 8) & 0x7, pc);
15883 let addr = AddrLdrStr::Pre {
15884 rn: Reg::parse(15, pc),
15885 offset: LdrStrOffset::Imm((((value) & 0xff) << 2) as i32),
15886 writeback: false,
15887 };
15888 Some((Ins::Ldr { cond, rd, addr }, 2))
15889}
15890#[cfg(feature = "thumb")]
15891fn parse_thumb_ldr_3(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
15892 const VERSIONS: Versions = Versions::of(
15893 &[
15894 #[cfg(feature = "v4t")]
15895 Version::V4T,
15896 #[cfg(feature = "v5t")]
15897 Version::V5T,
15898 #[cfg(feature = "v5te")]
15899 Version::V5Te,
15900 #[cfg(feature = "v5tej")]
15901 Version::V5Tej,
15902 #[cfg(feature = "v6")]
15903 Version::V6,
15904 #[cfg(feature = "v6k")]
15905 Version::V6K,
15906 ],
15907 );
15908 if !VERSIONS.has(options.version) {
15909 return None;
15910 }
15911 let cond = Cond::default();
15912 let rd = Reg::parse((value) & 0x7, pc);
15913 let addr = AddrLdrStr::Pre {
15914 rn: Reg::parse(((value) >> 3) & 0x7, pc),
15915 offset: LdrStrOffset::Reg {
15916 subtract: false,
15917 rm: Reg::parse(((value) >> 6) & 0x7, pc),
15918 shift_op: ShiftOp::default(),
15919 imm: 0,
15920 },
15921 writeback: false,
15922 };
15923 Some((Ins::Ldr { cond, rd, addr }, 2))
15924}
15925#[cfg(feature = "arm")]
15926fn parse_arm_ldrb_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
15927 if value & 0xf0000000 == 0xf0000000 {
15928 return Some(Ins::Illegal);
15929 }
15930 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
15931 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
15932 let Some(addr) = AddrLdrStr::parse(value, pc) else {
15933 return Some(Ins::Illegal);
15934 };
15935 Some(Ins::Ldrb { cond, rd, addr })
15936}
15937#[cfg(feature = "thumb")]
15938fn parse_thumb_ldrb_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
15939 const VERSIONS: Versions = Versions::of(
15940 &[
15941 #[cfg(feature = "v4t")]
15942 Version::V4T,
15943 #[cfg(feature = "v5t")]
15944 Version::V5T,
15945 #[cfg(feature = "v5te")]
15946 Version::V5Te,
15947 #[cfg(feature = "v5tej")]
15948 Version::V5Tej,
15949 #[cfg(feature = "v6")]
15950 Version::V6,
15951 #[cfg(feature = "v6k")]
15952 Version::V6K,
15953 ],
15954 );
15955 if !VERSIONS.has(options.version) {
15956 return None;
15957 }
15958 let cond = Cond::default();
15959 let rd = Reg::parse((value) & 0x7, pc);
15960 let addr = AddrLdrStr::Pre {
15961 rn: Reg::parse(((value) >> 3) & 0x7, pc),
15962 offset: LdrStrOffset::Imm(((((value) >> 6) & 0x1f)) as i32),
15963 writeback: false,
15964 };
15965 Some((Ins::Ldrb { cond, rd, addr }, 2))
15966}
15967#[cfg(feature = "thumb")]
15968fn parse_thumb_ldrb_1(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
15969 const VERSIONS: Versions = Versions::of(
15970 &[
15971 #[cfg(feature = "v4t")]
15972 Version::V4T,
15973 #[cfg(feature = "v5t")]
15974 Version::V5T,
15975 #[cfg(feature = "v5te")]
15976 Version::V5Te,
15977 #[cfg(feature = "v5tej")]
15978 Version::V5Tej,
15979 #[cfg(feature = "v6")]
15980 Version::V6,
15981 #[cfg(feature = "v6k")]
15982 Version::V6K,
15983 ],
15984 );
15985 if !VERSIONS.has(options.version) {
15986 return None;
15987 }
15988 let cond = Cond::default();
15989 let rd = Reg::parse((value) & 0x7, pc);
15990 let addr = AddrLdrStr::Pre {
15991 rn: Reg::parse(((value) >> 3) & 0x7, pc),
15992 offset: LdrStrOffset::Reg {
15993 subtract: false,
15994 rm: Reg::parse(((value) >> 6) & 0x7, pc),
15995 shift_op: ShiftOp::default(),
15996 imm: 0,
15997 },
15998 writeback: false,
15999 };
16000 Some((Ins::Ldrb { cond, rd, addr }, 2))
16001}
16002#[cfg(feature = "arm")]
16003fn parse_arm_ldrbt_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16004 if value & 0xf0000000 == 0xf0000000 {
16005 return Some(Ins::Illegal);
16006 }
16007 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
16008 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
16009 let Some(addr) = AddrLdrStrPost::parse(value, pc) else {
16010 return Some(Ins::Illegal);
16011 };
16012 Some(Ins::Ldrbt { cond, rd, addr })
16013}
16014#[cfg(
16015 all(
16016 feature = "arm",
16017 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
16018 )
16019)]
16020fn parse_arm_ldrd_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16021 const VERSIONS: Versions = Versions::of(
16022 &[
16023 #[cfg(feature = "v5te")]
16024 Version::V5Te,
16025 #[cfg(feature = "v5tej")]
16026 Version::V5Tej,
16027 #[cfg(feature = "v6")]
16028 Version::V6,
16029 #[cfg(feature = "v6k")]
16030 Version::V6K,
16031 ],
16032 );
16033 if !VERSIONS.has(options.version) {
16034 return None;
16035 }
16036 if value & 0x1000 != 0 {
16037 return Some(Ins::Illegal);
16038 }
16039 if value & 0xf0000000 == 0xf0000000 {
16040 return Some(Ins::Illegal);
16041 }
16042 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
16043 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
16044 let rd2 = Reg::parse((((value) >> 12) & 0xf).wrapping_add(1), pc);
16045 let Some(addr) = AddrMiscLoad::parse(value, pc) else {
16046 return Some(Ins::Illegal);
16047 };
16048 Some(Ins::Ldrd { cond, rd, rd2, addr })
16049}
16050#[cfg(
16051 all(
16052 feature = "arm",
16053 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
16054 )
16055)]
16056fn parse_arm_ldrd_1(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16057 const VERSIONS: Versions = Versions::of(
16058 &[
16059 #[cfg(feature = "v5te")]
16060 Version::V5Te,
16061 #[cfg(feature = "v5tej")]
16062 Version::V5Tej,
16063 #[cfg(feature = "v6")]
16064 Version::V6,
16065 #[cfg(feature = "v6k")]
16066 Version::V6K,
16067 ],
16068 );
16069 if !VERSIONS.has(options.version) {
16070 return None;
16071 }
16072 if value & 0x01201000 != 0x01000000 {
16073 return Some(Ins::Illegal);
16074 }
16075 if value & 0xf0000000 == 0xf0000000 {
16076 return Some(Ins::Illegal);
16077 }
16078 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
16079 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
16080 let rd2 = Reg::parse((((value) >> 12) & 0xf).wrapping_add(1), pc);
16081 let Some(addr) = AddrMiscLoad::parse(value, pc) else {
16082 return Some(Ins::Illegal);
16083 };
16084 Some(Ins::Ldrd { cond, rd, rd2, addr })
16085}
16086#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
16087fn parse_arm_ldrex_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16088 const VERSIONS: Versions = Versions::of(
16089 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
16090 );
16091 if !VERSIONS.has(options.version) {
16092 return None;
16093 }
16094 if value & 0xf0f != 0xf0f {
16095 return Some(Ins::Illegal);
16096 }
16097 if value & 0xf0000000 == 0xf0000000 {
16098 return Some(Ins::Illegal);
16099 }
16100 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
16101 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
16102 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
16103 Some(Ins::Ldrex { cond, rd, rn })
16104}
16105#[cfg(all(feature = "arm", feature = "v6k"))]
16106fn parse_arm_ldrexb_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16107 const VERSIONS: Versions = Versions::of(&[#[cfg(feature = "v6k")] Version::V6K]);
16108 if !VERSIONS.has(options.version) {
16109 return None;
16110 }
16111 if value & 0xf0f != 0xf0f {
16112 return Some(Ins::Illegal);
16113 }
16114 if value & 0xf0000000 == 0xf0000000 {
16115 return Some(Ins::Illegal);
16116 }
16117 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
16118 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
16119 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
16120 Some(Ins::Ldrexb { cond, rd, rn })
16121}
16122#[cfg(all(feature = "arm", feature = "v6k"))]
16123fn parse_arm_ldrexd_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16124 const VERSIONS: Versions = Versions::of(&[#[cfg(feature = "v6k")] Version::V6K]);
16125 if !VERSIONS.has(options.version) {
16126 return None;
16127 }
16128 if value & 0x1f0f != 0xf0f {
16129 return Some(Ins::Illegal);
16130 }
16131 if value & 0xf0000000 == 0xf0000000 {
16132 return Some(Ins::Illegal);
16133 }
16134 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
16135 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
16136 let rd2 = Reg::parse((((value) >> 12) & 0xf).wrapping_add(1), pc);
16137 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
16138 Some(Ins::Ldrexd { cond, rd, rd2, rn })
16139}
16140#[cfg(all(feature = "arm", feature = "v6k"))]
16141fn parse_arm_ldrexh_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16142 const VERSIONS: Versions = Versions::of(&[#[cfg(feature = "v6k")] Version::V6K]);
16143 if !VERSIONS.has(options.version) {
16144 return None;
16145 }
16146 if value & 0xf0f != 0xf0f {
16147 return Some(Ins::Illegal);
16148 }
16149 if value & 0xf0000000 == 0xf0000000 {
16150 return Some(Ins::Illegal);
16151 }
16152 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
16153 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
16154 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
16155 Some(Ins::Ldrexh { cond, rd, rn })
16156}
16157#[cfg(feature = "arm")]
16158fn parse_arm_ldrh_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16159 if value & 0xf0000000 == 0xf0000000 {
16160 return Some(Ins::Illegal);
16161 }
16162 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
16163 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
16164 let Some(addr) = AddrMiscLoad::parse(value, pc) else {
16165 return Some(Ins::Illegal);
16166 };
16167 Some(Ins::Ldrh { cond, rd, addr })
16168}
16169#[cfg(feature = "thumb")]
16170fn parse_thumb_ldrh_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
16171 const VERSIONS: Versions = Versions::of(
16172 &[
16173 #[cfg(feature = "v4t")]
16174 Version::V4T,
16175 #[cfg(feature = "v5t")]
16176 Version::V5T,
16177 #[cfg(feature = "v5te")]
16178 Version::V5Te,
16179 #[cfg(feature = "v5tej")]
16180 Version::V5Tej,
16181 #[cfg(feature = "v6")]
16182 Version::V6,
16183 #[cfg(feature = "v6k")]
16184 Version::V6K,
16185 ],
16186 );
16187 if !VERSIONS.has(options.version) {
16188 return None;
16189 }
16190 let cond = Cond::default();
16191 let rd = Reg::parse((value) & 0x7, pc);
16192 let addr = AddrMiscLoad::Pre {
16193 rn: Reg::parse(((value) >> 3) & 0x7, pc),
16194 offset: MiscLoadOffset::Imm(((((value) >> 6) & 0x1f) << 1) as i32),
16195 writeback: false,
16196 };
16197 Some((Ins::Ldrh { cond, rd, addr }, 2))
16198}
16199#[cfg(feature = "thumb")]
16200fn parse_thumb_ldrh_1(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
16201 const VERSIONS: Versions = Versions::of(
16202 &[
16203 #[cfg(feature = "v4t")]
16204 Version::V4T,
16205 #[cfg(feature = "v5t")]
16206 Version::V5T,
16207 #[cfg(feature = "v5te")]
16208 Version::V5Te,
16209 #[cfg(feature = "v5tej")]
16210 Version::V5Tej,
16211 #[cfg(feature = "v6")]
16212 Version::V6,
16213 #[cfg(feature = "v6k")]
16214 Version::V6K,
16215 ],
16216 );
16217 if !VERSIONS.has(options.version) {
16218 return None;
16219 }
16220 let cond = Cond::default();
16221 let rd = Reg::parse((value) & 0x7, pc);
16222 let addr = AddrMiscLoad::Pre {
16223 rn: Reg::parse(((value) >> 3) & 0x7, pc),
16224 offset: MiscLoadOffset::Reg {
16225 subtract: false,
16226 rm: Reg::parse(((value) >> 6) & 0x7, pc),
16227 },
16228 writeback: false,
16229 };
16230 Some((Ins::Ldrh { cond, rd, addr }, 2))
16231}
16232#[cfg(feature = "arm")]
16233fn parse_arm_ldrsb_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16234 if value & 0xf0000000 == 0xf0000000 {
16235 return Some(Ins::Illegal);
16236 }
16237 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
16238 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
16239 let Some(addr) = AddrMiscLoad::parse(value, pc) else {
16240 return Some(Ins::Illegal);
16241 };
16242 Some(Ins::Ldrsb { cond, rd, addr })
16243}
16244#[cfg(feature = "thumb")]
16245fn parse_thumb_ldrsb_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
16246 const VERSIONS: Versions = Versions::of(
16247 &[
16248 #[cfg(feature = "v4t")]
16249 Version::V4T,
16250 #[cfg(feature = "v5t")]
16251 Version::V5T,
16252 #[cfg(feature = "v5te")]
16253 Version::V5Te,
16254 #[cfg(feature = "v5tej")]
16255 Version::V5Tej,
16256 #[cfg(feature = "v6")]
16257 Version::V6,
16258 #[cfg(feature = "v6k")]
16259 Version::V6K,
16260 ],
16261 );
16262 if !VERSIONS.has(options.version) {
16263 return None;
16264 }
16265 let cond = Cond::default();
16266 let rd = Reg::parse((value) & 0x7, pc);
16267 let addr = AddrMiscLoad::Pre {
16268 rn: Reg::parse(((value) >> 3) & 0x7, pc),
16269 offset: MiscLoadOffset::Reg {
16270 subtract: false,
16271 rm: Reg::parse(((value) >> 6) & 0x7, pc),
16272 },
16273 writeback: false,
16274 };
16275 Some((Ins::Ldrsb { cond, rd, addr }, 2))
16276}
16277#[cfg(feature = "arm")]
16278fn parse_arm_ldrsh_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16279 if value & 0xf0000000 == 0xf0000000 {
16280 return Some(Ins::Illegal);
16281 }
16282 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
16283 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
16284 let Some(addr) = AddrMiscLoad::parse(value, pc) else {
16285 return Some(Ins::Illegal);
16286 };
16287 Some(Ins::Ldrsh { cond, rd, addr })
16288}
16289#[cfg(feature = "thumb")]
16290fn parse_thumb_ldrsh_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
16291 const VERSIONS: Versions = Versions::of(
16292 &[
16293 #[cfg(feature = "v4t")]
16294 Version::V4T,
16295 #[cfg(feature = "v5t")]
16296 Version::V5T,
16297 #[cfg(feature = "v5te")]
16298 Version::V5Te,
16299 #[cfg(feature = "v5tej")]
16300 Version::V5Tej,
16301 #[cfg(feature = "v6")]
16302 Version::V6,
16303 #[cfg(feature = "v6k")]
16304 Version::V6K,
16305 ],
16306 );
16307 if !VERSIONS.has(options.version) {
16308 return None;
16309 }
16310 let cond = Cond::default();
16311 let rd = Reg::parse((value) & 0x7, pc);
16312 let addr = AddrMiscLoad::Pre {
16313 rn: Reg::parse(((value) >> 3) & 0x7, pc),
16314 offset: MiscLoadOffset::Reg {
16315 subtract: false,
16316 rm: Reg::parse(((value) >> 6) & 0x7, pc),
16317 },
16318 writeback: false,
16319 };
16320 Some((Ins::Ldrsh { cond, rd, addr }, 2))
16321}
16322#[cfg(feature = "arm")]
16323fn parse_arm_ldrt_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16324 if value & 0xf0000000 == 0xf0000000 {
16325 return Some(Ins::Illegal);
16326 }
16327 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
16328 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
16329 let Some(addr) = AddrLdrStrPost::parse(value, pc) else {
16330 return Some(Ins::Illegal);
16331 };
16332 Some(Ins::Ldrt { cond, rd, addr })
16333}
16334#[cfg(feature = "arm")]
16335fn parse_arm_lsl_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16336 if !options.ual {
16337 return None;
16338 }
16339 if value & 0xf0000000 == 0xf0000000 {
16340 return Some(Ins::Illegal);
16341 }
16342 let s = (((value) >> 20) & 0x1) != 0;
16343 let thumb = false;
16344 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
16345 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
16346 let rn = Reg::parse((value) & 0xf, pc);
16347 let Some(op2) = Op2Shift::parse(value, pc) else {
16348 return Some(Ins::Illegal);
16349 };
16350 Some(Ins::Lsl {
16351 s,
16352 thumb,
16353 cond,
16354 rd,
16355 rn,
16356 op2,
16357 })
16358}
16359#[cfg(feature = "thumb")]
16360fn parse_thumb_lsl_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
16361 const VERSIONS: Versions = Versions::of(
16362 &[
16363 #[cfg(feature = "v4t")]
16364 Version::V4T,
16365 #[cfg(feature = "v5t")]
16366 Version::V5T,
16367 #[cfg(feature = "v5te")]
16368 Version::V5Te,
16369 #[cfg(feature = "v5tej")]
16370 Version::V5Tej,
16371 #[cfg(feature = "v6")]
16372 Version::V6,
16373 #[cfg(feature = "v6k")]
16374 Version::V6K,
16375 ],
16376 );
16377 if !VERSIONS.has(options.version) {
16378 return None;
16379 }
16380 let s = (1) != 0;
16381 let thumb = (1) != 0;
16382 let cond = Cond::default();
16383 let rd = Reg::parse((value) & 0x7, pc);
16384 let rn = Reg::parse(((value) >> 3) & 0x7, pc);
16385 let op2 = Op2Shift::Imm(((value) >> 6) & 0x1f);
16386 Some((
16387 Ins::Lsl {
16388 s,
16389 thumb,
16390 cond,
16391 rd,
16392 rn,
16393 op2,
16394 },
16395 2,
16396 ))
16397}
16398#[cfg(feature = "thumb")]
16399fn parse_thumb_lsl_1(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
16400 const VERSIONS: Versions = Versions::of(
16401 &[
16402 #[cfg(feature = "v4t")]
16403 Version::V4T,
16404 #[cfg(feature = "v5t")]
16405 Version::V5T,
16406 #[cfg(feature = "v5te")]
16407 Version::V5Te,
16408 #[cfg(feature = "v5tej")]
16409 Version::V5Tej,
16410 #[cfg(feature = "v6")]
16411 Version::V6,
16412 #[cfg(feature = "v6k")]
16413 Version::V6K,
16414 ],
16415 );
16416 if !VERSIONS.has(options.version) {
16417 return None;
16418 }
16419 let s = (1) != 0;
16420 let thumb = (1) != 0;
16421 let cond = Cond::default();
16422 let rd = Reg::parse((value) & 0x7, pc);
16423 let rn = Reg::parse((value) & 0x7, pc);
16424 let op2 = Op2Shift::Reg(Reg::parse(((value) >> 3) & 0x7, pc));
16425 Some((
16426 Ins::Lsl {
16427 s,
16428 thumb,
16429 cond,
16430 rd,
16431 rn,
16432 op2,
16433 },
16434 2,
16435 ))
16436}
16437#[cfg(feature = "arm")]
16438fn parse_arm_lsr_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16439 if !options.ual {
16440 return None;
16441 }
16442 if value & 0xf0000000 == 0xf0000000 {
16443 return Some(Ins::Illegal);
16444 }
16445 let s = (((value) >> 20) & 0x1) != 0;
16446 let thumb = false;
16447 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
16448 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
16449 let rn = Reg::parse((value) & 0xf, pc);
16450 let Some(op2) = Op2Shift::parse(value, pc) else {
16451 return Some(Ins::Illegal);
16452 };
16453 Some(Ins::Lsr {
16454 s,
16455 thumb,
16456 cond,
16457 rd,
16458 rn,
16459 op2,
16460 })
16461}
16462#[cfg(feature = "thumb")]
16463fn parse_thumb_lsr_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
16464 const VERSIONS: Versions = Versions::of(
16465 &[
16466 #[cfg(feature = "v4t")]
16467 Version::V4T,
16468 #[cfg(feature = "v5t")]
16469 Version::V5T,
16470 #[cfg(feature = "v5te")]
16471 Version::V5Te,
16472 #[cfg(feature = "v5tej")]
16473 Version::V5Tej,
16474 #[cfg(feature = "v6")]
16475 Version::V6,
16476 #[cfg(feature = "v6k")]
16477 Version::V6K,
16478 ],
16479 );
16480 if !VERSIONS.has(options.version) {
16481 return None;
16482 }
16483 let s = (1) != 0;
16484 let thumb = (1) != 0;
16485 let cond = Cond::default();
16486 let rd = Reg::parse((value) & 0x7, pc);
16487 let rn = Reg::parse(((value) >> 3) & 0x7, pc);
16488 let op2 = Op2Shift::Imm(
16489 if (((value) >> 6) & 0x1f) != 0 { (((value) >> 6) & 0x1f) } else { 32 },
16490 );
16491 Some((
16492 Ins::Lsr {
16493 s,
16494 thumb,
16495 cond,
16496 rd,
16497 rn,
16498 op2,
16499 },
16500 2,
16501 ))
16502}
16503#[cfg(feature = "thumb")]
16504fn parse_thumb_lsr_1(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
16505 const VERSIONS: Versions = Versions::of(
16506 &[
16507 #[cfg(feature = "v4t")]
16508 Version::V4T,
16509 #[cfg(feature = "v5t")]
16510 Version::V5T,
16511 #[cfg(feature = "v5te")]
16512 Version::V5Te,
16513 #[cfg(feature = "v5tej")]
16514 Version::V5Tej,
16515 #[cfg(feature = "v6")]
16516 Version::V6,
16517 #[cfg(feature = "v6k")]
16518 Version::V6K,
16519 ],
16520 );
16521 if !VERSIONS.has(options.version) {
16522 return None;
16523 }
16524 let s = (1) != 0;
16525 let thumb = (1) != 0;
16526 let cond = Cond::default();
16527 let rd = Reg::parse((value) & 0x7, pc);
16528 let rn = Reg::parse((value) & 0x7, pc);
16529 let op2 = Op2Shift::Reg(Reg::parse(((value) >> 3) & 0x7, pc));
16530 Some((
16531 Ins::Lsr {
16532 s,
16533 thumb,
16534 cond,
16535 rd,
16536 rn,
16537 op2,
16538 },
16539 2,
16540 ))
16541}
16542#[cfg(feature = "arm")]
16543fn parse_arm_mcr_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16544 if value & 0xf0000000 == 0xf0000000 {
16545 return Some(Ins::Illegal);
16546 }
16547 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
16548 let coproc = Coproc::parse(((value) >> 8) & 0xf, pc);
16549 let opc1 = ((value) >> 21) & 0x7;
16550 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
16551 let crn = CoReg::parse(((value) >> 16) & 0xf, pc);
16552 let crm = CoReg::parse((value) & 0xf, pc);
16553 let opc2 = ((value) >> 5) & 0x7;
16554 Some(Ins::Mcr {
16555 cond,
16556 coproc,
16557 opc1,
16558 rd,
16559 crn,
16560 crm,
16561 opc2,
16562 })
16563}
16564#[cfg(
16565 all(
16566 feature = "arm",
16567 any(
16568 feature = "v5t",
16569 feature = "v5te",
16570 feature = "v5tej",
16571 feature = "v6",
16572 feature = "v6k"
16573 )
16574 )
16575)]
16576fn parse_arm_mcr2_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16577 const VERSIONS: Versions = Versions::of(
16578 &[
16579 #[cfg(feature = "v5t")]
16580 Version::V5T,
16581 #[cfg(feature = "v5te")]
16582 Version::V5Te,
16583 #[cfg(feature = "v5tej")]
16584 Version::V5Tej,
16585 #[cfg(feature = "v6")]
16586 Version::V6,
16587 #[cfg(feature = "v6k")]
16588 Version::V6K,
16589 ],
16590 );
16591 if !VERSIONS.has(options.version) {
16592 return None;
16593 }
16594 let coproc = Coproc::parse(((value) >> 8) & 0xf, pc);
16595 let opc1 = ((value) >> 21) & 0x7;
16596 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
16597 let crn = CoReg::parse(((value) >> 16) & 0xf, pc);
16598 let crm = CoReg::parse((value) & 0xf, pc);
16599 let opc2 = ((value) >> 5) & 0x7;
16600 Some(Ins::Mcr2 {
16601 coproc,
16602 opc1,
16603 rd,
16604 crn,
16605 crm,
16606 opc2,
16607 })
16608}
16609#[cfg(
16610 all(
16611 feature = "arm",
16612 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
16613 )
16614)]
16615fn parse_arm_mcrr_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16616 const VERSIONS: Versions = Versions::of(
16617 &[
16618 #[cfg(feature = "v5te")]
16619 Version::V5Te,
16620 #[cfg(feature = "v5tej")]
16621 Version::V5Tej,
16622 #[cfg(feature = "v6")]
16623 Version::V6,
16624 #[cfg(feature = "v6k")]
16625 Version::V6K,
16626 ],
16627 );
16628 if !VERSIONS.has(options.version) {
16629 return None;
16630 }
16631 if value & 0xf0000000 == 0xf0000000 {
16632 return Some(Ins::Illegal);
16633 }
16634 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
16635 let coproc = Coproc::parse(((value) >> 8) & 0xf, pc);
16636 let opc = ((value) >> 20) & 0xf;
16637 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
16638 let rd2 = Reg::parse(((value) >> 16) & 0xf, pc);
16639 let crm = CoReg::parse((value) & 0xf, pc);
16640 Some(Ins::Mcrr {
16641 cond,
16642 coproc,
16643 opc,
16644 rd,
16645 rd2,
16646 crm,
16647 })
16648}
16649#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
16650fn parse_arm_mcrr2_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16651 const VERSIONS: Versions = Versions::of(
16652 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
16653 );
16654 if !VERSIONS.has(options.version) {
16655 return None;
16656 }
16657 let coproc = Coproc::parse(((value) >> 8) & 0xf, pc);
16658 let opc = ((value) >> 20) & 0xf;
16659 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
16660 let rd2 = Reg::parse(((value) >> 16) & 0xf, pc);
16661 let crm = CoReg::parse((value) & 0xf, pc);
16662 Some(Ins::Mcrr2 {
16663 coproc,
16664 opc,
16665 rd,
16666 rd2,
16667 crm,
16668 })
16669}
16670#[cfg(feature = "arm")]
16671fn parse_arm_mla_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16672 if value & 0xf0000000 == 0xf0000000 {
16673 return Some(Ins::Illegal);
16674 }
16675 let s = (((value) >> 20) & 0x1) != 0;
16676 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
16677 let rd = Reg::parse(((value) >> 16) & 0xf, pc);
16678 let rn = Reg::parse((value) & 0xf, pc);
16679 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
16680 let ra = Reg::parse(((value) >> 12) & 0xf, pc);
16681 Some(Ins::Mla {
16682 s,
16683 cond,
16684 rd,
16685 rn,
16686 rm,
16687 ra,
16688 })
16689}
16690#[cfg(feature = "arm")]
16691fn parse_arm_mov_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16692 if !options.ual {
16693 return None;
16694 }
16695 if value & 0xf0000 != 0 {
16696 return Some(Ins::Illegal);
16697 }
16698 if value & 0xf0000000 == 0xf0000000 {
16699 return Some(Ins::Illegal);
16700 }
16701 let s = (((value) >> 20) & 0x1) != 0;
16702 let thumb = false;
16703 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
16704 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
16705 let Some(op2) = Op2::parse(value, pc) else {
16706 return Some(Ins::Illegal);
16707 };
16708 Some(Ins::Mov {
16709 s,
16710 thumb,
16711 cond,
16712 rd,
16713 op2,
16714 })
16715}
16716#[cfg(feature = "arm")]
16717fn parse_arm_mov_1(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16718 if !options.ual {
16719 return None;
16720 }
16721 if value & 0xf0000 != 0 {
16722 return Some(Ins::Illegal);
16723 }
16724 if value & 0xf0000000 == 0xf0000000 {
16725 return Some(Ins::Illegal);
16726 }
16727 let s = (((value) >> 20) & 0x1) != 0;
16728 let thumb = false;
16729 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
16730 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
16731 let Some(op2) = Op2::parse(value, pc) else {
16732 return Some(Ins::Illegal);
16733 };
16734 Some(Ins::Mov {
16735 s,
16736 thumb,
16737 cond,
16738 rd,
16739 op2,
16740 })
16741}
16742#[cfg(feature = "arm")]
16743fn parse_arm_mov_2(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16744 if options.ual {
16745 return None;
16746 }
16747 if value & 0xf0000 != 0 {
16748 return Some(Ins::Illegal);
16749 }
16750 if value & 0xf0000000 == 0xf0000000 {
16751 return Some(Ins::Illegal);
16752 }
16753 let s = (((value) >> 20) & 0x1) != 0;
16754 let thumb = false;
16755 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
16756 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
16757 let Some(op2) = Op2::parse(value, pc) else {
16758 return Some(Ins::Illegal);
16759 };
16760 Some(Ins::Mov {
16761 s,
16762 thumb,
16763 cond,
16764 rd,
16765 op2,
16766 })
16767}
16768#[cfg(feature = "thumb")]
16769fn parse_thumb_mov_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
16770 const VERSIONS: Versions = Versions::of(
16771 &[
16772 #[cfg(feature = "v4t")]
16773 Version::V4T,
16774 #[cfg(feature = "v5t")]
16775 Version::V5T,
16776 #[cfg(feature = "v5te")]
16777 Version::V5Te,
16778 #[cfg(feature = "v5tej")]
16779 Version::V5Tej,
16780 #[cfg(feature = "v6")]
16781 Version::V6,
16782 #[cfg(feature = "v6k")]
16783 Version::V6K,
16784 ],
16785 );
16786 if !VERSIONS.has(options.version) {
16787 return None;
16788 }
16789 let s = (1) != 0;
16790 let thumb = (1) != 0;
16791 let cond = Cond::default();
16792 let rd = Reg::parse(((value) >> 8) & 0x7, pc);
16793 let op2 = Op2::Imm((value) & 0xff);
16794 Some((
16795 Ins::Mov {
16796 s,
16797 thumb,
16798 cond,
16799 rd,
16800 op2,
16801 },
16802 2,
16803 ))
16804}
16805#[cfg(feature = "thumb")]
16806fn parse_thumb_mov_1(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
16807 const VERSIONS: Versions = Versions::of(
16808 &[
16809 #[cfg(feature = "v4t")]
16810 Version::V4T,
16811 #[cfg(feature = "v5t")]
16812 Version::V5T,
16813 #[cfg(feature = "v5te")]
16814 Version::V5Te,
16815 #[cfg(feature = "v5tej")]
16816 Version::V5Tej,
16817 #[cfg(feature = "v6")]
16818 Version::V6,
16819 #[cfg(feature = "v6k")]
16820 Version::V6K,
16821 ],
16822 );
16823 if !VERSIONS.has(options.version) {
16824 return None;
16825 }
16826 let s = (0) != 0;
16827 let thumb = (1) != 0;
16828 let cond = Cond::default();
16829 let rd = Reg::parse(((((value) >> 7) & 0x1) << 3) | ((value) & 0x7), pc);
16830 let op2 = Op2::ShiftImm(ShiftImm {
16831 rm: Reg::parse(((value) >> 3) & 0xf, pc),
16832 shift_op: ShiftOp::default(),
16833 imm: 0,
16834 });
16835 Some((
16836 Ins::Mov {
16837 s,
16838 thumb,
16839 cond,
16840 rd,
16841 op2,
16842 },
16843 2,
16844 ))
16845}
16846#[cfg(feature = "thumb")]
16847fn parse_thumb_mov_2(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
16848 const VERSIONS: Versions = Versions::of(
16849 &[
16850 #[cfg(feature = "v4t")]
16851 Version::V4T,
16852 #[cfg(feature = "v5t")]
16853 Version::V5T,
16854 #[cfg(feature = "v5te")]
16855 Version::V5Te,
16856 #[cfg(feature = "v5tej")]
16857 Version::V5Tej,
16858 #[cfg(feature = "v6")]
16859 Version::V6,
16860 #[cfg(feature = "v6k")]
16861 Version::V6K,
16862 ],
16863 );
16864 if !VERSIONS.has(options.version) {
16865 return None;
16866 }
16867 if !options.ual {
16868 return None;
16869 }
16870 let s = (1) != 0;
16871 let thumb = (1) != 0;
16872 let cond = Cond::default();
16873 let rd = Reg::parse((value) & 0x7, pc);
16874 let op2 = Op2::ShiftImm(ShiftImm {
16875 rm: Reg::parse(((value) >> 3) & 0x7, pc),
16876 shift_op: ShiftOp::default(),
16877 imm: 0,
16878 });
16879 Some((
16880 Ins::Mov {
16881 s,
16882 thumb,
16883 cond,
16884 rd,
16885 op2,
16886 },
16887 2,
16888 ))
16889}
16890#[cfg(feature = "thumb")]
16891fn parse_thumb_mov_3(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
16892 const VERSIONS: Versions = Versions::of(
16893 &[
16894 #[cfg(feature = "v4t")]
16895 Version::V4T,
16896 #[cfg(feature = "v5t")]
16897 Version::V5T,
16898 #[cfg(feature = "v5te")]
16899 Version::V5Te,
16900 #[cfg(feature = "v5tej")]
16901 Version::V5Tej,
16902 #[cfg(feature = "v6")]
16903 Version::V6,
16904 #[cfg(feature = "v6k")]
16905 Version::V6K,
16906 ],
16907 );
16908 if !VERSIONS.has(options.version) {
16909 return None;
16910 }
16911 if options.ual {
16912 return None;
16913 }
16914 let s = (1) != 0;
16915 let thumb = (1) != 0;
16916 let cond = Cond::default();
16917 let rd = Reg::parse((value) & 0x7, pc);
16918 let op2 = Op2::ShiftImm(ShiftImm {
16919 rm: Reg::parse(((value) >> 3) & 0x7, pc),
16920 shift_op: ShiftOp::default(),
16921 imm: 0,
16922 });
16923 Some((
16924 Ins::Mov {
16925 s,
16926 thumb,
16927 cond,
16928 rd,
16929 op2,
16930 },
16931 2,
16932 ))
16933}
16934#[cfg(feature = "arm")]
16935fn parse_arm_mrc_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16936 if value & 0xf0000000 == 0xf0000000 {
16937 return Some(Ins::Illegal);
16938 }
16939 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
16940 let coproc = Coproc::parse(((value) >> 8) & 0xf, pc);
16941 let opc1 = ((value) >> 21) & 0x7;
16942 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
16943 let crn = CoReg::parse(((value) >> 16) & 0xf, pc);
16944 let crm = CoReg::parse((value) & 0xf, pc);
16945 let opc2 = ((value) >> 5) & 0x7;
16946 Some(Ins::Mrc {
16947 cond,
16948 coproc,
16949 opc1,
16950 rd,
16951 crn,
16952 crm,
16953 opc2,
16954 })
16955}
16956#[cfg(
16957 all(
16958 feature = "arm",
16959 any(
16960 feature = "v5t",
16961 feature = "v5te",
16962 feature = "v5tej",
16963 feature = "v6",
16964 feature = "v6k"
16965 )
16966 )
16967)]
16968fn parse_arm_mrc2_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
16969 const VERSIONS: Versions = Versions::of(
16970 &[
16971 #[cfg(feature = "v5t")]
16972 Version::V5T,
16973 #[cfg(feature = "v5te")]
16974 Version::V5Te,
16975 #[cfg(feature = "v5tej")]
16976 Version::V5Tej,
16977 #[cfg(feature = "v6")]
16978 Version::V6,
16979 #[cfg(feature = "v6k")]
16980 Version::V6K,
16981 ],
16982 );
16983 if !VERSIONS.has(options.version) {
16984 return None;
16985 }
16986 let coproc = Coproc::parse(((value) >> 8) & 0xf, pc);
16987 let opc1 = ((value) >> 21) & 0x7;
16988 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
16989 let crn = CoReg::parse(((value) >> 16) & 0xf, pc);
16990 let crm = CoReg::parse((value) & 0xf, pc);
16991 let opc2 = ((value) >> 5) & 0x7;
16992 Some(Ins::Mrc2 {
16993 coproc,
16994 opc1,
16995 rd,
16996 crn,
16997 crm,
16998 opc2,
16999 })
17000}
17001#[cfg(
17002 all(
17003 feature = "arm",
17004 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
17005 )
17006)]
17007fn parse_arm_mrrc_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17008 const VERSIONS: Versions = Versions::of(
17009 &[
17010 #[cfg(feature = "v5te")]
17011 Version::V5Te,
17012 #[cfg(feature = "v5tej")]
17013 Version::V5Tej,
17014 #[cfg(feature = "v6")]
17015 Version::V6,
17016 #[cfg(feature = "v6k")]
17017 Version::V6K,
17018 ],
17019 );
17020 if !VERSIONS.has(options.version) {
17021 return None;
17022 }
17023 if value & 0xf0000000 == 0xf0000000 {
17024 return Some(Ins::Illegal);
17025 }
17026 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17027 let coproc = Coproc::parse(((value) >> 8) & 0xf, pc);
17028 let opc = ((value) >> 4) & 0xf;
17029 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17030 let rd2 = Reg::parse(((value) >> 16) & 0xf, pc);
17031 let crm = CoReg::parse((value) & 0xf, pc);
17032 Some(Ins::Mrrc {
17033 cond,
17034 coproc,
17035 opc,
17036 rd,
17037 rd2,
17038 crm,
17039 })
17040}
17041#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
17042fn parse_arm_mrrc2_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17043 const VERSIONS: Versions = Versions::of(
17044 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
17045 );
17046 if !VERSIONS.has(options.version) {
17047 return None;
17048 }
17049 let coproc = Coproc::parse(((value) >> 8) & 0xf, pc);
17050 let opc = ((value) >> 4) & 0xf;
17051 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17052 let rd2 = Reg::parse(((value) >> 16) & 0xf, pc);
17053 let crm = CoReg::parse((value) & 0xf, pc);
17054 Some(Ins::Mrrc2 {
17055 coproc,
17056 opc,
17057 rd,
17058 rd2,
17059 crm,
17060 })
17061}
17062#[cfg(feature = "arm")]
17063fn parse_arm_mrs_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17064 if value & 0x000f0d0f != 0x000f0000 {
17065 return Some(Ins::Illegal);
17066 }
17067 if value & 0xf0000000 == 0xf0000000 {
17068 return Some(Ins::Illegal);
17069 }
17070 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17071 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17072 let status_reg = StatusReg::parse(((value) >> 22) & 0x1, pc);
17073 Some(Ins::Mrs { cond, rd, status_reg })
17074}
17075#[cfg(feature = "arm")]
17076fn parse_arm_msr_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17077 if value & 0xf000 != 0xf000 {
17078 return Some(Ins::Illegal);
17079 }
17080 if value & 0xf0000000 == 0xf0000000 {
17081 return Some(Ins::Illegal);
17082 }
17083 if value & 0x4f0000 == 0 {
17084 return Some(Ins::Illegal);
17085 }
17086 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17087 let status_fields = StatusFields::parse(value, pc);
17088 let Some(op2) = MsrOp2::parse(value, pc) else {
17089 return Some(Ins::Illegal);
17090 };
17091 Some(Ins::Msr {
17092 cond,
17093 status_fields,
17094 op2,
17095 })
17096}
17097#[cfg(feature = "arm")]
17098fn parse_arm_mul_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17099 if value & 0xf000 != 0 {
17100 return Some(Ins::Illegal);
17101 }
17102 if value & 0xf0000000 == 0xf0000000 {
17103 return Some(Ins::Illegal);
17104 }
17105 let s = (((value) >> 20) & 0x1) != 0;
17106 let thumb = false;
17107 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17108 let rd = Reg::parse(((value) >> 16) & 0xf, pc);
17109 let rn = Reg::parse((value) & 0xf, pc);
17110 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
17111 Some(Ins::Mul {
17112 s,
17113 thumb,
17114 cond,
17115 rd,
17116 rn,
17117 rm,
17118 })
17119}
17120#[cfg(feature = "thumb")]
17121fn parse_thumb_mul_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
17122 const VERSIONS: Versions = Versions::of(
17123 &[
17124 #[cfg(feature = "v4t")]
17125 Version::V4T,
17126 #[cfg(feature = "v5t")]
17127 Version::V5T,
17128 #[cfg(feature = "v5te")]
17129 Version::V5Te,
17130 #[cfg(feature = "v5tej")]
17131 Version::V5Tej,
17132 #[cfg(feature = "v6")]
17133 Version::V6,
17134 #[cfg(feature = "v6k")]
17135 Version::V6K,
17136 ],
17137 );
17138 if !VERSIONS.has(options.version) {
17139 return None;
17140 }
17141 let s = (1) != 0;
17142 let thumb = (1) != 0;
17143 let cond = Cond::default();
17144 let rd = Reg::parse((value) & 0x7, pc);
17145 let rn = Reg::parse(((value) >> 3) & 0x7, pc);
17146 let rm = Reg::parse((value) & 0x7, pc);
17147 Some((
17148 Ins::Mul {
17149 s,
17150 thumb,
17151 cond,
17152 rd,
17153 rn,
17154 rm,
17155 },
17156 2,
17157 ))
17158}
17159#[cfg(feature = "arm")]
17160fn parse_arm_mvn_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17161 if value & 0xf0000 != 0 {
17162 return Some(Ins::Illegal);
17163 }
17164 if value & 0xf0000000 == 0xf0000000 {
17165 return Some(Ins::Illegal);
17166 }
17167 let s = (((value) >> 20) & 0x1) != 0;
17168 let thumb = false;
17169 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17170 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17171 let Some(op2) = Op2::parse(value, pc) else {
17172 return Some(Ins::Illegal);
17173 };
17174 Some(Ins::Mvn {
17175 s,
17176 thumb,
17177 cond,
17178 rd,
17179 op2,
17180 })
17181}
17182#[cfg(feature = "thumb")]
17183fn parse_thumb_mvn_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
17184 const VERSIONS: Versions = Versions::of(
17185 &[
17186 #[cfg(feature = "v4t")]
17187 Version::V4T,
17188 #[cfg(feature = "v5t")]
17189 Version::V5T,
17190 #[cfg(feature = "v5te")]
17191 Version::V5Te,
17192 #[cfg(feature = "v5tej")]
17193 Version::V5Tej,
17194 #[cfg(feature = "v6")]
17195 Version::V6,
17196 #[cfg(feature = "v6k")]
17197 Version::V6K,
17198 ],
17199 );
17200 if !VERSIONS.has(options.version) {
17201 return None;
17202 }
17203 let s = (1) != 0;
17204 let thumb = (1) != 0;
17205 let cond = Cond::default();
17206 let rd = Reg::parse((value) & 0x7, pc);
17207 let op2 = Op2::ShiftImm(ShiftImm {
17208 rm: Reg::parse(((value) >> 3) & 0x7, pc),
17209 shift_op: ShiftOp::default(),
17210 imm: 0,
17211 });
17212 Some((
17213 Ins::Mvn {
17214 s,
17215 thumb,
17216 cond,
17217 rd,
17218 op2,
17219 },
17220 2,
17221 ))
17222}
17223#[cfg(feature = "thumb")]
17224fn parse_thumb_neg_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
17225 const VERSIONS: Versions = Versions::of(
17226 &[
17227 #[cfg(feature = "v4t")]
17228 Version::V4T,
17229 #[cfg(feature = "v5t")]
17230 Version::V5T,
17231 #[cfg(feature = "v5te")]
17232 Version::V5Te,
17233 #[cfg(feature = "v5tej")]
17234 Version::V5Tej,
17235 #[cfg(feature = "v6")]
17236 Version::V6,
17237 #[cfg(feature = "v6k")]
17238 Version::V6K,
17239 ],
17240 );
17241 if !VERSIONS.has(options.version) {
17242 return None;
17243 }
17244 if options.ual {
17245 return None;
17246 }
17247 let rd = Reg::parse((value) & 0x7, pc);
17248 let rm = Reg::parse(((value) >> 3) & 0x7, pc);
17249 Some((Ins::Neg { rd, rm }, 2))
17250}
17251#[cfg(all(feature = "arm", feature = "v6k"))]
17252fn parse_arm_nop_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17253 const VERSIONS: Versions = Versions::of(&[#[cfg(feature = "v6k")] Version::V6K]);
17254 if !VERSIONS.has(options.version) {
17255 return None;
17256 }
17257 if value & 0xff00 != 0xf000 {
17258 return Some(Ins::Illegal);
17259 }
17260 if value & 0xf0000000 == 0xf0000000 {
17261 return Some(Ins::Illegal);
17262 }
17263 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17264 Some(Ins::Nop { cond })
17265}
17266#[cfg(feature = "arm")]
17267fn parse_arm_orr_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17268 if value & 0xf0000000 == 0xf0000000 {
17269 return Some(Ins::Illegal);
17270 }
17271 let s = (((value) >> 20) & 0x1) != 0;
17272 let thumb = false;
17273 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17274 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17275 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
17276 let Some(op2) = Op2::parse(value, pc) else {
17277 return Some(Ins::Illegal);
17278 };
17279 Some(Ins::Orr {
17280 s,
17281 thumb,
17282 cond,
17283 rd,
17284 rn,
17285 op2,
17286 })
17287}
17288#[cfg(feature = "thumb")]
17289fn parse_thumb_orr_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
17290 const VERSIONS: Versions = Versions::of(
17291 &[
17292 #[cfg(feature = "v4t")]
17293 Version::V4T,
17294 #[cfg(feature = "v5t")]
17295 Version::V5T,
17296 #[cfg(feature = "v5te")]
17297 Version::V5Te,
17298 #[cfg(feature = "v5tej")]
17299 Version::V5Tej,
17300 #[cfg(feature = "v6")]
17301 Version::V6,
17302 #[cfg(feature = "v6k")]
17303 Version::V6K,
17304 ],
17305 );
17306 if !VERSIONS.has(options.version) {
17307 return None;
17308 }
17309 let s = (1) != 0;
17310 let thumb = (1) != 0;
17311 let cond = Cond::default();
17312 let rd = Reg::parse((value) & 0x7, pc);
17313 let rn = Reg::parse((value) & 0x7, pc);
17314 let op2 = Op2::ShiftImm(ShiftImm {
17315 rm: Reg::parse(((value) >> 3) & 0x7, pc),
17316 shift_op: ShiftOp::default(),
17317 imm: 0,
17318 });
17319 Some((
17320 Ins::Orr {
17321 s,
17322 thumb,
17323 cond,
17324 rd,
17325 rn,
17326 op2,
17327 },
17328 2,
17329 ))
17330}
17331#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
17332fn parse_arm_pkhbt_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17333 const VERSIONS: Versions = Versions::of(
17334 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
17335 );
17336 if !VERSIONS.has(options.version) {
17337 return None;
17338 }
17339 if value & 0xf0000000 == 0xf0000000 {
17340 return Some(Ins::Illegal);
17341 }
17342 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17343 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17344 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
17345 let rm = Reg::parse((value) & 0xf, pc);
17346 let shift_op = ShiftOp::parse(0, pc);
17347 let shift = ((value) >> 7) & 0x1f;
17348 Some(Ins::Pkhbt {
17349 cond,
17350 rd,
17351 rn,
17352 rm,
17353 shift_op,
17354 shift,
17355 })
17356}
17357#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
17358fn parse_arm_pkhtb_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17359 const VERSIONS: Versions = Versions::of(
17360 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
17361 );
17362 if !VERSIONS.has(options.version) {
17363 return None;
17364 }
17365 if value & 0xf0000000 == 0xf0000000 {
17366 return Some(Ins::Illegal);
17367 }
17368 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17369 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17370 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
17371 let rm = Reg::parse((value) & 0xf, pc);
17372 let shift_op = ShiftOp::parse(2, pc);
17373 let shift = if (((value) >> 7) & 0x1f) != 0 { (((value) >> 7) & 0x1f) } else { 32 };
17374 Some(Ins::Pkhtb {
17375 cond,
17376 rd,
17377 rn,
17378 rm,
17379 shift_op,
17380 shift,
17381 })
17382}
17383#[cfg(
17384 all(
17385 feature = "arm",
17386 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
17387 )
17388)]
17389fn parse_arm_pld_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17390 const VERSIONS: Versions = Versions::of(
17391 &[
17392 #[cfg(feature = "v5te")]
17393 Version::V5Te,
17394 #[cfg(feature = "v5tej")]
17395 Version::V5Tej,
17396 #[cfg(feature = "v6")]
17397 Version::V6,
17398 #[cfg(feature = "v6k")]
17399 Version::V6K,
17400 ],
17401 );
17402 if !VERSIONS.has(options.version) {
17403 return None;
17404 }
17405 if value & 0xf000 != 0xf000 {
17406 return Some(Ins::Illegal);
17407 }
17408 let Some(addr) = AddrLdrStr::parse(value, pc) else {
17409 return Some(Ins::Illegal);
17410 };
17411 Some(Ins::Pld { addr })
17412}
17413#[cfg(feature = "arm")]
17414fn parse_arm_pop_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17415 if !options.ual {
17416 return None;
17417 }
17418 if value & 0xffff == 0 {
17419 return Some(Ins::Illegal);
17420 }
17421 if value & 0xf0000000 == 0xf0000000 {
17422 return Some(Ins::Illegal);
17423 }
17424 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17425 let regs = RegList::parse((value) & 0xffff);
17426 Some(Ins::Pop { cond, regs })
17427}
17428#[cfg(feature = "arm")]
17429fn parse_arm_pop_1(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17430 if !options.ual {
17431 return None;
17432 }
17433 if value & 0xf0000000 == 0xf0000000 {
17434 return Some(Ins::Illegal);
17435 }
17436 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17437 let regs = RegList::parse(1 << (((value) >> 12) & 0xf));
17438 Some(Ins::Pop { cond, regs })
17439}
17440#[cfg(feature = "thumb")]
17441fn parse_thumb_pop_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
17442 const VERSIONS: Versions = Versions::of(
17443 &[
17444 #[cfg(feature = "v4t")]
17445 Version::V4T,
17446 #[cfg(feature = "v5t")]
17447 Version::V5T,
17448 #[cfg(feature = "v5te")]
17449 Version::V5Te,
17450 #[cfg(feature = "v5tej")]
17451 Version::V5Tej,
17452 #[cfg(feature = "v6")]
17453 Version::V6,
17454 #[cfg(feature = "v6k")]
17455 Version::V6K,
17456 ],
17457 );
17458 if !VERSIONS.has(options.version) {
17459 return None;
17460 }
17461 if value & 0x1ff == 0 {
17462 return Some((Ins::Illegal, 2));
17463 }
17464 let cond = Cond::parse(14, pc);
17465 let regs = RegList::parse(((((value) >> 8) & 0x1) << 15) | ((value) & 0xff));
17466 Some((Ins::Pop { cond, regs }, 2))
17467}
17468#[cfg(feature = "arm")]
17469fn parse_arm_push_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17470 if !options.ual {
17471 return None;
17472 }
17473 if value & 0xffff == 0 {
17474 return Some(Ins::Illegal);
17475 }
17476 if value & 0xf0000000 == 0xf0000000 {
17477 return Some(Ins::Illegal);
17478 }
17479 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17480 let regs = RegList::parse((value) & 0xffff);
17481 Some(Ins::Push { cond, regs })
17482}
17483#[cfg(feature = "arm")]
17484fn parse_arm_push_1(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17485 if !options.ual {
17486 return None;
17487 }
17488 if value & 0xf0000000 == 0xf0000000 {
17489 return Some(Ins::Illegal);
17490 }
17491 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17492 let regs = RegList::parse(1 << (((value) >> 12) & 0xf));
17493 Some(Ins::Push { cond, regs })
17494}
17495#[cfg(feature = "thumb")]
17496fn parse_thumb_push_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
17497 const VERSIONS: Versions = Versions::of(
17498 &[
17499 #[cfg(feature = "v4t")]
17500 Version::V4T,
17501 #[cfg(feature = "v5t")]
17502 Version::V5T,
17503 #[cfg(feature = "v5te")]
17504 Version::V5Te,
17505 #[cfg(feature = "v5tej")]
17506 Version::V5Tej,
17507 #[cfg(feature = "v6")]
17508 Version::V6,
17509 #[cfg(feature = "v6k")]
17510 Version::V6K,
17511 ],
17512 );
17513 if !VERSIONS.has(options.version) {
17514 return None;
17515 }
17516 if value & 0x1ff == 0 {
17517 return Some((Ins::Illegal, 2));
17518 }
17519 let cond = Cond::parse(14, pc);
17520 let regs = RegList::parse(((((value) >> 8) & 0x1) << 14) | ((value) & 0xff));
17521 Some((Ins::Push { cond, regs }, 2))
17522}
17523#[cfg(
17524 all(
17525 feature = "arm",
17526 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
17527 )
17528)]
17529fn parse_arm_qadd_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17530 const VERSIONS: Versions = Versions::of(
17531 &[
17532 #[cfg(feature = "v5te")]
17533 Version::V5Te,
17534 #[cfg(feature = "v5tej")]
17535 Version::V5Tej,
17536 #[cfg(feature = "v6")]
17537 Version::V6,
17538 #[cfg(feature = "v6k")]
17539 Version::V6K,
17540 ],
17541 );
17542 if !VERSIONS.has(options.version) {
17543 return None;
17544 }
17545 if value & 0xf00 != 0 {
17546 return Some(Ins::Illegal);
17547 }
17548 if value & 0xf0000000 == 0xf0000000 {
17549 return Some(Ins::Illegal);
17550 }
17551 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17552 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17553 let rm = Reg::parse((value) & 0xf, pc);
17554 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
17555 Some(Ins::Qadd { cond, rd, rm, rn })
17556}
17557#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
17558fn parse_arm_qadd16_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17559 const VERSIONS: Versions = Versions::of(
17560 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
17561 );
17562 if !VERSIONS.has(options.version) {
17563 return None;
17564 }
17565 if value & 0xf00 != 0xf00 {
17566 return Some(Ins::Illegal);
17567 }
17568 if value & 0xf0000000 == 0xf0000000 {
17569 return Some(Ins::Illegal);
17570 }
17571 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17572 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17573 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
17574 let rm = Reg::parse((value) & 0xf, pc);
17575 Some(Ins::Qadd16 { cond, rd, rn, rm })
17576}
17577#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
17578fn parse_arm_qadd8_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17579 const VERSIONS: Versions = Versions::of(
17580 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
17581 );
17582 if !VERSIONS.has(options.version) {
17583 return None;
17584 }
17585 if value & 0xf00 != 0xf00 {
17586 return Some(Ins::Illegal);
17587 }
17588 if value & 0xf0000000 == 0xf0000000 {
17589 return Some(Ins::Illegal);
17590 }
17591 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17592 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17593 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
17594 let rm = Reg::parse((value) & 0xf, pc);
17595 Some(Ins::Qadd8 { cond, rd, rn, rm })
17596}
17597#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
17598fn parse_arm_qasx_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17599 const VERSIONS: Versions = Versions::of(
17600 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
17601 );
17602 if !VERSIONS.has(options.version) {
17603 return None;
17604 }
17605 if value & 0xf00 != 0xf00 {
17606 return Some(Ins::Illegal);
17607 }
17608 if value & 0xf0000000 == 0xf0000000 {
17609 return Some(Ins::Illegal);
17610 }
17611 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17612 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17613 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
17614 let rm = Reg::parse((value) & 0xf, pc);
17615 Some(Ins::Qasx { cond, rd, rn, rm })
17616}
17617#[cfg(
17618 all(
17619 feature = "arm",
17620 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
17621 )
17622)]
17623fn parse_arm_qdadd_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17624 const VERSIONS: Versions = Versions::of(
17625 &[
17626 #[cfg(feature = "v5te")]
17627 Version::V5Te,
17628 #[cfg(feature = "v5tej")]
17629 Version::V5Tej,
17630 #[cfg(feature = "v6")]
17631 Version::V6,
17632 #[cfg(feature = "v6k")]
17633 Version::V6K,
17634 ],
17635 );
17636 if !VERSIONS.has(options.version) {
17637 return None;
17638 }
17639 if value & 0xf00 != 0 {
17640 return Some(Ins::Illegal);
17641 }
17642 if value & 0xf0000000 == 0xf0000000 {
17643 return Some(Ins::Illegal);
17644 }
17645 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17646 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17647 let rm = Reg::parse((value) & 0xf, pc);
17648 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
17649 Some(Ins::Qdadd { cond, rd, rm, rn })
17650}
17651#[cfg(
17652 all(
17653 feature = "arm",
17654 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
17655 )
17656)]
17657fn parse_arm_qdsub_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17658 const VERSIONS: Versions = Versions::of(
17659 &[
17660 #[cfg(feature = "v5te")]
17661 Version::V5Te,
17662 #[cfg(feature = "v5tej")]
17663 Version::V5Tej,
17664 #[cfg(feature = "v6")]
17665 Version::V6,
17666 #[cfg(feature = "v6k")]
17667 Version::V6K,
17668 ],
17669 );
17670 if !VERSIONS.has(options.version) {
17671 return None;
17672 }
17673 if value & 0xf00 != 0 {
17674 return Some(Ins::Illegal);
17675 }
17676 if value & 0xf0000000 == 0xf0000000 {
17677 return Some(Ins::Illegal);
17678 }
17679 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17680 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17681 let rm = Reg::parse((value) & 0xf, pc);
17682 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
17683 Some(Ins::Qdsub { cond, rd, rm, rn })
17684}
17685#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
17686fn parse_arm_qsax_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17687 const VERSIONS: Versions = Versions::of(
17688 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
17689 );
17690 if !VERSIONS.has(options.version) {
17691 return None;
17692 }
17693 if value & 0xf00 != 0xf00 {
17694 return Some(Ins::Illegal);
17695 }
17696 if value & 0xf0000000 == 0xf0000000 {
17697 return Some(Ins::Illegal);
17698 }
17699 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17700 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17701 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
17702 let rm = Reg::parse((value) & 0xf, pc);
17703 Some(Ins::Qsax { cond, rd, rn, rm })
17704}
17705#[cfg(
17706 all(
17707 feature = "arm",
17708 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
17709 )
17710)]
17711fn parse_arm_qsub_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17712 const VERSIONS: Versions = Versions::of(
17713 &[
17714 #[cfg(feature = "v5te")]
17715 Version::V5Te,
17716 #[cfg(feature = "v5tej")]
17717 Version::V5Tej,
17718 #[cfg(feature = "v6")]
17719 Version::V6,
17720 #[cfg(feature = "v6k")]
17721 Version::V6K,
17722 ],
17723 );
17724 if !VERSIONS.has(options.version) {
17725 return None;
17726 }
17727 if value & 0xf00 != 0 {
17728 return Some(Ins::Illegal);
17729 }
17730 if value & 0xf0000000 == 0xf0000000 {
17731 return Some(Ins::Illegal);
17732 }
17733 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17734 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17735 let rm = Reg::parse((value) & 0xf, pc);
17736 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
17737 Some(Ins::Qsub { cond, rd, rm, rn })
17738}
17739#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
17740fn parse_arm_qsub16_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17741 const VERSIONS: Versions = Versions::of(
17742 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
17743 );
17744 if !VERSIONS.has(options.version) {
17745 return None;
17746 }
17747 if value & 0xf00 != 0xf00 {
17748 return Some(Ins::Illegal);
17749 }
17750 if value & 0xf0000000 == 0xf0000000 {
17751 return Some(Ins::Illegal);
17752 }
17753 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17754 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17755 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
17756 let rm = Reg::parse((value) & 0xf, pc);
17757 Some(Ins::Qsub16 { cond, rd, rn, rm })
17758}
17759#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
17760fn parse_arm_qsub8_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17761 const VERSIONS: Versions = Versions::of(
17762 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
17763 );
17764 if !VERSIONS.has(options.version) {
17765 return None;
17766 }
17767 if value & 0xf00 != 0xf00 {
17768 return Some(Ins::Illegal);
17769 }
17770 if value & 0xf0000000 == 0xf0000000 {
17771 return Some(Ins::Illegal);
17772 }
17773 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17774 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17775 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
17776 let rm = Reg::parse((value) & 0xf, pc);
17777 Some(Ins::Qsub8 { cond, rd, rn, rm })
17778}
17779#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
17780fn parse_arm_rev_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17781 const VERSIONS: Versions = Versions::of(
17782 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
17783 );
17784 if !VERSIONS.has(options.version) {
17785 return None;
17786 }
17787 if value & 0xf0f00 != 0xf0f00 {
17788 return Some(Ins::Illegal);
17789 }
17790 if value & 0xf0000000 == 0xf0000000 {
17791 return Some(Ins::Illegal);
17792 }
17793 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17794 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17795 let rm = Reg::parse((value) & 0xf, pc);
17796 Some(Ins::Rev { cond, rd, rm })
17797}
17798#[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
17799fn parse_thumb_rev_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
17800 const VERSIONS: Versions = Versions::of(
17801 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
17802 );
17803 if !VERSIONS.has(options.version) {
17804 return None;
17805 }
17806 let cond = Cond::parse(14, pc);
17807 let rd = Reg::parse((value) & 0x7, pc);
17808 let rm = Reg::parse(((value) >> 3) & 0x7, pc);
17809 Some((Ins::Rev { cond, rd, rm }, 2))
17810}
17811#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
17812fn parse_arm_rev16_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17813 const VERSIONS: Versions = Versions::of(
17814 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
17815 );
17816 if !VERSIONS.has(options.version) {
17817 return None;
17818 }
17819 if value & 0xf0f00 != 0xf0f00 {
17820 return Some(Ins::Illegal);
17821 }
17822 if value & 0xf0000000 == 0xf0000000 {
17823 return Some(Ins::Illegal);
17824 }
17825 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17826 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17827 let rm = Reg::parse((value) & 0xf, pc);
17828 Some(Ins::Rev16 { cond, rd, rm })
17829}
17830#[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
17831fn parse_thumb_rev16_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
17832 const VERSIONS: Versions = Versions::of(
17833 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
17834 );
17835 if !VERSIONS.has(options.version) {
17836 return None;
17837 }
17838 let cond = Cond::parse(14, pc);
17839 let rd = Reg::parse((value) & 0x7, pc);
17840 let rm = Reg::parse(((value) >> 3) & 0x7, pc);
17841 Some((Ins::Rev16 { cond, rd, rm }, 2))
17842}
17843#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
17844fn parse_arm_revsh_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17845 const VERSIONS: Versions = Versions::of(
17846 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
17847 );
17848 if !VERSIONS.has(options.version) {
17849 return None;
17850 }
17851 if value & 0xf0f00 != 0xf0f00 {
17852 return Some(Ins::Illegal);
17853 }
17854 if value & 0xf0000000 == 0xf0000000 {
17855 return Some(Ins::Illegal);
17856 }
17857 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17858 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17859 let rm = Reg::parse((value) & 0xf, pc);
17860 Some(Ins::Revsh { cond, rd, rm })
17861}
17862#[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
17863fn parse_thumb_revsh_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
17864 const VERSIONS: Versions = Versions::of(
17865 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
17866 );
17867 if !VERSIONS.has(options.version) {
17868 return None;
17869 }
17870 let cond = Cond::parse(14, pc);
17871 let rd = Reg::parse((value) & 0x7, pc);
17872 let rm = Reg::parse(((value) >> 3) & 0x7, pc);
17873 Some((Ins::Revsh { cond, rd, rm }, 2))
17874}
17875#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
17876fn parse_arm_rfe_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17877 const VERSIONS: Versions = Versions::of(
17878 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
17879 );
17880 if !VERSIONS.has(options.version) {
17881 return None;
17882 }
17883 if value & 0xffff != 0x0a00 {
17884 return Some(Ins::Illegal);
17885 }
17886 let addr_mode = SrsRfeMode::parse(((value) >> 23) & 0x3, pc);
17887 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
17888 let writeback = (((value) >> 21) & 0x1) != 0;
17889 Some(Ins::Rfe {
17890 addr_mode,
17891 rn,
17892 writeback,
17893 })
17894}
17895#[cfg(feature = "arm")]
17896fn parse_arm_ror_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17897 if !options.ual {
17898 return None;
17899 }
17900 if value & 0xf0000000 == 0xf0000000 {
17901 return Some(Ins::Illegal);
17902 }
17903 let s = (((value) >> 20) & 0x1) != 0;
17904 let thumb = false;
17905 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17906 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17907 let rn = Reg::parse((value) & 0xf, pc);
17908 let Some(op2) = Op2Shift::parse(value, pc) else {
17909 return Some(Ins::Illegal);
17910 };
17911 Some(Ins::Ror {
17912 s,
17913 thumb,
17914 cond,
17915 rd,
17916 rn,
17917 op2,
17918 })
17919}
17920#[cfg(feature = "thumb")]
17921fn parse_thumb_ror_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
17922 const VERSIONS: Versions = Versions::of(
17923 &[
17924 #[cfg(feature = "v4t")]
17925 Version::V4T,
17926 #[cfg(feature = "v5t")]
17927 Version::V5T,
17928 #[cfg(feature = "v5te")]
17929 Version::V5Te,
17930 #[cfg(feature = "v5tej")]
17931 Version::V5Tej,
17932 #[cfg(feature = "v6")]
17933 Version::V6,
17934 #[cfg(feature = "v6k")]
17935 Version::V6K,
17936 ],
17937 );
17938 if !VERSIONS.has(options.version) {
17939 return None;
17940 }
17941 let s = (1) != 0;
17942 let thumb = (1) != 0;
17943 let cond = Cond::default();
17944 let rd = Reg::parse((value) & 0x7, pc);
17945 let rn = Reg::parse((value) & 0x7, pc);
17946 let op2 = Op2Shift::Reg(Reg::parse(((value) >> 3) & 0x7, pc));
17947 Some((
17948 Ins::Ror {
17949 s,
17950 thumb,
17951 cond,
17952 rd,
17953 rn,
17954 op2,
17955 },
17956 2,
17957 ))
17958}
17959#[cfg(feature = "arm")]
17960fn parse_arm_rrx_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17961 if !options.ual {
17962 return None;
17963 }
17964 if value & 0xf0000 != 0 {
17965 return Some(Ins::Illegal);
17966 }
17967 if value & 0xf0000000 == 0xf0000000 {
17968 return Some(Ins::Illegal);
17969 }
17970 let s = (((value) >> 20) & 0x1) != 0;
17971 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17972 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17973 let rm = Reg::parse((value) & 0xf, pc);
17974 Some(Ins::Rrx { s, cond, rd, rm })
17975}
17976#[cfg(feature = "arm")]
17977fn parse_arm_rsb_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
17978 if value & 0xf0000000 == 0xf0000000 {
17979 return Some(Ins::Illegal);
17980 }
17981 let s = (((value) >> 20) & 0x1) != 0;
17982 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
17983 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
17984 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
17985 let Some(op2) = Op2::parse(value, pc) else {
17986 return Some(Ins::Illegal);
17987 };
17988 Some(Ins::Rsb { s, cond, rd, rn, op2 })
17989}
17990#[cfg(feature = "thumb")]
17991fn parse_thumb_rsb_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
17992 const VERSIONS: Versions = Versions::of(
17993 &[
17994 #[cfg(feature = "v4t")]
17995 Version::V4T,
17996 #[cfg(feature = "v5t")]
17997 Version::V5T,
17998 #[cfg(feature = "v5te")]
17999 Version::V5Te,
18000 #[cfg(feature = "v5tej")]
18001 Version::V5Tej,
18002 #[cfg(feature = "v6")]
18003 Version::V6,
18004 #[cfg(feature = "v6k")]
18005 Version::V6K,
18006 ],
18007 );
18008 if !VERSIONS.has(options.version) {
18009 return None;
18010 }
18011 if !options.ual {
18012 return None;
18013 }
18014 let s = (1) != 0;
18015 let cond = Cond::default();
18016 let rd = Reg::parse((value) & 0x7, pc);
18017 let rn = Reg::parse(((value) >> 3) & 0x7, pc);
18018 let op2 = Op2::Imm(0);
18019 Some((Ins::Rsb { s, cond, rd, rn, op2 }, 2))
18020}
18021#[cfg(feature = "arm")]
18022fn parse_arm_rsc_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18023 if value & 0xf0000000 == 0xf0000000 {
18024 return Some(Ins::Illegal);
18025 }
18026 let s = (((value) >> 20) & 0x1) != 0;
18027 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18028 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
18029 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
18030 let Some(op2) = Op2::parse(value, pc) else {
18031 return Some(Ins::Illegal);
18032 };
18033 Some(Ins::Rsc { s, cond, rd, rn, op2 })
18034}
18035#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18036fn parse_arm_sadd16_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18037 const VERSIONS: Versions = Versions::of(
18038 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18039 );
18040 if !VERSIONS.has(options.version) {
18041 return None;
18042 }
18043 if value & 0xf00 != 0xf00 {
18044 return Some(Ins::Illegal);
18045 }
18046 if value & 0xf0000000 == 0xf0000000 {
18047 return Some(Ins::Illegal);
18048 }
18049 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18050 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
18051 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
18052 let rm = Reg::parse((value) & 0xf, pc);
18053 Some(Ins::Sadd16 { cond, rd, rn, rm })
18054}
18055#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18056fn parse_arm_sadd8_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18057 const VERSIONS: Versions = Versions::of(
18058 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18059 );
18060 if !VERSIONS.has(options.version) {
18061 return None;
18062 }
18063 if value & 0xf00 != 0xf00 {
18064 return Some(Ins::Illegal);
18065 }
18066 if value & 0xf0000000 == 0xf0000000 {
18067 return Some(Ins::Illegal);
18068 }
18069 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18070 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
18071 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
18072 let rm = Reg::parse((value) & 0xf, pc);
18073 Some(Ins::Sadd8 { cond, rd, rn, rm })
18074}
18075#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18076fn parse_arm_sasx_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18077 const VERSIONS: Versions = Versions::of(
18078 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18079 );
18080 if !VERSIONS.has(options.version) {
18081 return None;
18082 }
18083 if value & 0xf00 != 0xf00 {
18084 return Some(Ins::Illegal);
18085 }
18086 if value & 0xf0000000 == 0xf0000000 {
18087 return Some(Ins::Illegal);
18088 }
18089 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18090 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
18091 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
18092 let rm = Reg::parse((value) & 0xf, pc);
18093 Some(Ins::Sasx { cond, rd, rn, rm })
18094}
18095#[cfg(feature = "arm")]
18096fn parse_arm_sbc_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18097 if value & 0xf0000000 == 0xf0000000 {
18098 return Some(Ins::Illegal);
18099 }
18100 let s = (((value) >> 20) & 0x1) != 0;
18101 let thumb = false;
18102 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18103 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
18104 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
18105 let Some(op2) = Op2::parse(value, pc) else {
18106 return Some(Ins::Illegal);
18107 };
18108 Some(Ins::Sbc {
18109 s,
18110 thumb,
18111 cond,
18112 rd,
18113 rn,
18114 op2,
18115 })
18116}
18117#[cfg(feature = "thumb")]
18118fn parse_thumb_sbc_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
18119 const VERSIONS: Versions = Versions::of(
18120 &[
18121 #[cfg(feature = "v4t")]
18122 Version::V4T,
18123 #[cfg(feature = "v5t")]
18124 Version::V5T,
18125 #[cfg(feature = "v5te")]
18126 Version::V5Te,
18127 #[cfg(feature = "v5tej")]
18128 Version::V5Tej,
18129 #[cfg(feature = "v6")]
18130 Version::V6,
18131 #[cfg(feature = "v6k")]
18132 Version::V6K,
18133 ],
18134 );
18135 if !VERSIONS.has(options.version) {
18136 return None;
18137 }
18138 let s = (1) != 0;
18139 let thumb = (1) != 0;
18140 let cond = Cond::default();
18141 let rd = Reg::parse((value) & 0x7, pc);
18142 let rn = Reg::parse((value) & 0x7, pc);
18143 let op2 = Op2::ShiftImm(ShiftImm {
18144 rm: Reg::parse(((value) >> 3) & 0x7, pc),
18145 shift_op: ShiftOp::default(),
18146 imm: 0,
18147 });
18148 Some((
18149 Ins::Sbc {
18150 s,
18151 thumb,
18152 cond,
18153 rd,
18154 rn,
18155 op2,
18156 },
18157 2,
18158 ))
18159}
18160#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18161fn parse_arm_sel_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18162 const VERSIONS: Versions = Versions::of(
18163 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18164 );
18165 if !VERSIONS.has(options.version) {
18166 return None;
18167 }
18168 if value & 0xf00 != 0xf00 {
18169 return Some(Ins::Illegal);
18170 }
18171 if value & 0xf0000000 == 0xf0000000 {
18172 return Some(Ins::Illegal);
18173 }
18174 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18175 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
18176 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
18177 let rm = Reg::parse((value) & 0xf, pc);
18178 Some(Ins::Sel { cond, rd, rn, rm })
18179}
18180#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18181fn parse_arm_setend_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18182 const VERSIONS: Versions = Versions::of(
18183 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18184 );
18185 if !VERSIONS.has(options.version) {
18186 return None;
18187 }
18188 if value & 0xefd0f != 0 {
18189 return Some(Ins::Illegal);
18190 }
18191 let endian = Endianness::parse(((value) >> 9) & 0x1, pc);
18192 Some(Ins::Setend { endian })
18193}
18194#[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
18195fn parse_thumb_setend_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
18196 const VERSIONS: Versions = Versions::of(
18197 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18198 );
18199 if !VERSIONS.has(options.version) {
18200 return None;
18201 }
18202 if value & 0x17 != 0x10 {
18203 return Some((Ins::Illegal, 2));
18204 }
18205 let endian = Endianness::parse(((value) >> 3) & 0x1, pc);
18206 Some((Ins::Setend { endian }, 2))
18207}
18208#[cfg(all(feature = "arm", feature = "v6k"))]
18209fn parse_arm_sev_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18210 const VERSIONS: Versions = Versions::of(&[#[cfg(feature = "v6k")] Version::V6K]);
18211 if !VERSIONS.has(options.version) {
18212 return None;
18213 }
18214 if value & 0xff00 != 0xf000 {
18215 return Some(Ins::Illegal);
18216 }
18217 if value & 0xf0000000 == 0xf0000000 {
18218 return Some(Ins::Illegal);
18219 }
18220 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18221 Some(Ins::Sev { cond })
18222}
18223#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18224fn parse_arm_shadd16_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18225 const VERSIONS: Versions = Versions::of(
18226 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18227 );
18228 if !VERSIONS.has(options.version) {
18229 return None;
18230 }
18231 if value & 0xf00 != 0xf00 {
18232 return Some(Ins::Illegal);
18233 }
18234 if value & 0xf0000000 == 0xf0000000 {
18235 return Some(Ins::Illegal);
18236 }
18237 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18238 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
18239 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
18240 let rm = Reg::parse((value) & 0xf, pc);
18241 Some(Ins::Shadd16 { cond, rd, rn, rm })
18242}
18243#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18244fn parse_arm_shadd8_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18245 const VERSIONS: Versions = Versions::of(
18246 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18247 );
18248 if !VERSIONS.has(options.version) {
18249 return None;
18250 }
18251 if value & 0xf00 != 0xf00 {
18252 return Some(Ins::Illegal);
18253 }
18254 if value & 0xf0000000 == 0xf0000000 {
18255 return Some(Ins::Illegal);
18256 }
18257 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18258 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
18259 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
18260 let rm = Reg::parse((value) & 0xf, pc);
18261 Some(Ins::Shadd8 { cond, rd, rn, rm })
18262}
18263#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18264fn parse_arm_shasx_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18265 const VERSIONS: Versions = Versions::of(
18266 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18267 );
18268 if !VERSIONS.has(options.version) {
18269 return None;
18270 }
18271 if value & 0xf00 != 0xf00 {
18272 return Some(Ins::Illegal);
18273 }
18274 if value & 0xf0000000 == 0xf0000000 {
18275 return Some(Ins::Illegal);
18276 }
18277 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18278 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
18279 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
18280 let rm = Reg::parse((value) & 0xf, pc);
18281 Some(Ins::Shasx { cond, rd, rn, rm })
18282}
18283#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18284fn parse_arm_shsax_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18285 const VERSIONS: Versions = Versions::of(
18286 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18287 );
18288 if !VERSIONS.has(options.version) {
18289 return None;
18290 }
18291 if value & 0xf00 != 0xf00 {
18292 return Some(Ins::Illegal);
18293 }
18294 if value & 0xf0000000 == 0xf0000000 {
18295 return Some(Ins::Illegal);
18296 }
18297 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18298 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
18299 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
18300 let rm = Reg::parse((value) & 0xf, pc);
18301 Some(Ins::Shsax { cond, rd, rn, rm })
18302}
18303#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18304fn parse_arm_shsub16_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18305 const VERSIONS: Versions = Versions::of(
18306 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18307 );
18308 if !VERSIONS.has(options.version) {
18309 return None;
18310 }
18311 if value & 0xf00 != 0xf00 {
18312 return Some(Ins::Illegal);
18313 }
18314 if value & 0xf0000000 == 0xf0000000 {
18315 return Some(Ins::Illegal);
18316 }
18317 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18318 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
18319 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
18320 let rm = Reg::parse((value) & 0xf, pc);
18321 Some(Ins::Shsub16 { cond, rd, rn, rm })
18322}
18323#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18324fn parse_arm_shsub8_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18325 const VERSIONS: Versions = Versions::of(
18326 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18327 );
18328 if !VERSIONS.has(options.version) {
18329 return None;
18330 }
18331 if value & 0xf00 != 0xf00 {
18332 return Some(Ins::Illegal);
18333 }
18334 if value & 0xf0000000 == 0xf0000000 {
18335 return Some(Ins::Illegal);
18336 }
18337 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18338 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
18339 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
18340 let rm = Reg::parse((value) & 0xf, pc);
18341 Some(Ins::Shsub8 { cond, rd, rn, rm })
18342}
18343#[cfg(
18344 all(
18345 feature = "arm",
18346 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
18347 )
18348)]
18349fn parse_arm_smla_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18350 const VERSIONS: Versions = Versions::of(
18351 &[
18352 #[cfg(feature = "v5te")]
18353 Version::V5Te,
18354 #[cfg(feature = "v5tej")]
18355 Version::V5Tej,
18356 #[cfg(feature = "v6")]
18357 Version::V6,
18358 #[cfg(feature = "v6k")]
18359 Version::V6K,
18360 ],
18361 );
18362 if !VERSIONS.has(options.version) {
18363 return None;
18364 }
18365 if value & 0xf0000000 == 0xf0000000 {
18366 return Some(Ins::Illegal);
18367 }
18368 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18369 let rd = Reg::parse(((value) >> 16) & 0xf, pc);
18370 let rn = Reg::parse((value) & 0xf, pc);
18371 let rn_side = RegSide::parse(((value) >> 5) & 0x1, pc);
18372 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
18373 let rm_side = RegSide::parse(((value) >> 6) & 0x1, pc);
18374 let ra = Reg::parse(((value) >> 12) & 0xf, pc);
18375 Some(Ins::Smla {
18376 cond,
18377 rd,
18378 rn,
18379 rn_side,
18380 rm,
18381 rm_side,
18382 ra,
18383 })
18384}
18385#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18386fn parse_arm_smlad_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18387 const VERSIONS: Versions = Versions::of(
18388 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18389 );
18390 if !VERSIONS.has(options.version) {
18391 return None;
18392 }
18393 if value & 0xf0000000 == 0xf0000000 {
18394 return Some(Ins::Illegal);
18395 }
18396 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18397 let rd = Reg::parse(((value) >> 16) & 0xf, pc);
18398 let rn = Reg::parse((value) & 0xf, pc);
18399 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
18400 let swap_rm = (((value) >> 5) & 0x1) != 0;
18401 let ra = Reg::parse(((value) >> 12) & 0xf, pc);
18402 Some(Ins::Smlad {
18403 cond,
18404 rd,
18405 rn,
18406 rm,
18407 swap_rm,
18408 ra,
18409 })
18410}
18411#[cfg(feature = "arm")]
18412fn parse_arm_smlal_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18413 if value & 0xf0000000 == 0xf0000000 {
18414 return Some(Ins::Illegal);
18415 }
18416 let s = (((value) >> 20) & 0x1) != 0;
18417 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18418 let rd_lo = Reg::parse(((value) >> 12) & 0xf, pc);
18419 let rd_hi = Reg::parse(((value) >> 16) & 0xf, pc);
18420 let rn = Reg::parse((value) & 0xf, pc);
18421 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
18422 Some(Ins::Smlal {
18423 s,
18424 cond,
18425 rd_lo,
18426 rd_hi,
18427 rn,
18428 rm,
18429 })
18430}
18431#[cfg(
18432 all(
18433 feature = "arm",
18434 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
18435 )
18436)]
18437fn parse_arm_smlal_half_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18438 const VERSIONS: Versions = Versions::of(
18439 &[
18440 #[cfg(feature = "v5te")]
18441 Version::V5Te,
18442 #[cfg(feature = "v5tej")]
18443 Version::V5Tej,
18444 #[cfg(feature = "v6")]
18445 Version::V6,
18446 #[cfg(feature = "v6k")]
18447 Version::V6K,
18448 ],
18449 );
18450 if !VERSIONS.has(options.version) {
18451 return None;
18452 }
18453 if value & 0xf0000000 == 0xf0000000 {
18454 return Some(Ins::Illegal);
18455 }
18456 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18457 let rd_lo = Reg::parse(((value) >> 12) & 0xf, pc);
18458 let rd_hi = Reg::parse(((value) >> 16) & 0xf, pc);
18459 let rn = Reg::parse((value) & 0xf, pc);
18460 let rn_side = RegSide::parse(((value) >> 5) & 0x1, pc);
18461 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
18462 let rm_side = RegSide::parse(((value) >> 6) & 0x1, pc);
18463 Some(Ins::SmlalHalf {
18464 cond,
18465 rd_lo,
18466 rd_hi,
18467 rn,
18468 rn_side,
18469 rm,
18470 rm_side,
18471 })
18472}
18473#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18474fn parse_arm_smlald_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18475 const VERSIONS: Versions = Versions::of(
18476 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18477 );
18478 if !VERSIONS.has(options.version) {
18479 return None;
18480 }
18481 if value & 0xf0000000 == 0xf0000000 {
18482 return Some(Ins::Illegal);
18483 }
18484 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18485 let rd_lo = Reg::parse(((value) >> 12) & 0xf, pc);
18486 let rd_hi = Reg::parse(((value) >> 16) & 0xf, pc);
18487 let rn = Reg::parse((value) & 0xf, pc);
18488 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
18489 let swap_rm = (((value) >> 5) & 0x1) != 0;
18490 Some(Ins::Smlald {
18491 cond,
18492 rd_lo,
18493 rd_hi,
18494 rn,
18495 rm,
18496 swap_rm,
18497 })
18498}
18499#[cfg(
18500 all(
18501 feature = "arm",
18502 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
18503 )
18504)]
18505fn parse_arm_smlaw_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18506 const VERSIONS: Versions = Versions::of(
18507 &[
18508 #[cfg(feature = "v5te")]
18509 Version::V5Te,
18510 #[cfg(feature = "v5tej")]
18511 Version::V5Tej,
18512 #[cfg(feature = "v6")]
18513 Version::V6,
18514 #[cfg(feature = "v6k")]
18515 Version::V6K,
18516 ],
18517 );
18518 if !VERSIONS.has(options.version) {
18519 return None;
18520 }
18521 if value & 0xf0000000 == 0xf0000000 {
18522 return Some(Ins::Illegal);
18523 }
18524 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18525 let rd = Reg::parse(((value) >> 16) & 0xf, pc);
18526 let rn = Reg::parse((value) & 0xf, pc);
18527 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
18528 let rm_side = RegSide::parse(((value) >> 6) & 0x1, pc);
18529 let ra = Reg::parse(((value) >> 12) & 0xf, pc);
18530 Some(Ins::Smlaw {
18531 cond,
18532 rd,
18533 rn,
18534 rm,
18535 rm_side,
18536 ra,
18537 })
18538}
18539#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18540fn parse_arm_smlsd_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18541 const VERSIONS: Versions = Versions::of(
18542 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18543 );
18544 if !VERSIONS.has(options.version) {
18545 return None;
18546 }
18547 if value & 0xf0000000 == 0xf0000000 {
18548 return Some(Ins::Illegal);
18549 }
18550 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18551 let rd = Reg::parse(((value) >> 16) & 0xf, pc);
18552 let rn = Reg::parse((value) & 0xf, pc);
18553 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
18554 let swap_rm = (((value) >> 5) & 0x1) != 0;
18555 let ra = Reg::parse(((value) >> 12) & 0xf, pc);
18556 Some(Ins::Smlsd {
18557 cond,
18558 rd,
18559 rn,
18560 rm,
18561 swap_rm,
18562 ra,
18563 })
18564}
18565#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18566fn parse_arm_smlsld_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18567 const VERSIONS: Versions = Versions::of(
18568 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18569 );
18570 if !VERSIONS.has(options.version) {
18571 return None;
18572 }
18573 if value & 0xf0000000 == 0xf0000000 {
18574 return Some(Ins::Illegal);
18575 }
18576 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18577 let rd_lo = Reg::parse(((value) >> 12) & 0xf, pc);
18578 let rd_hi = Reg::parse(((value) >> 16) & 0xf, pc);
18579 let rn = Reg::parse((value) & 0xf, pc);
18580 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
18581 let swap_rm = (((value) >> 5) & 0x1) != 0;
18582 Some(Ins::Smlsld {
18583 cond,
18584 rd_lo,
18585 rd_hi,
18586 rn,
18587 rm,
18588 swap_rm,
18589 })
18590}
18591#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18592fn parse_arm_smmla_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18593 const VERSIONS: Versions = Versions::of(
18594 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18595 );
18596 if !VERSIONS.has(options.version) {
18597 return None;
18598 }
18599 if value & 0xf0000000 == 0xf0000000 {
18600 return Some(Ins::Illegal);
18601 }
18602 let round = (((value) >> 5) & 0x1) != 0;
18603 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18604 let rd = Reg::parse(((value) >> 16) & 0xf, pc);
18605 let rn = Reg::parse((value) & 0xf, pc);
18606 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
18607 let ra = Reg::parse(((value) >> 12) & 0xf, pc);
18608 Some(Ins::Smmla {
18609 round,
18610 cond,
18611 rd,
18612 rn,
18613 rm,
18614 ra,
18615 })
18616}
18617#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18618fn parse_arm_smmls_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18619 const VERSIONS: Versions = Versions::of(
18620 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18621 );
18622 if !VERSIONS.has(options.version) {
18623 return None;
18624 }
18625 if value & 0xf0000000 == 0xf0000000 {
18626 return Some(Ins::Illegal);
18627 }
18628 let round = (((value) >> 5) & 0x1) != 0;
18629 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18630 let rd = Reg::parse(((value) >> 16) & 0xf, pc);
18631 let rn = Reg::parse((value) & 0xf, pc);
18632 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
18633 let ra = Reg::parse(((value) >> 12) & 0xf, pc);
18634 Some(Ins::Smmls {
18635 round,
18636 cond,
18637 rd,
18638 rn,
18639 rm,
18640 ra,
18641 })
18642}
18643#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18644fn parse_arm_smmul_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18645 const VERSIONS: Versions = Versions::of(
18646 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18647 );
18648 if !VERSIONS.has(options.version) {
18649 return None;
18650 }
18651 if value & 0xf0000000 == 0xf0000000 {
18652 return Some(Ins::Illegal);
18653 }
18654 let round = (((value) >> 5) & 0x1) != 0;
18655 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18656 let rd = Reg::parse(((value) >> 16) & 0xf, pc);
18657 let rn = Reg::parse((value) & 0xf, pc);
18658 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
18659 Some(Ins::Smmul {
18660 round,
18661 cond,
18662 rd,
18663 rn,
18664 rm,
18665 })
18666}
18667#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18668fn parse_arm_smuad_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18669 const VERSIONS: Versions = Versions::of(
18670 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18671 );
18672 if !VERSIONS.has(options.version) {
18673 return None;
18674 }
18675 if value & 0xf0000000 == 0xf0000000 {
18676 return Some(Ins::Illegal);
18677 }
18678 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18679 let rd = Reg::parse(((value) >> 16) & 0xf, pc);
18680 let rn = Reg::parse((value) & 0xf, pc);
18681 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
18682 let swap_rm = (((value) >> 5) & 0x1) != 0;
18683 Some(Ins::Smuad {
18684 cond,
18685 rd,
18686 rn,
18687 rm,
18688 swap_rm,
18689 })
18690}
18691#[cfg(
18692 all(
18693 feature = "arm",
18694 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
18695 )
18696)]
18697fn parse_arm_smul_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18698 const VERSIONS: Versions = Versions::of(
18699 &[
18700 #[cfg(feature = "v5te")]
18701 Version::V5Te,
18702 #[cfg(feature = "v5tej")]
18703 Version::V5Tej,
18704 #[cfg(feature = "v6")]
18705 Version::V6,
18706 #[cfg(feature = "v6k")]
18707 Version::V6K,
18708 ],
18709 );
18710 if !VERSIONS.has(options.version) {
18711 return None;
18712 }
18713 if value & 0xf000 != 0 {
18714 return Some(Ins::Illegal);
18715 }
18716 if value & 0xf0000000 == 0xf0000000 {
18717 return Some(Ins::Illegal);
18718 }
18719 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18720 let rd = Reg::parse(((value) >> 16) & 0xf, pc);
18721 let rn = Reg::parse((value) & 0xf, pc);
18722 let rn_side = RegSide::parse(((value) >> 5) & 0x1, pc);
18723 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
18724 let rm_side = RegSide::parse(((value) >> 6) & 0x1, pc);
18725 Some(Ins::Smul {
18726 cond,
18727 rd,
18728 rn,
18729 rn_side,
18730 rm,
18731 rm_side,
18732 })
18733}
18734#[cfg(feature = "arm")]
18735fn parse_arm_smull_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18736 if value & 0xf0000000 == 0xf0000000 {
18737 return Some(Ins::Illegal);
18738 }
18739 let s = (((value) >> 20) & 0x1) != 0;
18740 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18741 let rd_lo = Reg::parse(((value) >> 12) & 0xf, pc);
18742 let rd_hi = Reg::parse(((value) >> 16) & 0xf, pc);
18743 let rn = Reg::parse((value) & 0xf, pc);
18744 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
18745 Some(Ins::Smull {
18746 s,
18747 cond,
18748 rd_lo,
18749 rd_hi,
18750 rn,
18751 rm,
18752 })
18753}
18754#[cfg(
18755 all(
18756 feature = "arm",
18757 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
18758 )
18759)]
18760fn parse_arm_smulw_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18761 const VERSIONS: Versions = Versions::of(
18762 &[
18763 #[cfg(feature = "v5te")]
18764 Version::V5Te,
18765 #[cfg(feature = "v5tej")]
18766 Version::V5Tej,
18767 #[cfg(feature = "v6")]
18768 Version::V6,
18769 #[cfg(feature = "v6k")]
18770 Version::V6K,
18771 ],
18772 );
18773 if !VERSIONS.has(options.version) {
18774 return None;
18775 }
18776 if value & 0xf000 != 0 {
18777 return Some(Ins::Illegal);
18778 }
18779 if value & 0xf0000000 == 0xf0000000 {
18780 return Some(Ins::Illegal);
18781 }
18782 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18783 let rd = Reg::parse(((value) >> 16) & 0xf, pc);
18784 let rn = Reg::parse((value) & 0xf, pc);
18785 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
18786 let rm_side = RegSide::parse(((value) >> 6) & 0x1, pc);
18787 Some(Ins::Smulw {
18788 cond,
18789 rd,
18790 rn,
18791 rm,
18792 rm_side,
18793 })
18794}
18795#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18796fn parse_arm_smusd_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18797 const VERSIONS: Versions = Versions::of(
18798 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18799 );
18800 if !VERSIONS.has(options.version) {
18801 return None;
18802 }
18803 if value & 0xf0000000 == 0xf0000000 {
18804 return Some(Ins::Illegal);
18805 }
18806 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18807 let rd = Reg::parse(((value) >> 16) & 0xf, pc);
18808 let rn = Reg::parse((value) & 0xf, pc);
18809 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
18810 let swap_rm = (((value) >> 5) & 0x1) != 0;
18811 Some(Ins::Smusd {
18812 cond,
18813 rd,
18814 rn,
18815 rm,
18816 swap_rm,
18817 })
18818}
18819#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18820fn parse_arm_srs_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18821 const VERSIONS: Versions = Versions::of(
18822 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18823 );
18824 if !VERSIONS.has(options.version) {
18825 return None;
18826 }
18827 if value & 0xfffe0 != 0xd0500 {
18828 return Some(Ins::Illegal);
18829 }
18830 let addr_mode = SrsRfeMode::parse(((value) >> 23) & 0x3, pc);
18831 let rn = Reg::parse(13, pc);
18832 let writeback = (((value) >> 21) & 0x1) != 0;
18833 let mode = (value) & 0x1f;
18834 Some(Ins::Srs {
18835 addr_mode,
18836 rn,
18837 writeback,
18838 mode,
18839 })
18840}
18841#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18842fn parse_arm_ssat_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18843 const VERSIONS: Versions = Versions::of(
18844 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18845 );
18846 if !VERSIONS.has(options.version) {
18847 return None;
18848 }
18849 if value & 0xf0000000 == 0xf0000000 {
18850 return Some(Ins::Illegal);
18851 }
18852 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18853 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
18854 let imm = (((value) >> 16) & 0x1f).wrapping_add(1);
18855 let op2 = ShiftImm::parse((value) & 0xfff, pc);
18856 Some(Ins::Ssat { cond, rd, imm, op2 })
18857}
18858#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18859fn parse_arm_ssat16_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18860 const VERSIONS: Versions = Versions::of(
18861 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18862 );
18863 if !VERSIONS.has(options.version) {
18864 return None;
18865 }
18866 if value & 0xf00 != 0xf00 {
18867 return Some(Ins::Illegal);
18868 }
18869 if value & 0xf0000000 == 0xf0000000 {
18870 return Some(Ins::Illegal);
18871 }
18872 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18873 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
18874 let imm = (((value) >> 16) & 0x1f).wrapping_add(1);
18875 let rn = Reg::parse((value) & 0xf, pc);
18876 Some(Ins::Ssat16 { cond, rd, imm, rn })
18877}
18878#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18879fn parse_arm_ssax_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18880 const VERSIONS: Versions = Versions::of(
18881 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18882 );
18883 if !VERSIONS.has(options.version) {
18884 return None;
18885 }
18886 if value & 0xf00 != 0xf00 {
18887 return Some(Ins::Illegal);
18888 }
18889 if value & 0xf0000000 == 0xf0000000 {
18890 return Some(Ins::Illegal);
18891 }
18892 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18893 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
18894 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
18895 let rm = Reg::parse((value) & 0xf, pc);
18896 Some(Ins::Ssax { cond, rd, rn, rm })
18897}
18898#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18899fn parse_arm_ssub16_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18900 const VERSIONS: Versions = Versions::of(
18901 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18902 );
18903 if !VERSIONS.has(options.version) {
18904 return None;
18905 }
18906 if value & 0xf00 != 0xf00 {
18907 return Some(Ins::Illegal);
18908 }
18909 if value & 0xf0000000 == 0xf0000000 {
18910 return Some(Ins::Illegal);
18911 }
18912 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18913 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
18914 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
18915 let rm = Reg::parse((value) & 0xf, pc);
18916 Some(Ins::Ssub16 { cond, rd, rn, rm })
18917}
18918#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
18919fn parse_arm_ssub8_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18920 const VERSIONS: Versions = Versions::of(
18921 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
18922 );
18923 if !VERSIONS.has(options.version) {
18924 return None;
18925 }
18926 if value & 0xf00 != 0xf00 {
18927 return Some(Ins::Illegal);
18928 }
18929 if value & 0xf0000000 == 0xf0000000 {
18930 return Some(Ins::Illegal);
18931 }
18932 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18933 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
18934 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
18935 let rm = Reg::parse((value) & 0xf, pc);
18936 Some(Ins::Ssub8 { cond, rd, rn, rm })
18937}
18938#[cfg(feature = "arm")]
18939fn parse_arm_stc_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18940 if value & 0xf0000000 == 0xf0000000 {
18941 return Some(Ins::Illegal);
18942 }
18943 let l = (((value) >> 22) & 0x1) != 0;
18944 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
18945 let coproc = Coproc::parse(((value) >> 8) & 0xf, pc);
18946 let crd = CoReg::parse(((value) >> 12) & 0xf, pc);
18947 let Some(dest) = AddrLdcStc::parse(value, pc) else {
18948 return Some(Ins::Illegal);
18949 };
18950 Some(Ins::Stc {
18951 l,
18952 cond,
18953 coproc,
18954 crd,
18955 dest,
18956 })
18957}
18958#[cfg(
18959 all(
18960 feature = "arm",
18961 any(
18962 feature = "v5t",
18963 feature = "v5te",
18964 feature = "v5tej",
18965 feature = "v6",
18966 feature = "v6k"
18967 )
18968 )
18969)]
18970fn parse_arm_stc2_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18971 const VERSIONS: Versions = Versions::of(
18972 &[
18973 #[cfg(feature = "v5t")]
18974 Version::V5T,
18975 #[cfg(feature = "v5te")]
18976 Version::V5Te,
18977 #[cfg(feature = "v5tej")]
18978 Version::V5Tej,
18979 #[cfg(feature = "v6")]
18980 Version::V6,
18981 #[cfg(feature = "v6k")]
18982 Version::V6K,
18983 ],
18984 );
18985 if !VERSIONS.has(options.version) {
18986 return None;
18987 }
18988 let l = (((value) >> 22) & 0x1) != 0;
18989 let coproc = Coproc::parse(((value) >> 8) & 0xf, pc);
18990 let crd = CoReg::parse(((value) >> 12) & 0xf, pc);
18991 let Some(dest) = AddrLdcStc::parse(value, pc) else {
18992 return Some(Ins::Illegal);
18993 };
18994 Some(Ins::Stc2 { l, coproc, crd, dest })
18995}
18996#[cfg(feature = "arm")]
18997fn parse_arm_stm_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
18998 if value & 0xffff == 0 {
18999 return Some(Ins::Illegal);
19000 }
19001 if value & 0xf0000000 == 0xf0000000 {
19002 return Some(Ins::Illegal);
19003 }
19004 let mode = LdmStmMode::parse(((value) >> 23) & 0x3, pc);
19005 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19006 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
19007 let writeback = (((value) >> 21) & 0x1) != 0;
19008 let regs = RegList::parse((value) & 0xffff);
19009 let user_mode = (((value) >> 22) & 0x1) != 0;
19010 Some(Ins::Stm {
19011 mode,
19012 cond,
19013 rn,
19014 writeback,
19015 regs,
19016 user_mode,
19017 })
19018}
19019#[cfg(feature = "thumb")]
19020fn parse_thumb_stm_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
19021 const VERSIONS: Versions = Versions::of(
19022 &[
19023 #[cfg(feature = "v4t")]
19024 Version::V4T,
19025 #[cfg(feature = "v5t")]
19026 Version::V5T,
19027 #[cfg(feature = "v5te")]
19028 Version::V5Te,
19029 #[cfg(feature = "v5tej")]
19030 Version::V5Tej,
19031 #[cfg(feature = "v6")]
19032 Version::V6,
19033 #[cfg(feature = "v6k")]
19034 Version::V6K,
19035 ],
19036 );
19037 if !VERSIONS.has(options.version) {
19038 return None;
19039 }
19040 if value & 0xff == 0 {
19041 return Some((Ins::Illegal, 2));
19042 }
19043 let mode = LdmStmMode::default();
19044 let cond = Cond::default();
19045 let rn = Reg::parse(((value) >> 8) & 0x7, pc);
19046 let writeback = (1) != 0;
19047 let regs = RegList::parse((value) & 0xff);
19048 let user_mode = (0) != 0;
19049 Some((
19050 Ins::Stm {
19051 mode,
19052 cond,
19053 rn,
19054 writeback,
19055 regs,
19056 user_mode,
19057 },
19058 2,
19059 ))
19060}
19061#[cfg(feature = "arm")]
19062fn parse_arm_str_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19063 if value & 0xf0000000 == 0xf0000000 {
19064 return Some(Ins::Illegal);
19065 }
19066 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19067 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
19068 let Some(addr) = AddrLdrStr::parse(value, pc) else {
19069 return Some(Ins::Illegal);
19070 };
19071 Some(Ins::Str { cond, rd, addr })
19072}
19073#[cfg(feature = "thumb")]
19074fn parse_thumb_str_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
19075 const VERSIONS: Versions = Versions::of(
19076 &[
19077 #[cfg(feature = "v4t")]
19078 Version::V4T,
19079 #[cfg(feature = "v5t")]
19080 Version::V5T,
19081 #[cfg(feature = "v5te")]
19082 Version::V5Te,
19083 #[cfg(feature = "v5tej")]
19084 Version::V5Tej,
19085 #[cfg(feature = "v6")]
19086 Version::V6,
19087 #[cfg(feature = "v6k")]
19088 Version::V6K,
19089 ],
19090 );
19091 if !VERSIONS.has(options.version) {
19092 return None;
19093 }
19094 let cond = Cond::default();
19095 let rd = Reg::parse((value) & 0x7, pc);
19096 let addr = AddrLdrStr::Pre {
19097 rn: Reg::parse(((value) >> 3) & 0x7, pc),
19098 offset: LdrStrOffset::Imm(((((value) >> 6) & 0x1f) << 2) as i32),
19099 writeback: false,
19100 };
19101 Some((Ins::Str { cond, rd, addr }, 2))
19102}
19103#[cfg(feature = "thumb")]
19104fn parse_thumb_str_1(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
19105 const VERSIONS: Versions = Versions::of(
19106 &[
19107 #[cfg(feature = "v4t")]
19108 Version::V4T,
19109 #[cfg(feature = "v5t")]
19110 Version::V5T,
19111 #[cfg(feature = "v5te")]
19112 Version::V5Te,
19113 #[cfg(feature = "v5tej")]
19114 Version::V5Tej,
19115 #[cfg(feature = "v6")]
19116 Version::V6,
19117 #[cfg(feature = "v6k")]
19118 Version::V6K,
19119 ],
19120 );
19121 if !VERSIONS.has(options.version) {
19122 return None;
19123 }
19124 let cond = Cond::default();
19125 let rd = Reg::parse(((value) >> 8) & 0x7, pc);
19126 let addr = AddrLdrStr::Pre {
19127 rn: Reg::parse(13, pc),
19128 offset: LdrStrOffset::Imm((((value) & 0xff) << 2) as i32),
19129 writeback: false,
19130 };
19131 Some((Ins::Str { cond, rd, addr }, 2))
19132}
19133#[cfg(feature = "thumb")]
19134fn parse_thumb_str_2(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
19135 const VERSIONS: Versions = Versions::of(
19136 &[
19137 #[cfg(feature = "v4t")]
19138 Version::V4T,
19139 #[cfg(feature = "v5t")]
19140 Version::V5T,
19141 #[cfg(feature = "v5te")]
19142 Version::V5Te,
19143 #[cfg(feature = "v5tej")]
19144 Version::V5Tej,
19145 #[cfg(feature = "v6")]
19146 Version::V6,
19147 #[cfg(feature = "v6k")]
19148 Version::V6K,
19149 ],
19150 );
19151 if !VERSIONS.has(options.version) {
19152 return None;
19153 }
19154 let cond = Cond::default();
19155 let rd = Reg::parse((value) & 0x7, pc);
19156 let addr = AddrLdrStr::Pre {
19157 rn: Reg::parse(((value) >> 3) & 0x7, pc),
19158 offset: LdrStrOffset::Reg {
19159 subtract: false,
19160 rm: Reg::parse(((value) >> 6) & 0x7, pc),
19161 shift_op: ShiftOp::default(),
19162 imm: 0,
19163 },
19164 writeback: false,
19165 };
19166 Some((Ins::Str { cond, rd, addr }, 2))
19167}
19168#[cfg(feature = "arm")]
19169fn parse_arm_strb_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19170 if value & 0xf0000000 == 0xf0000000 {
19171 return Some(Ins::Illegal);
19172 }
19173 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19174 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
19175 let Some(addr) = AddrLdrStr::parse(value, pc) else {
19176 return Some(Ins::Illegal);
19177 };
19178 Some(Ins::Strb { cond, rd, addr })
19179}
19180#[cfg(feature = "thumb")]
19181fn parse_thumb_strb_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
19182 const VERSIONS: Versions = Versions::of(
19183 &[
19184 #[cfg(feature = "v4t")]
19185 Version::V4T,
19186 #[cfg(feature = "v5t")]
19187 Version::V5T,
19188 #[cfg(feature = "v5te")]
19189 Version::V5Te,
19190 #[cfg(feature = "v5tej")]
19191 Version::V5Tej,
19192 #[cfg(feature = "v6")]
19193 Version::V6,
19194 #[cfg(feature = "v6k")]
19195 Version::V6K,
19196 ],
19197 );
19198 if !VERSIONS.has(options.version) {
19199 return None;
19200 }
19201 let cond = Cond::default();
19202 let rd = Reg::parse((value) & 0x7, pc);
19203 let addr = AddrLdrStr::Pre {
19204 rn: Reg::parse(((value) >> 3) & 0x7, pc),
19205 offset: LdrStrOffset::Imm(((((value) >> 6) & 0x1f)) as i32),
19206 writeback: false,
19207 };
19208 Some((Ins::Strb { cond, rd, addr }, 2))
19209}
19210#[cfg(feature = "thumb")]
19211fn parse_thumb_strb_1(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
19212 const VERSIONS: Versions = Versions::of(
19213 &[
19214 #[cfg(feature = "v4t")]
19215 Version::V4T,
19216 #[cfg(feature = "v5t")]
19217 Version::V5T,
19218 #[cfg(feature = "v5te")]
19219 Version::V5Te,
19220 #[cfg(feature = "v5tej")]
19221 Version::V5Tej,
19222 #[cfg(feature = "v6")]
19223 Version::V6,
19224 #[cfg(feature = "v6k")]
19225 Version::V6K,
19226 ],
19227 );
19228 if !VERSIONS.has(options.version) {
19229 return None;
19230 }
19231 let cond = Cond::default();
19232 let rd = Reg::parse((value) & 0x7, pc);
19233 let addr = AddrLdrStr::Pre {
19234 rn: Reg::parse(((value) >> 3) & 0x7, pc),
19235 offset: LdrStrOffset::Reg {
19236 subtract: false,
19237 rm: Reg::parse(((value) >> 6) & 0x7, pc),
19238 shift_op: ShiftOp::default(),
19239 imm: 0,
19240 },
19241 writeback: false,
19242 };
19243 Some((Ins::Strb { cond, rd, addr }, 2))
19244}
19245#[cfg(feature = "arm")]
19246fn parse_arm_strbt_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19247 if value & 0xf0000000 == 0xf0000000 {
19248 return Some(Ins::Illegal);
19249 }
19250 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19251 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
19252 let Some(addr) = AddrLdrStrPost::parse(value, pc) else {
19253 return Some(Ins::Illegal);
19254 };
19255 Some(Ins::Strbt { cond, rd, addr })
19256}
19257#[cfg(
19258 all(
19259 feature = "arm",
19260 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
19261 )
19262)]
19263fn parse_arm_strd_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19264 const VERSIONS: Versions = Versions::of(
19265 &[
19266 #[cfg(feature = "v5te")]
19267 Version::V5Te,
19268 #[cfg(feature = "v5tej")]
19269 Version::V5Tej,
19270 #[cfg(feature = "v6")]
19271 Version::V6,
19272 #[cfg(feature = "v6k")]
19273 Version::V6K,
19274 ],
19275 );
19276 if !VERSIONS.has(options.version) {
19277 return None;
19278 }
19279 if value & 0x1000 != 0 {
19280 return Some(Ins::Illegal);
19281 }
19282 if value & 0xf0000000 == 0xf0000000 {
19283 return Some(Ins::Illegal);
19284 }
19285 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19286 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
19287 let rd2 = Reg::parse((((value) >> 12) & 0xf).wrapping_add(1), pc);
19288 let Some(addr) = AddrMiscLoad::parse(value, pc) else {
19289 return Some(Ins::Illegal);
19290 };
19291 Some(Ins::Strd { cond, rd, rd2, addr })
19292}
19293#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
19294fn parse_arm_strex_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19295 const VERSIONS: Versions = Versions::of(
19296 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
19297 );
19298 if !VERSIONS.has(options.version) {
19299 return None;
19300 }
19301 if value & 0xf00 != 0xf00 {
19302 return Some(Ins::Illegal);
19303 }
19304 if value & 0xf0000000 == 0xf0000000 {
19305 return Some(Ins::Illegal);
19306 }
19307 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19308 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
19309 let rm = Reg::parse((value) & 0xf, pc);
19310 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
19311 Some(Ins::Strex { cond, rd, rm, rn })
19312}
19313#[cfg(all(feature = "arm", feature = "v6k"))]
19314fn parse_arm_strexb_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19315 const VERSIONS: Versions = Versions::of(&[#[cfg(feature = "v6k")] Version::V6K]);
19316 if !VERSIONS.has(options.version) {
19317 return None;
19318 }
19319 if value & 0xf00 != 0xf00 {
19320 return Some(Ins::Illegal);
19321 }
19322 if value & 0xf0000000 == 0xf0000000 {
19323 return Some(Ins::Illegal);
19324 }
19325 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19326 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
19327 let rm = Reg::parse((value) & 0xf, pc);
19328 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
19329 Some(Ins::Strexb { cond, rd, rm, rn })
19330}
19331#[cfg(all(feature = "arm", feature = "v6k"))]
19332fn parse_arm_strexd_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19333 const VERSIONS: Versions = Versions::of(&[#[cfg(feature = "v6k")] Version::V6K]);
19334 if !VERSIONS.has(options.version) {
19335 return None;
19336 }
19337 if value & 0xf01 != 0xf00 {
19338 return Some(Ins::Illegal);
19339 }
19340 if value & 0xf0000000 == 0xf0000000 {
19341 return Some(Ins::Illegal);
19342 }
19343 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19344 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
19345 let rm = Reg::parse((value) & 0xf, pc);
19346 let rm2 = Reg::parse(((value) & 0xf).wrapping_add(1), pc);
19347 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
19348 Some(Ins::Strexd {
19349 cond,
19350 rd,
19351 rm,
19352 rm2,
19353 rn,
19354 })
19355}
19356#[cfg(all(feature = "arm", feature = "v6k"))]
19357fn parse_arm_strexh_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19358 const VERSIONS: Versions = Versions::of(&[#[cfg(feature = "v6k")] Version::V6K]);
19359 if !VERSIONS.has(options.version) {
19360 return None;
19361 }
19362 if value & 0xf01 != 0xf01 {
19363 return Some(Ins::Illegal);
19364 }
19365 if value & 0xf0000000 == 0xf0000000 {
19366 return Some(Ins::Illegal);
19367 }
19368 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19369 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
19370 let rm = Reg::parse((value) & 0xf, pc);
19371 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
19372 Some(Ins::Strexh { cond, rd, rm, rn })
19373}
19374#[cfg(feature = "arm")]
19375fn parse_arm_strh_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19376 if value & 0xf0000000 == 0xf0000000 {
19377 return Some(Ins::Illegal);
19378 }
19379 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19380 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
19381 let Some(addr) = AddrMiscLoad::parse(value, pc) else {
19382 return Some(Ins::Illegal);
19383 };
19384 Some(Ins::Strh { cond, rd, addr })
19385}
19386#[cfg(feature = "thumb")]
19387fn parse_thumb_strh_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
19388 const VERSIONS: Versions = Versions::of(
19389 &[
19390 #[cfg(feature = "v4t")]
19391 Version::V4T,
19392 #[cfg(feature = "v5t")]
19393 Version::V5T,
19394 #[cfg(feature = "v5te")]
19395 Version::V5Te,
19396 #[cfg(feature = "v5tej")]
19397 Version::V5Tej,
19398 #[cfg(feature = "v6")]
19399 Version::V6,
19400 #[cfg(feature = "v6k")]
19401 Version::V6K,
19402 ],
19403 );
19404 if !VERSIONS.has(options.version) {
19405 return None;
19406 }
19407 let cond = Cond::default();
19408 let rd = Reg::parse((value) & 0x7, pc);
19409 let addr = AddrMiscLoad::Pre {
19410 rn: Reg::parse(((value) >> 3) & 0x7, pc),
19411 offset: MiscLoadOffset::Imm(((((value) >> 6) & 0x1f) << 1) as i32),
19412 writeback: false,
19413 };
19414 Some((Ins::Strh { cond, rd, addr }, 2))
19415}
19416#[cfg(feature = "thumb")]
19417fn parse_thumb_strh_1(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
19418 const VERSIONS: Versions = Versions::of(
19419 &[
19420 #[cfg(feature = "v4t")]
19421 Version::V4T,
19422 #[cfg(feature = "v5t")]
19423 Version::V5T,
19424 #[cfg(feature = "v5te")]
19425 Version::V5Te,
19426 #[cfg(feature = "v5tej")]
19427 Version::V5Tej,
19428 #[cfg(feature = "v6")]
19429 Version::V6,
19430 #[cfg(feature = "v6k")]
19431 Version::V6K,
19432 ],
19433 );
19434 if !VERSIONS.has(options.version) {
19435 return None;
19436 }
19437 let cond = Cond::default();
19438 let rd = Reg::parse((value) & 0x7, pc);
19439 let addr = AddrMiscLoad::Pre {
19440 rn: Reg::parse(((value) >> 3) & 0x7, pc),
19441 offset: MiscLoadOffset::Reg {
19442 subtract: false,
19443 rm: Reg::parse(((value) >> 6) & 0x7, pc),
19444 },
19445 writeback: false,
19446 };
19447 Some((Ins::Strh { cond, rd, addr }, 2))
19448}
19449#[cfg(feature = "arm")]
19450fn parse_arm_strt_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19451 if value & 0xf0000000 == 0xf0000000 {
19452 return Some(Ins::Illegal);
19453 }
19454 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19455 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
19456 let Some(addr) = AddrLdrStrPost::parse(value, pc) else {
19457 return Some(Ins::Illegal);
19458 };
19459 Some(Ins::Strt { cond, rd, addr })
19460}
19461#[cfg(feature = "arm")]
19462fn parse_arm_sub_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19463 if value & 0xf0000000 == 0xf0000000 {
19464 return Some(Ins::Illegal);
19465 }
19466 let s = (((value) >> 20) & 0x1) != 0;
19467 let thumb = false;
19468 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19469 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
19470 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
19471 let Some(op2) = Op2::parse(value, pc) else {
19472 return Some(Ins::Illegal);
19473 };
19474 Some(Ins::Sub {
19475 s,
19476 thumb,
19477 cond,
19478 rd,
19479 rn,
19480 op2,
19481 })
19482}
19483#[cfg(feature = "thumb")]
19484fn parse_thumb_sub_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
19485 const VERSIONS: Versions = Versions::of(
19486 &[
19487 #[cfg(feature = "v4t")]
19488 Version::V4T,
19489 #[cfg(feature = "v5t")]
19490 Version::V5T,
19491 #[cfg(feature = "v5te")]
19492 Version::V5Te,
19493 #[cfg(feature = "v5tej")]
19494 Version::V5Tej,
19495 #[cfg(feature = "v6")]
19496 Version::V6,
19497 #[cfg(feature = "v6k")]
19498 Version::V6K,
19499 ],
19500 );
19501 if !VERSIONS.has(options.version) {
19502 return None;
19503 }
19504 let s = (1) != 0;
19505 let thumb = (1) != 0;
19506 let cond = Cond::default();
19507 let rd = Reg::parse((value) & 0x7, pc);
19508 let rn = Reg::parse(((value) >> 3) & 0x7, pc);
19509 let op2 = Op2::Imm(((value) >> 6) & 0x7);
19510 Some((
19511 Ins::Sub {
19512 s,
19513 thumb,
19514 cond,
19515 rd,
19516 rn,
19517 op2,
19518 },
19519 2,
19520 ))
19521}
19522#[cfg(feature = "thumb")]
19523fn parse_thumb_sub_1(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
19524 const VERSIONS: Versions = Versions::of(
19525 &[
19526 #[cfg(feature = "v4t")]
19527 Version::V4T,
19528 #[cfg(feature = "v5t")]
19529 Version::V5T,
19530 #[cfg(feature = "v5te")]
19531 Version::V5Te,
19532 #[cfg(feature = "v5tej")]
19533 Version::V5Tej,
19534 #[cfg(feature = "v6")]
19535 Version::V6,
19536 #[cfg(feature = "v6k")]
19537 Version::V6K,
19538 ],
19539 );
19540 if !VERSIONS.has(options.version) {
19541 return None;
19542 }
19543 let s = (1) != 0;
19544 let thumb = (1) != 0;
19545 let cond = Cond::default();
19546 let rd = Reg::parse(((value) >> 8) & 0x7, pc);
19547 let rn = Reg::parse(((value) >> 8) & 0x7, pc);
19548 let op2 = Op2::Imm((value) & 0xff);
19549 Some((
19550 Ins::Sub {
19551 s,
19552 thumb,
19553 cond,
19554 rd,
19555 rn,
19556 op2,
19557 },
19558 2,
19559 ))
19560}
19561#[cfg(feature = "thumb")]
19562fn parse_thumb_sub_2(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
19563 const VERSIONS: Versions = Versions::of(
19564 &[
19565 #[cfg(feature = "v4t")]
19566 Version::V4T,
19567 #[cfg(feature = "v5t")]
19568 Version::V5T,
19569 #[cfg(feature = "v5te")]
19570 Version::V5Te,
19571 #[cfg(feature = "v5tej")]
19572 Version::V5Tej,
19573 #[cfg(feature = "v6")]
19574 Version::V6,
19575 #[cfg(feature = "v6k")]
19576 Version::V6K,
19577 ],
19578 );
19579 if !VERSIONS.has(options.version) {
19580 return None;
19581 }
19582 let s = (1) != 0;
19583 let thumb = (1) != 0;
19584 let cond = Cond::default();
19585 let rd = Reg::parse((value) & 0x7, pc);
19586 let rn = Reg::parse(((value) >> 3) & 0x7, pc);
19587 let op2 = Op2::ShiftImm(ShiftImm {
19588 rm: Reg::parse(((value) >> 6) & 0x7, pc),
19589 shift_op: ShiftOp::default(),
19590 imm: 0,
19591 });
19592 Some((
19593 Ins::Sub {
19594 s,
19595 thumb,
19596 cond,
19597 rd,
19598 rn,
19599 op2,
19600 },
19601 2,
19602 ))
19603}
19604#[cfg(feature = "thumb")]
19605fn parse_thumb_sub_3(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
19606 const VERSIONS: Versions = Versions::of(
19607 &[
19608 #[cfg(feature = "v4t")]
19609 Version::V4T,
19610 #[cfg(feature = "v5t")]
19611 Version::V5T,
19612 #[cfg(feature = "v5te")]
19613 Version::V5Te,
19614 #[cfg(feature = "v5tej")]
19615 Version::V5Tej,
19616 #[cfg(feature = "v6")]
19617 Version::V6,
19618 #[cfg(feature = "v6k")]
19619 Version::V6K,
19620 ],
19621 );
19622 if !VERSIONS.has(options.version) {
19623 return None;
19624 }
19625 let s = false;
19626 let thumb = (1) != 0;
19627 let cond = Cond::default();
19628 let rd = Reg::parse(13, pc);
19629 let rn = Reg::parse(13, pc);
19630 let op2 = Op2::Imm(((value) & 0x7f) << 2);
19631 Some((
19632 Ins::Sub {
19633 s,
19634 thumb,
19635 cond,
19636 rd,
19637 rn,
19638 op2,
19639 },
19640 2,
19641 ))
19642}
19643#[cfg(feature = "arm")]
19644fn parse_arm_svc_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19645 if value & 0xf0000000 == 0xf0000000 {
19646 return Some(Ins::Illegal);
19647 }
19648 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19649 let imm = (value) & 0xffffff;
19650 Some(Ins::Svc { cond, imm })
19651}
19652#[cfg(feature = "thumb")]
19653fn parse_thumb_svc_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
19654 const VERSIONS: Versions = Versions::of(
19655 &[
19656 #[cfg(feature = "v4t")]
19657 Version::V4T,
19658 #[cfg(feature = "v5t")]
19659 Version::V5T,
19660 #[cfg(feature = "v5te")]
19661 Version::V5Te,
19662 #[cfg(feature = "v5tej")]
19663 Version::V5Tej,
19664 #[cfg(feature = "v6")]
19665 Version::V6,
19666 #[cfg(feature = "v6k")]
19667 Version::V6K,
19668 ],
19669 );
19670 if !VERSIONS.has(options.version) {
19671 return None;
19672 }
19673 let cond = Cond::default();
19674 let imm = (value) & 0xff;
19675 Some((Ins::Svc { cond, imm }, 2))
19676}
19677#[cfg(feature = "arm")]
19678fn parse_arm_swp_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19679 if value & 0xf00 != 0 {
19680 return Some(Ins::Illegal);
19681 }
19682 if value & 0xf0000000 == 0xf0000000 {
19683 return Some(Ins::Illegal);
19684 }
19685 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19686 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
19687 let rd2 = Reg::parse((value) & 0xf, pc);
19688 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
19689 Some(Ins::Swp { cond, rd, rd2, rn })
19690}
19691#[cfg(feature = "arm")]
19692fn parse_arm_swpb_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19693 if value & 0xf00 != 0 {
19694 return Some(Ins::Illegal);
19695 }
19696 if value & 0xf0000000 == 0xf0000000 {
19697 return Some(Ins::Illegal);
19698 }
19699 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19700 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
19701 let rd2 = Reg::parse((value) & 0xf, pc);
19702 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
19703 Some(Ins::Swpb { cond, rd, rd2, rn })
19704}
19705#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
19706fn parse_arm_sxtab_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19707 const VERSIONS: Versions = Versions::of(
19708 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
19709 );
19710 if !VERSIONS.has(options.version) {
19711 return None;
19712 }
19713 if value & 0x300 != 0 {
19714 return Some(Ins::Illegal);
19715 }
19716 if value & 0xf0000000 == 0xf0000000 {
19717 return Some(Ins::Illegal);
19718 }
19719 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19720 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
19721 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
19722 let rm = Reg::parse((value) & 0xf, pc);
19723 let rotate = (((value) >> 10) & 0x3) << 3;
19724 Some(Ins::Sxtab {
19725 cond,
19726 rd,
19727 rn,
19728 rm,
19729 rotate,
19730 })
19731}
19732#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
19733fn parse_arm_sxtab16_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19734 const VERSIONS: Versions = Versions::of(
19735 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
19736 );
19737 if !VERSIONS.has(options.version) {
19738 return None;
19739 }
19740 if value & 0x300 != 0 {
19741 return Some(Ins::Illegal);
19742 }
19743 if value & 0xf0000000 == 0xf0000000 {
19744 return Some(Ins::Illegal);
19745 }
19746 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19747 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
19748 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
19749 let rm = Reg::parse((value) & 0xf, pc);
19750 let rotate = (((value) >> 10) & 0x3) << 3;
19751 Some(Ins::Sxtab16 {
19752 cond,
19753 rd,
19754 rn,
19755 rm,
19756 rotate,
19757 })
19758}
19759#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
19760fn parse_arm_sxtah_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19761 const VERSIONS: Versions = Versions::of(
19762 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
19763 );
19764 if !VERSIONS.has(options.version) {
19765 return None;
19766 }
19767 if value & 0x300 != 0 {
19768 return Some(Ins::Illegal);
19769 }
19770 if value & 0xf0000000 == 0xf0000000 {
19771 return Some(Ins::Illegal);
19772 }
19773 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19774 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
19775 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
19776 let rm = Reg::parse((value) & 0xf, pc);
19777 let rotate = (((value) >> 10) & 0x3) << 3;
19778 Some(Ins::Sxtah {
19779 cond,
19780 rd,
19781 rn,
19782 rm,
19783 rotate,
19784 })
19785}
19786#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
19787fn parse_arm_sxtb_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19788 const VERSIONS: Versions = Versions::of(
19789 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
19790 );
19791 if !VERSIONS.has(options.version) {
19792 return None;
19793 }
19794 if value & 0x300 != 0 {
19795 return Some(Ins::Illegal);
19796 }
19797 if value & 0xf0000000 == 0xf0000000 {
19798 return Some(Ins::Illegal);
19799 }
19800 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19801 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
19802 let rm = Reg::parse((value) & 0xf, pc);
19803 let rotate = (((value) >> 10) & 0x3) << 3;
19804 Some(Ins::Sxtb { cond, rd, rm, rotate })
19805}
19806#[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
19807fn parse_thumb_sxtb_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
19808 const VERSIONS: Versions = Versions::of(
19809 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
19810 );
19811 if !VERSIONS.has(options.version) {
19812 return None;
19813 }
19814 let cond = Cond::default();
19815 let rd = Reg::parse((value) & 0x7, pc);
19816 let rm = Reg::parse(((value) >> 3) & 0x7, pc);
19817 let rotate = 0;
19818 Some((Ins::Sxtb { cond, rd, rm, rotate }, 2))
19819}
19820#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
19821fn parse_arm_sxtb16_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19822 const VERSIONS: Versions = Versions::of(
19823 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
19824 );
19825 if !VERSIONS.has(options.version) {
19826 return None;
19827 }
19828 if value & 0x300 != 0 {
19829 return Some(Ins::Illegal);
19830 }
19831 if value & 0xf0000000 == 0xf0000000 {
19832 return Some(Ins::Illegal);
19833 }
19834 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19835 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
19836 let rm = Reg::parse((value) & 0xf, pc);
19837 let rotate = (((value) >> 10) & 0x3) << 3;
19838 Some(Ins::Sxtb16 {
19839 cond,
19840 rd,
19841 rm,
19842 rotate,
19843 })
19844}
19845#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
19846fn parse_arm_sxth_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19847 const VERSIONS: Versions = Versions::of(
19848 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
19849 );
19850 if !VERSIONS.has(options.version) {
19851 return None;
19852 }
19853 if value & 0x300 != 0 {
19854 return Some(Ins::Illegal);
19855 }
19856 if value & 0xf0000000 == 0xf0000000 {
19857 return Some(Ins::Illegal);
19858 }
19859 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19860 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
19861 let rm = Reg::parse((value) & 0xf, pc);
19862 let rotate = (((value) >> 10) & 0x3) << 3;
19863 Some(Ins::Sxth { cond, rd, rm, rotate })
19864}
19865#[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
19866fn parse_thumb_sxth_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
19867 const VERSIONS: Versions = Versions::of(
19868 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
19869 );
19870 if !VERSIONS.has(options.version) {
19871 return None;
19872 }
19873 let cond = Cond::default();
19874 let rd = Reg::parse((value) & 0x7, pc);
19875 let rm = Reg::parse(((value) >> 3) & 0x7, pc);
19876 let rotate = 0;
19877 Some((Ins::Sxth { cond, rd, rm, rotate }, 2))
19878}
19879#[cfg(feature = "arm")]
19880fn parse_arm_teq_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19881 if value & 0xf000 != 0 {
19882 return Some(Ins::Illegal);
19883 }
19884 if value & 0xf0000000 == 0xf0000000 {
19885 return Some(Ins::Illegal);
19886 }
19887 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19888 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
19889 let Some(op2) = Op2::parse(value, pc) else {
19890 return Some(Ins::Illegal);
19891 };
19892 Some(Ins::Teq { cond, rn, op2 })
19893}
19894#[cfg(feature = "arm")]
19895fn parse_arm_tst_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19896 if value & 0xf000 != 0 {
19897 return Some(Ins::Illegal);
19898 }
19899 if value & 0xf0000000 == 0xf0000000 {
19900 return Some(Ins::Illegal);
19901 }
19902 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19903 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
19904 let Some(op2) = Op2::parse(value, pc) else {
19905 return Some(Ins::Illegal);
19906 };
19907 Some(Ins::Tst { cond, rn, op2 })
19908}
19909#[cfg(feature = "thumb")]
19910fn parse_thumb_tst_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
19911 const VERSIONS: Versions = Versions::of(
19912 &[
19913 #[cfg(feature = "v4t")]
19914 Version::V4T,
19915 #[cfg(feature = "v5t")]
19916 Version::V5T,
19917 #[cfg(feature = "v5te")]
19918 Version::V5Te,
19919 #[cfg(feature = "v5tej")]
19920 Version::V5Tej,
19921 #[cfg(feature = "v6")]
19922 Version::V6,
19923 #[cfg(feature = "v6k")]
19924 Version::V6K,
19925 ],
19926 );
19927 if !VERSIONS.has(options.version) {
19928 return None;
19929 }
19930 let cond = Cond::default();
19931 let rn = Reg::parse((value) & 0x7, pc);
19932 let op2 = Op2::ShiftImm(ShiftImm {
19933 rm: Reg::parse(((value) >> 3) & 0x7, pc),
19934 shift_op: ShiftOp::default(),
19935 imm: 0,
19936 });
19937 Some((Ins::Tst { cond, rn, op2 }, 2))
19938}
19939#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
19940fn parse_arm_uadd16_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19941 const VERSIONS: Versions = Versions::of(
19942 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
19943 );
19944 if !VERSIONS.has(options.version) {
19945 return None;
19946 }
19947 if value & 0xf00 != 0xf00 {
19948 return Some(Ins::Illegal);
19949 }
19950 if value & 0xf0000000 == 0xf0000000 {
19951 return Some(Ins::Illegal);
19952 }
19953 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19954 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
19955 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
19956 let rm = Reg::parse((value) & 0xf, pc);
19957 Some(Ins::Uadd16 { cond, rd, rn, rm })
19958}
19959#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
19960fn parse_arm_uadd8_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19961 const VERSIONS: Versions = Versions::of(
19962 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
19963 );
19964 if !VERSIONS.has(options.version) {
19965 return None;
19966 }
19967 if value & 0xf00 != 0xf00 {
19968 return Some(Ins::Illegal);
19969 }
19970 if value & 0xf0000000 == 0xf0000000 {
19971 return Some(Ins::Illegal);
19972 }
19973 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19974 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
19975 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
19976 let rm = Reg::parse((value) & 0xf, pc);
19977 Some(Ins::Uadd8 { cond, rd, rn, rm })
19978}
19979#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
19980fn parse_arm_uasx_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
19981 const VERSIONS: Versions = Versions::of(
19982 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
19983 );
19984 if !VERSIONS.has(options.version) {
19985 return None;
19986 }
19987 if value & 0xf00 != 0xf00 {
19988 return Some(Ins::Illegal);
19989 }
19990 if value & 0xf0000000 == 0xf0000000 {
19991 return Some(Ins::Illegal);
19992 }
19993 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
19994 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
19995 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
19996 let rm = Reg::parse((value) & 0xf, pc);
19997 Some(Ins::Uasx { cond, rd, rn, rm })
19998}
19999#[cfg(
20000 all(
20001 feature = "arm",
20002 any(
20003 feature = "v4t",
20004 feature = "v5t",
20005 feature = "v5te",
20006 feature = "v5tej",
20007 feature = "v6",
20008 feature = "v6k"
20009 )
20010 )
20011)]
20012fn parse_arm_udf_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20013 const VERSIONS: Versions = Versions::of(
20014 &[
20015 #[cfg(feature = "v4t")]
20016 Version::V4T,
20017 #[cfg(feature = "v5t")]
20018 Version::V5T,
20019 #[cfg(feature = "v5te")]
20020 Version::V5Te,
20021 #[cfg(feature = "v5tej")]
20022 Version::V5Tej,
20023 #[cfg(feature = "v6")]
20024 Version::V6,
20025 #[cfg(feature = "v6k")]
20026 Version::V6K,
20027 ],
20028 );
20029 if !VERSIONS.has(options.version) {
20030 return None;
20031 }
20032 let imm = ((((value) >> 8) & 0xfff) << 4) | ((value) & 0xf);
20033 Some(Ins::Udf { imm })
20034}
20035#[cfg(feature = "thumb")]
20036fn parse_thumb_udf_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
20037 const VERSIONS: Versions = Versions::of(
20038 &[
20039 #[cfg(feature = "v4t")]
20040 Version::V4T,
20041 #[cfg(feature = "v5t")]
20042 Version::V5T,
20043 #[cfg(feature = "v5te")]
20044 Version::V5Te,
20045 #[cfg(feature = "v5tej")]
20046 Version::V5Tej,
20047 #[cfg(feature = "v6")]
20048 Version::V6,
20049 #[cfg(feature = "v6k")]
20050 Version::V6K,
20051 ],
20052 );
20053 if !VERSIONS.has(options.version) {
20054 return None;
20055 }
20056 let imm = (value) & 0xff;
20057 Some((Ins::Udf { imm }, 2))
20058}
20059#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20060fn parse_arm_uhadd16_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20061 const VERSIONS: Versions = Versions::of(
20062 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20063 );
20064 if !VERSIONS.has(options.version) {
20065 return None;
20066 }
20067 if value & 0xf00 != 0xf00 {
20068 return Some(Ins::Illegal);
20069 }
20070 if value & 0xf0000000 == 0xf0000000 {
20071 return Some(Ins::Illegal);
20072 }
20073 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20074 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20075 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
20076 let rm = Reg::parse((value) & 0xf, pc);
20077 Some(Ins::Uhadd16 { cond, rd, rn, rm })
20078}
20079#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20080fn parse_arm_uhadd8_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20081 const VERSIONS: Versions = Versions::of(
20082 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20083 );
20084 if !VERSIONS.has(options.version) {
20085 return None;
20086 }
20087 if value & 0xf00 != 0xf00 {
20088 return Some(Ins::Illegal);
20089 }
20090 if value & 0xf0000000 == 0xf0000000 {
20091 return Some(Ins::Illegal);
20092 }
20093 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20094 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20095 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
20096 let rm = Reg::parse((value) & 0xf, pc);
20097 Some(Ins::Uhadd8 { cond, rd, rn, rm })
20098}
20099#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20100fn parse_arm_uhasx_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20101 const VERSIONS: Versions = Versions::of(
20102 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20103 );
20104 if !VERSIONS.has(options.version) {
20105 return None;
20106 }
20107 if value & 0xf00 != 0xf00 {
20108 return Some(Ins::Illegal);
20109 }
20110 if value & 0xf0000000 == 0xf0000000 {
20111 return Some(Ins::Illegal);
20112 }
20113 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20114 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20115 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
20116 let rm = Reg::parse((value) & 0xf, pc);
20117 Some(Ins::Uhasx { cond, rd, rn, rm })
20118}
20119#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20120fn parse_arm_uhsax_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20121 const VERSIONS: Versions = Versions::of(
20122 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20123 );
20124 if !VERSIONS.has(options.version) {
20125 return None;
20126 }
20127 if value & 0xf00 != 0xf00 {
20128 return Some(Ins::Illegal);
20129 }
20130 if value & 0xf0000000 == 0xf0000000 {
20131 return Some(Ins::Illegal);
20132 }
20133 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20134 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20135 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
20136 let rm = Reg::parse((value) & 0xf, pc);
20137 Some(Ins::Uhsax { cond, rd, rn, rm })
20138}
20139#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20140fn parse_arm_uhsub16_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20141 const VERSIONS: Versions = Versions::of(
20142 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20143 );
20144 if !VERSIONS.has(options.version) {
20145 return None;
20146 }
20147 if value & 0xf00 != 0xf00 {
20148 return Some(Ins::Illegal);
20149 }
20150 if value & 0xf0000000 == 0xf0000000 {
20151 return Some(Ins::Illegal);
20152 }
20153 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20154 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20155 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
20156 let rm = Reg::parse((value) & 0xf, pc);
20157 Some(Ins::Uhsub16 { cond, rd, rn, rm })
20158}
20159#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20160fn parse_arm_uhsub8_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20161 const VERSIONS: Versions = Versions::of(
20162 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20163 );
20164 if !VERSIONS.has(options.version) {
20165 return None;
20166 }
20167 if value & 0xf00 != 0xf00 {
20168 return Some(Ins::Illegal);
20169 }
20170 if value & 0xf0000000 == 0xf0000000 {
20171 return Some(Ins::Illegal);
20172 }
20173 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20174 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20175 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
20176 let rm = Reg::parse((value) & 0xf, pc);
20177 Some(Ins::Uhsub8 { cond, rd, rn, rm })
20178}
20179#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20180fn parse_arm_umaal_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20181 const VERSIONS: Versions = Versions::of(
20182 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20183 );
20184 if !VERSIONS.has(options.version) {
20185 return None;
20186 }
20187 if value & 0xf0000000 == 0xf0000000 {
20188 return Some(Ins::Illegal);
20189 }
20190 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20191 let rd_lo = Reg::parse(((value) >> 12) & 0xf, pc);
20192 let rd_hi = Reg::parse(((value) >> 16) & 0xf, pc);
20193 let rn = Reg::parse((value) & 0xf, pc);
20194 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
20195 Some(Ins::Umaal {
20196 cond,
20197 rd_lo,
20198 rd_hi,
20199 rn,
20200 rm,
20201 })
20202}
20203#[cfg(feature = "arm")]
20204fn parse_arm_umlal_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20205 if value & 0xf0000000 == 0xf0000000 {
20206 return Some(Ins::Illegal);
20207 }
20208 let s = (((value) >> 20) & 0x1) != 0;
20209 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20210 let rd_lo = Reg::parse(((value) >> 12) & 0xf, pc);
20211 let rd_hi = Reg::parse(((value) >> 16) & 0xf, pc);
20212 let rn = Reg::parse((value) & 0xf, pc);
20213 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
20214 Some(Ins::Umlal {
20215 s,
20216 cond,
20217 rd_lo,
20218 rd_hi,
20219 rn,
20220 rm,
20221 })
20222}
20223#[cfg(feature = "arm")]
20224fn parse_arm_umull_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20225 if value & 0xf0000000 == 0xf0000000 {
20226 return Some(Ins::Illegal);
20227 }
20228 let s = (((value) >> 20) & 0x1) != 0;
20229 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20230 let rd_lo = Reg::parse(((value) >> 12) & 0xf, pc);
20231 let rd_hi = Reg::parse(((value) >> 16) & 0xf, pc);
20232 let rn = Reg::parse((value) & 0xf, pc);
20233 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
20234 Some(Ins::Umull {
20235 s,
20236 cond,
20237 rd_lo,
20238 rd_hi,
20239 rn,
20240 rm,
20241 })
20242}
20243#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20244fn parse_arm_uqadd16_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20245 const VERSIONS: Versions = Versions::of(
20246 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20247 );
20248 if !VERSIONS.has(options.version) {
20249 return None;
20250 }
20251 if value & 0xf00 != 0xf00 {
20252 return Some(Ins::Illegal);
20253 }
20254 if value & 0xf0000000 == 0xf0000000 {
20255 return Some(Ins::Illegal);
20256 }
20257 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20258 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20259 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
20260 let rm = Reg::parse((value) & 0xf, pc);
20261 Some(Ins::Uqadd16 { cond, rd, rn, rm })
20262}
20263#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20264fn parse_arm_uqadd8_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20265 const VERSIONS: Versions = Versions::of(
20266 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20267 );
20268 if !VERSIONS.has(options.version) {
20269 return None;
20270 }
20271 if value & 0xf00 != 0xf00 {
20272 return Some(Ins::Illegal);
20273 }
20274 if value & 0xf0000000 == 0xf0000000 {
20275 return Some(Ins::Illegal);
20276 }
20277 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20278 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20279 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
20280 let rm = Reg::parse((value) & 0xf, pc);
20281 Some(Ins::Uqadd8 { cond, rd, rn, rm })
20282}
20283#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20284fn parse_arm_uqasx_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20285 const VERSIONS: Versions = Versions::of(
20286 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20287 );
20288 if !VERSIONS.has(options.version) {
20289 return None;
20290 }
20291 if value & 0xf00 != 0xf00 {
20292 return Some(Ins::Illegal);
20293 }
20294 if value & 0xf0000000 == 0xf0000000 {
20295 return Some(Ins::Illegal);
20296 }
20297 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20298 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20299 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
20300 let rm = Reg::parse((value) & 0xf, pc);
20301 Some(Ins::Uqasx { cond, rd, rn, rm })
20302}
20303#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20304fn parse_arm_uqsax_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20305 const VERSIONS: Versions = Versions::of(
20306 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20307 );
20308 if !VERSIONS.has(options.version) {
20309 return None;
20310 }
20311 if value & 0xf00 != 0xf00 {
20312 return Some(Ins::Illegal);
20313 }
20314 if value & 0xf0000000 == 0xf0000000 {
20315 return Some(Ins::Illegal);
20316 }
20317 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20318 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20319 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
20320 let rm = Reg::parse((value) & 0xf, pc);
20321 Some(Ins::Uqsax { cond, rd, rn, rm })
20322}
20323#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20324fn parse_arm_uqsub16_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20325 const VERSIONS: Versions = Versions::of(
20326 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20327 );
20328 if !VERSIONS.has(options.version) {
20329 return None;
20330 }
20331 if value & 0xf00 != 0xf00 {
20332 return Some(Ins::Illegal);
20333 }
20334 if value & 0xf0000000 == 0xf0000000 {
20335 return Some(Ins::Illegal);
20336 }
20337 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20338 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20339 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
20340 let rm = Reg::parse((value) & 0xf, pc);
20341 Some(Ins::Uqsub16 { cond, rd, rn, rm })
20342}
20343#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20344fn parse_arm_uqsub8_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20345 const VERSIONS: Versions = Versions::of(
20346 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20347 );
20348 if !VERSIONS.has(options.version) {
20349 return None;
20350 }
20351 if value & 0xf00 != 0xf00 {
20352 return Some(Ins::Illegal);
20353 }
20354 if value & 0xf0000000 == 0xf0000000 {
20355 return Some(Ins::Illegal);
20356 }
20357 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20358 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20359 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
20360 let rm = Reg::parse((value) & 0xf, pc);
20361 Some(Ins::Uqsub8 { cond, rd, rn, rm })
20362}
20363#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20364fn parse_arm_usad8_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20365 const VERSIONS: Versions = Versions::of(
20366 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20367 );
20368 if !VERSIONS.has(options.version) {
20369 return None;
20370 }
20371 if value & 0xf0000000 == 0xf0000000 {
20372 return Some(Ins::Illegal);
20373 }
20374 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20375 let rd = Reg::parse(((value) >> 16) & 0xf, pc);
20376 let rn = Reg::parse((value) & 0xf, pc);
20377 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
20378 Some(Ins::Usad8 { cond, rd, rn, rm })
20379}
20380#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20381fn parse_arm_usada8_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20382 const VERSIONS: Versions = Versions::of(
20383 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20384 );
20385 if !VERSIONS.has(options.version) {
20386 return None;
20387 }
20388 if value & 0xf0000000 == 0xf0000000 {
20389 return Some(Ins::Illegal);
20390 }
20391 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20392 let rd = Reg::parse(((value) >> 16) & 0xf, pc);
20393 let rn = Reg::parse((value) & 0xf, pc);
20394 let rm = Reg::parse(((value) >> 8) & 0xf, pc);
20395 let ra = Reg::parse(((value) >> 12) & 0xf, pc);
20396 Some(Ins::Usada8 {
20397 cond,
20398 rd,
20399 rn,
20400 rm,
20401 ra,
20402 })
20403}
20404#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20405fn parse_arm_usat_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20406 const VERSIONS: Versions = Versions::of(
20407 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20408 );
20409 if !VERSIONS.has(options.version) {
20410 return None;
20411 }
20412 if value & 0xf0000000 == 0xf0000000 {
20413 return Some(Ins::Illegal);
20414 }
20415 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20416 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20417 let imm = (((value) >> 16) & 0x1f);
20418 let op2 = ShiftImm::parse((value) & 0xfff, pc);
20419 Some(Ins::Usat { cond, rd, imm, op2 })
20420}
20421#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20422fn parse_arm_usat16_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20423 const VERSIONS: Versions = Versions::of(
20424 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20425 );
20426 if !VERSIONS.has(options.version) {
20427 return None;
20428 }
20429 if value & 0xf00 != 0xf00 {
20430 return Some(Ins::Illegal);
20431 }
20432 if value & 0xf0000000 == 0xf0000000 {
20433 return Some(Ins::Illegal);
20434 }
20435 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20436 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20437 let imm = (((value) >> 16) & 0x1f);
20438 let rn = Reg::parse((value) & 0xf, pc);
20439 Some(Ins::Usat16 { cond, rd, imm, rn })
20440}
20441#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20442fn parse_arm_usax_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20443 const VERSIONS: Versions = Versions::of(
20444 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20445 );
20446 if !VERSIONS.has(options.version) {
20447 return None;
20448 }
20449 if value & 0xf00 != 0xf00 {
20450 return Some(Ins::Illegal);
20451 }
20452 if value & 0xf0000000 == 0xf0000000 {
20453 return Some(Ins::Illegal);
20454 }
20455 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20456 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20457 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
20458 let rm = Reg::parse((value) & 0xf, pc);
20459 Some(Ins::Usax { cond, rd, rn, rm })
20460}
20461#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20462fn parse_arm_usub16_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20463 const VERSIONS: Versions = Versions::of(
20464 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20465 );
20466 if !VERSIONS.has(options.version) {
20467 return None;
20468 }
20469 if value & 0xf00 != 0xf00 {
20470 return Some(Ins::Illegal);
20471 }
20472 if value & 0xf0000000 == 0xf0000000 {
20473 return Some(Ins::Illegal);
20474 }
20475 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20476 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20477 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
20478 let rm = Reg::parse((value) & 0xf, pc);
20479 Some(Ins::Usub16 { cond, rd, rn, rm })
20480}
20481#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20482fn parse_arm_usub8_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20483 const VERSIONS: Versions = Versions::of(
20484 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20485 );
20486 if !VERSIONS.has(options.version) {
20487 return None;
20488 }
20489 if value & 0xf00 != 0xf00 {
20490 return Some(Ins::Illegal);
20491 }
20492 if value & 0xf0000000 == 0xf0000000 {
20493 return Some(Ins::Illegal);
20494 }
20495 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20496 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20497 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
20498 let rm = Reg::parse((value) & 0xf, pc);
20499 Some(Ins::Usub8 { cond, rd, rn, rm })
20500}
20501#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20502fn parse_arm_uxtab_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20503 const VERSIONS: Versions = Versions::of(
20504 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20505 );
20506 if !VERSIONS.has(options.version) {
20507 return None;
20508 }
20509 if value & 0x300 != 0 {
20510 return Some(Ins::Illegal);
20511 }
20512 if value & 0xf0000000 == 0xf0000000 {
20513 return Some(Ins::Illegal);
20514 }
20515 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20516 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20517 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
20518 let rm = Reg::parse((value) & 0xf, pc);
20519 let rotate = (((value) >> 10) & 0x3) << 3;
20520 Some(Ins::Uxtab {
20521 cond,
20522 rd,
20523 rn,
20524 rm,
20525 rotate,
20526 })
20527}
20528#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20529fn parse_arm_uxtab16_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20530 const VERSIONS: Versions = Versions::of(
20531 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20532 );
20533 if !VERSIONS.has(options.version) {
20534 return None;
20535 }
20536 if value & 0x300 != 0 {
20537 return Some(Ins::Illegal);
20538 }
20539 if value & 0xf0000000 == 0xf0000000 {
20540 return Some(Ins::Illegal);
20541 }
20542 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20543 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20544 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
20545 let rm = Reg::parse((value) & 0xf, pc);
20546 let rotate = (((value) >> 10) & 0x3) << 3;
20547 Some(Ins::Uxtab16 {
20548 cond,
20549 rd,
20550 rn,
20551 rm,
20552 rotate,
20553 })
20554}
20555#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20556fn parse_arm_uxtah_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20557 const VERSIONS: Versions = Versions::of(
20558 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20559 );
20560 if !VERSIONS.has(options.version) {
20561 return None;
20562 }
20563 if value & 0x300 != 0 {
20564 return Some(Ins::Illegal);
20565 }
20566 if value & 0xf0000000 == 0xf0000000 {
20567 return Some(Ins::Illegal);
20568 }
20569 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20570 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20571 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
20572 let rm = Reg::parse((value) & 0xf, pc);
20573 let rotate = (((value) >> 10) & 0x3) << 3;
20574 Some(Ins::Uxtah {
20575 cond,
20576 rd,
20577 rn,
20578 rm,
20579 rotate,
20580 })
20581}
20582#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20583fn parse_arm_uxtb_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20584 const VERSIONS: Versions = Versions::of(
20585 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20586 );
20587 if !VERSIONS.has(options.version) {
20588 return None;
20589 }
20590 if value & 0x300 != 0 {
20591 return Some(Ins::Illegal);
20592 }
20593 if value & 0xf0000000 == 0xf0000000 {
20594 return Some(Ins::Illegal);
20595 }
20596 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20597 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20598 let rm = Reg::parse((value) & 0xf, pc);
20599 let rotate = (((value) >> 10) & 0x3) << 3;
20600 Some(Ins::Uxtb { cond, rd, rm, rotate })
20601}
20602#[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
20603fn parse_thumb_uxtb_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
20604 const VERSIONS: Versions = Versions::of(
20605 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20606 );
20607 if !VERSIONS.has(options.version) {
20608 return None;
20609 }
20610 let cond = Cond::default();
20611 let rd = Reg::parse((value) & 0x7, pc);
20612 let rm = Reg::parse(((value) >> 3) & 0x7, pc);
20613 let rotate = 0;
20614 Some((Ins::Uxtb { cond, rd, rm, rotate }, 2))
20615}
20616#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20617fn parse_arm_uxtb16_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20618 const VERSIONS: Versions = Versions::of(
20619 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20620 );
20621 if !VERSIONS.has(options.version) {
20622 return None;
20623 }
20624 if value & 0x300 != 0 {
20625 return Some(Ins::Illegal);
20626 }
20627 if value & 0xf0000000 == 0xf0000000 {
20628 return Some(Ins::Illegal);
20629 }
20630 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20631 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20632 let rm = Reg::parse((value) & 0xf, pc);
20633 let rotate = (((value) >> 10) & 0x3) << 3;
20634 Some(Ins::Uxtb16 {
20635 cond,
20636 rd,
20637 rm,
20638 rotate,
20639 })
20640}
20641#[cfg(all(feature = "arm", any(feature = "v6", feature = "v6k")))]
20642fn parse_arm_uxth_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20643 const VERSIONS: Versions = Versions::of(
20644 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20645 );
20646 if !VERSIONS.has(options.version) {
20647 return None;
20648 }
20649 if value & 0x300 != 0 {
20650 return Some(Ins::Illegal);
20651 }
20652 if value & 0xf0000000 == 0xf0000000 {
20653 return Some(Ins::Illegal);
20654 }
20655 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20656 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
20657 let rm = Reg::parse((value) & 0xf, pc);
20658 let rotate = (((value) >> 10) & 0x3) << 3;
20659 Some(Ins::Uxth { cond, rd, rm, rotate })
20660}
20661#[cfg(all(feature = "thumb", any(feature = "v6", feature = "v6k")))]
20662fn parse_thumb_uxth_0(value: u32, pc: u32, options: &Options) -> Option<(Ins, u32)> {
20663 const VERSIONS: Versions = Versions::of(
20664 &[#[cfg(feature = "v6")] Version::V6, #[cfg(feature = "v6k")] Version::V6K],
20665 );
20666 if !VERSIONS.has(options.version) {
20667 return None;
20668 }
20669 let cond = Cond::default();
20670 let rd = Reg::parse((value) & 0x7, pc);
20671 let rm = Reg::parse(((value) >> 3) & 0x7, pc);
20672 let rotate = 0;
20673 Some((Ins::Uxth { cond, rd, rm, rotate }, 2))
20674}
20675#[cfg(
20676 all(
20677 feature = "arm",
20678 feature = "vfp_v2",
20679 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
20680 )
20681)]
20682fn parse_arm_vabs_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20683 const VERSIONS: Versions = Versions::of(
20684 &[
20685 #[cfg(feature = "v5te")]
20686 Version::V5Te,
20687 #[cfg(feature = "v5tej")]
20688 Version::V5Tej,
20689 #[cfg(feature = "v6")]
20690 Version::V6,
20691 #[cfg(feature = "v6k")]
20692 Version::V6K,
20693 ],
20694 );
20695 if !VERSIONS.has(options.version) {
20696 return None;
20697 }
20698 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
20699 if !EXTENSIONS.has_all(options.extensions) {
20700 return None;
20701 }
20702 if value & 0xf0000000 == 0xf0000000 {
20703 return Some(Ins::Illegal);
20704 }
20705 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20706 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
20707 let sm = Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc);
20708 Some(Ins::VabsF32 { cond, sd, sm })
20709}
20710#[cfg(
20711 all(
20712 feature = "arm",
20713 feature = "vfp_v2",
20714 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
20715 )
20716)]
20717fn parse_arm_vabs_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20718 const VERSIONS: Versions = Versions::of(
20719 &[
20720 #[cfg(feature = "v5te")]
20721 Version::V5Te,
20722 #[cfg(feature = "v5tej")]
20723 Version::V5Tej,
20724 #[cfg(feature = "v6")]
20725 Version::V6,
20726 #[cfg(feature = "v6k")]
20727 Version::V6K,
20728 ],
20729 );
20730 if !VERSIONS.has(options.version) {
20731 return None;
20732 }
20733 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
20734 if !EXTENSIONS.has_all(options.extensions) {
20735 return None;
20736 }
20737 if value & 0xf0000000 == 0xf0000000 {
20738 return Some(Ins::Illegal);
20739 }
20740 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20741 let dd = Dreg::parse(((((value) >> 22) & 0x1) << 4) | (((value) >> 12) & 0xf), pc);
20742 let dm = Dreg::parse(((((value) >> 5) & 0x1) << 4) | ((value) & 0xf), pc);
20743 Some(Ins::VabsF64 { cond, dd, dm })
20744}
20745#[cfg(
20746 all(
20747 feature = "arm",
20748 feature = "vfp_v2",
20749 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
20750 )
20751)]
20752fn parse_arm_vadd_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20753 const VERSIONS: Versions = Versions::of(
20754 &[
20755 #[cfg(feature = "v5te")]
20756 Version::V5Te,
20757 #[cfg(feature = "v5tej")]
20758 Version::V5Tej,
20759 #[cfg(feature = "v6")]
20760 Version::V6,
20761 #[cfg(feature = "v6k")]
20762 Version::V6K,
20763 ],
20764 );
20765 if !VERSIONS.has(options.version) {
20766 return None;
20767 }
20768 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
20769 if !EXTENSIONS.has_all(options.extensions) {
20770 return None;
20771 }
20772 if value & 0xf0000000 == 0xf0000000 {
20773 return Some(Ins::Illegal);
20774 }
20775 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20776 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
20777 let sn = Sreg::parse(((((value) >> 16) & 0xf) << 1) | (((value) >> 7) & 0x1), pc);
20778 let sm = Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc);
20779 Some(Ins::VaddF32 { cond, sd, sn, sm })
20780}
20781#[cfg(
20782 all(
20783 feature = "arm",
20784 feature = "vfp_v2",
20785 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
20786 )
20787)]
20788fn parse_arm_vadd_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20789 const VERSIONS: Versions = Versions::of(
20790 &[
20791 #[cfg(feature = "v5te")]
20792 Version::V5Te,
20793 #[cfg(feature = "v5tej")]
20794 Version::V5Tej,
20795 #[cfg(feature = "v6")]
20796 Version::V6,
20797 #[cfg(feature = "v6k")]
20798 Version::V6K,
20799 ],
20800 );
20801 if !VERSIONS.has(options.version) {
20802 return None;
20803 }
20804 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
20805 if !EXTENSIONS.has_all(options.extensions) {
20806 return None;
20807 }
20808 if value & 0xf0000000 == 0xf0000000 {
20809 return Some(Ins::Illegal);
20810 }
20811 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20812 let dd = Dreg::parse(((((value) >> 22) & 0x1) << 4) | (((value) >> 12) & 0xf), pc);
20813 let dn = Dreg::parse(((((value) >> 7) & 0x1) << 4) | (((value) >> 16) & 0xf), pc);
20814 let dm = Dreg::parse(((((value) >> 5) & 0x1) << 4) | ((value) & 0xf), pc);
20815 Some(Ins::VaddF64 { cond, dd, dn, dm })
20816}
20817#[cfg(
20818 all(
20819 feature = "arm",
20820 feature = "vfp_v2",
20821 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
20822 )
20823)]
20824fn parse_arm_vcmp_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20825 const VERSIONS: Versions = Versions::of(
20826 &[
20827 #[cfg(feature = "v5te")]
20828 Version::V5Te,
20829 #[cfg(feature = "v5tej")]
20830 Version::V5Tej,
20831 #[cfg(feature = "v6")]
20832 Version::V6,
20833 #[cfg(feature = "v6k")]
20834 Version::V6K,
20835 ],
20836 );
20837 if !VERSIONS.has(options.version) {
20838 return None;
20839 }
20840 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
20841 if !EXTENSIONS.has_all(options.extensions) {
20842 return None;
20843 }
20844 if value & 0xf0000000 == 0xf0000000 {
20845 return Some(Ins::Illegal);
20846 }
20847 let nan_exc = (((value) >> 7) & 0x1) != 0;
20848 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20849 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
20850 let Some(op2) = VcmpF32Op2::parse(value, pc) else {
20851 return Some(Ins::Illegal);
20852 };
20853 Some(Ins::VcmpF32 {
20854 nan_exc,
20855 cond,
20856 sd,
20857 op2,
20858 })
20859}
20860#[cfg(
20861 all(
20862 feature = "arm",
20863 feature = "vfp_v2",
20864 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
20865 )
20866)]
20867fn parse_arm_vcmp_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20868 const VERSIONS: Versions = Versions::of(
20869 &[
20870 #[cfg(feature = "v5te")]
20871 Version::V5Te,
20872 #[cfg(feature = "v5tej")]
20873 Version::V5Tej,
20874 #[cfg(feature = "v6")]
20875 Version::V6,
20876 #[cfg(feature = "v6k")]
20877 Version::V6K,
20878 ],
20879 );
20880 if !VERSIONS.has(options.version) {
20881 return None;
20882 }
20883 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
20884 if !EXTENSIONS.has_all(options.extensions) {
20885 return None;
20886 }
20887 if value & 0xf0000000 == 0xf0000000 {
20888 return Some(Ins::Illegal);
20889 }
20890 let nan_exc = (((value) >> 7) & 0x1) != 0;
20891 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20892 let dd = Dreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
20893 let Some(op2) = VcmpF64Op2::parse(value, pc) else {
20894 return Some(Ins::Illegal);
20895 };
20896 Some(Ins::VcmpF64 {
20897 nan_exc,
20898 cond,
20899 dd,
20900 op2,
20901 })
20902}
20903#[cfg(
20904 all(
20905 feature = "arm",
20906 feature = "vfp_v2",
20907 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
20908 )
20909)]
20910fn parse_arm_vcvt_f32_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20911 const VERSIONS: Versions = Versions::of(
20912 &[
20913 #[cfg(feature = "v5te")]
20914 Version::V5Te,
20915 #[cfg(feature = "v5tej")]
20916 Version::V5Tej,
20917 #[cfg(feature = "v6")]
20918 Version::V6,
20919 #[cfg(feature = "v6k")]
20920 Version::V6K,
20921 ],
20922 );
20923 if !VERSIONS.has(options.version) {
20924 return None;
20925 }
20926 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
20927 if !EXTENSIONS.has_all(options.extensions) {
20928 return None;
20929 }
20930 if value & 0xf0000000 == 0xf0000000 {
20931 return Some(Ins::Illegal);
20932 }
20933 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20934 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
20935 let dm = Dreg::parse(((((value) >> 5) & 0x1) << 4) | ((value) & 0xf), pc);
20936 Some(Ins::VcvtF32F64 { cond, sd, dm })
20937}
20938#[cfg(
20939 all(
20940 feature = "arm",
20941 feature = "vfp_v2",
20942 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
20943 )
20944)]
20945fn parse_arm_vcvt_f32_s32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20946 const VERSIONS: Versions = Versions::of(
20947 &[
20948 #[cfg(feature = "v5te")]
20949 Version::V5Te,
20950 #[cfg(feature = "v5tej")]
20951 Version::V5Tej,
20952 #[cfg(feature = "v6")]
20953 Version::V6,
20954 #[cfg(feature = "v6k")]
20955 Version::V6K,
20956 ],
20957 );
20958 if !VERSIONS.has(options.version) {
20959 return None;
20960 }
20961 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
20962 if !EXTENSIONS.has_all(options.extensions) {
20963 return None;
20964 }
20965 if value & 0xf0000000 == 0xf0000000 {
20966 return Some(Ins::Illegal);
20967 }
20968 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
20969 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
20970 let sm = Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc);
20971 Some(Ins::VcvtF32S32 { cond, sd, sm })
20972}
20973#[cfg(
20974 all(
20975 feature = "arm",
20976 feature = "vfp_v2",
20977 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
20978 )
20979)]
20980fn parse_arm_vcvt_f32_u32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
20981 const VERSIONS: Versions = Versions::of(
20982 &[
20983 #[cfg(feature = "v5te")]
20984 Version::V5Te,
20985 #[cfg(feature = "v5tej")]
20986 Version::V5Tej,
20987 #[cfg(feature = "v6")]
20988 Version::V6,
20989 #[cfg(feature = "v6k")]
20990 Version::V6K,
20991 ],
20992 );
20993 if !VERSIONS.has(options.version) {
20994 return None;
20995 }
20996 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
20997 if !EXTENSIONS.has_all(options.extensions) {
20998 return None;
20999 }
21000 if value & 0xf0000000 == 0xf0000000 {
21001 return Some(Ins::Illegal);
21002 }
21003 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21004 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
21005 let sm = Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc);
21006 Some(Ins::VcvtF32U32 { cond, sd, sm })
21007}
21008#[cfg(
21009 all(
21010 feature = "arm",
21011 feature = "vfp_v2",
21012 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21013 )
21014)]
21015fn parse_arm_vcvt_f64_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21016 const VERSIONS: Versions = Versions::of(
21017 &[
21018 #[cfg(feature = "v5te")]
21019 Version::V5Te,
21020 #[cfg(feature = "v5tej")]
21021 Version::V5Tej,
21022 #[cfg(feature = "v6")]
21023 Version::V6,
21024 #[cfg(feature = "v6k")]
21025 Version::V6K,
21026 ],
21027 );
21028 if !VERSIONS.has(options.version) {
21029 return None;
21030 }
21031 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21032 if !EXTENSIONS.has_all(options.extensions) {
21033 return None;
21034 }
21035 if value & 0xf0000000 == 0xf0000000 {
21036 return Some(Ins::Illegal);
21037 }
21038 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21039 let dd = Dreg::parse(((((value) >> 22) & 0x1) << 4) | (((value) >> 12) & 0xf), pc);
21040 let sm = Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc);
21041 Some(Ins::VcvtF64F32 { cond, dd, sm })
21042}
21043#[cfg(
21044 all(
21045 feature = "arm",
21046 feature = "vfp_v2",
21047 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21048 )
21049)]
21050fn parse_arm_vcvt_f64_s32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21051 const VERSIONS: Versions = Versions::of(
21052 &[
21053 #[cfg(feature = "v5te")]
21054 Version::V5Te,
21055 #[cfg(feature = "v5tej")]
21056 Version::V5Tej,
21057 #[cfg(feature = "v6")]
21058 Version::V6,
21059 #[cfg(feature = "v6k")]
21060 Version::V6K,
21061 ],
21062 );
21063 if !VERSIONS.has(options.version) {
21064 return None;
21065 }
21066 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21067 if !EXTENSIONS.has_all(options.extensions) {
21068 return None;
21069 }
21070 if value & 0xf0000000 == 0xf0000000 {
21071 return Some(Ins::Illegal);
21072 }
21073 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21074 let dd = Dreg::parse(((((value) >> 22) & 0x1) << 4) | (((value) >> 12) & 0xf), pc);
21075 let sm = Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc);
21076 Some(Ins::VcvtF64S32 { cond, dd, sm })
21077}
21078#[cfg(
21079 all(
21080 feature = "arm",
21081 feature = "vfp_v2",
21082 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21083 )
21084)]
21085fn parse_arm_vcvt_f64_u32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21086 const VERSIONS: Versions = Versions::of(
21087 &[
21088 #[cfg(feature = "v5te")]
21089 Version::V5Te,
21090 #[cfg(feature = "v5tej")]
21091 Version::V5Tej,
21092 #[cfg(feature = "v6")]
21093 Version::V6,
21094 #[cfg(feature = "v6k")]
21095 Version::V6K,
21096 ],
21097 );
21098 if !VERSIONS.has(options.version) {
21099 return None;
21100 }
21101 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21102 if !EXTENSIONS.has_all(options.extensions) {
21103 return None;
21104 }
21105 if value & 0xf0000000 == 0xf0000000 {
21106 return Some(Ins::Illegal);
21107 }
21108 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21109 let dd = Dreg::parse(((((value) >> 22) & 0x1) << 4) | (((value) >> 12) & 0xf), pc);
21110 let sm = Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc);
21111 Some(Ins::VcvtF64U32 { cond, dd, sm })
21112}
21113#[cfg(
21114 all(
21115 feature = "arm",
21116 feature = "vfp_v2",
21117 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21118 )
21119)]
21120fn parse_arm_vcvt_s32_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21121 const VERSIONS: Versions = Versions::of(
21122 &[
21123 #[cfg(feature = "v5te")]
21124 Version::V5Te,
21125 #[cfg(feature = "v5tej")]
21126 Version::V5Tej,
21127 #[cfg(feature = "v6")]
21128 Version::V6,
21129 #[cfg(feature = "v6k")]
21130 Version::V6K,
21131 ],
21132 );
21133 if !VERSIONS.has(options.version) {
21134 return None;
21135 }
21136 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21137 if !EXTENSIONS.has_all(options.extensions) {
21138 return None;
21139 }
21140 if value & 0xf0000000 == 0xf0000000 {
21141 return Some(Ins::Illegal);
21142 }
21143 let round_zero = ((((value) >> 7) & 0x1) ^ 1) != 0;
21144 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21145 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
21146 let sm = Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc);
21147 Some(Ins::VcvtS32F32 {
21148 round_zero,
21149 cond,
21150 sd,
21151 sm,
21152 })
21153}
21154#[cfg(
21155 all(
21156 feature = "arm",
21157 feature = "vfp_v2",
21158 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21159 )
21160)]
21161fn parse_arm_vcvt_s32_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21162 const VERSIONS: Versions = Versions::of(
21163 &[
21164 #[cfg(feature = "v5te")]
21165 Version::V5Te,
21166 #[cfg(feature = "v5tej")]
21167 Version::V5Tej,
21168 #[cfg(feature = "v6")]
21169 Version::V6,
21170 #[cfg(feature = "v6k")]
21171 Version::V6K,
21172 ],
21173 );
21174 if !VERSIONS.has(options.version) {
21175 return None;
21176 }
21177 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21178 if !EXTENSIONS.has_all(options.extensions) {
21179 return None;
21180 }
21181 if value & 0xf0000000 == 0xf0000000 {
21182 return Some(Ins::Illegal);
21183 }
21184 let round_zero = ((((value) >> 7) & 0x1) ^ 1) != 0;
21185 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21186 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
21187 let dm = Dreg::parse(((((value) >> 5) & 0x1) << 4) | ((value) & 0xf), pc);
21188 Some(Ins::VcvtS32F64 {
21189 round_zero,
21190 cond,
21191 sd,
21192 dm,
21193 })
21194}
21195#[cfg(
21196 all(
21197 feature = "arm",
21198 feature = "vfp_v2",
21199 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21200 )
21201)]
21202fn parse_arm_vcvt_u32_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21203 const VERSIONS: Versions = Versions::of(
21204 &[
21205 #[cfg(feature = "v5te")]
21206 Version::V5Te,
21207 #[cfg(feature = "v5tej")]
21208 Version::V5Tej,
21209 #[cfg(feature = "v6")]
21210 Version::V6,
21211 #[cfg(feature = "v6k")]
21212 Version::V6K,
21213 ],
21214 );
21215 if !VERSIONS.has(options.version) {
21216 return None;
21217 }
21218 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21219 if !EXTENSIONS.has_all(options.extensions) {
21220 return None;
21221 }
21222 if value & 0xf0000000 == 0xf0000000 {
21223 return Some(Ins::Illegal);
21224 }
21225 let round_zero = ((((value) >> 7) & 0x1) ^ 1) != 0;
21226 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21227 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
21228 let sm = Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc);
21229 Some(Ins::VcvtU32F32 {
21230 round_zero,
21231 cond,
21232 sd,
21233 sm,
21234 })
21235}
21236#[cfg(
21237 all(
21238 feature = "arm",
21239 feature = "vfp_v2",
21240 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21241 )
21242)]
21243fn parse_arm_vcvt_u32_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21244 const VERSIONS: Versions = Versions::of(
21245 &[
21246 #[cfg(feature = "v5te")]
21247 Version::V5Te,
21248 #[cfg(feature = "v5tej")]
21249 Version::V5Tej,
21250 #[cfg(feature = "v6")]
21251 Version::V6,
21252 #[cfg(feature = "v6k")]
21253 Version::V6K,
21254 ],
21255 );
21256 if !VERSIONS.has(options.version) {
21257 return None;
21258 }
21259 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21260 if !EXTENSIONS.has_all(options.extensions) {
21261 return None;
21262 }
21263 if value & 0xf0000000 == 0xf0000000 {
21264 return Some(Ins::Illegal);
21265 }
21266 let round_zero = ((((value) >> 7) & 0x1) ^ 1) != 0;
21267 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21268 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
21269 let dm = Dreg::parse(((((value) >> 5) & 0x1) << 4) | ((value) & 0xf), pc);
21270 Some(Ins::VcvtU32F64 {
21271 round_zero,
21272 cond,
21273 sd,
21274 dm,
21275 })
21276}
21277#[cfg(
21278 all(
21279 feature = "arm",
21280 feature = "vfp_v2",
21281 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21282 )
21283)]
21284fn parse_arm_vdiv_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21285 const VERSIONS: Versions = Versions::of(
21286 &[
21287 #[cfg(feature = "v5te")]
21288 Version::V5Te,
21289 #[cfg(feature = "v5tej")]
21290 Version::V5Tej,
21291 #[cfg(feature = "v6")]
21292 Version::V6,
21293 #[cfg(feature = "v6k")]
21294 Version::V6K,
21295 ],
21296 );
21297 if !VERSIONS.has(options.version) {
21298 return None;
21299 }
21300 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21301 if !EXTENSIONS.has_all(options.extensions) {
21302 return None;
21303 }
21304 if value & 0xf0000000 == 0xf0000000 {
21305 return Some(Ins::Illegal);
21306 }
21307 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21308 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
21309 let sn = Sreg::parse(((((value) >> 16) & 0xf) << 1) | (((value) >> 7) & 0x1), pc);
21310 let sm = Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc);
21311 Some(Ins::VdivF32 { cond, sd, sn, sm })
21312}
21313#[cfg(
21314 all(
21315 feature = "arm",
21316 feature = "vfp_v2",
21317 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21318 )
21319)]
21320fn parse_arm_vdiv_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21321 const VERSIONS: Versions = Versions::of(
21322 &[
21323 #[cfg(feature = "v5te")]
21324 Version::V5Te,
21325 #[cfg(feature = "v5tej")]
21326 Version::V5Tej,
21327 #[cfg(feature = "v6")]
21328 Version::V6,
21329 #[cfg(feature = "v6k")]
21330 Version::V6K,
21331 ],
21332 );
21333 if !VERSIONS.has(options.version) {
21334 return None;
21335 }
21336 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21337 if !EXTENSIONS.has_all(options.extensions) {
21338 return None;
21339 }
21340 if value & 0xf0000000 == 0xf0000000 {
21341 return Some(Ins::Illegal);
21342 }
21343 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21344 let dd = Dreg::parse(((((value) >> 22) & 0x1) << 4) | (((value) >> 12) & 0xf), pc);
21345 let dn = Dreg::parse(((((value) >> 7) & 0x1) << 4) | (((value) >> 16) & 0xf), pc);
21346 let dm = Dreg::parse(((((value) >> 5) & 0x1) << 4) | ((value) & 0xf), pc);
21347 Some(Ins::VdivF64 { cond, dd, dn, dm })
21348}
21349#[cfg(
21350 all(
21351 feature = "arm",
21352 feature = "vfp_v2",
21353 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21354 )
21355)]
21356fn parse_arm_vldm_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21357 const VERSIONS: Versions = Versions::of(
21358 &[
21359 #[cfg(feature = "v5te")]
21360 Version::V5Te,
21361 #[cfg(feature = "v5tej")]
21362 Version::V5Tej,
21363 #[cfg(feature = "v6")]
21364 Version::V6,
21365 #[cfg(feature = "v6k")]
21366 Version::V6K,
21367 ],
21368 );
21369 if !VERSIONS.has(options.version) {
21370 return None;
21371 }
21372 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21373 if !EXTENSIONS.has_all(options.extensions) {
21374 return None;
21375 }
21376 if value & 0xf0000000 == 0xf0000000 {
21377 return Some(Ins::Illegal);
21378 }
21379 let Some(mode) = VldmVstmMode::parse(((value) >> 23) & 0x3, pc) else {
21380 return Some(Ins::Illegal);
21381 };
21382 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21383 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
21384 let writeback = (((value) >> 21) & 0x1) != 0;
21385 let regs = SregList::parse(value);
21386 Some(Ins::VldmF32 {
21387 mode,
21388 cond,
21389 rn,
21390 writeback,
21391 regs,
21392 })
21393}
21394#[cfg(
21395 all(
21396 feature = "arm",
21397 feature = "vfp_v2",
21398 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21399 )
21400)]
21401fn parse_arm_vldm_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21402 const VERSIONS: Versions = Versions::of(
21403 &[
21404 #[cfg(feature = "v5te")]
21405 Version::V5Te,
21406 #[cfg(feature = "v5tej")]
21407 Version::V5Tej,
21408 #[cfg(feature = "v6")]
21409 Version::V6,
21410 #[cfg(feature = "v6k")]
21411 Version::V6K,
21412 ],
21413 );
21414 if !VERSIONS.has(options.version) {
21415 return None;
21416 }
21417 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21418 if !EXTENSIONS.has_all(options.extensions) {
21419 return None;
21420 }
21421 if value & 0xf0000000 == 0xf0000000 {
21422 return Some(Ins::Illegal);
21423 }
21424 let Some(mode) = VldmVstmMode::parse(((value) >> 23) & 0x3, pc) else {
21425 return Some(Ins::Illegal);
21426 };
21427 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21428 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
21429 let writeback = (((value) >> 21) & 0x1) != 0;
21430 let regs = DregList::parse(value);
21431 Some(Ins::VldmF64 {
21432 mode,
21433 cond,
21434 rn,
21435 writeback,
21436 regs,
21437 })
21438}
21439#[cfg(
21440 all(
21441 feature = "arm",
21442 feature = "vfp_v2",
21443 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21444 )
21445)]
21446fn parse_arm_vldr_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21447 const VERSIONS: Versions = Versions::of(
21448 &[
21449 #[cfg(feature = "v5te")]
21450 Version::V5Te,
21451 #[cfg(feature = "v5tej")]
21452 Version::V5Tej,
21453 #[cfg(feature = "v6")]
21454 Version::V6,
21455 #[cfg(feature = "v6k")]
21456 Version::V6K,
21457 ],
21458 );
21459 if !VERSIONS.has(options.version) {
21460 return None;
21461 }
21462 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21463 if !EXTENSIONS.has_all(options.extensions) {
21464 return None;
21465 }
21466 if value & 0xf0000000 == 0xf0000000 {
21467 return Some(Ins::Illegal);
21468 }
21469 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21470 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
21471 let addr = AddrLdrStr::Pre {
21472 rn: Reg::parse(((value) >> 16) & 0xf, pc),
21473 offset: LdrStrOffset::Imm(
21474 ((if (((value) >> 23) & 0x1) == 0 {
21475 -((((value) & 0xff) << 2) as i32)
21476 } else {
21477 (((value) & 0xff) << 2) as i32
21478 })) as i32,
21479 ),
21480 writeback: false,
21481 };
21482 Some(Ins::VldrF32 { cond, sd, addr })
21483}
21484#[cfg(
21485 all(
21486 feature = "arm",
21487 feature = "vfp_v2",
21488 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21489 )
21490)]
21491fn parse_arm_vldr_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21492 const VERSIONS: Versions = Versions::of(
21493 &[
21494 #[cfg(feature = "v5te")]
21495 Version::V5Te,
21496 #[cfg(feature = "v5tej")]
21497 Version::V5Tej,
21498 #[cfg(feature = "v6")]
21499 Version::V6,
21500 #[cfg(feature = "v6k")]
21501 Version::V6K,
21502 ],
21503 );
21504 if !VERSIONS.has(options.version) {
21505 return None;
21506 }
21507 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21508 if !EXTENSIONS.has_all(options.extensions) {
21509 return None;
21510 }
21511 if value & 0xf0000000 == 0xf0000000 {
21512 return Some(Ins::Illegal);
21513 }
21514 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21515 let dd = Dreg::parse(((((value) >> 22) & 0x1) << 4) | (((value) >> 12) & 0xf), pc);
21516 let addr = AddrLdrStr::Pre {
21517 rn: Reg::parse(((value) >> 16) & 0xf, pc),
21518 offset: LdrStrOffset::Imm(
21519 ((if (((value) >> 23) & 0x1) == 0 {
21520 -((((value) & 0xff) << 2) as i32)
21521 } else {
21522 (((value) & 0xff) << 2) as i32
21523 })) as i32,
21524 ),
21525 writeback: false,
21526 };
21527 Some(Ins::VldrF64 { cond, dd, addr })
21528}
21529#[cfg(
21530 all(
21531 feature = "arm",
21532 feature = "vfp_v2",
21533 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21534 )
21535)]
21536fn parse_arm_vmla_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21537 const VERSIONS: Versions = Versions::of(
21538 &[
21539 #[cfg(feature = "v5te")]
21540 Version::V5Te,
21541 #[cfg(feature = "v5tej")]
21542 Version::V5Tej,
21543 #[cfg(feature = "v6")]
21544 Version::V6,
21545 #[cfg(feature = "v6k")]
21546 Version::V6K,
21547 ],
21548 );
21549 if !VERSIONS.has(options.version) {
21550 return None;
21551 }
21552 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21553 if !EXTENSIONS.has_all(options.extensions) {
21554 return None;
21555 }
21556 if value & 0xf0000000 == 0xf0000000 {
21557 return Some(Ins::Illegal);
21558 }
21559 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21560 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
21561 let sn = Sreg::parse(((((value) >> 16) & 0xf) << 1) | (((value) >> 7) & 0x1), pc);
21562 let sm = Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc);
21563 Some(Ins::VmlaF32 { cond, sd, sn, sm })
21564}
21565#[cfg(
21566 all(
21567 feature = "arm",
21568 feature = "vfp_v2",
21569 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21570 )
21571)]
21572fn parse_arm_vmla_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21573 const VERSIONS: Versions = Versions::of(
21574 &[
21575 #[cfg(feature = "v5te")]
21576 Version::V5Te,
21577 #[cfg(feature = "v5tej")]
21578 Version::V5Tej,
21579 #[cfg(feature = "v6")]
21580 Version::V6,
21581 #[cfg(feature = "v6k")]
21582 Version::V6K,
21583 ],
21584 );
21585 if !VERSIONS.has(options.version) {
21586 return None;
21587 }
21588 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21589 if !EXTENSIONS.has_all(options.extensions) {
21590 return None;
21591 }
21592 if value & 0xf0000000 == 0xf0000000 {
21593 return Some(Ins::Illegal);
21594 }
21595 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21596 let dd = Dreg::parse(((((value) >> 22) & 0x1) << 4) | (((value) >> 12) & 0xf), pc);
21597 let dn = Dreg::parse(((((value) >> 7) & 0x1) << 4) | (((value) >> 16) & 0xf), pc);
21598 let dm = Dreg::parse(((((value) >> 5) & 0x1) << 4) | ((value) & 0xf), pc);
21599 Some(Ins::VmlaF64 { cond, dd, dn, dm })
21600}
21601#[cfg(
21602 all(
21603 feature = "arm",
21604 feature = "vfp_v2",
21605 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21606 )
21607)]
21608fn parse_arm_vmls_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21609 const VERSIONS: Versions = Versions::of(
21610 &[
21611 #[cfg(feature = "v5te")]
21612 Version::V5Te,
21613 #[cfg(feature = "v5tej")]
21614 Version::V5Tej,
21615 #[cfg(feature = "v6")]
21616 Version::V6,
21617 #[cfg(feature = "v6k")]
21618 Version::V6K,
21619 ],
21620 );
21621 if !VERSIONS.has(options.version) {
21622 return None;
21623 }
21624 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21625 if !EXTENSIONS.has_all(options.extensions) {
21626 return None;
21627 }
21628 if value & 0xf0000000 == 0xf0000000 {
21629 return Some(Ins::Illegal);
21630 }
21631 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21632 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
21633 let sn = Sreg::parse(((((value) >> 16) & 0xf) << 1) | (((value) >> 7) & 0x1), pc);
21634 let sm = Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc);
21635 Some(Ins::VmlsF32 { cond, sd, sn, sm })
21636}
21637#[cfg(
21638 all(
21639 feature = "arm",
21640 feature = "vfp_v2",
21641 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21642 )
21643)]
21644fn parse_arm_vmls_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21645 const VERSIONS: Versions = Versions::of(
21646 &[
21647 #[cfg(feature = "v5te")]
21648 Version::V5Te,
21649 #[cfg(feature = "v5tej")]
21650 Version::V5Tej,
21651 #[cfg(feature = "v6")]
21652 Version::V6,
21653 #[cfg(feature = "v6k")]
21654 Version::V6K,
21655 ],
21656 );
21657 if !VERSIONS.has(options.version) {
21658 return None;
21659 }
21660 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21661 if !EXTENSIONS.has_all(options.extensions) {
21662 return None;
21663 }
21664 if value & 0xf0000000 == 0xf0000000 {
21665 return Some(Ins::Illegal);
21666 }
21667 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21668 let dd = Dreg::parse(((((value) >> 22) & 0x1) << 4) | (((value) >> 12) & 0xf), pc);
21669 let dn = Dreg::parse(((((value) >> 7) & 0x1) << 4) | (((value) >> 16) & 0xf), pc);
21670 let dm = Dreg::parse(((((value) >> 5) & 0x1) << 4) | ((value) & 0xf), pc);
21671 Some(Ins::VmlsF64 { cond, dd, dn, dm })
21672}
21673#[cfg(
21674 all(
21675 feature = "arm",
21676 feature = "vfp_v2",
21677 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21678 )
21679)]
21680fn parse_arm_vmov_32_reg_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21681 const VERSIONS: Versions = Versions::of(
21682 &[
21683 #[cfg(feature = "v5te")]
21684 Version::V5Te,
21685 #[cfg(feature = "v5tej")]
21686 Version::V5Tej,
21687 #[cfg(feature = "v6")]
21688 Version::V6,
21689 #[cfg(feature = "v6k")]
21690 Version::V6K,
21691 ],
21692 );
21693 if !VERSIONS.has(options.version) {
21694 return None;
21695 }
21696 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21697 if !EXTENSIONS.has_all(options.extensions) {
21698 return None;
21699 }
21700 if value & 0xf != 0 {
21701 return Some(Ins::Illegal);
21702 }
21703 if value & 0xf0000000 == 0xf0000000 {
21704 return Some(Ins::Illegal);
21705 }
21706 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21707 let dd = DregIndex::parse(value, pc);
21708 let rt = Reg::parse(((value) >> 12) & 0xf, pc);
21709 Some(Ins::Vmov32Reg { cond, dd, rt })
21710}
21711#[cfg(
21712 all(
21713 feature = "arm",
21714 feature = "vfp_v2",
21715 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21716 )
21717)]
21718fn parse_arm_vmov_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21719 const VERSIONS: Versions = Versions::of(
21720 &[
21721 #[cfg(feature = "v5te")]
21722 Version::V5Te,
21723 #[cfg(feature = "v5tej")]
21724 Version::V5Tej,
21725 #[cfg(feature = "v6")]
21726 Version::V6,
21727 #[cfg(feature = "v6k")]
21728 Version::V6K,
21729 ],
21730 );
21731 if !VERSIONS.has(options.version) {
21732 return None;
21733 }
21734 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21735 if !EXTENSIONS.has_all(options.extensions) {
21736 return None;
21737 }
21738 if value & 0xf0000000 == 0xf0000000 {
21739 return Some(Ins::Illegal);
21740 }
21741 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21742 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
21743 let sm = Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc);
21744 Some(Ins::VmovF32 { cond, sd, sm })
21745}
21746#[cfg(
21747 all(
21748 feature = "arm",
21749 feature = "vfp_v2",
21750 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21751 )
21752)]
21753fn parse_arm_vmov_f32_reg_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21754 const VERSIONS: Versions = Versions::of(
21755 &[
21756 #[cfg(feature = "v5te")]
21757 Version::V5Te,
21758 #[cfg(feature = "v5tej")]
21759 Version::V5Tej,
21760 #[cfg(feature = "v6")]
21761 Version::V6,
21762 #[cfg(feature = "v6k")]
21763 Version::V6K,
21764 ],
21765 );
21766 if !VERSIONS.has(options.version) {
21767 return None;
21768 }
21769 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21770 if !EXTENSIONS.has_all(options.extensions) {
21771 return None;
21772 }
21773 if value & 0x6f != 0 {
21774 return Some(Ins::Illegal);
21775 }
21776 if value & 0xf0000000 == 0xf0000000 {
21777 return Some(Ins::Illegal);
21778 }
21779 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21780 let sn = Sreg::parse(((((value) >> 16) & 0xf) << 1) | (((value) >> 7) & 0x1), pc);
21781 let rt = Reg::parse(((value) >> 12) & 0xf, pc);
21782 Some(Ins::VmovF32Reg { cond, sn, rt })
21783}
21784#[cfg(
21785 all(
21786 feature = "arm",
21787 feature = "vfp_v2",
21788 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21789 )
21790)]
21791fn parse_arm_vmov_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21792 const VERSIONS: Versions = Versions::of(
21793 &[
21794 #[cfg(feature = "v5te")]
21795 Version::V5Te,
21796 #[cfg(feature = "v5tej")]
21797 Version::V5Tej,
21798 #[cfg(feature = "v6")]
21799 Version::V6,
21800 #[cfg(feature = "v6k")]
21801 Version::V6K,
21802 ],
21803 );
21804 if !VERSIONS.has(options.version) {
21805 return None;
21806 }
21807 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21808 if !EXTENSIONS.has_all(options.extensions) {
21809 return None;
21810 }
21811 if value & 0xf0000000 == 0xf0000000 {
21812 return Some(Ins::Illegal);
21813 }
21814 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21815 let dd = Dreg::parse(((((value) >> 22) & 0x1) << 4) | (((value) >> 12) & 0xf), pc);
21816 let dm = Dreg::parse(((((value) >> 5) & 0x1) << 4) | ((value) & 0xf), pc);
21817 Some(Ins::VmovF64 { cond, dd, dm })
21818}
21819#[cfg(
21820 all(
21821 feature = "arm",
21822 feature = "vfp_v2",
21823 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21824 )
21825)]
21826fn parse_arm_vmov_reg_32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21827 const VERSIONS: Versions = Versions::of(
21828 &[
21829 #[cfg(feature = "v5te")]
21830 Version::V5Te,
21831 #[cfg(feature = "v5tej")]
21832 Version::V5Tej,
21833 #[cfg(feature = "v6")]
21834 Version::V6,
21835 #[cfg(feature = "v6k")]
21836 Version::V6K,
21837 ],
21838 );
21839 if !VERSIONS.has(options.version) {
21840 return None;
21841 }
21842 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21843 if !EXTENSIONS.has_all(options.extensions) {
21844 return None;
21845 }
21846 if value & 0xf != 0 {
21847 return Some(Ins::Illegal);
21848 }
21849 if value & 0xf0000000 == 0xf0000000 {
21850 return Some(Ins::Illegal);
21851 }
21852 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21853 let rt = Reg::parse(((value) >> 12) & 0xf, pc);
21854 let dn = DregIndex::parse(value, pc);
21855 Some(Ins::VmovReg32 { cond, rt, dn })
21856}
21857#[cfg(
21858 all(
21859 feature = "arm",
21860 feature = "vfp_v2",
21861 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21862 )
21863)]
21864fn parse_arm_vmov_reg_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21865 const VERSIONS: Versions = Versions::of(
21866 &[
21867 #[cfg(feature = "v5te")]
21868 Version::V5Te,
21869 #[cfg(feature = "v5tej")]
21870 Version::V5Tej,
21871 #[cfg(feature = "v6")]
21872 Version::V6,
21873 #[cfg(feature = "v6k")]
21874 Version::V6K,
21875 ],
21876 );
21877 if !VERSIONS.has(options.version) {
21878 return None;
21879 }
21880 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21881 if !EXTENSIONS.has_all(options.extensions) {
21882 return None;
21883 }
21884 if value & 0x6f != 0 {
21885 return Some(Ins::Illegal);
21886 }
21887 if value & 0xf0000000 == 0xf0000000 {
21888 return Some(Ins::Illegal);
21889 }
21890 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21891 let rt = Reg::parse(((value) >> 12) & 0xf, pc);
21892 let sn = Sreg::parse(((((value) >> 16) & 0xf) << 1) | (((value) >> 7) & 0x1), pc);
21893 Some(Ins::VmovRegF32 { cond, rt, sn })
21894}
21895#[cfg(
21896 all(
21897 feature = "arm",
21898 feature = "vfp_v2",
21899 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21900 )
21901)]
21902fn parse_arm_vmov_reg_f32_dual_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21903 const VERSIONS: Versions = Versions::of(
21904 &[
21905 #[cfg(feature = "v5te")]
21906 Version::V5Te,
21907 #[cfg(feature = "v5tej")]
21908 Version::V5Tej,
21909 #[cfg(feature = "v6")]
21910 Version::V6,
21911 #[cfg(feature = "v6k")]
21912 Version::V6K,
21913 ],
21914 );
21915 if !VERSIONS.has(options.version) {
21916 return None;
21917 }
21918 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21919 if !EXTENSIONS.has_all(options.extensions) {
21920 return None;
21921 }
21922 if value & 0x2f == 0x2f {
21923 return Some(Ins::Illegal);
21924 }
21925 if value & 0xf0000000 == 0xf0000000 {
21926 return Some(Ins::Illegal);
21927 }
21928 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21929 let rt = Reg::parse(((value) >> 12) & 0xf, pc);
21930 let rt2 = Reg::parse(((value) >> 16) & 0xf, pc);
21931 let sm = Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc);
21932 let sm2 = Sreg::parse(
21933 ((((value) & 0xf) << 1) | (((value) >> 5) & 0x1)).wrapping_add(1),
21934 pc,
21935 );
21936 Some(Ins::VmovRegF32Dual {
21937 cond,
21938 rt,
21939 rt2,
21940 sm,
21941 sm2,
21942 })
21943}
21944#[cfg(
21945 all(
21946 feature = "arm",
21947 feature = "vfp_v2",
21948 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21949 )
21950)]
21951fn parse_arm_vmov_f32_reg_dual_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
21952 const VERSIONS: Versions = Versions::of(
21953 &[
21954 #[cfg(feature = "v5te")]
21955 Version::V5Te,
21956 #[cfg(feature = "v5tej")]
21957 Version::V5Tej,
21958 #[cfg(feature = "v6")]
21959 Version::V6,
21960 #[cfg(feature = "v6k")]
21961 Version::V6K,
21962 ],
21963 );
21964 if !VERSIONS.has(options.version) {
21965 return None;
21966 }
21967 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
21968 if !EXTENSIONS.has_all(options.extensions) {
21969 return None;
21970 }
21971 if value & 0x2f == 0x2f {
21972 return Some(Ins::Illegal);
21973 }
21974 if value & 0xf0000000 == 0xf0000000 {
21975 return Some(Ins::Illegal);
21976 }
21977 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
21978 let sm = Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc);
21979 let sm2 = Sreg::parse(
21980 ((((value) & 0xf) << 1) | (((value) >> 5) & 0x1)).wrapping_add(1),
21981 pc,
21982 );
21983 let rt = Reg::parse(((value) >> 12) & 0xf, pc);
21984 let rt2 = Reg::parse(((value) >> 16) & 0xf, pc);
21985 Some(Ins::VmovF32RegDual {
21986 cond,
21987 sm,
21988 sm2,
21989 rt,
21990 rt2,
21991 })
21992}
21993#[cfg(
21994 all(
21995 feature = "arm",
21996 feature = "vfp_v2",
21997 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
21998 )
21999)]
22000fn parse_arm_vmov_reg_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22001 const VERSIONS: Versions = Versions::of(
22002 &[
22003 #[cfg(feature = "v5te")]
22004 Version::V5Te,
22005 #[cfg(feature = "v5tej")]
22006 Version::V5Tej,
22007 #[cfg(feature = "v6")]
22008 Version::V6,
22009 #[cfg(feature = "v6k")]
22010 Version::V6K,
22011 ],
22012 );
22013 if !VERSIONS.has(options.version) {
22014 return None;
22015 }
22016 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22017 if !EXTENSIONS.has_all(options.extensions) {
22018 return None;
22019 }
22020 if value & 0xf0000000 == 0xf0000000 {
22021 return Some(Ins::Illegal);
22022 }
22023 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22024 let rt = Reg::parse(((value) >> 12) & 0xf, pc);
22025 let rt2 = Reg::parse(((value) >> 16) & 0xf, pc);
22026 let dm = Dreg::parse(((((value) >> 5) & 0x1) << 4) | ((value) & 0xf), pc);
22027 Some(Ins::VmovRegF64 {
22028 cond,
22029 rt,
22030 rt2,
22031 dm,
22032 })
22033}
22034#[cfg(
22035 all(
22036 feature = "arm",
22037 feature = "vfp_v2",
22038 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22039 )
22040)]
22041fn parse_arm_vmov_f64_reg_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22042 const VERSIONS: Versions = Versions::of(
22043 &[
22044 #[cfg(feature = "v5te")]
22045 Version::V5Te,
22046 #[cfg(feature = "v5tej")]
22047 Version::V5Tej,
22048 #[cfg(feature = "v6")]
22049 Version::V6,
22050 #[cfg(feature = "v6k")]
22051 Version::V6K,
22052 ],
22053 );
22054 if !VERSIONS.has(options.version) {
22055 return None;
22056 }
22057 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22058 if !EXTENSIONS.has_all(options.extensions) {
22059 return None;
22060 }
22061 if value & 0xf0000000 == 0xf0000000 {
22062 return Some(Ins::Illegal);
22063 }
22064 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22065 let dm = Dreg::parse(((((value) >> 5) & 0x1) << 4) | ((value) & 0xf), pc);
22066 let rt = Reg::parse(((value) >> 12) & 0xf, pc);
22067 let rt2 = Reg::parse(((value) >> 16) & 0xf, pc);
22068 Some(Ins::VmovF64Reg {
22069 cond,
22070 dm,
22071 rt,
22072 rt2,
22073 })
22074}
22075#[cfg(
22076 all(
22077 feature = "arm",
22078 feature = "vfp_v2",
22079 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22080 )
22081)]
22082fn parse_arm_vmrs_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22083 const VERSIONS: Versions = Versions::of(
22084 &[
22085 #[cfg(feature = "v5te")]
22086 Version::V5Te,
22087 #[cfg(feature = "v5tej")]
22088 Version::V5Tej,
22089 #[cfg(feature = "v6")]
22090 Version::V6,
22091 #[cfg(feature = "v6k")]
22092 Version::V6K,
22093 ],
22094 );
22095 if !VERSIONS.has(options.version) {
22096 return None;
22097 }
22098 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22099 if !EXTENSIONS.has_all(options.extensions) {
22100 return None;
22101 }
22102 if value & 0xef != 0 {
22103 return Some(Ins::Illegal);
22104 }
22105 if value & 0xf0000000 == 0xf0000000 {
22106 return Some(Ins::Illegal);
22107 }
22108 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22109 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
22110 let fpscr = Fpscr::default();
22111 Some(Ins::Vmrs { cond, rd, fpscr })
22112}
22113#[cfg(
22114 all(
22115 feature = "arm",
22116 feature = "vfp_v2",
22117 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22118 )
22119)]
22120fn parse_arm_vmsr_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22121 const VERSIONS: Versions = Versions::of(
22122 &[
22123 #[cfg(feature = "v5te")]
22124 Version::V5Te,
22125 #[cfg(feature = "v5tej")]
22126 Version::V5Tej,
22127 #[cfg(feature = "v6")]
22128 Version::V6,
22129 #[cfg(feature = "v6k")]
22130 Version::V6K,
22131 ],
22132 );
22133 if !VERSIONS.has(options.version) {
22134 return None;
22135 }
22136 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22137 if !EXTENSIONS.has_all(options.extensions) {
22138 return None;
22139 }
22140 if value & 0xef != 0 {
22141 return Some(Ins::Illegal);
22142 }
22143 if value & 0xf0000000 == 0xf0000000 {
22144 return Some(Ins::Illegal);
22145 }
22146 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22147 let fpscr = Fpscr::default();
22148 let rd = Reg::parse(((value) >> 12) & 0xf, pc);
22149 Some(Ins::Vmsr { cond, fpscr, rd })
22150}
22151#[cfg(
22152 all(
22153 feature = "arm",
22154 feature = "vfp_v2",
22155 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22156 )
22157)]
22158fn parse_arm_vmul_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22159 const VERSIONS: Versions = Versions::of(
22160 &[
22161 #[cfg(feature = "v5te")]
22162 Version::V5Te,
22163 #[cfg(feature = "v5tej")]
22164 Version::V5Tej,
22165 #[cfg(feature = "v6")]
22166 Version::V6,
22167 #[cfg(feature = "v6k")]
22168 Version::V6K,
22169 ],
22170 );
22171 if !VERSIONS.has(options.version) {
22172 return None;
22173 }
22174 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22175 if !EXTENSIONS.has_all(options.extensions) {
22176 return None;
22177 }
22178 if value & 0xf0000000 == 0xf0000000 {
22179 return Some(Ins::Illegal);
22180 }
22181 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22182 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
22183 let sn = Sreg::parse(((((value) >> 16) & 0xf) << 1) | (((value) >> 7) & 0x1), pc);
22184 let sm = Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc);
22185 Some(Ins::VmulF32 { cond, sd, sn, sm })
22186}
22187#[cfg(
22188 all(
22189 feature = "arm",
22190 feature = "vfp_v2",
22191 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22192 )
22193)]
22194fn parse_arm_vmul_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22195 const VERSIONS: Versions = Versions::of(
22196 &[
22197 #[cfg(feature = "v5te")]
22198 Version::V5Te,
22199 #[cfg(feature = "v5tej")]
22200 Version::V5Tej,
22201 #[cfg(feature = "v6")]
22202 Version::V6,
22203 #[cfg(feature = "v6k")]
22204 Version::V6K,
22205 ],
22206 );
22207 if !VERSIONS.has(options.version) {
22208 return None;
22209 }
22210 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22211 if !EXTENSIONS.has_all(options.extensions) {
22212 return None;
22213 }
22214 if value & 0xf0000000 == 0xf0000000 {
22215 return Some(Ins::Illegal);
22216 }
22217 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22218 let dd = Dreg::parse(((((value) >> 22) & 0x1) << 4) | (((value) >> 12) & 0xf), pc);
22219 let dn = Dreg::parse(((((value) >> 7) & 0x1) << 4) | (((value) >> 16) & 0xf), pc);
22220 let dm = Dreg::parse(((((value) >> 5) & 0x1) << 4) | ((value) & 0xf), pc);
22221 Some(Ins::VmulF64 { cond, dd, dn, dm })
22222}
22223#[cfg(
22224 all(
22225 feature = "arm",
22226 feature = "vfp_v2",
22227 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22228 )
22229)]
22230fn parse_arm_vneg_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22231 const VERSIONS: Versions = Versions::of(
22232 &[
22233 #[cfg(feature = "v5te")]
22234 Version::V5Te,
22235 #[cfg(feature = "v5tej")]
22236 Version::V5Tej,
22237 #[cfg(feature = "v6")]
22238 Version::V6,
22239 #[cfg(feature = "v6k")]
22240 Version::V6K,
22241 ],
22242 );
22243 if !VERSIONS.has(options.version) {
22244 return None;
22245 }
22246 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22247 if !EXTENSIONS.has_all(options.extensions) {
22248 return None;
22249 }
22250 if value & 0xf0000000 == 0xf0000000 {
22251 return Some(Ins::Illegal);
22252 }
22253 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22254 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
22255 let sm = Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc);
22256 Some(Ins::VnegF32 { cond, sd, sm })
22257}
22258#[cfg(
22259 all(
22260 feature = "arm",
22261 feature = "vfp_v2",
22262 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22263 )
22264)]
22265fn parse_arm_vneg_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22266 const VERSIONS: Versions = Versions::of(
22267 &[
22268 #[cfg(feature = "v5te")]
22269 Version::V5Te,
22270 #[cfg(feature = "v5tej")]
22271 Version::V5Tej,
22272 #[cfg(feature = "v6")]
22273 Version::V6,
22274 #[cfg(feature = "v6k")]
22275 Version::V6K,
22276 ],
22277 );
22278 if !VERSIONS.has(options.version) {
22279 return None;
22280 }
22281 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22282 if !EXTENSIONS.has_all(options.extensions) {
22283 return None;
22284 }
22285 if value & 0xf0000000 == 0xf0000000 {
22286 return Some(Ins::Illegal);
22287 }
22288 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22289 let dd = Dreg::parse(((((value) >> 22) & 0x1) << 4) | (((value) >> 12) & 0xf), pc);
22290 let dm = Dreg::parse(((((value) >> 5) & 0x1) << 4) | ((value) & 0xf), pc);
22291 Some(Ins::VnegF64 { cond, dd, dm })
22292}
22293#[cfg(
22294 all(
22295 feature = "arm",
22296 feature = "vfp_v2",
22297 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22298 )
22299)]
22300fn parse_arm_vnmla_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22301 const VERSIONS: Versions = Versions::of(
22302 &[
22303 #[cfg(feature = "v5te")]
22304 Version::V5Te,
22305 #[cfg(feature = "v5tej")]
22306 Version::V5Tej,
22307 #[cfg(feature = "v6")]
22308 Version::V6,
22309 #[cfg(feature = "v6k")]
22310 Version::V6K,
22311 ],
22312 );
22313 if !VERSIONS.has(options.version) {
22314 return None;
22315 }
22316 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22317 if !EXTENSIONS.has_all(options.extensions) {
22318 return None;
22319 }
22320 if value & 0xf0000000 == 0xf0000000 {
22321 return Some(Ins::Illegal);
22322 }
22323 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22324 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
22325 let sn = Sreg::parse(((((value) >> 16) & 0xf) << 1) | (((value) >> 7) & 0x1), pc);
22326 let sm = Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc);
22327 Some(Ins::VnmlaF32 { cond, sd, sn, sm })
22328}
22329#[cfg(
22330 all(
22331 feature = "arm",
22332 feature = "vfp_v2",
22333 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22334 )
22335)]
22336fn parse_arm_vnmla_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22337 const VERSIONS: Versions = Versions::of(
22338 &[
22339 #[cfg(feature = "v5te")]
22340 Version::V5Te,
22341 #[cfg(feature = "v5tej")]
22342 Version::V5Tej,
22343 #[cfg(feature = "v6")]
22344 Version::V6,
22345 #[cfg(feature = "v6k")]
22346 Version::V6K,
22347 ],
22348 );
22349 if !VERSIONS.has(options.version) {
22350 return None;
22351 }
22352 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22353 if !EXTENSIONS.has_all(options.extensions) {
22354 return None;
22355 }
22356 if value & 0xf0000000 == 0xf0000000 {
22357 return Some(Ins::Illegal);
22358 }
22359 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22360 let dd = Dreg::parse(((((value) >> 22) & 0x1) << 4) | (((value) >> 12) & 0xf), pc);
22361 let dn = Dreg::parse(((((value) >> 7) & 0x1) << 4) | (((value) >> 16) & 0xf), pc);
22362 let dm = Dreg::parse(((((value) >> 5) & 0x1) << 4) | ((value) & 0xf), pc);
22363 Some(Ins::VnmlaF64 { cond, dd, dn, dm })
22364}
22365#[cfg(
22366 all(
22367 feature = "arm",
22368 feature = "vfp_v2",
22369 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22370 )
22371)]
22372fn parse_arm_vnmls_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22373 const VERSIONS: Versions = Versions::of(
22374 &[
22375 #[cfg(feature = "v5te")]
22376 Version::V5Te,
22377 #[cfg(feature = "v5tej")]
22378 Version::V5Tej,
22379 #[cfg(feature = "v6")]
22380 Version::V6,
22381 #[cfg(feature = "v6k")]
22382 Version::V6K,
22383 ],
22384 );
22385 if !VERSIONS.has(options.version) {
22386 return None;
22387 }
22388 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22389 if !EXTENSIONS.has_all(options.extensions) {
22390 return None;
22391 }
22392 if value & 0xf0000000 == 0xf0000000 {
22393 return Some(Ins::Illegal);
22394 }
22395 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22396 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
22397 let sn = Sreg::parse(((((value) >> 16) & 0xf) << 1) | (((value) >> 7) & 0x1), pc);
22398 let sm = Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc);
22399 Some(Ins::VnmlsF32 { cond, sd, sn, sm })
22400}
22401#[cfg(
22402 all(
22403 feature = "arm",
22404 feature = "vfp_v2",
22405 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22406 )
22407)]
22408fn parse_arm_vnmls_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22409 const VERSIONS: Versions = Versions::of(
22410 &[
22411 #[cfg(feature = "v5te")]
22412 Version::V5Te,
22413 #[cfg(feature = "v5tej")]
22414 Version::V5Tej,
22415 #[cfg(feature = "v6")]
22416 Version::V6,
22417 #[cfg(feature = "v6k")]
22418 Version::V6K,
22419 ],
22420 );
22421 if !VERSIONS.has(options.version) {
22422 return None;
22423 }
22424 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22425 if !EXTENSIONS.has_all(options.extensions) {
22426 return None;
22427 }
22428 if value & 0xf0000000 == 0xf0000000 {
22429 return Some(Ins::Illegal);
22430 }
22431 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22432 let dd = Dreg::parse(((((value) >> 22) & 0x1) << 4) | (((value) >> 12) & 0xf), pc);
22433 let dn = Dreg::parse(((((value) >> 7) & 0x1) << 4) | (((value) >> 16) & 0xf), pc);
22434 let dm = Dreg::parse(((((value) >> 5) & 0x1) << 4) | ((value) & 0xf), pc);
22435 Some(Ins::VnmlsF64 { cond, dd, dn, dm })
22436}
22437#[cfg(
22438 all(
22439 feature = "arm",
22440 feature = "vfp_v2",
22441 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22442 )
22443)]
22444fn parse_arm_vnmul_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22445 const VERSIONS: Versions = Versions::of(
22446 &[
22447 #[cfg(feature = "v5te")]
22448 Version::V5Te,
22449 #[cfg(feature = "v5tej")]
22450 Version::V5Tej,
22451 #[cfg(feature = "v6")]
22452 Version::V6,
22453 #[cfg(feature = "v6k")]
22454 Version::V6K,
22455 ],
22456 );
22457 if !VERSIONS.has(options.version) {
22458 return None;
22459 }
22460 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22461 if !EXTENSIONS.has_all(options.extensions) {
22462 return None;
22463 }
22464 if value & 0xf0000000 == 0xf0000000 {
22465 return Some(Ins::Illegal);
22466 }
22467 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22468 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
22469 let sn = Sreg::parse(((((value) >> 16) & 0xf) << 1) | (((value) >> 7) & 0x1), pc);
22470 let sm = Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc);
22471 Some(Ins::VnmulF32 { cond, sd, sn, sm })
22472}
22473#[cfg(
22474 all(
22475 feature = "arm",
22476 feature = "vfp_v2",
22477 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22478 )
22479)]
22480fn parse_arm_vnmul_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22481 const VERSIONS: Versions = Versions::of(
22482 &[
22483 #[cfg(feature = "v5te")]
22484 Version::V5Te,
22485 #[cfg(feature = "v5tej")]
22486 Version::V5Tej,
22487 #[cfg(feature = "v6")]
22488 Version::V6,
22489 #[cfg(feature = "v6k")]
22490 Version::V6K,
22491 ],
22492 );
22493 if !VERSIONS.has(options.version) {
22494 return None;
22495 }
22496 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22497 if !EXTENSIONS.has_all(options.extensions) {
22498 return None;
22499 }
22500 if value & 0xf0000000 == 0xf0000000 {
22501 return Some(Ins::Illegal);
22502 }
22503 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22504 let dd = Dreg::parse(((((value) >> 22) & 0x1) << 4) | (((value) >> 12) & 0xf), pc);
22505 let dn = Dreg::parse(((((value) >> 7) & 0x1) << 4) | (((value) >> 16) & 0xf), pc);
22506 let dm = Dreg::parse(((((value) >> 5) & 0x1) << 4) | ((value) & 0xf), pc);
22507 Some(Ins::VnmulF64 { cond, dd, dn, dm })
22508}
22509#[cfg(
22510 all(
22511 feature = "arm",
22512 feature = "vfp_v2",
22513 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22514 )
22515)]
22516fn parse_arm_vpop_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22517 const VERSIONS: Versions = Versions::of(
22518 &[
22519 #[cfg(feature = "v5te")]
22520 Version::V5Te,
22521 #[cfg(feature = "v5tej")]
22522 Version::V5Tej,
22523 #[cfg(feature = "v6")]
22524 Version::V6,
22525 #[cfg(feature = "v6k")]
22526 Version::V6K,
22527 ],
22528 );
22529 if !VERSIONS.has(options.version) {
22530 return None;
22531 }
22532 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22533 if !EXTENSIONS.has_all(options.extensions) {
22534 return None;
22535 }
22536 if !options.ual {
22537 return None;
22538 }
22539 if value & 0xf0000000 == 0xf0000000 {
22540 return Some(Ins::Illegal);
22541 }
22542 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22543 let regs = SregList::parse(value);
22544 Some(Ins::VpopF32 { cond, regs })
22545}
22546#[cfg(
22547 all(
22548 feature = "arm",
22549 feature = "vfp_v2",
22550 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22551 )
22552)]
22553fn parse_arm_vpop_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22554 const VERSIONS: Versions = Versions::of(
22555 &[
22556 #[cfg(feature = "v5te")]
22557 Version::V5Te,
22558 #[cfg(feature = "v5tej")]
22559 Version::V5Tej,
22560 #[cfg(feature = "v6")]
22561 Version::V6,
22562 #[cfg(feature = "v6k")]
22563 Version::V6K,
22564 ],
22565 );
22566 if !VERSIONS.has(options.version) {
22567 return None;
22568 }
22569 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22570 if !EXTENSIONS.has_all(options.extensions) {
22571 return None;
22572 }
22573 if !options.ual {
22574 return None;
22575 }
22576 if value & 0xf0000000 == 0xf0000000 {
22577 return Some(Ins::Illegal);
22578 }
22579 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22580 let regs = DregList::parse(value);
22581 Some(Ins::VpopF64 { cond, regs })
22582}
22583#[cfg(
22584 all(
22585 feature = "arm",
22586 feature = "vfp_v2",
22587 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22588 )
22589)]
22590fn parse_arm_vpush_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22591 const VERSIONS: Versions = Versions::of(
22592 &[
22593 #[cfg(feature = "v5te")]
22594 Version::V5Te,
22595 #[cfg(feature = "v5tej")]
22596 Version::V5Tej,
22597 #[cfg(feature = "v6")]
22598 Version::V6,
22599 #[cfg(feature = "v6k")]
22600 Version::V6K,
22601 ],
22602 );
22603 if !VERSIONS.has(options.version) {
22604 return None;
22605 }
22606 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22607 if !EXTENSIONS.has_all(options.extensions) {
22608 return None;
22609 }
22610 if !options.ual {
22611 return None;
22612 }
22613 if value & 0xf0000000 == 0xf0000000 {
22614 return Some(Ins::Illegal);
22615 }
22616 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22617 let regs = SregList::parse(value);
22618 Some(Ins::VpushF32 { cond, regs })
22619}
22620#[cfg(
22621 all(
22622 feature = "arm",
22623 feature = "vfp_v2",
22624 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22625 )
22626)]
22627fn parse_arm_vpush_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22628 const VERSIONS: Versions = Versions::of(
22629 &[
22630 #[cfg(feature = "v5te")]
22631 Version::V5Te,
22632 #[cfg(feature = "v5tej")]
22633 Version::V5Tej,
22634 #[cfg(feature = "v6")]
22635 Version::V6,
22636 #[cfg(feature = "v6k")]
22637 Version::V6K,
22638 ],
22639 );
22640 if !VERSIONS.has(options.version) {
22641 return None;
22642 }
22643 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22644 if !EXTENSIONS.has_all(options.extensions) {
22645 return None;
22646 }
22647 if !options.ual {
22648 return None;
22649 }
22650 if value & 0xf0000000 == 0xf0000000 {
22651 return Some(Ins::Illegal);
22652 }
22653 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22654 let regs = DregList::parse(value);
22655 Some(Ins::VpushF64 { cond, regs })
22656}
22657#[cfg(
22658 all(
22659 feature = "arm",
22660 feature = "vfp_v2",
22661 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22662 )
22663)]
22664fn parse_arm_vsqrt_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22665 const VERSIONS: Versions = Versions::of(
22666 &[
22667 #[cfg(feature = "v5te")]
22668 Version::V5Te,
22669 #[cfg(feature = "v5tej")]
22670 Version::V5Tej,
22671 #[cfg(feature = "v6")]
22672 Version::V6,
22673 #[cfg(feature = "v6k")]
22674 Version::V6K,
22675 ],
22676 );
22677 if !VERSIONS.has(options.version) {
22678 return None;
22679 }
22680 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22681 if !EXTENSIONS.has_all(options.extensions) {
22682 return None;
22683 }
22684 if value & 0xf0000000 == 0xf0000000 {
22685 return Some(Ins::Illegal);
22686 }
22687 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22688 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
22689 let sm = Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc);
22690 Some(Ins::VsqrtF32 { cond, sd, sm })
22691}
22692#[cfg(
22693 all(
22694 feature = "arm",
22695 feature = "vfp_v2",
22696 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22697 )
22698)]
22699fn parse_arm_vsqrt_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22700 const VERSIONS: Versions = Versions::of(
22701 &[
22702 #[cfg(feature = "v5te")]
22703 Version::V5Te,
22704 #[cfg(feature = "v5tej")]
22705 Version::V5Tej,
22706 #[cfg(feature = "v6")]
22707 Version::V6,
22708 #[cfg(feature = "v6k")]
22709 Version::V6K,
22710 ],
22711 );
22712 if !VERSIONS.has(options.version) {
22713 return None;
22714 }
22715 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22716 if !EXTENSIONS.has_all(options.extensions) {
22717 return None;
22718 }
22719 if value & 0xf0000000 == 0xf0000000 {
22720 return Some(Ins::Illegal);
22721 }
22722 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22723 let dd = Dreg::parse(((((value) >> 22) & 0x1) << 4) | (((value) >> 12) & 0xf), pc);
22724 let dm = Dreg::parse(((((value) >> 5) & 0x1) << 4) | ((value) & 0xf), pc);
22725 Some(Ins::VsqrtF64 { cond, dd, dm })
22726}
22727#[cfg(
22728 all(
22729 feature = "arm",
22730 feature = "vfp_v2",
22731 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22732 )
22733)]
22734fn parse_arm_vstm_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22735 const VERSIONS: Versions = Versions::of(
22736 &[
22737 #[cfg(feature = "v5te")]
22738 Version::V5Te,
22739 #[cfg(feature = "v5tej")]
22740 Version::V5Tej,
22741 #[cfg(feature = "v6")]
22742 Version::V6,
22743 #[cfg(feature = "v6k")]
22744 Version::V6K,
22745 ],
22746 );
22747 if !VERSIONS.has(options.version) {
22748 return None;
22749 }
22750 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22751 if !EXTENSIONS.has_all(options.extensions) {
22752 return None;
22753 }
22754 if value & 0xf0000000 == 0xf0000000 {
22755 return Some(Ins::Illegal);
22756 }
22757 let Some(mode) = VldmVstmMode::parse(((value) >> 23) & 0x3, pc) else {
22758 return Some(Ins::Illegal);
22759 };
22760 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22761 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
22762 let writeback = (((value) >> 21) & 0x1) != 0;
22763 let regs = SregList::parse(value);
22764 Some(Ins::VstmF32 {
22765 mode,
22766 cond,
22767 rn,
22768 writeback,
22769 regs,
22770 })
22771}
22772#[cfg(
22773 all(
22774 feature = "arm",
22775 feature = "vfp_v2",
22776 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22777 )
22778)]
22779fn parse_arm_vstm_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22780 const VERSIONS: Versions = Versions::of(
22781 &[
22782 #[cfg(feature = "v5te")]
22783 Version::V5Te,
22784 #[cfg(feature = "v5tej")]
22785 Version::V5Tej,
22786 #[cfg(feature = "v6")]
22787 Version::V6,
22788 #[cfg(feature = "v6k")]
22789 Version::V6K,
22790 ],
22791 );
22792 if !VERSIONS.has(options.version) {
22793 return None;
22794 }
22795 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22796 if !EXTENSIONS.has_all(options.extensions) {
22797 return None;
22798 }
22799 if value & 0xf0000000 == 0xf0000000 {
22800 return Some(Ins::Illegal);
22801 }
22802 let Some(mode) = VldmVstmMode::parse(((value) >> 23) & 0x3, pc) else {
22803 return Some(Ins::Illegal);
22804 };
22805 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22806 let rn = Reg::parse(((value) >> 16) & 0xf, pc);
22807 let writeback = (((value) >> 21) & 0x1) != 0;
22808 let regs = DregList::parse(value);
22809 Some(Ins::VstmF64 {
22810 mode,
22811 cond,
22812 rn,
22813 writeback,
22814 regs,
22815 })
22816}
22817#[cfg(
22818 all(
22819 feature = "arm",
22820 feature = "vfp_v2",
22821 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22822 )
22823)]
22824fn parse_arm_vstr_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22825 const VERSIONS: Versions = Versions::of(
22826 &[
22827 #[cfg(feature = "v5te")]
22828 Version::V5Te,
22829 #[cfg(feature = "v5tej")]
22830 Version::V5Tej,
22831 #[cfg(feature = "v6")]
22832 Version::V6,
22833 #[cfg(feature = "v6k")]
22834 Version::V6K,
22835 ],
22836 );
22837 if !VERSIONS.has(options.version) {
22838 return None;
22839 }
22840 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22841 if !EXTENSIONS.has_all(options.extensions) {
22842 return None;
22843 }
22844 if value & 0xf0000000 == 0xf0000000 {
22845 return Some(Ins::Illegal);
22846 }
22847 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22848 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
22849 let addr = AddrLdrStr::Pre {
22850 rn: Reg::parse(((value) >> 16) & 0xf, pc),
22851 offset: LdrStrOffset::Imm(
22852 ((if (((value) >> 23) & 0x1) == 0 {
22853 -((((value) & 0xff) << 2) as i32)
22854 } else {
22855 (((value) & 0xff) << 2) as i32
22856 })) as i32,
22857 ),
22858 writeback: false,
22859 };
22860 Some(Ins::VstrF32 { cond, sd, addr })
22861}
22862#[cfg(
22863 all(
22864 feature = "arm",
22865 feature = "vfp_v2",
22866 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22867 )
22868)]
22869fn parse_arm_vstr_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22870 const VERSIONS: Versions = Versions::of(
22871 &[
22872 #[cfg(feature = "v5te")]
22873 Version::V5Te,
22874 #[cfg(feature = "v5tej")]
22875 Version::V5Tej,
22876 #[cfg(feature = "v6")]
22877 Version::V6,
22878 #[cfg(feature = "v6k")]
22879 Version::V6K,
22880 ],
22881 );
22882 if !VERSIONS.has(options.version) {
22883 return None;
22884 }
22885 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22886 if !EXTENSIONS.has_all(options.extensions) {
22887 return None;
22888 }
22889 if value & 0xf0000000 == 0xf0000000 {
22890 return Some(Ins::Illegal);
22891 }
22892 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22893 let dd = Dreg::parse(((((value) >> 22) & 0x1) << 4) | (((value) >> 12) & 0xf), pc);
22894 let addr = AddrLdrStr::Pre {
22895 rn: Reg::parse(((value) >> 16) & 0xf, pc),
22896 offset: LdrStrOffset::Imm(
22897 ((if (((value) >> 23) & 0x1) == 0 {
22898 -((((value) & 0xff) << 2) as i32)
22899 } else {
22900 (((value) & 0xff) << 2) as i32
22901 })) as i32,
22902 ),
22903 writeback: false,
22904 };
22905 Some(Ins::VstrF64 { cond, dd, addr })
22906}
22907#[cfg(
22908 all(
22909 feature = "arm",
22910 feature = "vfp_v2",
22911 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22912 )
22913)]
22914fn parse_arm_vsub_f32_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22915 const VERSIONS: Versions = Versions::of(
22916 &[
22917 #[cfg(feature = "v5te")]
22918 Version::V5Te,
22919 #[cfg(feature = "v5tej")]
22920 Version::V5Tej,
22921 #[cfg(feature = "v6")]
22922 Version::V6,
22923 #[cfg(feature = "v6k")]
22924 Version::V6K,
22925 ],
22926 );
22927 if !VERSIONS.has(options.version) {
22928 return None;
22929 }
22930 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22931 if !EXTENSIONS.has_all(options.extensions) {
22932 return None;
22933 }
22934 if value & 0xf0000000 == 0xf0000000 {
22935 return Some(Ins::Illegal);
22936 }
22937 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22938 let sd = Sreg::parse(((((value) >> 12) & 0xf) << 1) | (((value) >> 22) & 0x1), pc);
22939 let sn = Sreg::parse(((((value) >> 16) & 0xf) << 1) | (((value) >> 7) & 0x1), pc);
22940 let sm = Sreg::parse((((value) & 0xf) << 1) | (((value) >> 5) & 0x1), pc);
22941 Some(Ins::VsubF32 { cond, sd, sn, sm })
22942}
22943#[cfg(
22944 all(
22945 feature = "arm",
22946 feature = "vfp_v2",
22947 any(feature = "v5te", feature = "v5tej", feature = "v6", feature = "v6k")
22948 )
22949)]
22950fn parse_arm_vsub_f64_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22951 const VERSIONS: Versions = Versions::of(
22952 &[
22953 #[cfg(feature = "v5te")]
22954 Version::V5Te,
22955 #[cfg(feature = "v5tej")]
22956 Version::V5Tej,
22957 #[cfg(feature = "v6")]
22958 Version::V6,
22959 #[cfg(feature = "v6k")]
22960 Version::V6K,
22961 ],
22962 );
22963 if !VERSIONS.has(options.version) {
22964 return None;
22965 }
22966 const EXTENSIONS: Extensions = Extensions::of(&[Extension::VfpV2]);
22967 if !EXTENSIONS.has_all(options.extensions) {
22968 return None;
22969 }
22970 if value & 0xf0000000 == 0xf0000000 {
22971 return Some(Ins::Illegal);
22972 }
22973 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22974 let dd = Dreg::parse(((((value) >> 22) & 0x1) << 4) | (((value) >> 12) & 0xf), pc);
22975 let dn = Dreg::parse(((((value) >> 7) & 0x1) << 4) | (((value) >> 16) & 0xf), pc);
22976 let dm = Dreg::parse(((((value) >> 5) & 0x1) << 4) | ((value) & 0xf), pc);
22977 Some(Ins::VsubF64 { cond, dd, dn, dm })
22978}
22979#[cfg(all(feature = "arm", feature = "v6k"))]
22980fn parse_arm_wfe_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22981 const VERSIONS: Versions = Versions::of(&[#[cfg(feature = "v6k")] Version::V6K]);
22982 if !VERSIONS.has(options.version) {
22983 return None;
22984 }
22985 if value & 0xff00 != 0xf000 {
22986 return Some(Ins::Illegal);
22987 }
22988 if value & 0xf0000000 == 0xf0000000 {
22989 return Some(Ins::Illegal);
22990 }
22991 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
22992 Some(Ins::Wfe { cond })
22993}
22994#[cfg(all(feature = "arm", feature = "v6k"))]
22995fn parse_arm_wfi_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
22996 const VERSIONS: Versions = Versions::of(&[#[cfg(feature = "v6k")] Version::V6K]);
22997 if !VERSIONS.has(options.version) {
22998 return None;
22999 }
23000 if value & 0xff00 != 0xf000 {
23001 return Some(Ins::Illegal);
23002 }
23003 if value & 0xf0000000 == 0xf0000000 {
23004 return Some(Ins::Illegal);
23005 }
23006 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
23007 Some(Ins::Wfi { cond })
23008}
23009#[cfg(all(feature = "arm", feature = "v6k"))]
23010fn parse_arm_yield_0(value: u32, pc: u32, options: &Options) -> Option<Ins> {
23011 const VERSIONS: Versions = Versions::of(&[#[cfg(feature = "v6k")] Version::V6K]);
23012 if !VERSIONS.has(options.version) {
23013 return None;
23014 }
23015 if value & 0xff00 != 0xf000 {
23016 return Some(Ins::Illegal);
23017 }
23018 if value & 0xf0000000 == 0xf0000000 {
23019 return Some(Ins::Illegal);
23020 }
23021 let cond = Cond::parse(((value) >> 28) & 0xf, pc);
23022 Some(Ins::Yield { cond })
23023}