/
basic-a64-instructions.s
4883 lines (4449 loc) · 246 KB
/
basic-a64-instructions.s
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// RUN: llvm-mc -triple aarch64-none-linux-gnu -show-encoding -mattr=+v8a,+fp-armv8 %s | FileCheck %s
.globl _func
// Check that the assembler can handle the documented syntax from the ARM ARM.
// For complex constructs like shifter operands, check more thoroughly for them
// once then spot check that following instructions accept the form generally.
// This gives us good coverage while keeping the overall size of the test
// more reasonable.
_func:
// CHECK: _func
//------------------------------------------------------------------------------
// Add/sub (extended register)
//------------------------------------------------------------------------------
// Basic extends 64-bit ops
add x2, x4, w5, uxtb
add x20, sp, w19, uxth
add x12, x1, w20, uxtw
add x20, x3, x13, uxtx
add x17, x25, w20, sxtb
add x18, x13, w19, sxth
add sp, x2, w3, sxtw
add x3, x5, x9, sxtx
// CHECK: add x2, x4, w5, uxtb // encoding: [0x82,0x00,0x25,0x8b]
// CHECK: add x20, sp, w19, uxth // encoding: [0xf4,0x23,0x33,0x8b]
// CHECK: add x12, x1, w20, uxtw // encoding: [0x2c,0x40,0x34,0x8b]
// CHECK: add x20, x3, x13, uxtx // encoding: [0x74,0x60,0x2d,0x8b]
// CHECK: add x17, x25, w20, sxtb // encoding: [0x31,0x83,0x34,0x8b]
// CHECK: add x18, x13, w19, sxth // encoding: [0xb2,0xa1,0x33,0x8b]
// CHECK: add sp, x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x8b]
// CHECK: add x3, x5, x9, sxtx // encoding: [0xa3,0xe0,0x29,0x8b]
// Basic extends, 32-bit ops
add w2, w5, w7, uxtb
add w21, w15, w17, uxth
add w30, w29, wzr, uxtw
add w19, w17, w1, uxtx // Goodness knows what this means
add w2, w5, w1, sxtb
add w26, w17, w19, sxth
add w0, w2, w3, sxtw
add w2, w3, w5, sxtx
// CHECK: add w2, w5, w7, uxtb // encoding: [0xa2,0x00,0x27,0x0b]
// CHECK: add w21, w15, w17, uxth // encoding: [0xf5,0x21,0x31,0x0b]
// CHECK: add w30, w29, wzr, uxtw // encoding: [0xbe,0x43,0x3f,0x0b]
// CHECK: add w19, w17, w1, uxtx // encoding: [0x33,0x62,0x21,0x0b]
// CHECK: add w2, w5, w1, sxtb // encoding: [0xa2,0x80,0x21,0x0b]
// CHECK: add w26, w17, w19, sxth // encoding: [0x3a,0xa2,0x33,0x0b]
// CHECK: add w0, w2, w3, sxtw // encoding: [0x40,0xc0,0x23,0x0b]
// CHECK: add w2, w3, w5, sxtx // encoding: [0x62,0xe0,0x25,0x0b]
// Nonzero shift amounts
add x2, x3, w5, sxtb #0
add x7, x11, w13, uxth #4
add w17, w19, w23, uxtw #2
add w29, w23, w17, uxtx #1
// CHECK: add x2, x3, w5, sxtb // encoding: [0x62,0x80,0x25,0x8b]
// CHECK: add x7, x11, w13, uxth #4 // encoding: [0x67,0x31,0x2d,0x8b]
// CHECK: add w17, w19, w23, uxtw #2 // encoding: [0x71,0x4a,0x37,0x0b]
// CHECK: add w29, w23, w17, uxtx #1 // encoding: [0xfd,0x66,0x31,0x0b]
// Sub
sub x2, x4, w5, uxtb #2
sub x20, sp, w19, uxth #4
sub x12, x1, w20, uxtw
sub x20, x3, x13, uxtx #0
sub x17, x25, w20, sxtb
sub x18, x13, w19, sxth
sub sp, x2, w3, sxtw
sub x3, x5, x9, sxtx
// CHECK: sub x2, x4, w5, uxtb #2 // encoding: [0x82,0x08,0x25,0xcb]
// CHECK: sub x20, sp, w19, uxth #4 // encoding: [0xf4,0x33,0x33,0xcb]
// CHECK: sub x12, x1, w20, uxtw // encoding: [0x2c,0x40,0x34,0xcb]
// CHECK: sub x20, x3, x13, uxtx // encoding: [0x74,0x60,0x2d,0xcb]
// CHECK: sub x17, x25, w20, sxtb // encoding: [0x31,0x83,0x34,0xcb]
// CHECK: sub x18, x13, w19, sxth // encoding: [0xb2,0xa1,0x33,0xcb]
// CHECK: sub sp, x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0xcb]
// CHECK: sub x3, x5, x9, sxtx // encoding: [0xa3,0xe0,0x29,0xcb]
sub w2, w5, w7, uxtb
sub w21, w15, w17, uxth
sub w30, w29, wzr, uxtw
sub w19, w17, w1, uxtx // Goodness knows what this means
sub w2, w5, w1, sxtb
sub w26, wsp, w19, sxth
sub wsp, w2, w3, sxtw
sub w2, w3, w5, sxtx
// CHECK: sub w2, w5, w7, uxtb // encoding: [0xa2,0x00,0x27,0x4b]
// CHECK: sub w21, w15, w17, uxth // encoding: [0xf5,0x21,0x31,0x4b]
// CHECK: sub w30, w29, wzr, uxtw // encoding: [0xbe,0x43,0x3f,0x4b]
// CHECK: sub w19, w17, w1, uxtx // encoding: [0x33,0x62,0x21,0x4b]
// CHECK: sub w2, w5, w1, sxtb // encoding: [0xa2,0x80,0x21,0x4b]
// CHECK: sub w26, wsp, w19, sxth // encoding: [0xfa,0xa3,0x33,0x4b]
// CHECK: sub wsp, w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x4b]
// CHECK: sub w2, w3, w5, sxtx // encoding: [0x62,0xe0,0x25,0x4b]
// Adds
adds x2, x4, w5, uxtb #2
adds x20, sp, w19, uxth #4
adds x12, x1, w20, uxtw
adds x20, x3, x13, uxtx #0
adds xzr, x25, w20, sxtb #3
adds x18, sp, w19, sxth
adds xzr, x2, w3, sxtw
adds x3, x5, x9, sxtx #2
// CHECK: adds x2, x4, w5, uxtb #2 // encoding: [0x82,0x08,0x25,0xab]
// CHECK: adds x20, sp, w19, uxth #4 // encoding: [0xf4,0x33,0x33,0xab]
// CHECK: adds x12, x1, w20, uxtw // encoding: [0x2c,0x40,0x34,0xab]
// CHECK: adds x20, x3, x13, uxtx // encoding: [0x74,0x60,0x2d,0xab]
// CHECK: {{adds xzr,|cmn}} x25, w20, sxtb #3 // encoding: [0x3f,0x8f,0x34,0xab]
// CHECK: adds x18, sp, w19, sxth // encoding: [0xf2,0xa3,0x33,0xab]
// CHECK: {{adds xzr,|cmn}} x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0xab]
// CHECK: adds x3, x5, x9, sxtx #2 // encoding: [0xa3,0xe8,0x29,0xab]
adds w2, w5, w7, uxtb
adds w21, w15, w17, uxth
adds w30, w29, wzr, uxtw
adds w19, w17, w1, uxtx // Goodness knows what this means
adds w2, w5, w1, sxtb #1
adds w26, wsp, w19, sxth
adds wzr, w2, w3, sxtw
adds w2, w3, w5, sxtx
// CHECK: adds w2, w5, w7, uxtb // encoding: [0xa2,0x00,0x27,0x2b]
// CHECK: adds w21, w15, w17, uxth // encoding: [0xf5,0x21,0x31,0x2b]
// CHECK: adds w30, w29, wzr, uxtw // encoding: [0xbe,0x43,0x3f,0x2b]
// CHECK: adds w19, w17, w1, uxtx // encoding: [0x33,0x62,0x21,0x2b]
// CHECK: adds w2, w5, w1, sxtb #1 // encoding: [0xa2,0x84,0x21,0x2b]
// CHECK: adds w26, wsp, w19, sxth // encoding: [0xfa,0xa3,0x33,0x2b]
// CHECK: cmn w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x2b]
// CHECK: adds w2, w3, w5, sxtx // encoding: [0x62,0xe0,0x25,0x2b]
// subs
subs x2, x4, w5, uxtb #2
subs x20, sp, w19, uxth #4
subs x12, x1, w20, uxtw
subs x20, x3, x13, uxtx #0
subs xzr, x25, w20, sxtb #3
subs x18, sp, w19, sxth
subs xzr, x2, w3, sxtw
subs x3, x5, x9, sxtx #2
// CHECK: subs x2, x4, w5, uxtb #2 // encoding: [0x82,0x08,0x25,0xeb]
// CHECK: subs x20, sp, w19, uxth #4 // encoding: [0xf4,0x33,0x33,0xeb]
// CHECK: subs x12, x1, w20, uxtw // encoding: [0x2c,0x40,0x34,0xeb]
// CHECK: subs x20, x3, x13, uxtx // encoding: [0x74,0x60,0x2d,0xeb]
// CHECK: {{subs xzr,|cmp}} x25, w20, sxtb #3 // encoding: [0x3f,0x8f,0x34,0xeb]
// CHECK: subs x18, sp, w19, sxth // encoding: [0xf2,0xa3,0x33,0xeb]
// CHECK: {{subs xzr,|cmp}} x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0xeb]
// CHECK: subs x3, x5, x9, sxtx #2 // encoding: [0xa3,0xe8,0x29,0xeb]
subs w2, w5, w7, uxtb
subs w21, w15, w17, uxth
subs w30, w29, wzr, uxtw
subs w19, w17, w1, uxtx // Goodness knows what this means
subs w2, w5, w1, sxtb #1
subs w26, wsp, w19, sxth
subs wzr, w2, w3, sxtw
subs w2, w3, w5, sxtx
// CHECK: subs w2, w5, w7, uxtb // encoding: [0xa2,0x00,0x27,0x6b]
// CHECK: subs w21, w15, w17, uxth // encoding: [0xf5,0x21,0x31,0x6b]
// CHECK: subs w30, w29, wzr, uxtw // encoding: [0xbe,0x43,0x3f,0x6b]
// CHECK: subs w19, w17, w1, uxtx // encoding: [0x33,0x62,0x21,0x6b]
// CHECK: subs w2, w5, w1, sxtb #1 // encoding: [0xa2,0x84,0x21,0x6b]
// CHECK: subs w26, wsp, w19, sxth // encoding: [0xfa,0xa3,0x33,0x6b]
// CHECK: {{subs wzr,|cmp}} w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x6b]
// CHECK: subs w2, w3, w5, sxtx // encoding: [0x62,0xe0,0x25,0x6b]
// cmp
cmp x4, w5, uxtb #2
cmp sp, w19, uxth #4
cmp x1, w20, uxtw
cmp x3, x13, uxtx #0
cmp x25, w20, sxtb #3
cmp sp, w19, sxth
cmp x2, w3, sxtw
cmp x5, x9, sxtx #2
// CHECK: cmp x4, w5, uxtb #2 // encoding: [0x9f,0x08,0x25,0xeb]
// CHECK: cmp sp, w19, uxth #4 // encoding: [0xff,0x33,0x33,0xeb]
// CHECK: cmp x1, w20, uxtw // encoding: [0x3f,0x40,0x34,0xeb]
// CHECK: cmp x3, x13, uxtx // encoding: [0x7f,0x60,0x2d,0xeb]
// CHECK: cmp x25, w20, sxtb #3 // encoding: [0x3f,0x8f,0x34,0xeb]
// CHECK: cmp sp, w19, sxth // encoding: [0xff,0xa3,0x33,0xeb]
// CHECK: cmp x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0xeb]
// CHECK: cmp x5, x9, sxtx #2 // encoding: [0xbf,0xe8,0x29,0xeb]
cmp w5, w7, uxtb
cmp w15, w17, uxth
cmp w29, wzr, uxtw
cmp w17, w1, uxtx // Goodness knows what this means
cmp w5, w1, sxtb #1
cmp wsp, w19, sxth
cmp w2, w3, sxtw
cmp w3, w5, sxtx
// CHECK: cmp w5, w7, uxtb // encoding: [0xbf,0x00,0x27,0x6b]
// CHECK: cmp w15, w17, uxth // encoding: [0xff,0x21,0x31,0x6b]
// CHECK: cmp w29, wzr, uxtw // encoding: [0xbf,0x43,0x3f,0x6b]
// CHECK: cmp w17, w1, uxtx // encoding: [0x3f,0x62,0x21,0x6b]
// CHECK: cmp w5, w1, sxtb #1 // encoding: [0xbf,0x84,0x21,0x6b]
// CHECK: cmp wsp, w19, sxth // encoding: [0xff,0xa3,0x33,0x6b]
// CHECK: cmp w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x6b]
// CHECK: cmp w3, w5, sxtx // encoding: [0x7f,0xe0,0x25,0x6b]
// cmn
cmn x4, w5, uxtb #2
cmn sp, w19, uxth #4
cmn x1, w20, uxtw
cmn x3, x13, uxtx #0
cmn x25, w20, sxtb #3
cmn sp, w19, sxth
cmn x2, w3, sxtw
cmn x5, x9, sxtx #2
// CHECK: cmn x4, w5, uxtb #2 // encoding: [0x9f,0x08,0x25,0xab]
// CHECK: cmn sp, w19, uxth #4 // encoding: [0xff,0x33,0x33,0xab]
// CHECK: cmn x1, w20, uxtw // encoding: [0x3f,0x40,0x34,0xab]
// CHECK: cmn x3, x13, uxtx // encoding: [0x7f,0x60,0x2d,0xab]
// CHECK: cmn x25, w20, sxtb #3 // encoding: [0x3f,0x8f,0x34,0xab]
// CHECK: cmn sp, w19, sxth // encoding: [0xff,0xa3,0x33,0xab]
// CHECK: cmn x2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0xab]
// CHECK: cmn x5, x9, sxtx #2 // encoding: [0xbf,0xe8,0x29,0xab]
cmn w5, w7, uxtb
cmn w15, w17, uxth
cmn w29, wzr, uxtw
cmn w17, w1, uxtx // Goodness knows what this means
cmn w5, w1, sxtb #1
cmn wsp, w19, sxth
cmn w2, w3, sxtw
cmn w3, w5, sxtx
// CHECK: {{cmn|adds wzr,}} w5, w7, uxtb // encoding: [0xbf,0x00,0x27,0x2b]
// CHECK: {{cmn|adds wzr,}} w15, w17, uxth // encoding: [0xff,0x21,0x31,0x2b]
// CHECK: {{cmn|adds wzr,}} w29, wzr, uxtw // encoding: [0xbf,0x43,0x3f,0x2b]
// CHECK: {{cmn|adds wzr,}} w17, w1, uxtx // encoding: [0x3f,0x62,0x21,0x2b]
// CHECK: {{cmn|adds wzr,}} w5, w1, sxtb #1 // encoding: [0xbf,0x84,0x21,0x2b]
// CHECK: {{cmn|adds wzr,}} wsp, w19, sxth // encoding: [0xff,0xa3,0x33,0x2b]
// CHECK: {{cmn|adds wzr,}} w2, w3, sxtw // encoding: [0x5f,0xc0,0x23,0x2b]
// CHECK: {{cmn|adds wzr,}} w3, w5, sxtx // encoding: [0x7f,0xe0,0x25,0x2b]
// operands for cmp
cmp x20, w29, uxtb #3
cmp x12, x13, uxtx #4
cmp wsp, w1, uxtb
cmn wsp, wzr, sxtw
// CHECK: cmp x20, w29, uxtb #3 // encoding: [0x9f,0x0e,0x3d,0xeb]
// CHECK: cmp x12, x13, uxtx #4 // encoding: [0x9f,0x71,0x2d,0xeb]
// CHECK: cmp wsp, w1, uxtb // encoding: [0xff,0x03,0x21,0x6b]
// CHECK: {{cmn|adds wzr,}} wsp, wzr, sxtw // encoding: [0xff,0xc3,0x3f,0x2b]
// LSL variant if sp involved
sub sp, x3, x7, lsl #4
add w2, wsp, w3, lsl #1
cmp wsp, w9, lsl #0
adds wzr, wsp, w3, lsl #4
subs x3, sp, x9, lsl #2
// CHECK: sub sp, x3, x7, lsl #4 // encoding: [0x7f,0x70,0x27,0xcb]
// CHECK: add w2, wsp, w3, lsl #1 // encoding: [0xe2,0x47,0x23,0x0b]
// CHECK: cmp wsp, w9 // encoding: [0xff,0x43,0x29,0x6b]
// CHECK: cmn wsp, w3, lsl #4 // encoding: [0xff,0x53,0x23,0x2b]
// CHECK: subs x3, sp, x9, lsl #2 // encoding: [0xe3,0x6b,0x29,0xeb]
//------------------------------------------------------------------------------
// Add/sub (immediate)
//------------------------------------------------------------------------------
// Check basic immediate values: an unsigned 12-bit immediate, optionally
// shifted left by 12 bits.
add w4, w5, #0x0
add w2, w3, #4095
add w30, w29, #1, lsl #12
add w13, w5, #4095, lsl #12
add x5, x7, #1638
// CHECK: add w4, w5, #0 // encoding: [0xa4,0x00,0x00,0x11]
// CHECK: add w2, w3, #4095 // encoding: [0x62,0xfc,0x3f,0x11]
// CHECK: add w30, w29, #1, lsl #12 // encoding: [0xbe,0x07,0x40,0x11]
// CHECK: add w13, w5, #4095, lsl #12 // encoding: [0xad,0xfc,0x7f,0x11]
// CHECK: add x5, x7, #1638 // encoding: [0xe5,0x98,0x19,0x91]
// All registers involved in the non-S variants have 31 encoding sp rather than zr
add w20, wsp, #801, lsl #0
add wsp, wsp, #1104
add wsp, w30, #4084
// CHECK: add w20, wsp, #801 // encoding: [0xf4,0x87,0x0c,0x11]
// CHECK: add wsp, wsp, #1104 // encoding: [0xff,0x43,0x11,0x11]
// CHECK: add wsp, w30, #4084 // encoding: [0xdf,0xd3,0x3f,0x11]
// A few checks on the sanity of 64-bit versions
add x0, x24, #291
add x3, x24, #4095, lsl #12
add x8, sp, #1074
add sp, x29, #3816
// CHECK: add x0, x24, #291 // encoding: [0x00,0x8f,0x04,0x91]
// CHECK: add x3, x24, #4095, lsl #12 // encoding: [0x03,0xff,0x7f,0x91]
// CHECK: add x8, sp, #1074 // encoding: [0xe8,0xcb,0x10,0x91]
// CHECK: add sp, x29, #3816 // encoding: [0xbf,0xa3,0x3b,0x91]
// And on sub
sub w0, wsp, #4077
sub w4, w20, #546, lsl #12
sub sp, sp, #288
sub wsp, w19, #16
// CHECK: sub w0, wsp, #4077 // encoding: [0xe0,0xb7,0x3f,0x51]
// CHECK: sub w4, w20, #546, lsl #12 // encoding: [0x84,0x8a,0x48,0x51]
// CHECK: sub sp, sp, #288 // encoding: [0xff,0x83,0x04,0xd1]
// CHECK: sub wsp, w19, #16 // encoding: [0x7f,0x42,0x00,0x51]
// ADDS/SUBS accept zr in the Rd position but sp in the Rn position
adds w13, w23, #291, lsl #12
adds wzr, w2, #4095 // FIXME: canonically should be cmn
adds w20, wsp, #0x0
adds xzr, x3, #0x1, lsl #12 // FIXME: canonically should be cmn
// CHECK: adds w13, w23, #291, lsl #12 // encoding: [0xed,0x8e,0x44,0x31]
// CHECK: {{adds wzr,|cmn}} w2, #4095 // encoding: [0x5f,0xfc,0x3f,0x31]
// CHECK: adds w20, wsp, #0 // encoding: [0xf4,0x03,0x00,0x31]
// CHECK: {{adds xzr,|cmn}} x3, #1, lsl #12 // encoding: [0x7f,0x04,0x40,0xb1]
// Checks for subs
subs xzr, sp, #20, lsl #12 // FIXME: canonically should be cmp
subs xzr, x30, #4095, lsl #0 // FIXME: canonically should be cmp
subs x4, sp, #3822
// CHECK: {{subs xzr,|cmp}} sp, #20, lsl #12 // encoding: [0xff,0x53,0x40,0xf1]
// CHECK: {{subs xzr,|cmp}} x30, #4095 // encoding: [0xdf,0xff,0x3f,0xf1]
// CHECK: subs x4, sp, #3822 // encoding: [0xe4,0xbb,0x3b,0xf1]
// cmn is an alias for adds zr, ...
cmn w3, #291, lsl #12
cmn wsp, #1365, lsl #0
cmn sp, #1092, lsl #12
// CHECK: cmn w3, #291, lsl #12 // encoding: [0x7f,0x8c,0x44,0x31]
// CHECK: cmn wsp, #1365 // encoding: [0xff,0x57,0x15,0x31]
// CHECK: cmn sp, #1092, lsl #12 // encoding: [0xff,0x13,0x51,0xb1]
// cmp is an alias for subs zr, ... (FIXME: should always disassemble as such too).
cmp x4, #300, lsl #12
cmp wsp, #500
cmp sp, #200, lsl #0
// CHECK: cmp x4, #300, lsl #12 // encoding: [0x9f,0xb0,0x44,0xf1]
// CHECK: cmp wsp, #500 // encoding: [0xff,0xd3,0x07,0x71]
// CHECK: cmp sp, #200 // encoding: [0xff,0x23,0x03,0xf1]
// A "MOV" involving sp is encoded in this manner: add Reg, Reg, #0
mov sp, x30
mov wsp, w20
mov x11, sp
mov w24, wsp
// CHECK: mov sp, x30 // encoding: [0xdf,0x03,0x00,0x91]
// CHECK: mov wsp, w20 // encoding: [0x9f,0x02,0x00,0x11]
// CHECK: mov x11, sp // encoding: [0xeb,0x03,0x00,0x91]
// CHECK: mov w24, wsp // encoding: [0xf8,0x03,0x00,0x11]
// A relocation check (default to lo12, which is the only sane relocation anyway really)
add x0, x4, #:lo12:var
// CHECK: add x0, x4, :lo12:var // encoding: [0x80,0bAAAAAA00,0b00AAAAAA,0x91]
// CHECK: // fixup A - offset: 0, value: :lo12:var, kind: fixup_aarch64_add_imm12
//------------------------------------------------------------------------------
// Add-sub (shifted register)
//------------------------------------------------------------------------------
// As usual, we don't print the canonical forms of many instructions.
add w3, w5, w7
add wzr, w3, w5
add w20, wzr, w4
add w4, w6, wzr
// CHECK: add w3, w5, w7 // encoding: [0xa3,0x00,0x07,0x0b]
// CHECK: add wzr, w3, w5 // encoding: [0x7f,0x00,0x05,0x0b]
// CHECK: add w20, wzr, w4 // encoding: [0xf4,0x03,0x04,0x0b]
// CHECK: add w4, w6, wzr // encoding: [0xc4,0x00,0x1f,0x0b]
add w11, w13, w15, lsl #0
add w9, w3, wzr, lsl #10
add w17, w29, w20, lsl #31
add w17, w29, w20, lsl #(31-2)
// CHECK: add w11, w13, w15 // encoding: [0xab,0x01,0x0f,0x0b]
// CHECK: add w9, w3, wzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x0b]
// CHECK: add w17, w29, w20, lsl #31 // encoding: [0xb1,0x7f,0x14,0x0b]
// CHECK: add w17, w29, w20, lsl #29 // encoding: [0xb1,0x77,0x14,0x0b]
add w21, w22, w23, lsr #0
add w24, w25, w26, lsr #18
add w27, w28, w29, lsr #31
add w27, w28, w29, lsr #(31-2)
// CHECK: add w21, w22, w23, lsr #0 // encoding: [0xd5,0x02,0x57,0x0b]
// CHECK: add w24, w25, w26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x0b]
// CHECK: add w27, w28, w29, lsr #31 // encoding: [0x9b,0x7f,0x5d,0x0b]
// CHECK: add w27, w28, w29, lsr #29 // encoding: [0x9b,0x77,0x5d,0x0b]
add w2, w3, w4, asr #0
add w5, w6, w7, asr #21
add w8, w9, w10, asr #31
add w8, w9, w10, asr #(31-2)
// CHECK: add w2, w3, w4, asr #0 // encoding: [0x62,0x00,0x84,0x0b]
// CHECK: add w5, w6, w7, asr #21 // encoding: [0xc5,0x54,0x87,0x0b]
// CHECK: add w8, w9, w10, asr #31 // encoding: [0x28,0x7d,0x8a,0x0b]
// CHECK: add w8, w9, w10, asr #29 // encoding: [0x28,0x75,0x8a,0x0b]
add x3, x5, x7
add xzr, x3, x5
add x20, xzr, x4
add x4, x6, xzr
// CHECK: add x3, x5, x7 // encoding: [0xa3,0x00,0x07,0x8b]
// CHECK: add xzr, x3, x5 // encoding: [0x7f,0x00,0x05,0x8b]
// CHECK: add x20, xzr, x4 // encoding: [0xf4,0x03,0x04,0x8b]
// CHECK: add x4, x6, xzr // encoding: [0xc4,0x00,0x1f,0x8b]
add x11, x13, x15, lsl #0
add x9, x3, xzr, lsl #10
add x17, x29, x20, lsl #63
add x17, x29, x20, lsl #(63-5)
// CHECK: add x11, x13, x15 // encoding: [0xab,0x01,0x0f,0x8b]
// CHECK: add x9, x3, xzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x8b]
// CHECK: add x17, x29, x20, lsl #63 // encoding: [0xb1,0xff,0x14,0x8b]
// CHECK: add x17, x29, x20, lsl #58 // encoding: [0xb1,0xeb,0x14,0x8b]
add x21, x22, x23, lsr #0
add x24, x25, x26, lsr #18
add x27, x28, x29, lsr #63
add x17, x29, x20, lsr #(63-5)
// CHECK: add x21, x22, x23, lsr #0 // encoding: [0xd5,0x02,0x57,0x8b]
// CHECK: add x24, x25, x26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x8b]
// CHECK: add x27, x28, x29, lsr #63 // encoding: [0x9b,0xff,0x5d,0x8b]
// CHECK: add x17, x29, x20, lsr #58 // encoding: [0xb1,0xeb,0x54,0x8b]
add x2, x3, x4, asr #0
add x5, x6, x7, asr #21
add x8, x9, x10, asr #63
add x17, x29, x20, asr #(63-5)
// CHECK: add x2, x3, x4, asr #0 // encoding: [0x62,0x00,0x84,0x8b]
// CHECK: add x5, x6, x7, asr #21 // encoding: [0xc5,0x54,0x87,0x8b]
// CHECK: add x8, x9, x10, asr #63 // encoding: [0x28,0xfd,0x8a,0x8b]
// CHECK: add x17, x29, x20, asr #58 // encoding: [0xb1,0xeb,0x94,0x8b]
adds w3, w5, w7
adds wzr, w3, w5
adds w20, wzr, w4
adds w4, w6, wzr
// CHECK: adds w3, w5, w7 // encoding: [0xa3,0x00,0x07,0x2b]
// CHECK: {{adds wzr,|cmn}} w3, w5 // encoding: [0x7f,0x00,0x05,0x2b]
// CHECK: adds w20, wzr, w4 // encoding: [0xf4,0x03,0x04,0x2b]
// CHECK: adds w4, w6, wzr // encoding: [0xc4,0x00,0x1f,0x2b]
adds w11, w13, w15, lsl #0
adds w9, w3, wzr, lsl #10
adds w17, w29, w20, lsl #31
// CHECK: adds w11, w13, w15 // encoding: [0xab,0x01,0x0f,0x2b]
// CHECK: adds w9, w3, wzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x2b]
// CHECK: adds w17, w29, w20, lsl #31 // encoding: [0xb1,0x7f,0x14,0x2b]
adds w21, w22, w23, lsr #0
adds w24, w25, w26, lsr #18
adds w27, w28, w29, lsr #31
// CHECK: adds w21, w22, w23, lsr #0 // encoding: [0xd5,0x02,0x57,0x2b]
// CHECK: adds w24, w25, w26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x2b]
// CHECK: adds w27, w28, w29, lsr #31 // encoding: [0x9b,0x7f,0x5d,0x2b]
adds w2, w3, w4, asr #0
adds w5, w6, w7, asr #21
adds w8, w9, w10, asr #31
// CHECK: adds w2, w3, w4, asr #0 // encoding: [0x62,0x00,0x84,0x2b]
// CHECK: adds w5, w6, w7, asr #21 // encoding: [0xc5,0x54,0x87,0x2b]
// CHECK: adds w8, w9, w10, asr #31 // encoding: [0x28,0x7d,0x8a,0x2b]
adds x3, x5, x7
adds xzr, x3, x5
adds x20, xzr, x4
adds x4, x6, xzr
// CHECK: adds x3, x5, x7 // encoding: [0xa3,0x00,0x07,0xab]
// CHECK: {{adds xzr,|cmn}} x3, x5 // encoding: [0x7f,0x00,0x05,0xab]
// CHECK: adds x20, xzr, x4 // encoding: [0xf4,0x03,0x04,0xab]
// CHECK: adds x4, x6, xzr // encoding: [0xc4,0x00,0x1f,0xab]
adds x11, x13, x15, lsl #0
adds x9, x3, xzr, lsl #10
adds x17, x29, x20, lsl #63
// CHECK: adds x11, x13, x15 // encoding: [0xab,0x01,0x0f,0xab]
// CHECK: adds x9, x3, xzr, lsl #10 // encoding: [0x69,0x28,0x1f,0xab]
// CHECK: adds x17, x29, x20, lsl #63 // encoding: [0xb1,0xff,0x14,0xab]
adds x21, x22, x23, lsr #0
adds x24, x25, x26, lsr #18
adds x27, x28, x29, lsr #63
// CHECK: adds x21, x22, x23, lsr #0 // encoding: [0xd5,0x02,0x57,0xab]
// CHECK: adds x24, x25, x26, lsr #18 // encoding: [0x38,0x4b,0x5a,0xab]
// CHECK: adds x27, x28, x29, lsr #63 // encoding: [0x9b,0xff,0x5d,0xab]
adds x2, x3, x4, asr #0
adds x5, x6, x7, asr #21
adds x8, x9, x10, asr #63
// CHECK: adds x2, x3, x4, asr #0 // encoding: [0x62,0x00,0x84,0xab]
// CHECK: adds x5, x6, x7, asr #21 // encoding: [0xc5,0x54,0x87,0xab]
// CHECK: adds x8, x9, x10, asr #63 // encoding: [0x28,0xfd,0x8a,0xab]
sub w3, w5, w7
sub wzr, w3, w5
sub w20, wzr, w4
sub w4, w6, wzr
// CHECK: sub w3, w5, w7 // encoding: [0xa3,0x00,0x07,0x4b]
// CHECK: sub wzr, w3, w5 // encoding: [0x7f,0x00,0x05,0x4b]
// CHECK: neg w20, w4 // encoding: [0xf4,0x03,0x04,0x4b]
// CHECK: sub w4, w6, wzr // encoding: [0xc4,0x00,0x1f,0x4b]
sub w11, w13, w15, lsl #0
sub w9, w3, wzr, lsl #10
sub w17, w29, w20, lsl #31
// CHECK: sub w11, w13, w15 // encoding: [0xab,0x01,0x0f,0x4b]
// CHECK: sub w9, w3, wzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x4b]
// CHECK: sub w17, w29, w20, lsl #31 // encoding: [0xb1,0x7f,0x14,0x4b]
sub w21, w22, w23, lsr #0
sub w24, w25, w26, lsr #18
sub w27, w28, w29, lsr #31
// CHECK: sub w21, w22, w23, lsr #0 // encoding: [0xd5,0x02,0x57,0x4b]
// CHECK: sub w24, w25, w26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x4b]
// CHECK: sub w27, w28, w29, lsr #31 // encoding: [0x9b,0x7f,0x5d,0x4b]
sub w2, w3, w4, asr #0
sub w5, w6, w7, asr #21
sub w8, w9, w10, asr #31
// CHECK: sub w2, w3, w4, asr #0 // encoding: [0x62,0x00,0x84,0x4b]
// CHECK: sub w5, w6, w7, asr #21 // encoding: [0xc5,0x54,0x87,0x4b]
// CHECK: sub w8, w9, w10, asr #31 // encoding: [0x28,0x7d,0x8a,0x4b]
sub x3, x5, x7
sub xzr, x3, x5
sub x20, xzr, x4
sub x4, x6, xzr
// CHECK: sub x3, x5, x7 // encoding: [0xa3,0x00,0x07,0xcb]
// CHECK: sub xzr, x3, x5 // encoding: [0x7f,0x00,0x05,0xcb]
// CHECK: neg x20, x4 // encoding: [0xf4,0x03,0x04,0xcb]
// CHECK: sub x4, x6, xzr // encoding: [0xc4,0x00,0x1f,0xcb]
sub x11, x13, x15, lsl #0
sub x9, x3, xzr, lsl #10
sub x17, x29, x20, lsl #63
// CHECK: sub x11, x13, x15 // encoding: [0xab,0x01,0x0f,0xcb]
// CHECK: sub x9, x3, xzr, lsl #10 // encoding: [0x69,0x28,0x1f,0xcb]
// CHECK: sub x17, x29, x20, lsl #63 // encoding: [0xb1,0xff,0x14,0xcb]
sub x21, x22, x23, lsr #0
sub x24, x25, x26, lsr #18
sub x27, x28, x29, lsr #63
// CHECK: sub x21, x22, x23, lsr #0 // encoding: [0xd5,0x02,0x57,0xcb]
// CHECK: sub x24, x25, x26, lsr #18 // encoding: [0x38,0x4b,0x5a,0xcb]
// CHECK: sub x27, x28, x29, lsr #63 // encoding: [0x9b,0xff,0x5d,0xcb]
sub x2, x3, x4, asr #0
sub x5, x6, x7, asr #21
sub x8, x9, x10, asr #63
// CHECK: sub x2, x3, x4, asr #0 // encoding: [0x62,0x00,0x84,0xcb]
// CHECK: sub x5, x6, x7, asr #21 // encoding: [0xc5,0x54,0x87,0xcb]
// CHECK: sub x8, x9, x10, asr #63 // encoding: [0x28,0xfd,0x8a,0xcb]
subs w3, w5, w7
subs wzr, w3, w5
subs w20, wzr, w4
subs w4, w6, wzr
// CHECK: subs w3, w5, w7 // encoding: [0xa3,0x00,0x07,0x6b]
// CHECK: {{subs wzr,|cmp}} w3, w5 // encoding: [0x7f,0x00,0x05,0x6b]
// CHECK: negs w20, w4 // encoding: [0xf4,0x03,0x04,0x6b]
// CHECK: subs w4, w6, wzr // encoding: [0xc4,0x00,0x1f,0x6b]
subs w11, w13, w15, lsl #0
subs w9, w3, wzr, lsl #10
subs w17, w29, w20, lsl #31
// CHECK: subs w11, w13, w15 // encoding: [0xab,0x01,0x0f,0x6b]
// CHECK: subs w9, w3, wzr, lsl #10 // encoding: [0x69,0x28,0x1f,0x6b]
// CHECK: subs w17, w29, w20, lsl #31 // encoding: [0xb1,0x7f,0x14,0x6b]
subs w21, w22, w23, lsr #0
subs w24, w25, w26, lsr #18
subs w27, w28, w29, lsr #31
// CHECK: subs w21, w22, w23, lsr #0 // encoding: [0xd5,0x02,0x57,0x6b]
// CHECK: subs w24, w25, w26, lsr #18 // encoding: [0x38,0x4b,0x5a,0x6b]
// CHECK: subs w27, w28, w29, lsr #31 // encoding: [0x9b,0x7f,0x5d,0x6b]
subs w2, w3, w4, asr #0
subs w5, w6, w7, asr #21
subs w8, w9, w10, asr #31
// CHECK: subs w2, w3, w4, asr #0 // encoding: [0x62,0x00,0x84,0x6b]
// CHECK: subs w5, w6, w7, asr #21 // encoding: [0xc5,0x54,0x87,0x6b]
// CHECK: subs w8, w9, w10, asr #31 // encoding: [0x28,0x7d,0x8a,0x6b]
subs x3, x5, x7
subs xzr, x3, x5
subs x20, xzr, x4
subs x4, x6, xzr
// CHECK: subs x3, x5, x7 // encoding: [0xa3,0x00,0x07,0xeb]
// CHECK: {{subs xzr,|cmp}} x3, x5 // encoding: [0x7f,0x00,0x05,0xeb]
// CHECK: negs x20, x4 // encoding: [0xf4,0x03,0x04,0xeb]
// CHECK: subs x4, x6, xzr // encoding: [0xc4,0x00,0x1f,0xeb]
subs x11, x13, x15, lsl #0
subs x9, x3, xzr, lsl #10
subs x17, x29, x20, lsl #63
// CHECK: subs x11, x13, x15 // encoding: [0xab,0x01,0x0f,0xeb]
// CHECK: subs x9, x3, xzr, lsl #10 // encoding: [0x69,0x28,0x1f,0xeb]
// CHECK: subs x17, x29, x20, lsl #63 // encoding: [0xb1,0xff,0x14,0xeb]
subs x21, x22, x23, lsr #0
subs x24, x25, x26, lsr #18
subs x27, x28, x29, lsr #63
// CHECK: subs x21, x22, x23, lsr #0 // encoding: [0xd5,0x02,0x57,0xeb]
// CHECK: subs x24, x25, x26, lsr #18 // encoding: [0x38,0x4b,0x5a,0xeb]
// CHECK: subs x27, x28, x29, lsr #63 // encoding: [0x9b,0xff,0x5d,0xeb]
subs x2, x3, x4, asr #0
subs x5, x6, x7, asr #21
subs x8, x9, x10, asr #63
// CHECK: subs x2, x3, x4, asr #0 // encoding: [0x62,0x00,0x84,0xeb]
// CHECK: subs x5, x6, x7, asr #21 // encoding: [0xc5,0x54,0x87,0xeb]
// CHECK: subs x8, x9, x10, asr #63 // encoding: [0x28,0xfd,0x8a,0xeb]
cmn w0, w3
cmn wzr, w4
cmn w5, wzr
cmn wsp, w6
// CHECK: cmn w0, w3 // encoding: [0x1f,0x00,0x03,0x2b]
// CHECK: cmn wzr, w4 // encoding: [0xff,0x03,0x04,0x2b]
// CHECK: cmn w5, wzr // encoding: [0xbf,0x00,0x1f,0x2b]
// CHECK: cmn wsp, w6 // encoding: [0xff,0x43,0x26,0x2b]
cmn w6, w7, lsl #0
cmn w8, w9, lsl #15
cmn w10, w11, lsl #31
// CHECK: cmn w6, w7 // encoding: [0xdf,0x00,0x07,0x2b]
// CHECK: cmn w8, w9, lsl #15 // encoding: [0x1f,0x3d,0x09,0x2b]
// CHECK: cmn w10, w11, lsl #31 // encoding: [0x5f,0x7d,0x0b,0x2b]
cmn w12, w13, lsr #0
cmn w14, w15, lsr #21
cmn w16, w17, lsr #31
// CHECK: cmn w12, w13, lsr #0 // encoding: [0x9f,0x01,0x4d,0x2b]
// CHECK: cmn w14, w15, lsr #21 // encoding: [0xdf,0x55,0x4f,0x2b]
// CHECK: cmn w16, w17, lsr #31 // encoding: [0x1f,0x7e,0x51,0x2b]
cmn w18, w19, asr #0
cmn w20, w21, asr #22
cmn w22, w23, asr #31
// CHECK: cmn w18, w19, asr #0 // encoding: [0x5f,0x02,0x93,0x2b]
// CHECK: cmn w20, w21, asr #22 // encoding: [0x9f,0x5a,0x95,0x2b]
// CHECK: cmn w22, w23, asr #31 // encoding: [0xdf,0x7e,0x97,0x2b]
cmn x0, x3
cmn xzr, x4
cmn x5, xzr
cmn sp, x6
// CHECK: cmn x0, x3 // encoding: [0x1f,0x00,0x03,0xab]
// CHECK: cmn xzr, x4 // encoding: [0xff,0x03,0x04,0xab]
// CHECK: cmn x5, xzr // encoding: [0xbf,0x00,0x1f,0xab]
// CHECK: cmn sp, x6 // encoding: [0xff,0x63,0x26,0xab]
cmn x6, x7, lsl #0
cmn x8, x9, lsl #15
cmn x10, x11, lsl #63
// CHECK: cmn x6, x7 // encoding: [0xdf,0x00,0x07,0xab]
// CHECK: cmn x8, x9, lsl #15 // encoding: [0x1f,0x3d,0x09,0xab]
// CHECK: cmn x10, x11, lsl #63 // encoding: [0x5f,0xfd,0x0b,0xab]
cmn x12, x13, lsr #0
cmn x14, x15, lsr #41
cmn x16, x17, lsr #63
// CHECK: cmn x12, x13, lsr #0 // encoding: [0x9f,0x01,0x4d,0xab]
// CHECK: cmn x14, x15, lsr #41 // encoding: [0xdf,0xa5,0x4f,0xab]
// CHECK: cmn x16, x17, lsr #63 // encoding: [0x1f,0xfe,0x51,0xab]
cmn x18, x19, asr #0
cmn x20, x21, asr #55
cmn x22, x23, asr #63
// CHECK: cmn x18, x19, asr #0 // encoding: [0x5f,0x02,0x93,0xab]
// CHECK: cmn x20, x21, asr #55 // encoding: [0x9f,0xde,0x95,0xab]
// CHECK: cmn x22, x23, asr #63 // encoding: [0xdf,0xfe,0x97,0xab]
cmp w0, w3
cmp wzr, w4
cmp w5, wzr
cmp wsp, w6
// CHECK: cmp w0, w3 // encoding: [0x1f,0x00,0x03,0x6b]
// CHECK: cmp wzr, w4 // encoding: [0xff,0x03,0x04,0x6b]
// CHECK: cmp w5, wzr // encoding: [0xbf,0x00,0x1f,0x6b]
// CHECK: cmp wsp, w6 // encoding: [0xff,0x43,0x26,0x6b]
cmp w6, w7, lsl #0
cmp w8, w9, lsl #15
cmp w10, w11, lsl #31
// CHECK: cmp w6, w7 // encoding: [0xdf,0x00,0x07,0x6b]
// CHECK: cmp w8, w9, lsl #15 // encoding: [0x1f,0x3d,0x09,0x6b]
// CHECK: cmp w10, w11, lsl #31 // encoding: [0x5f,0x7d,0x0b,0x6b]
cmp w12, w13, lsr #0
cmp w14, w15, lsr #21
cmp w16, w17, lsr #31
// CHECK: cmp w12, w13, lsr #0 // encoding: [0x9f,0x01,0x4d,0x6b]
// CHECK: cmp w14, w15, lsr #21 // encoding: [0xdf,0x55,0x4f,0x6b]
// CHECK: cmp w16, w17, lsr #31 // encoding: [0x1f,0x7e,0x51,0x6b]
cmp w18, w19, asr #0
cmp w20, w21, asr #22
cmp w22, w23, asr #31
// CHECK: cmp w18, w19, asr #0 // encoding: [0x5f,0x02,0x93,0x6b]
// CHECK: cmp w20, w21, asr #22 // encoding: [0x9f,0x5a,0x95,0x6b]
// CHECK: cmp w22, w23, asr #31 // encoding: [0xdf,0x7e,0x97,0x6b]
cmp x0, x3
cmp xzr, x4
cmp x5, xzr
cmp sp, x6
// CHECK: cmp x0, x3 // encoding: [0x1f,0x00,0x03,0xeb]
// CHECK: cmp xzr, x4 // encoding: [0xff,0x03,0x04,0xeb]
// CHECK: cmp x5, xzr // encoding: [0xbf,0x00,0x1f,0xeb]
// CHECK: cmp sp, x6 // encoding: [0xff,0x63,0x26,0xeb]
cmp x6, x7, lsl #0
cmp x8, x9, lsl #15
cmp x10, x11, lsl #63
// CHECK: cmp x6, x7 // encoding: [0xdf,0x00,0x07,0xeb]
// CHECK: cmp x8, x9, lsl #15 // encoding: [0x1f,0x3d,0x09,0xeb]
// CHECK: cmp x10, x11, lsl #63 // encoding: [0x5f,0xfd,0x0b,0xeb]
cmp x12, x13, lsr #0
cmp x14, x15, lsr #41
cmp x16, x17, lsr #63
// CHECK: cmp x12, x13, lsr #0 // encoding: [0x9f,0x01,0x4d,0xeb]
// CHECK: cmp x14, x15, lsr #41 // encoding: [0xdf,0xa5,0x4f,0xeb]
// CHECK: cmp x16, x17, lsr #63 // encoding: [0x1f,0xfe,0x51,0xeb]
cmp x18, x19, asr #0
cmp x20, x21, asr #55
cmp x22, x23, asr #63
// CHECK: cmp x18, x19, asr #0 // encoding: [0x5f,0x02,0x93,0xeb]
// CHECK: cmp x20, x21, asr #55 // encoding: [0x9f,0xde,0x95,0xeb]
// CHECK: cmp x22, x23, asr #63 // encoding: [0xdf,0xfe,0x97,0xeb]
neg w29, w30
neg w30, wzr
neg wzr, w0
// CHECK: neg w29, w30 // encoding: [0xfd,0x03,0x1e,0x4b]
// CHECK: neg w30, wzr // encoding: [0xfe,0x03,0x1f,0x4b]
// CHECK: neg wzr, w0 // encoding: [0xff,0x03,0x00,0x4b]
neg w28, w27, lsl #0
neg w26, w25, lsl #29
neg w24, w23, lsl #31
// CHECK: neg w28, w27 // encoding: [0xfc,0x03,0x1b,0x4b]
// CHECK: neg w26, w25, lsl #29 // encoding: [0xfa,0x77,0x19,0x4b]
// CHECK: neg w24, w23, lsl #31 // encoding: [0xf8,0x7f,0x17,0x4b]
neg w22, w21, lsr #0
neg w20, w19, lsr #1
neg w18, w17, lsr #31
// CHECK: neg w22, w21, lsr #0 // encoding: [0xf6,0x03,0x55,0x4b]
// CHECK: neg w20, w19, lsr #1 // encoding: [0xf4,0x07,0x53,0x4b]
// CHECK: neg w18, w17, lsr #31 // encoding: [0xf2,0x7f,0x51,0x4b]
neg w16, w15, asr #0
neg w14, w13, asr #12
neg w12, w11, asr #31
// CHECK: neg w16, w15, asr #0 // encoding: [0xf0,0x03,0x8f,0x4b]
// CHECK: neg w14, w13, asr #12 // encoding: [0xee,0x33,0x8d,0x4b]
// CHECK: neg w12, w11, asr #31 // encoding: [0xec,0x7f,0x8b,0x4b]
neg x29, x30
neg x30, xzr
neg xzr, x0
// CHECK: neg x29, x30 // encoding: [0xfd,0x03,0x1e,0xcb]
// CHECK: neg x30, xzr // encoding: [0xfe,0x03,0x1f,0xcb]
// CHECK: neg xzr, x0 // encoding: [0xff,0x03,0x00,0xcb]
neg x28, x27, lsl #0
neg x26, x25, lsl #29
neg x24, x23, lsl #31
// CHECK: neg x28, x27 // encoding: [0xfc,0x03,0x1b,0xcb]
// CHECK: neg x26, x25, lsl #29 // encoding: [0xfa,0x77,0x19,0xcb]
// CHECK: neg x24, x23, lsl #31 // encoding: [0xf8,0x7f,0x17,0xcb]
neg x22, x21, lsr #0
neg x20, x19, lsr #1
neg x18, x17, lsr #31
// CHECK: neg x22, x21, lsr #0 // encoding: [0xf6,0x03,0x55,0xcb]
// CHECK: neg x20, x19, lsr #1 // encoding: [0xf4,0x07,0x53,0xcb]
// CHECK: neg x18, x17, lsr #31 // encoding: [0xf2,0x7f,0x51,0xcb]
neg x16, x15, asr #0
neg x14, x13, asr #12
neg x12, x11, asr #31
// CHECK: neg x16, x15, asr #0 // encoding: [0xf0,0x03,0x8f,0xcb]
// CHECK: neg x14, x13, asr #12 // encoding: [0xee,0x33,0x8d,0xcb]
// CHECK: neg x12, x11, asr #31 // encoding: [0xec,0x7f,0x8b,0xcb]
negs w29, w30
negs w30, wzr
negs wzr, w0
// CHECK: negs w29, w30 // encoding: [0xfd,0x03,0x1e,0x6b]
// CHECK: negs w30, wzr // encoding: [0xfe,0x03,0x1f,0x6b]
// CHECK: cmp wzr, w0 // encoding: [0xff,0x03,0x00,0x6b]
negs w28, w27, lsl #0
negs w26, w25, lsl #29
negs w24, w23, lsl #31
// CHECK: negs w28, w27 // encoding: [0xfc,0x03,0x1b,0x6b]
// CHECK: negs w26, w25, lsl #29 // encoding: [0xfa,0x77,0x19,0x6b]
// CHECK: negs w24, w23, lsl #31 // encoding: [0xf8,0x7f,0x17,0x6b]
negs w22, w21, lsr #0
negs w20, w19, lsr #1
negs w18, w17, lsr #31
// CHECK: negs w22, w21, lsr #0 // encoding: [0xf6,0x03,0x55,0x6b]
// CHECK: negs w20, w19, lsr #1 // encoding: [0xf4,0x07,0x53,0x6b]
// CHECK: negs w18, w17, lsr #31 // encoding: [0xf2,0x7f,0x51,0x6b]
negs w16, w15, asr #0
negs w14, w13, asr #12
negs w12, w11, asr #31
// CHECK: negs w16, w15, asr #0 // encoding: [0xf0,0x03,0x8f,0x6b]
// CHECK: negs w14, w13, asr #12 // encoding: [0xee,0x33,0x8d,0x6b]
// CHECK: negs w12, w11, asr #31 // encoding: [0xec,0x7f,0x8b,0x6b]
negs x29, x30
negs x30, xzr
negs xzr, x0
// CHECK: negs x29, x30 // encoding: [0xfd,0x03,0x1e,0xeb]
// CHECK: negs x30, xzr // encoding: [0xfe,0x03,0x1f,0xeb]
// CHECK: cmp xzr, x0 // encoding: [0xff,0x03,0x00,0xeb]
negs x28, x27, lsl #0
negs x26, x25, lsl #29
negs x24, x23, lsl #31
// CHECK: negs x28, x27 // encoding: [0xfc,0x03,0x1b,0xeb]
// CHECK: negs x26, x25, lsl #29 // encoding: [0xfa,0x77,0x19,0xeb]
// CHECK: negs x24, x23, lsl #31 // encoding: [0xf8,0x7f,0x17,0xeb]
negs x22, x21, lsr #0
negs x20, x19, lsr #1
negs x18, x17, lsr #31
// CHECK: negs x22, x21, lsr #0 // encoding: [0xf6,0x03,0x55,0xeb]
// CHECK: negs x20, x19, lsr #1 // encoding: [0xf4,0x07,0x53,0xeb]
// CHECK: negs x18, x17, lsr #31 // encoding: [0xf2,0x7f,0x51,0xeb]
negs x16, x15, asr #0
negs x14, x13, asr #12
negs x12, x11, asr #31
// CHECK: negs x16, x15, asr #0 // encoding: [0xf0,0x03,0x8f,0xeb]
// CHECK: negs x14, x13, asr #12 // encoding: [0xee,0x33,0x8d,0xeb]
// CHECK: negs x12, x11, asr #31 // encoding: [0xec,0x7f,0x8b,0xeb]
//------------------------------------------------------------------------------
// Add-sub (shifted register)
//------------------------------------------------------------------------------
adc w29, w27, w25
adc wzr, w3, w4
adc w9, wzr, w10
adc w20, w0, wzr
// CHECK: adc w29, w27, w25 // encoding: [0x7d,0x03,0x19,0x1a]
// CHECK: adc wzr, w3, w4 // encoding: [0x7f,0x00,0x04,0x1a]
// CHECK: adc w9, wzr, w10 // encoding: [0xe9,0x03,0x0a,0x1a]
// CHECK: adc w20, w0, wzr // encoding: [0x14,0x00,0x1f,0x1a]
adc x29, x27, x25
adc xzr, x3, x4
adc x9, xzr, x10
adc x20, x0, xzr
// CHECK: adc x29, x27, x25 // encoding: [0x7d,0x03,0x19,0x9a]
// CHECK: adc xzr, x3, x4 // encoding: [0x7f,0x00,0x04,0x9a]
// CHECK: adc x9, xzr, x10 // encoding: [0xe9,0x03,0x0a,0x9a]
// CHECK: adc x20, x0, xzr // encoding: [0x14,0x00,0x1f,0x9a]
adcs w29, w27, w25
adcs wzr, w3, w4
adcs w9, wzr, w10
adcs w20, w0, wzr
// CHECK: adcs w29, w27, w25 // encoding: [0x7d,0x03,0x19,0x3a]
// CHECK: adcs wzr, w3, w4 // encoding: [0x7f,0x00,0x04,0x3a]
// CHECK: adcs w9, wzr, w10 // encoding: [0xe9,0x03,0x0a,0x3a]
// CHECK: adcs w20, w0, wzr // encoding: [0x14,0x00,0x1f,0x3a]
adcs x29, x27, x25
adcs xzr, x3, x4
adcs x9, xzr, x10
adcs x20, x0, xzr
// CHECK: adcs x29, x27, x25 // encoding: [0x7d,0x03,0x19,0xba]
// CHECK: adcs xzr, x3, x4 // encoding: [0x7f,0x00,0x04,0xba]
// CHECK: adcs x9, xzr, x10 // encoding: [0xe9,0x03,0x0a,0xba]
// CHECK: adcs x20, x0, xzr // encoding: [0x14,0x00,0x1f,0xba]
sbc w29, w27, w25
sbc wzr, w3, w4
sbc w9, wzr, w10
sbc w20, w0, wzr
// CHECK: sbc w29, w27, w25 // encoding: [0x7d,0x03,0x19,0x5a]
// CHECK: sbc wzr, w3, w4 // encoding: [0x7f,0x00,0x04,0x5a]
// CHECK: ngc w9, w10 // encoding: [0xe9,0x03,0x0a,0x5a]
// CHECK: sbc w20, w0, wzr // encoding: [0x14,0x00,0x1f,0x5a]
sbc x29, x27, x25
sbc xzr, x3, x4
sbc x9, xzr, x10
sbc x20, x0, xzr
// CHECK: sbc x29, x27, x25 // encoding: [0x7d,0x03,0x19,0xda]
// CHECK: sbc xzr, x3, x4 // encoding: [0x7f,0x00,0x04,0xda]
// CHECK: ngc x9, x10 // encoding: [0xe9,0x03,0x0a,0xda]
// CHECK: sbc x20, x0, xzr // encoding: [0x14,0x00,0x1f,0xda]
sbcs w29, w27, w25
sbcs wzr, w3, w4
sbcs w9, wzr, w10
sbcs w20, w0, wzr
// CHECK: sbcs w29, w27, w25 // encoding: [0x7d,0x03,0x19,0x7a]
// CHECK: sbcs wzr, w3, w4 // encoding: [0x7f,0x00,0x04,0x7a]
// CHECK: ngcs w9, w10 // encoding: [0xe9,0x03,0x0a,0x7a]
// CHECK: sbcs w20, w0, wzr // encoding: [0x14,0x00,0x1f,0x7a]
sbcs x29, x27, x25
sbcs xzr, x3, x4
sbcs x9, xzr, x10
sbcs x20, x0, xzr
// CHECK: sbcs x29, x27, x25 // encoding: [0x7d,0x03,0x19,0xfa]
// CHECK: sbcs xzr, x3, x4 // encoding: [0x7f,0x00,0x04,0xfa]
// CHECK: ngcs x9, x10 // encoding: [0xe9,0x03,0x0a,0xfa]
// CHECK: sbcs x20, x0, xzr // encoding: [0x14,0x00,0x1f,0xfa]
ngc w3, w12
ngc wzr, w9
ngc w23, wzr
// CHECK: ngc w3, w12 // encoding: [0xe3,0x03,0x0c,0x5a]
// CHECK: ngc wzr, w9 // encoding: [0xff,0x03,0x09,0x5a]
// CHECK: ngc w23, wzr // encoding: [0xf7,0x03,0x1f,0x5a]
ngc x29, x30
ngc xzr, x0
ngc x0, xzr
// CHECK: ngc x29, x30 // encoding: [0xfd,0x03,0x1e,0xda]
// CHECK: ngc xzr, x0 // encoding: [0xff,0x03,0x00,0xda]
// CHECK: ngc x0, xzr // encoding: [0xe0,0x03,0x1f,0xda]
ngcs w3, w12
ngcs wzr, w9
ngcs w23, wzr
// CHECK: ngcs w3, w12 // encoding: [0xe3,0x03,0x0c,0x7a]
// CHECK: ngcs wzr, w9 // encoding: [0xff,0x03,0x09,0x7a]
// CHECK: ngcs w23, wzr // encoding: [0xf7,0x03,0x1f,0x7a]
ngcs x29, x30
ngcs xzr, x0
ngcs x0, xzr
// CHECK: ngcs x29, x30 // encoding: [0xfd,0x03,0x1e,0xfa]
// CHECK: ngcs xzr, x0 // encoding: [0xff,0x03,0x00,0xfa]
// CHECK: ngcs x0, xzr // encoding: [0xe0,0x03,0x1f,0xfa]
//------------------------------------------------------------------------------
// Bitfield
//------------------------------------------------------------------------------
sbfm x1, x2, #3, #4
sbfm x3, x4, #63, #63
sbfm wzr, wzr, #31, #31
sbfm w12, w9, #0, #0
// CHECK: sbfx x1, x2, #3, #2 // encoding: [0x41,0x10,0x43,0x93]
// CHECK: asr x3, x4, #63 // encoding: [0x83,0xfc,0x7f,0x93]
// CHECK: asr wzr, wzr, #31 // encoding: [0xff,0x7f,0x1f,0x13]
// CHECK: sbfx w12, w9, #0, #1 // encoding: [0x2c,0x01,0x00,0x13]
ubfm x4, x5, #12, #10
ubfm xzr, x4, #0, #0
ubfm x4, xzr, #63, #5
ubfm x5, x6, #12, #63
// CHECK: ubfiz x4, x5, #52, #11 // encoding: [0xa4,0x28,0x4c,0xd3]
// CHECK: ubfx xzr, x4, #0, #1 // encoding: [0x9f,0x00,0x40,0xd3]
// CHECK: ubfiz x4, xzr, #1, #6 // encoding: [0xe4,0x17,0x7f,0xd3]
// CHECK: lsr x5, x6, #12 // encoding: [0xc5,0xfc,0x4c,0xd3]
bfm x4, x5, #12, #10
bfm xzr, x4, #0, #0
bfm x4, xzr, #63, #5
bfm x5, x6, #12, #63
// CHECK: bfi x4, x5, #52, #11 // encoding: [0xa4,0x28,0x4c,0xb3]
// CHECK: bfxil xzr, x4, #0, #1 // encoding: [0x9f,0x00,0x40,0xb3]
// CHECK: bfi x4, xzr, #1, #6 // encoding: [0xe4,0x17,0x7f,0xb3]
// CHECK: bfxil x5, x6, #12, #52 // encoding: [0xc5,0xfc,0x4c,0xb3]
sxtb w1, w2
sxtb xzr, w3
sxth w9, w10
sxth x0, w1
sxtw x3, w30
// CHECK: sxtb w1, w2 // encoding: [0x41,0x1c,0x00,0x13]
// CHECK: sxtb xzr, w3 // encoding: [0x7f,0x1c,0x40,0x93]
// CHECK: sxth w9, w10 // encoding: [0x49,0x3d,0x00,0x13]
// CHECK: sxth x0, w1 // encoding: [0x20,0x3c,0x40,0x93]
// CHECK: sxtw x3, w30 // encoding: [0xc3,0x7f,0x40,0x93]
uxtb w1, w2
uxtb xzr, w3
uxth w9, w10
uxth x0, w1
// CHECK: uxtb w1, w2 // encoding: [0x41,0x1c,0x00,0x53]
// CHECK: uxtb {{[wx]}}zr, w3 // encoding: [0x7f,0x1c,0x00,0x53]