24 changes: 12 additions & 12 deletions llvm/test/MC/AArch64/SME/bfmopa.s
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,71 +16,71 @@ bfmopa za0.s, p0/m, p0/m, z0.h, z0.h
// CHECK-INST: bfmopa za0.s, p0/m, p0/m, z0.h, z0.h
// CHECK-ENCODING: [0x00,0x00,0x80,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 00 80 81 <unknown>
// CHECK-UNKNOWN: 81800000 <unknown>

bfmopa za1.s, p5/m, p2/m, z10.h, z21.h
// CHECK-INST: bfmopa za1.s, p5/m, p2/m, z10.h, z21.h
// CHECK-ENCODING: [0x41,0x55,0x95,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 41 55 95 81 <unknown>
// CHECK-UNKNOWN: 81955541 <unknown>

bfmopa za3.s, p3/m, p7/m, z13.h, z8.h
// CHECK-INST: bfmopa za3.s, p3/m, p7/m, z13.h, z8.h
// CHECK-ENCODING: [0xa3,0xed,0x88,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a3 ed 88 81 <unknown>
// CHECK-UNKNOWN: 8188eda3 <unknown>

bfmopa za3.s, p7/m, p7/m, z31.h, z31.h
// CHECK-INST: bfmopa za3.s, p7/m, p7/m, z31.h, z31.h
// CHECK-ENCODING: [0xe3,0xff,0x9f,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: e3 ff 9f 81 <unknown>
// CHECK-UNKNOWN: 819fffe3 <unknown>

bfmopa za1.s, p3/m, p0/m, z17.h, z16.h
// CHECK-INST: bfmopa za1.s, p3/m, p0/m, z17.h, z16.h
// CHECK-ENCODING: [0x21,0x0e,0x90,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 0e 90 81 <unknown>
// CHECK-UNKNOWN: 81900e21 <unknown>

bfmopa za1.s, p1/m, p4/m, z1.h, z30.h
// CHECK-INST: bfmopa za1.s, p1/m, p4/m, z1.h, z30.h
// CHECK-ENCODING: [0x21,0x84,0x9e,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 84 9e 81 <unknown>
// CHECK-UNKNOWN: 819e8421 <unknown>

bfmopa za0.s, p5/m, p2/m, z19.h, z20.h
// CHECK-INST: bfmopa za0.s, p5/m, p2/m, z19.h, z20.h
// CHECK-ENCODING: [0x60,0x56,0x94,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 60 56 94 81 <unknown>
// CHECK-UNKNOWN: 81945660 <unknown>

bfmopa za0.s, p6/m, p0/m, z12.h, z2.h
// CHECK-INST: bfmopa za0.s, p6/m, p0/m, z12.h, z2.h
// CHECK-ENCODING: [0x80,0x19,0x82,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 19 82 81 <unknown>
// CHECK-UNKNOWN: 81821980 <unknown>

bfmopa za1.s, p2/m, p6/m, z1.h, z26.h
// CHECK-INST: bfmopa za1.s, p2/m, p6/m, z1.h, z26.h
// CHECK-ENCODING: [0x21,0xc8,0x9a,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 c8 9a 81 <unknown>
// CHECK-UNKNOWN: 819ac821 <unknown>

bfmopa za1.s, p2/m, p0/m, z22.h, z30.h
// CHECK-INST: bfmopa za1.s, p2/m, p0/m, z22.h, z30.h
// CHECK-ENCODING: [0xc1,0x0a,0x9e,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: c1 0a 9e 81 <unknown>
// CHECK-UNKNOWN: 819e0ac1 <unknown>

bfmopa za2.s, p5/m, p7/m, z9.h, z1.h
// CHECK-INST: bfmopa za2.s, p5/m, p7/m, z9.h, z1.h
// CHECK-ENCODING: [0x22,0xf5,0x81,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 f5 81 81 <unknown>
// CHECK-UNKNOWN: 8181f522 <unknown>

bfmopa za3.s, p2/m, p5/m, z12.h, z11.h
// CHECK-INST: bfmopa za3.s, p2/m, p5/m, z12.h, z11.h
// CHECK-ENCODING: [0x83,0xa9,0x8b,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 83 a9 8b 81 <unknown>
// CHECK-UNKNOWN: 818ba983 <unknown>

24 changes: 12 additions & 12 deletions llvm/test/MC/AArch64/SME/bfmops.s
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,71 +16,71 @@ bfmops za0.s, p0/m, p0/m, z0.h, z0.h
// CHECK-INST: bfmops za0.s, p0/m, p0/m, z0.h, z0.h
// CHECK-ENCODING: [0x10,0x00,0x80,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 10 00 80 81 <unknown>
// CHECK-UNKNOWN: 81800010 <unknown>

bfmops za1.s, p5/m, p2/m, z10.h, z21.h
// CHECK-INST: bfmops za1.s, p5/m, p2/m, z10.h, z21.h
// CHECK-ENCODING: [0x51,0x55,0x95,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 51 55 95 81 <unknown>
// CHECK-UNKNOWN: 81955551 <unknown>

bfmops za3.s, p3/m, p7/m, z13.h, z8.h
// CHECK-INST: bfmops za3.s, p3/m, p7/m, z13.h, z8.h
// CHECK-ENCODING: [0xb3,0xed,0x88,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: b3 ed 88 81 <unknown>
// CHECK-UNKNOWN: 8188edb3 <unknown>

bfmops za3.s, p7/m, p7/m, z31.h, z31.h
// CHECK-INST: bfmops za3.s, p7/m, p7/m, z31.h, z31.h
// CHECK-ENCODING: [0xf3,0xff,0x9f,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: f3 ff 9f 81 <unknown>
// CHECK-UNKNOWN: 819ffff3 <unknown>

bfmops za1.s, p3/m, p0/m, z17.h, z16.h
// CHECK-INST: bfmops za1.s, p3/m, p0/m, z17.h, z16.h
// CHECK-ENCODING: [0x31,0x0e,0x90,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 31 0e 90 81 <unknown>
// CHECK-UNKNOWN: 81900e31 <unknown>

bfmops za1.s, p1/m, p4/m, z1.h, z30.h
// CHECK-INST: bfmops za1.s, p1/m, p4/m, z1.h, z30.h
// CHECK-ENCODING: [0x31,0x84,0x9e,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 31 84 9e 81 <unknown>
// CHECK-UNKNOWN: 819e8431 <unknown>

bfmops za0.s, p5/m, p2/m, z19.h, z20.h
// CHECK-INST: bfmops za0.s, p5/m, p2/m, z19.h, z20.h
// CHECK-ENCODING: [0x70,0x56,0x94,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 70 56 94 81 <unknown>
// CHECK-UNKNOWN: 81945670 <unknown>

bfmops za0.s, p6/m, p0/m, z12.h, z2.h
// CHECK-INST: bfmops za0.s, p6/m, p0/m, z12.h, z2.h
// CHECK-ENCODING: [0x90,0x19,0x82,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 90 19 82 81 <unknown>
// CHECK-UNKNOWN: 81821990 <unknown>

bfmops za1.s, p2/m, p6/m, z1.h, z26.h
// CHECK-INST: bfmops za1.s, p2/m, p6/m, z1.h, z26.h
// CHECK-ENCODING: [0x31,0xc8,0x9a,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 31 c8 9a 81 <unknown>
// CHECK-UNKNOWN: 819ac831 <unknown>

bfmops za1.s, p2/m, p0/m, z22.h, z30.h
// CHECK-INST: bfmops za1.s, p2/m, p0/m, z22.h, z30.h
// CHECK-ENCODING: [0xd1,0x0a,0x9e,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: d1 0a 9e 81 <unknown>
// CHECK-UNKNOWN: 819e0ad1 <unknown>

bfmops za2.s, p5/m, p7/m, z9.h, z1.h
// CHECK-INST: bfmops za2.s, p5/m, p7/m, z9.h, z1.h
// CHECK-ENCODING: [0x32,0xf5,0x81,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 32 f5 81 81 <unknown>
// CHECK-UNKNOWN: 8181f532 <unknown>

bfmops za3.s, p2/m, p5/m, z12.h, z11.h
// CHECK-INST: bfmops za3.s, p2/m, p5/m, z12.h, z11.h
// CHECK-ENCODING: [0x93,0xa9,0x8b,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 93 a9 8b 81 <unknown>
// CHECK-UNKNOWN: 818ba993 <unknown>

24 changes: 12 additions & 12 deletions llvm/test/MC/AArch64/SME/fmopa-fp64.s
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,70 +19,70 @@ fmopa za0.d, p0/m, p0/m, z0.d, z0.d
// CHECK-INST: fmopa za0.d, p0/m, p0/m, z0.d, z0.d
// CHECK-ENCODING: [0x00,0x00,0xc0,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: 00 00 c0 80 <unknown>
// CHECK-UNKNOWN: 80c00000 <unknown>

fmopa za5.d, p5/m, p2/m, z10.d, z21.d
// CHECK-INST: fmopa za5.d, p5/m, p2/m, z10.d, z21.d
// CHECK-ENCODING: [0x45,0x55,0xd5,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: 45 55 d5 80 <unknown>
// CHECK-UNKNOWN: 80d55545 <unknown>

fmopa za7.d, p3/m, p7/m, z13.d, z8.d
// CHECK-INST: fmopa za7.d, p3/m, p7/m, z13.d, z8.d
// CHECK-ENCODING: [0xa7,0xed,0xc8,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: a7 ed c8 80 <unknown>
// CHECK-UNKNOWN: 80c8eda7 <unknown>

fmopa za7.d, p7/m, p7/m, z31.d, z31.d
// CHECK-INST: fmopa za7.d, p7/m, p7/m, z31.d, z31.d
// CHECK-ENCODING: [0xe7,0xff,0xdf,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: e7 ff df 80 <unknown>
// CHECK-UNKNOWN: 80dfffe7 <unknown>

fmopa za5.d, p3/m, p0/m, z17.d, z16.d
// CHECK-INST: fmopa za5.d, p3/m, p0/m, z17.d, z16.d
// CHECK-ENCODING: [0x25,0x0e,0xd0,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: 25 0e d0 80 <unknown>
// CHECK-UNKNOWN: 80d00e25 <unknown>

fmopa za1.d, p1/m, p4/m, z1.d, z30.d
// CHECK-INST: fmopa za1.d, p1/m, p4/m, z1.d, z30.d
// CHECK-ENCODING: [0x21,0x84,0xde,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: 21 84 de 80 <unknown>
// CHECK-UNKNOWN: 80de8421 <unknown>

fmopa za0.d, p5/m, p2/m, z19.d, z20.d
// CHECK-INST: fmopa za0.d, p5/m, p2/m, z19.d, z20.d
// CHECK-ENCODING: [0x60,0x56,0xd4,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: 60 56 d4 80 <unknown>
// CHECK-UNKNOWN: 80d45660 <unknown>

fmopa za0.d, p6/m, p0/m, z12.d, z2.d
// CHECK-INST: fmopa za0.d, p6/m, p0/m, z12.d, z2.d
// CHECK-ENCODING: [0x80,0x19,0xc2,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: 80 19 c2 80 <unknown>
// CHECK-UNKNOWN: 80c21980 <unknown>

fmopa za1.d, p2/m, p6/m, z1.d, z26.d
// CHECK-INST: fmopa za1.d, p2/m, p6/m, z1.d, z26.d
// CHECK-ENCODING: [0x21,0xc8,0xda,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: 21 c8 da 80 <unknown>
// CHECK-UNKNOWN: 80dac821 <unknown>

fmopa za5.d, p2/m, p0/m, z22.d, z30.d
// CHECK-INST: fmopa za5.d, p2/m, p0/m, z22.d, z30.d
// CHECK-ENCODING: [0xc5,0x0a,0xde,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: c5 0a de 80 <unknown>
// CHECK-UNKNOWN: 80de0ac5 <unknown>

fmopa za2.d, p5/m, p7/m, z9.d, z1.d
// CHECK-INST: fmopa za2.d, p5/m, p7/m, z9.d, z1.d
// CHECK-ENCODING: [0x22,0xf5,0xc1,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: 22 f5 c1 80 <unknown>
// CHECK-UNKNOWN: 80c1f522 <unknown>

fmopa za7.d, p2/m, p5/m, z12.d, z11.d
// CHECK-INST: fmopa za7.d, p2/m, p5/m, z12.d, z11.d
// CHECK-ENCODING: [0x87,0xa9,0xcb,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: 87 a9 cb 80 <unknown>
// CHECK-UNKNOWN: 80cba987 <unknown>
48 changes: 24 additions & 24 deletions llvm/test/MC/AArch64/SME/fmopa.s
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,73 +19,73 @@ fmopa za0.s, p0/m, p0/m, z0.h, z0.h
// CHECK-INST: fmopa za0.s, p0/m, p0/m, z0.h, z0.h
// CHECK-ENCODING: [0x00,0x00,0xa0,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 00 a0 81 <unknown>
// CHECK-UNKNOWN: 81a00000 <unknown>

fmopa za1.s, p5/m, p2/m, z10.h, z21.h
// CHECK-INST: fmopa za1.s, p5/m, p2/m, z10.h, z21.h
// CHECK-ENCODING: [0x41,0x55,0xb5,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 41 55 b5 81 <unknown>
// CHECK-UNKNOWN: 81b55541 <unknown>

fmopa za3.s, p3/m, p7/m, z13.h, z8.h
// CHECK-INST: fmopa za3.s, p3/m, p7/m, z13.h, z8.h
// CHECK-ENCODING: [0xa3,0xed,0xa8,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a3 ed a8 81 <unknown>
// CHECK-UNKNOWN: 81a8eda3 <unknown>

fmopa za3.s, p7/m, p7/m, z31.h, z31.h
// CHECK-INST: fmopa za3.s, p7/m, p7/m, z31.h, z31.h
// CHECK-ENCODING: [0xe3,0xff,0xbf,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: e3 ff bf 81 <unknown>
// CHECK-UNKNOWN: 81bfffe3 <unknown>

fmopa za1.s, p3/m, p0/m, z17.h, z16.h
// CHECK-INST: fmopa za1.s, p3/m, p0/m, z17.h, z16.h
// CHECK-ENCODING: [0x21,0x0e,0xb0,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 0e b0 81 <unknown>
// CHECK-UNKNOWN: 81b00e21 <unknown>

fmopa za1.s, p1/m, p4/m, z1.h, z30.h
// CHECK-INST: fmopa za1.s, p1/m, p4/m, z1.h, z30.h
// CHECK-ENCODING: [0x21,0x84,0xbe,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 84 be 81 <unknown>
// CHECK-UNKNOWN: 81be8421 <unknown>

fmopa za0.s, p5/m, p2/m, z19.h, z20.h
// CHECK-INST: fmopa za0.s, p5/m, p2/m, z19.h, z20.h
// CHECK-ENCODING: [0x60,0x56,0xb4,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 60 56 b4 81 <unknown>
// CHECK-UNKNOWN: 81b45660 <unknown>

fmopa za0.s, p6/m, p0/m, z12.h, z2.h
// CHECK-INST: fmopa za0.s, p6/m, p0/m, z12.h, z2.h
// CHECK-ENCODING: [0x80,0x19,0xa2,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 19 a2 81 <unknown>
// CHECK-UNKNOWN: 81a21980 <unknown>

fmopa za1.s, p2/m, p6/m, z1.h, z26.h
// CHECK-INST: fmopa za1.s, p2/m, p6/m, z1.h, z26.h
// CHECK-ENCODING: [0x21,0xc8,0xba,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 c8 ba 81 <unknown>
// CHECK-UNKNOWN: 81bac821 <unknown>

fmopa za1.s, p2/m, p0/m, z22.h, z30.h
// CHECK-INST: fmopa za1.s, p2/m, p0/m, z22.h, z30.h
// CHECK-ENCODING: [0xc1,0x0a,0xbe,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: c1 0a be 81 <unknown>
// CHECK-UNKNOWN: 81be0ac1 <unknown>

fmopa za2.s, p5/m, p7/m, z9.h, z1.h
// CHECK-INST: fmopa za2.s, p5/m, p7/m, z9.h, z1.h
// CHECK-ENCODING: [0x22,0xf5,0xa1,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 f5 a1 81 <unknown>
// CHECK-UNKNOWN: 81a1f522 <unknown>

fmopa za3.s, p2/m, p5/m, z12.h, z11.h
// CHECK-INST: fmopa za3.s, p2/m, p5/m, z12.h, z11.h
// CHECK-ENCODING: [0x83,0xa9,0xab,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 83 a9 ab 81 <unknown>
// CHECK-UNKNOWN: 81aba983 <unknown>

// --------------------------------------------------------------------------//
// Non-widening (single-precision)
Expand All @@ -94,70 +94,70 @@ fmopa za0.s, p0/m, p0/m, z0.s, z0.s
// CHECK-INST: fmopa za0.s, p0/m, p0/m, z0.s, z0.s
// CHECK-ENCODING: [0x00,0x00,0x80,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 00 80 80 <unknown>
// CHECK-UNKNOWN: 80800000 <unknown>

fmopa za1.s, p5/m, p2/m, z10.s, z21.s
// CHECK-INST: fmopa za1.s, p5/m, p2/m, z10.s, z21.s
// CHECK-ENCODING: [0x41,0x55,0x95,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 41 55 95 80 <unknown>
// CHECK-UNKNOWN: 80955541 <unknown>

fmopa za3.s, p3/m, p7/m, z13.s, z8.s
// CHECK-INST: fmopa za3.s, p3/m, p7/m, z13.s, z8.s
// CHECK-ENCODING: [0xa3,0xed,0x88,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a3 ed 88 80 <unknown>
// CHECK-UNKNOWN: 8088eda3 <unknown>

fmopa za3.s, p7/m, p7/m, z31.s, z31.s
// CHECK-INST: fmopa za3.s, p7/m, p7/m, z31.s, z31.s
// CHECK-ENCODING: [0xe3,0xff,0x9f,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: e3 ff 9f 80 <unknown>
// CHECK-UNKNOWN: 809fffe3 <unknown>

fmopa za1.s, p3/m, p0/m, z17.s, z16.s
// CHECK-INST: fmopa za1.s, p3/m, p0/m, z17.s, z16.s
// CHECK-ENCODING: [0x21,0x0e,0x90,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 0e 90 80 <unknown>
// CHECK-UNKNOWN: 80900e21 <unknown>

fmopa za1.s, p1/m, p4/m, z1.s, z30.s
// CHECK-INST: fmopa za1.s, p1/m, p4/m, z1.s, z30.s
// CHECK-ENCODING: [0x21,0x84,0x9e,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 84 9e 80 <unknown>
// CHECK-UNKNOWN: 809e8421 <unknown>

fmopa za0.s, p5/m, p2/m, z19.s, z20.s
// CHECK-INST: fmopa za0.s, p5/m, p2/m, z19.s, z20.s
// CHECK-ENCODING: [0x60,0x56,0x94,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 60 56 94 80 <unknown>
// CHECK-UNKNOWN: 80945660 <unknown>

fmopa za0.s, p6/m, p0/m, z12.s, z2.s
// CHECK-INST: fmopa za0.s, p6/m, p0/m, z12.s, z2.s
// CHECK-ENCODING: [0x80,0x19,0x82,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 19 82 80 <unknown>
// CHECK-UNKNOWN: 80821980 <unknown>

fmopa za1.s, p2/m, p6/m, z1.s, z26.s
// CHECK-INST: fmopa za1.s, p2/m, p6/m, z1.s, z26.s
// CHECK-ENCODING: [0x21,0xc8,0x9a,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 c8 9a 80 <unknown>
// CHECK-UNKNOWN: 809ac821 <unknown>

fmopa za1.s, p2/m, p0/m, z22.s, z30.s
// CHECK-INST: fmopa za1.s, p2/m, p0/m, z22.s, z30.s
// CHECK-ENCODING: [0xc1,0x0a,0x9e,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: c1 0a 9e 80 <unknown>
// CHECK-UNKNOWN: 809e0ac1 <unknown>

fmopa za2.s, p5/m, p7/m, z9.s, z1.s
// CHECK-INST: fmopa za2.s, p5/m, p7/m, z9.s, z1.s
// CHECK-ENCODING: [0x22,0xf5,0x81,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 f5 81 80 <unknown>
// CHECK-UNKNOWN: 8081f522 <unknown>

fmopa za3.s, p2/m, p5/m, z12.s, z11.s
// CHECK-INST: fmopa za3.s, p2/m, p5/m, z12.s, z11.s
// CHECK-ENCODING: [0x83,0xa9,0x8b,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 83 a9 8b 80 <unknown>
// CHECK-UNKNOWN: 808ba983 <unknown>
24 changes: 12 additions & 12 deletions llvm/test/MC/AArch64/SME/fmops-fp64.s
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,70 +19,70 @@ fmops za0.d, p0/m, p0/m, z0.d, z0.d
// CHECK-INST: fmops za0.d, p0/m, p0/m, z0.d, z0.d
// CHECK-ENCODING: [0x10,0x00,0xc0,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: 10 00 c0 80 <unknown>
// CHECK-UNKNOWN: 80c00010 <unknown>

fmops za5.d, p5/m, p2/m, z10.d, z21.d
// CHECK-INST: fmops za5.d, p5/m, p2/m, z10.d, z21.d
// CHECK-ENCODING: [0x55,0x55,0xd5,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: 55 55 d5 80 <unknown>
// CHECK-UNKNOWN: 80d55555 <unknown>

fmops za7.d, p3/m, p7/m, z13.d, z8.d
// CHECK-INST: fmops za7.d, p3/m, p7/m, z13.d, z8.d
// CHECK-ENCODING: [0xb7,0xed,0xc8,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: b7 ed c8 80 <unknown>
// CHECK-UNKNOWN: 80c8edb7 <unknown>

fmops za7.d, p7/m, p7/m, z31.d, z31.d
// CHECK-INST: fmops za7.d, p7/m, p7/m, z31.d, z31.d
// CHECK-ENCODING: [0xf7,0xff,0xdf,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: f7 ff df 80 <unknown>
// CHECK-UNKNOWN: 80dffff7 <unknown>

fmops za5.d, p3/m, p0/m, z17.d, z16.d
// CHECK-INST: fmops za5.d, p3/m, p0/m, z17.d, z16.d
// CHECK-ENCODING: [0x35,0x0e,0xd0,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: 35 0e d0 80 <unknown>
// CHECK-UNKNOWN: 80d00e35 <unknown>

fmops za1.d, p1/m, p4/m, z1.d, z30.d
// CHECK-INST: fmops za1.d, p1/m, p4/m, z1.d, z30.d
// CHECK-ENCODING: [0x31,0x84,0xde,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: 31 84 de 80 <unknown>
// CHECK-UNKNOWN: 80de8431 <unknown>

fmops za0.d, p5/m, p2/m, z19.d, z20.d
// CHECK-INST: fmops za0.d, p5/m, p2/m, z19.d, z20.d
// CHECK-ENCODING: [0x70,0x56,0xd4,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: 70 56 d4 80 <unknown>
// CHECK-UNKNOWN: 80d45670 <unknown>

fmops za0.d, p6/m, p0/m, z12.d, z2.d
// CHECK-INST: fmops za0.d, p6/m, p0/m, z12.d, z2.d
// CHECK-ENCODING: [0x90,0x19,0xc2,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: 90 19 c2 80 <unknown>
// CHECK-UNKNOWN: 80c21990 <unknown>

fmops za1.d, p2/m, p6/m, z1.d, z26.d
// CHECK-INST: fmops za1.d, p2/m, p6/m, z1.d, z26.d
// CHECK-ENCODING: [0x31,0xc8,0xda,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: 31 c8 da 80 <unknown>
// CHECK-UNKNOWN: 80dac831 <unknown>

fmops za5.d, p2/m, p0/m, z22.d, z30.d
// CHECK-INST: fmops za5.d, p2/m, p0/m, z22.d, z30.d
// CHECK-ENCODING: [0xd5,0x0a,0xde,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: d5 0a de 80 <unknown>
// CHECK-UNKNOWN: 80de0ad5 <unknown>

fmops za2.d, p5/m, p7/m, z9.d, z1.d
// CHECK-INST: fmops za2.d, p5/m, p7/m, z9.d, z1.d
// CHECK-ENCODING: [0x32,0xf5,0xc1,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: 32 f5 c1 80 <unknown>
// CHECK-UNKNOWN: 80c1f532 <unknown>

fmops za7.d, p2/m, p5/m, z12.d, z11.d
// CHECK-INST: fmops za7.d, p2/m, p5/m, z12.d, z11.d
// CHECK-ENCODING: [0x97,0xa9,0xcb,0x80]
// CHECK-ERROR: instruction requires: sme-f64
// CHECK-UNKNOWN: 97 a9 cb 80 <unknown>
// CHECK-UNKNOWN: 80cba997 <unknown>
48 changes: 24 additions & 24 deletions llvm/test/MC/AArch64/SME/fmops.s
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,73 +19,73 @@ fmops za0.s, p0/m, p0/m, z0.h, z0.h
// CHECK-INST: fmops za0.s, p0/m, p0/m, z0.h, z0.h
// CHECK-ENCODING: [0x10,0x00,0xa0,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 10 00 a0 81 <unknown>
// CHECK-UNKNOWN: 81a00010 <unknown>

fmops za1.s, p5/m, p2/m, z10.h, z21.h
// CHECK-INST: fmops za1.s, p5/m, p2/m, z10.h, z21.h
// CHECK-ENCODING: [0x51,0x55,0xb5,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 51 55 b5 81 <unknown>
// CHECK-UNKNOWN: 81b55551 <unknown>

fmops za3.s, p3/m, p7/m, z13.h, z8.h
// CHECK-INST: fmops za3.s, p3/m, p7/m, z13.h, z8.h
// CHECK-ENCODING: [0xb3,0xed,0xa8,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: b3 ed a8 81 <unknown>
// CHECK-UNKNOWN: 81a8edb3 <unknown>

fmops za3.s, p7/m, p7/m, z31.h, z31.h
// CHECK-INST: fmops za3.s, p7/m, p7/m, z31.h, z31.h
// CHECK-ENCODING: [0xf3,0xff,0xbf,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: f3 ff bf 81 <unknown>
// CHECK-UNKNOWN: 81bffff3 <unknown>

fmops za1.s, p3/m, p0/m, z17.h, z16.h
// CHECK-INST: fmops za1.s, p3/m, p0/m, z17.h, z16.h
// CHECK-ENCODING: [0x31,0x0e,0xb0,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 31 0e b0 81 <unknown>
// CHECK-UNKNOWN: 81b00e31 <unknown>

fmops za1.s, p1/m, p4/m, z1.h, z30.h
// CHECK-INST: fmops za1.s, p1/m, p4/m, z1.h, z30.h
// CHECK-ENCODING: [0x31,0x84,0xbe,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 31 84 be 81 <unknown>
// CHECK-UNKNOWN: 81be8431 <unknown>

fmops za0.s, p5/m, p2/m, z19.h, z20.h
// CHECK-INST: fmops za0.s, p5/m, p2/m, z19.h, z20.h
// CHECK-ENCODING: [0x70,0x56,0xb4,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 70 56 b4 81 <unknown>
// CHECK-UNKNOWN: 81b45670 <unknown>

fmops za0.s, p6/m, p0/m, z12.h, z2.h
// CHECK-INST: fmops za0.s, p6/m, p0/m, z12.h, z2.h
// CHECK-ENCODING: [0x90,0x19,0xa2,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 90 19 a2 81 <unknown>
// CHECK-UNKNOWN: 81a21990 <unknown>

fmops za1.s, p2/m, p6/m, z1.h, z26.h
// CHECK-INST: fmops za1.s, p2/m, p6/m, z1.h, z26.h
// CHECK-ENCODING: [0x31,0xc8,0xba,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 31 c8 ba 81 <unknown>
// CHECK-UNKNOWN: 81bac831 <unknown>

fmops za1.s, p2/m, p0/m, z22.h, z30.h
// CHECK-INST: fmops za1.s, p2/m, p0/m, z22.h, z30.h
// CHECK-ENCODING: [0xd1,0x0a,0xbe,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: d1 0a be 81 <unknown>
// CHECK-UNKNOWN: 81be0ad1 <unknown>

fmops za2.s, p5/m, p7/m, z9.h, z1.h
// CHECK-INST: fmops za2.s, p5/m, p7/m, z9.h, z1.h
// CHECK-ENCODING: [0x32,0xf5,0xa1,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 32 f5 a1 81 <unknown>
// CHECK-UNKNOWN: 81a1f532 <unknown>

fmops za3.s, p2/m, p5/m, z12.h, z11.h
// CHECK-INST: fmops za3.s, p2/m, p5/m, z12.h, z11.h
// CHECK-ENCODING: [0x93,0xa9,0xab,0x81]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 93 a9 ab 81 <unknown>
// CHECK-UNKNOWN: 81aba993 <unknown>

// --------------------------------------------------------------------------//
// Non-widening (single-precision)
Expand All @@ -94,70 +94,70 @@ fmops za0.s, p0/m, p0/m, z0.s, z0.s
// CHECK-INST: fmops za0.s, p0/m, p0/m, z0.s, z0.s
// CHECK-ENCODING: [0x10,0x00,0x80,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 10 00 80 80 <unknown>
// CHECK-UNKNOWN: 80800010 <unknown>

fmops za1.s, p5/m, p2/m, z10.s, z21.s
// CHECK-INST: fmops za1.s, p5/m, p2/m, z10.s, z21.s
// CHECK-ENCODING: [0x51,0x55,0x95,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 51 55 95 80 <unknown>
// CHECK-UNKNOWN: 80955551 <unknown>

fmops za3.s, p3/m, p7/m, z13.s, z8.s
// CHECK-INST: fmops za3.s, p3/m, p7/m, z13.s, z8.s
// CHECK-ENCODING: [0xb3,0xed,0x88,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: b3 ed 88 80 <unknown>
// CHECK-UNKNOWN: 8088edb3 <unknown>

fmops za3.s, p7/m, p7/m, z31.s, z31.s
// CHECK-INST: fmops za3.s, p7/m, p7/m, z31.s, z31.s
// CHECK-ENCODING: [0xf3,0xff,0x9f,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: f3 ff 9f 80 <unknown>
// CHECK-UNKNOWN: 809ffff3 <unknown>

fmops za1.s, p3/m, p0/m, z17.s, z16.s
// CHECK-INST: fmops za1.s, p3/m, p0/m, z17.s, z16.s
// CHECK-ENCODING: [0x31,0x0e,0x90,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 31 0e 90 80 <unknown>
// CHECK-UNKNOWN: 80900e31 <unknown>

fmops za1.s, p1/m, p4/m, z1.s, z30.s
// CHECK-INST: fmops za1.s, p1/m, p4/m, z1.s, z30.s
// CHECK-ENCODING: [0x31,0x84,0x9e,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 31 84 9e 80 <unknown>
// CHECK-UNKNOWN: 809e8431 <unknown>

fmops za0.s, p5/m, p2/m, z19.s, z20.s
// CHECK-INST: fmops za0.s, p5/m, p2/m, z19.s, z20.s
// CHECK-ENCODING: [0x70,0x56,0x94,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 70 56 94 80 <unknown>
// CHECK-UNKNOWN: 80945670 <unknown>

fmops za0.s, p6/m, p0/m, z12.s, z2.s
// CHECK-INST: fmops za0.s, p6/m, p0/m, z12.s, z2.s
// CHECK-ENCODING: [0x90,0x19,0x82,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 90 19 82 80 <unknown>
// CHECK-UNKNOWN: 80821990 <unknown>

fmops za1.s, p2/m, p6/m, z1.s, z26.s
// CHECK-INST: fmops za1.s, p2/m, p6/m, z1.s, z26.s
// CHECK-ENCODING: [0x31,0xc8,0x9a,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 31 c8 9a 80 <unknown>
// CHECK-UNKNOWN: 809ac831 <unknown>

fmops za1.s, p2/m, p0/m, z22.s, z30.s
// CHECK-INST: fmops za1.s, p2/m, p0/m, z22.s, z30.s
// CHECK-ENCODING: [0xd1,0x0a,0x9e,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: d1 0a 9e 80 <unknown>
// CHECK-UNKNOWN: 809e0ad1 <unknown>

fmops za2.s, p5/m, p7/m, z9.s, z1.s
// CHECK-INST: fmops za2.s, p5/m, p7/m, z9.s, z1.s
// CHECK-ENCODING: [0x32,0xf5,0x81,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 32 f5 81 80 <unknown>
// CHECK-UNKNOWN: 8081f532 <unknown>

fmops za3.s, p2/m, p5/m, z12.s, z11.s
// CHECK-INST: fmops za3.s, p2/m, p5/m, z12.s, z11.s
// CHECK-ENCODING: [0x93,0xa9,0x8b,0x80]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 93 a9 8b 80 <unknown>
// CHECK-UNKNOWN: 808ba993 <unknown>
96 changes: 48 additions & 48 deletions llvm/test/MC/AArch64/SME/ld1b.s
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,145 +19,145 @@ ld1b {za0h.b[w12, 0]}, p0/z, [x0, x0]
// CHECK-INST: ld1b {za0h.b[w12, 0]}, p0/z, [x0, x0]
// CHECK-ENCODING: [0x00,0x00,0x00,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 00 00 e0 <unknown>
// CHECK-UNKNOWN: e0000000 <unknown>

ld1b {za0h.b[w14, 5]}, p5/z, [x10, x21]
// CHECK-INST: ld1b {za0h.b[w14, 5]}, p5/z, [x10, x21]
// CHECK-ENCODING: [0x45,0x55,0x15,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 45 55 15 e0 <unknown>
// CHECK-UNKNOWN: e0155545 <unknown>

ld1b {za0h.b[w15, 7]}, p3/z, [x13, x8]
// CHECK-INST: ld1b {za0h.b[w15, 7]}, p3/z, [x13, x8]
// CHECK-ENCODING: [0xa7,0x6d,0x08,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a7 6d 08 e0 <unknown>
// CHECK-UNKNOWN: e0086da7 <unknown>

ld1b {za0h.b[w15, 15]}, p7/z, [sp]
// CHECK-INST: ld1b {za0h.b[w15, 15]}, p7/z, [sp]
// CHECK-ENCODING: [0xef,0x7f,0x1f,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: ef 7f 1f e0 <unknown>
// CHECK-UNKNOWN: e01f7fef <unknown>

ld1b {za0h.b[w12, 5]}, p3/z, [x17, x16]
// CHECK-INST: ld1b {za0h.b[w12, 5]}, p3/z, [x17, x16]
// CHECK-ENCODING: [0x25,0x0e,0x10,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 25 0e 10 e0 <unknown>
// CHECK-UNKNOWN: e0100e25 <unknown>

ld1b {za0h.b[w12, 1]}, p1/z, [x1, x30]
// CHECK-INST: ld1b {za0h.b[w12, 1]}, p1/z, [x1, x30]
// CHECK-ENCODING: [0x21,0x04,0x1e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 04 1e e0 <unknown>
// CHECK-UNKNOWN: e01e0421 <unknown>

ld1b {za0h.b[w14, 8]}, p5/z, [x19, x20]
// CHECK-INST: ld1b {za0h.b[w14, 8]}, p5/z, [x19, x20]
// CHECK-ENCODING: [0x68,0x56,0x14,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 68 56 14 e0 <unknown>
// CHECK-UNKNOWN: e0145668 <unknown>

ld1b {za0h.b[w12, 0]}, p6/z, [x12, x2]
// CHECK-INST: ld1b {za0h.b[w12, 0]}, p6/z, [x12, x2]
// CHECK-ENCODING: [0x80,0x19,0x02,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 19 02 e0 <unknown>
// CHECK-UNKNOWN: e0021980 <unknown>

ld1b {za0h.b[w14, 1]}, p2/z, [x1, x26]
// CHECK-INST: ld1b {za0h.b[w14, 1]}, p2/z, [x1, x26]
// CHECK-ENCODING: [0x21,0x48,0x1a,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 48 1a e0 <unknown>
// CHECK-UNKNOWN: e01a4821 <unknown>

ld1b {za0h.b[w12, 13]}, p2/z, [x22, x30]
// CHECK-INST: ld1b {za0h.b[w12, 13]}, p2/z, [x22, x30]
// CHECK-ENCODING: [0xcd,0x0a,0x1e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: cd 0a 1e e0 <unknown>
// CHECK-UNKNOWN: e01e0acd <unknown>

ld1b {za0h.b[w15, 2]}, p5/z, [x9, x1]
// CHECK-INST: ld1b {za0h.b[w15, 2]}, p5/z, [x9, x1]
// CHECK-ENCODING: [0x22,0x75,0x01,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 75 01 e0 <unknown>
// CHECK-UNKNOWN: e0017522 <unknown>

ld1b {za0h.b[w13, 7]}, p2/z, [x12, x11]
// CHECK-INST: ld1b {za0h.b[w13, 7]}, p2/z, [x12, x11]
// CHECK-ENCODING: [0x87,0x29,0x0b,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 87 29 0b e0 <unknown>
// CHECK-UNKNOWN: e00b2987 <unknown>

ld1b za0h.b[w12, 0], p0/z, [x0, x0]
// CHECK-INST: ld1b {za0h.b[w12, 0]}, p0/z, [x0, x0]
// CHECK-ENCODING: [0x00,0x00,0x00,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 00 00 e0 <unknown>
// CHECK-UNKNOWN: e0000000 <unknown>

ld1b za0h.b[w14, 5], p5/z, [x10, x21]
// CHECK-INST: ld1b {za0h.b[w14, 5]}, p5/z, [x10, x21]
// CHECK-ENCODING: [0x45,0x55,0x15,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 45 55 15 e0 <unknown>
// CHECK-UNKNOWN: e0155545 <unknown>

ld1b za0h.b[w15, 7], p3/z, [x13, x8]
// CHECK-INST: ld1b {za0h.b[w15, 7]}, p3/z, [x13, x8]
// CHECK-ENCODING: [0xa7,0x6d,0x08,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a7 6d 08 e0 <unknown>
// CHECK-UNKNOWN: e0086da7 <unknown>

ld1b za0h.b[w15, 15], p7/z, [sp]
// CHECK-INST: ld1b {za0h.b[w15, 15]}, p7/z, [sp]
// CHECK-ENCODING: [0xef,0x7f,0x1f,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: ef 7f 1f e0 <unknown>
// CHECK-UNKNOWN: e01f7fef <unknown>

ld1b za0h.b[w12, 5], p3/z, [x17, x16]
// CHECK-INST: ld1b {za0h.b[w12, 5]}, p3/z, [x17, x16]
// CHECK-ENCODING: [0x25,0x0e,0x10,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 25 0e 10 e0 <unknown>
// CHECK-UNKNOWN: e0100e25 <unknown>

ld1b za0h.b[w12, 1], p1/z, [x1, x30]
// CHECK-INST: ld1b {za0h.b[w12, 1]}, p1/z, [x1, x30]
// CHECK-ENCODING: [0x21,0x04,0x1e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 04 1e e0 <unknown>
// CHECK-UNKNOWN: e01e0421 <unknown>

ld1b za0h.b[w14, 8], p5/z, [x19, x20]
// CHECK-INST: ld1b {za0h.b[w14, 8]}, p5/z, [x19, x20]
// CHECK-ENCODING: [0x68,0x56,0x14,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 68 56 14 e0 <unknown>
// CHECK-UNKNOWN: e0145668 <unknown>

ld1b za0h.b[w12, 0], p6/z, [x12, x2]
// CHECK-INST: ld1b {za0h.b[w12, 0]}, p6/z, [x12, x2]
// CHECK-ENCODING: [0x80,0x19,0x02,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 19 02 e0 <unknown>
// CHECK-UNKNOWN: e0021980 <unknown>

ld1b za0h.b[w14, 1], p2/z, [x1, x26]
// CHECK-INST: ld1b {za0h.b[w14, 1]}, p2/z, [x1, x26]
// CHECK-ENCODING: [0x21,0x48,0x1a,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 48 1a e0 <unknown>
// CHECK-UNKNOWN: e01a4821 <unknown>

ld1b za0h.b[w12, 13], p2/z, [x22, x30]
// CHECK-INST: ld1b {za0h.b[w12, 13]}, p2/z, [x22, x30]
// CHECK-ENCODING: [0xcd,0x0a,0x1e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: cd 0a 1e e0 <unknown>
// CHECK-UNKNOWN: e01e0acd <unknown>

ld1b za0h.b[w15, 2], p5/z, [x9, x1]
// CHECK-INST: ld1b {za0h.b[w15, 2]}, p5/z, [x9, x1]
// CHECK-ENCODING: [0x22,0x75,0x01,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 75 01 e0 <unknown>
// CHECK-UNKNOWN: e0017522 <unknown>

ld1b za0h.b[w13, 7], p2/z, [x12, x11]
// CHECK-INST: ld1b {za0h.b[w13, 7]}, p2/z, [x12, x11]
// CHECK-ENCODING: [0x87,0x29,0x0b,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 87 29 0b e0 <unknown>
// CHECK-UNKNOWN: e00b2987 <unknown>

// --------------------------------------------------------------------------//
// Vertical
Expand All @@ -166,142 +166,142 @@ ld1b {za0v.b[w12, 0]}, p0/z, [x0, x0]
// CHECK-INST: ld1b {za0v.b[w12, 0]}, p0/z, [x0, x0]
// CHECK-ENCODING: [0x00,0x80,0x00,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 80 00 e0 <unknown>
// CHECK-UNKNOWN: e0008000 <unknown>

ld1b {za0v.b[w14, 5]}, p5/z, [x10, x21]
// CHECK-INST: ld1b {za0v.b[w14, 5]}, p5/z, [x10, x21]
// CHECK-ENCODING: [0x45,0xd5,0x15,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 45 d5 15 e0 <unknown>
// CHECK-UNKNOWN: e015d545 <unknown>

ld1b {za0v.b[w15, 7]}, p3/z, [x13, x8]
// CHECK-INST: ld1b {za0v.b[w15, 7]}, p3/z, [x13, x8]
// CHECK-ENCODING: [0xa7,0xed,0x08,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a7 ed 08 e0 <unknown>
// CHECK-UNKNOWN: e008eda7 <unknown>

ld1b {za0v.b[w15, 15]}, p7/z, [sp]
// CHECK-INST: ld1b {za0v.b[w15, 15]}, p7/z, [sp]
// CHECK-ENCODING: [0xef,0xff,0x1f,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: ef ff 1f e0 <unknown>
// CHECK-UNKNOWN: e01fffef <unknown>

ld1b {za0v.b[w12, 5]}, p3/z, [x17, x16]
// CHECK-INST: ld1b {za0v.b[w12, 5]}, p3/z, [x17, x16]
// CHECK-ENCODING: [0x25,0x8e,0x10,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 25 8e 10 e0 <unknown>
// CHECK-UNKNOWN: e0108e25 <unknown>

ld1b {za0v.b[w12, 1]}, p1/z, [x1, x30]
// CHECK-INST: ld1b {za0v.b[w12, 1]}, p1/z, [x1, x30]
// CHECK-ENCODING: [0x21,0x84,0x1e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 84 1e e0 <unknown>
// CHECK-UNKNOWN: e01e8421 <unknown>

ld1b {za0v.b[w14, 8]}, p5/z, [x19, x20]
// CHECK-INST: ld1b {za0v.b[w14, 8]}, p5/z, [x19, x20]
// CHECK-ENCODING: [0x68,0xd6,0x14,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 68 d6 14 e0 <unknown>
// CHECK-UNKNOWN: e014d668 <unknown>

ld1b {za0v.b[w12, 0]}, p6/z, [x12, x2]
// CHECK-INST: ld1b {za0v.b[w12, 0]}, p6/z, [x12, x2]
// CHECK-ENCODING: [0x80,0x99,0x02,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 99 02 e0 <unknown>
// CHECK-UNKNOWN: e0029980 <unknown>

ld1b {za0v.b[w14, 1]}, p2/z, [x1, x26]
// CHECK-INST: ld1b {za0v.b[w14, 1]}, p2/z, [x1, x26]
// CHECK-ENCODING: [0x21,0xc8,0x1a,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 c8 1a e0 <unknown>
// CHECK-UNKNOWN: e01ac821 <unknown>

ld1b {za0v.b[w12, 13]}, p2/z, [x22, x30]
// CHECK-INST: ld1b {za0v.b[w12, 13]}, p2/z, [x22, x30]
// CHECK-ENCODING: [0xcd,0x8a,0x1e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: cd 8a 1e e0 <unknown>
// CHECK-UNKNOWN: e01e8acd <unknown>

ld1b {za0v.b[w15, 2]}, p5/z, [x9, x1]
// CHECK-INST: ld1b {za0v.b[w15, 2]}, p5/z, [x9, x1]
// CHECK-ENCODING: [0x22,0xf5,0x01,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 f5 01 e0 <unknown>
// CHECK-UNKNOWN: e001f522 <unknown>

ld1b {za0v.b[w13, 7]}, p2/z, [x12, x11]
// CHECK-INST: ld1b {za0v.b[w13, 7]}, p2/z, [x12, x11]
// CHECK-ENCODING: [0x87,0xa9,0x0b,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 87 a9 0b e0 <unknown>
// CHECK-UNKNOWN: e00ba987 <unknown>

ld1b za0v.b[w12, 0], p0/z, [x0, x0]
// CHECK-INST: ld1b {za0v.b[w12, 0]}, p0/z, [x0, x0]
// CHECK-ENCODING: [0x00,0x80,0x00,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 80 00 e0 <unknown>
// CHECK-UNKNOWN: e0008000 <unknown>

ld1b za0v.b[w14, 5], p5/z, [x10, x21]
// CHECK-INST: ld1b {za0v.b[w14, 5]}, p5/z, [x10, x21]
// CHECK-ENCODING: [0x45,0xd5,0x15,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 45 d5 15 e0 <unknown>
// CHECK-UNKNOWN: e015d545 <unknown>

ld1b za0v.b[w15, 7], p3/z, [x13, x8]
// CHECK-INST: ld1b {za0v.b[w15, 7]}, p3/z, [x13, x8]
// CHECK-ENCODING: [0xa7,0xed,0x08,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a7 ed 08 e0 <unknown>
// CHECK-UNKNOWN: e008eda7 <unknown>

ld1b za0v.b[w15, 15], p7/z, [sp]
// CHECK-INST: ld1b {za0v.b[w15, 15]}, p7/z, [sp]
// CHECK-ENCODING: [0xef,0xff,0x1f,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: ef ff 1f e0 <unknown>
// CHECK-UNKNOWN: e01fffef <unknown>

ld1b za0v.b[w12, 5], p3/z, [x17, x16]
// CHECK-INST: ld1b {za0v.b[w12, 5]}, p3/z, [x17, x16]
// CHECK-ENCODING: [0x25,0x8e,0x10,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 25 8e 10 e0 <unknown>
// CHECK-UNKNOWN: e0108e25 <unknown>

ld1b za0v.b[w12, 1], p1/z, [x1, x30]
// CHECK-INST: ld1b {za0v.b[w12, 1]}, p1/z, [x1, x30]
// CHECK-ENCODING: [0x21,0x84,0x1e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 84 1e e0 <unknown>
// CHECK-UNKNOWN: e01e8421 <unknown>

ld1b za0v.b[w14, 8], p5/z, [x19, x20]
// CHECK-INST: ld1b {za0v.b[w14, 8]}, p5/z, [x19, x20]
// CHECK-ENCODING: [0x68,0xd6,0x14,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 68 d6 14 e0 <unknown>
// CHECK-UNKNOWN: e014d668 <unknown>

ld1b za0v.b[w12, 0], p6/z, [x12, x2]
// CHECK-INST: ld1b {za0v.b[w12, 0]}, p6/z, [x12, x2]
// CHECK-ENCODING: [0x80,0x99,0x02,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 99 02 e0 <unknown>
// CHECK-UNKNOWN: e0029980 <unknown>

ld1b za0v.b[w14, 1], p2/z, [x1, x26]
// CHECK-INST: ld1b {za0v.b[w14, 1]}, p2/z, [x1, x26]
// CHECK-ENCODING: [0x21,0xc8,0x1a,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 c8 1a e0 <unknown>
// CHECK-UNKNOWN: e01ac821 <unknown>

ld1b za0v.b[w12, 13], p2/z, [x22, x30]
// CHECK-INST: ld1b {za0v.b[w12, 13]}, p2/z, [x22, x30]
// CHECK-ENCODING: [0xcd,0x8a,0x1e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: cd 8a 1e e0 <unknown>
// CHECK-UNKNOWN: e01e8acd <unknown>

ld1b za0v.b[w15, 2], p5/z, [x9, x1]
// CHECK-INST: ld1b {za0v.b[w15, 2]}, p5/z, [x9, x1]
// CHECK-ENCODING: [0x22,0xf5,0x01,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 f5 01 e0 <unknown>
// CHECK-UNKNOWN: e001f522 <unknown>

ld1b za0v.b[w13, 7], p2/z, [x12, x11]
// CHECK-INST: ld1b {za0v.b[w13, 7]}, p2/z, [x12, x11]
// CHECK-ENCODING: [0x87,0xa9,0x0b,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 87 a9 0b e0 <unknown>
// CHECK-UNKNOWN: e00ba987 <unknown>
96 changes: 48 additions & 48 deletions llvm/test/MC/AArch64/SME/ld1d.s
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,145 +19,145 @@ ld1d {za0h.d[w12, 0]}, p0/z, [x0, x0, lsl #3]
// CHECK-INST: ld1d {za0h.d[w12, 0]}, p0/z, [x0, x0, lsl #3]
// CHECK-ENCODING: [0x00,0x00,0xc0,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 00 c0 e0 <unknown>
// CHECK-UNKNOWN: e0c00000 <unknown>

ld1d {za2h.d[w14, 1]}, p5/z, [x10, x21, lsl #3]
// CHECK-INST: ld1d {za2h.d[w14, 1]}, p5/z, [x10, x21, lsl #3]
// CHECK-ENCODING: [0x45,0x55,0xd5,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 45 55 d5 e0 <unknown>
// CHECK-UNKNOWN: e0d55545 <unknown>

ld1d {za3h.d[w15, 1]}, p3/z, [x13, x8, lsl #3]
// CHECK-INST: ld1d {za3h.d[w15, 1]}, p3/z, [x13, x8, lsl #3]
// CHECK-ENCODING: [0xa7,0x6d,0xc8,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a7 6d c8 e0 <unknown>
// CHECK-UNKNOWN: e0c86da7 <unknown>

ld1d {za7h.d[w15, 1]}, p7/z, [sp]
// CHECK-INST: ld1d {za7h.d[w15, 1]}, p7/z, [sp]
// CHECK-ENCODING: [0xef,0x7f,0xdf,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: ef 7f df e0 <unknown>
// CHECK-UNKNOWN: e0df7fef <unknown>

ld1d {za2h.d[w12, 1]}, p3/z, [x17, x16, lsl #3]
// CHECK-INST: ld1d {za2h.d[w12, 1]}, p3/z, [x17, x16, lsl #3]
// CHECK-ENCODING: [0x25,0x0e,0xd0,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 25 0e d0 e0 <unknown>
// CHECK-UNKNOWN: e0d00e25 <unknown>

ld1d {za0h.d[w12, 1]}, p1/z, [x1, x30, lsl #3]
// CHECK-INST: ld1d {za0h.d[w12, 1]}, p1/z, [x1, x30, lsl #3]
// CHECK-ENCODING: [0x21,0x04,0xde,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 04 de e0 <unknown>
// CHECK-UNKNOWN: e0de0421 <unknown>

ld1d {za4h.d[w14, 0]}, p5/z, [x19, x20, lsl #3]
// CHECK-INST: ld1d {za4h.d[w14, 0]}, p5/z, [x19, x20, lsl #3]
// CHECK-ENCODING: [0x68,0x56,0xd4,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 68 56 d4 e0 <unknown>
// CHECK-UNKNOWN: e0d45668 <unknown>

ld1d {za0h.d[w12, 0]}, p6/z, [x12, x2, lsl #3]
// CHECK-INST: ld1d {za0h.d[w12, 0]}, p6/z, [x12, x2, lsl #3]
// CHECK-ENCODING: [0x80,0x19,0xc2,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 19 c2 e0 <unknown>
// CHECK-UNKNOWN: e0c21980 <unknown>

ld1d {za0h.d[w14, 1]}, p2/z, [x1, x26, lsl #3]
// CHECK-INST: ld1d {za0h.d[w14, 1]}, p2/z, [x1, x26, lsl #3]
// CHECK-ENCODING: [0x21,0x48,0xda,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 48 da e0 <unknown>
// CHECK-UNKNOWN: e0da4821 <unknown>

ld1d {za6h.d[w12, 1]}, p2/z, [x22, x30, lsl #3]
// CHECK-INST: ld1d {za6h.d[w12, 1]}, p2/z, [x22, x30, lsl #3]
// CHECK-ENCODING: [0xcd,0x0a,0xde,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: cd 0a de e0 <unknown>
// CHECK-UNKNOWN: e0de0acd <unknown>

ld1d {za1h.d[w15, 0]}, p5/z, [x9, x1, lsl #3]
// CHECK-INST: ld1d {za1h.d[w15, 0]}, p5/z, [x9, x1, lsl #3]
// CHECK-ENCODING: [0x22,0x75,0xc1,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 75 c1 e0 <unknown>
// CHECK-UNKNOWN: e0c17522 <unknown>

ld1d {za3h.d[w13, 1]}, p2/z, [x12, x11, lsl #3]
// CHECK-INST: ld1d {za3h.d[w13, 1]}, p2/z, [x12, x11, lsl #3]
// CHECK-ENCODING: [0x87,0x29,0xcb,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 87 29 cb e0 <unknown>
// CHECK-UNKNOWN: e0cb2987 <unknown>

ld1d za0h.d[w12, 0], p0/z, [x0, x0, lsl #3]
// CHECK-INST: ld1d {za0h.d[w12, 0]}, p0/z, [x0, x0, lsl #3]
// CHECK-ENCODING: [0x00,0x00,0xc0,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 00 c0 e0 <unknown>
// CHECK-UNKNOWN: e0c00000 <unknown>

ld1d za2h.d[w14, 1], p5/z, [x10, x21, lsl #3]
// CHECK-INST: ld1d {za2h.d[w14, 1]}, p5/z, [x10, x21, lsl #3]
// CHECK-ENCODING: [0x45,0x55,0xd5,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 45 55 d5 e0 <unknown>
// CHECK-UNKNOWN: e0d55545 <unknown>

ld1d za3h.d[w15, 1], p3/z, [x13, x8, lsl #3]
// CHECK-INST: ld1d {za3h.d[w15, 1]}, p3/z, [x13, x8, lsl #3]
// CHECK-ENCODING: [0xa7,0x6d,0xc8,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a7 6d c8 e0 <unknown>
// CHECK-UNKNOWN: e0c86da7 <unknown>

ld1d za7h.d[w15, 1], p7/z, [sp]
// CHECK-INST: ld1d {za7h.d[w15, 1]}, p7/z, [sp]
// CHECK-ENCODING: [0xef,0x7f,0xdf,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: ef 7f df e0 <unknown>
// CHECK-UNKNOWN: e0df7fef <unknown>

ld1d za2h.d[w12, 1], p3/z, [x17, x16, lsl #3]
// CHECK-INST: ld1d {za2h.d[w12, 1]}, p3/z, [x17, x16, lsl #3]
// CHECK-ENCODING: [0x25,0x0e,0xd0,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 25 0e d0 e0 <unknown>
// CHECK-UNKNOWN: e0d00e25 <unknown>

ld1d za0h.d[w12, 1], p1/z, [x1, x30, lsl #3]
// CHECK-INST: ld1d {za0h.d[w12, 1]}, p1/z, [x1, x30, lsl #3]
// CHECK-ENCODING: [0x21,0x04,0xde,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 04 de e0 <unknown>
// CHECK-UNKNOWN: e0de0421 <unknown>

ld1d za4h.d[w14, 0], p5/z, [x19, x20, lsl #3]
// CHECK-INST: ld1d {za4h.d[w14, 0]}, p5/z, [x19, x20, lsl #3]
// CHECK-ENCODING: [0x68,0x56,0xd4,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 68 56 d4 e0 <unknown>
// CHECK-UNKNOWN: e0d45668 <unknown>

ld1d za0h.d[w12, 0], p6/z, [x12, x2, lsl #3]
// CHECK-INST: ld1d {za0h.d[w12, 0]}, p6/z, [x12, x2, lsl #3]
// CHECK-ENCODING: [0x80,0x19,0xc2,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 19 c2 e0 <unknown>
// CHECK-UNKNOWN: e0c21980 <unknown>

ld1d za0h.d[w14, 1], p2/z, [x1, x26, lsl #3]
// CHECK-INST: ld1d {za0h.d[w14, 1]}, p2/z, [x1, x26, lsl #3]
// CHECK-ENCODING: [0x21,0x48,0xda,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 48 da e0 <unknown>
// CHECK-UNKNOWN: e0da4821 <unknown>

ld1d za6h.d[w12, 1], p2/z, [x22, x30, lsl #3]
// CHECK-INST: ld1d {za6h.d[w12, 1]}, p2/z, [x22, x30, lsl #3]
// CHECK-ENCODING: [0xcd,0x0a,0xde,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: cd 0a de e0 <unknown>
// CHECK-UNKNOWN: e0de0acd <unknown>

ld1d za1h.d[w15, 0], p5/z, [x9, x1, lsl #3]
// CHECK-INST: ld1d {za1h.d[w15, 0]}, p5/z, [x9, x1, lsl #3]
// CHECK-ENCODING: [0x22,0x75,0xc1,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 75 c1 e0 <unknown>
// CHECK-UNKNOWN: e0c17522 <unknown>

ld1d za3h.d[w13, 1], p2/z, [x12, x11, lsl #3]
// CHECK-INST: ld1d {za3h.d[w13, 1]}, p2/z, [x12, x11, lsl #3]
// CHECK-ENCODING: [0x87,0x29,0xcb,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 87 29 cb e0 <unknown>
// CHECK-UNKNOWN: e0cb2987 <unknown>

// --------------------------------------------------------------------------//
// Vertical
Expand All @@ -166,142 +166,142 @@ ld1d {za0v.d[w12, 0]}, p0/z, [x0, x0, lsl #3]
// CHECK-INST: ld1d {za0v.d[w12, 0]}, p0/z, [x0, x0, lsl #3]
// CHECK-ENCODING: [0x00,0x80,0xc0,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 80 c0 e0 <unknown>
// CHECK-UNKNOWN: e0c08000 <unknown>

ld1d {za2v.d[w14, 1]}, p5/z, [x10, x21, lsl #3]
// CHECK-INST: ld1d {za2v.d[w14, 1]}, p5/z, [x10, x21, lsl #3]
// CHECK-ENCODING: [0x45,0xd5,0xd5,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 45 d5 d5 e0 <unknown>
// CHECK-UNKNOWN: e0d5d545 <unknown>

ld1d {za3v.d[w15, 1]}, p3/z, [x13, x8, lsl #3]
// CHECK-INST: ld1d {za3v.d[w15, 1]}, p3/z, [x13, x8, lsl #3]
// CHECK-ENCODING: [0xa7,0xed,0xc8,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a7 ed c8 e0 <unknown>
// CHECK-UNKNOWN: e0c8eda7 <unknown>

ld1d {za7v.d[w15, 1]}, p7/z, [sp]
// CHECK-INST: ld1d {za7v.d[w15, 1]}, p7/z, [sp]
// CHECK-ENCODING: [0xef,0xff,0xdf,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: ef ff df e0 <unknown>
// CHECK-UNKNOWN: e0dfffef <unknown>

ld1d {za2v.d[w12, 1]}, p3/z, [x17, x16, lsl #3]
// CHECK-INST: ld1d {za2v.d[w12, 1]}, p3/z, [x17, x16, lsl #3]
// CHECK-ENCODING: [0x25,0x8e,0xd0,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 25 8e d0 e0 <unknown>
// CHECK-UNKNOWN: e0d08e25 <unknown>

ld1d {za0v.d[w12, 1]}, p1/z, [x1, x30, lsl #3]
// CHECK-INST: ld1d {za0v.d[w12, 1]}, p1/z, [x1, x30, lsl #3]
// CHECK-ENCODING: [0x21,0x84,0xde,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 84 de e0 <unknown>
// CHECK-UNKNOWN: e0de8421 <unknown>

ld1d {za4v.d[w14, 0]}, p5/z, [x19, x20, lsl #3]
// CHECK-INST: ld1d {za4v.d[w14, 0]}, p5/z, [x19, x20, lsl #3]
// CHECK-ENCODING: [0x68,0xd6,0xd4,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 68 d6 d4 e0 <unknown>
// CHECK-UNKNOWN: e0d4d668 <unknown>

ld1d {za0v.d[w12, 0]}, p6/z, [x12, x2, lsl #3]
// CHECK-INST: ld1d {za0v.d[w12, 0]}, p6/z, [x12, x2, lsl #3]
// CHECK-ENCODING: [0x80,0x99,0xc2,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 99 c2 e0 <unknown>
// CHECK-UNKNOWN: e0c29980 <unknown>

ld1d {za0v.d[w14, 1]}, p2/z, [x1, x26, lsl #3]
// CHECK-INST: ld1d {za0v.d[w14, 1]}, p2/z, [x1, x26, lsl #3]
// CHECK-ENCODING: [0x21,0xc8,0xda,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 c8 da e0 <unknown>
// CHECK-UNKNOWN: e0dac821 <unknown>

ld1d {za6v.d[w12, 1]}, p2/z, [x22, x30, lsl #3]
// CHECK-INST: ld1d {za6v.d[w12, 1]}, p2/z, [x22, x30, lsl #3]
// CHECK-ENCODING: [0xcd,0x8a,0xde,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: cd 8a de e0 <unknown>
// CHECK-UNKNOWN: e0de8acd <unknown>

ld1d {za1v.d[w15, 0]}, p5/z, [x9, x1, lsl #3]
// CHECK-INST: ld1d {za1v.d[w15, 0]}, p5/z, [x9, x1, lsl #3]
// CHECK-ENCODING: [0x22,0xf5,0xc1,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 f5 c1 e0 <unknown>
// CHECK-UNKNOWN: e0c1f522 <unknown>

ld1d {za3v.d[w13, 1]}, p2/z, [x12, x11, lsl #3]
// CHECK-INST: ld1d {za3v.d[w13, 1]}, p2/z, [x12, x11, lsl #3]
// CHECK-ENCODING: [0x87,0xa9,0xcb,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 87 a9 cb e0 <unknown>
// CHECK-UNKNOWN: e0cba987 <unknown>

ld1d za0v.d[w12, 0], p0/z, [x0, x0, lsl #3]
// CHECK-INST: ld1d {za0v.d[w12, 0]}, p0/z, [x0, x0, lsl #3]
// CHECK-ENCODING: [0x00,0x80,0xc0,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 80 c0 e0 <unknown>
// CHECK-UNKNOWN: e0c08000 <unknown>

ld1d za2v.d[w14, 1], p5/z, [x10, x21, lsl #3]
// CHECK-INST: ld1d {za2v.d[w14, 1]}, p5/z, [x10, x21, lsl #3]
// CHECK-ENCODING: [0x45,0xd5,0xd5,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 45 d5 d5 e0 <unknown>
// CHECK-UNKNOWN: e0d5d545 <unknown>

ld1d za3v.d[w15, 1], p3/z, [x13, x8, lsl #3]
// CHECK-INST: ld1d {za3v.d[w15, 1]}, p3/z, [x13, x8, lsl #3]
// CHECK-ENCODING: [0xa7,0xed,0xc8,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a7 ed c8 e0 <unknown>
// CHECK-UNKNOWN: e0c8eda7 <unknown>

ld1d za7v.d[w15, 1], p7/z, [sp]
// CHECK-INST: ld1d {za7v.d[w15, 1]}, p7/z, [sp]
// CHECK-ENCODING: [0xef,0xff,0xdf,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: ef ff df e0 <unknown>
// CHECK-UNKNOWN: e0dfffef <unknown>

ld1d za2v.d[w12, 1], p3/z, [x17, x16, lsl #3]
// CHECK-INST: ld1d {za2v.d[w12, 1]}, p3/z, [x17, x16, lsl #3]
// CHECK-ENCODING: [0x25,0x8e,0xd0,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 25 8e d0 e0 <unknown>
// CHECK-UNKNOWN: e0d08e25 <unknown>

ld1d za0v.d[w12, 1], p1/z, [x1, x30, lsl #3]
// CHECK-INST: ld1d {za0v.d[w12, 1]}, p1/z, [x1, x30, lsl #3]
// CHECK-ENCODING: [0x21,0x84,0xde,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 84 de e0 <unknown>
// CHECK-UNKNOWN: e0de8421 <unknown>

ld1d za4v.d[w14, 0], p5/z, [x19, x20, lsl #3]
// CHECK-INST: ld1d {za4v.d[w14, 0]}, p5/z, [x19, x20, lsl #3]
// CHECK-ENCODING: [0x68,0xd6,0xd4,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 68 d6 d4 e0 <unknown>
// CHECK-UNKNOWN: e0d4d668 <unknown>

ld1d za0v.d[w12, 0], p6/z, [x12, x2, lsl #3]
// CHECK-INST: ld1d {za0v.d[w12, 0]}, p6/z, [x12, x2, lsl #3]
// CHECK-ENCODING: [0x80,0x99,0xc2,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 99 c2 e0 <unknown>
// CHECK-UNKNOWN: e0c29980 <unknown>

ld1d za0v.d[w14, 1], p2/z, [x1, x26, lsl #3]
// CHECK-INST: ld1d {za0v.d[w14, 1]}, p2/z, [x1, x26, lsl #3]
// CHECK-ENCODING: [0x21,0xc8,0xda,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 c8 da e0 <unknown>
// CHECK-UNKNOWN: e0dac821 <unknown>

ld1d za6v.d[w12, 1], p2/z, [x22, x30, lsl #3]
// CHECK-INST: ld1d {za6v.d[w12, 1]}, p2/z, [x22, x30, lsl #3]
// CHECK-ENCODING: [0xcd,0x8a,0xde,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: cd 8a de e0 <unknown>
// CHECK-UNKNOWN: e0de8acd <unknown>

ld1d za1v.d[w15, 0], p5/z, [x9, x1, lsl #3]
// CHECK-INST: ld1d {za1v.d[w15, 0]}, p5/z, [x9, x1, lsl #3]
// CHECK-ENCODING: [0x22,0xf5,0xc1,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 f5 c1 e0 <unknown>
// CHECK-UNKNOWN: e0c1f522 <unknown>

ld1d za3v.d[w13, 1], p2/z, [x12, x11, lsl #3]
// CHECK-INST: ld1d {za3v.d[w13, 1]}, p2/z, [x12, x11, lsl #3]
// CHECK-ENCODING: [0x87,0xa9,0xcb,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 87 a9 cb e0 <unknown>
// CHECK-UNKNOWN: e0cba987 <unknown>
96 changes: 48 additions & 48 deletions llvm/test/MC/AArch64/SME/ld1h.s
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,145 +19,145 @@ ld1h {za0h.h[w12, 0]}, p0/z, [x0, x0, lsl #1]
// CHECK-INST: ld1h {za0h.h[w12, 0]}, p0/z, [x0, x0, lsl #1]
// CHECK-ENCODING: [0x00,0x00,0x40,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 00 40 e0 <unknown>
// CHECK-UNKNOWN: e0400000 <unknown>

ld1h {za0h.h[w14, 5]}, p5/z, [x10, x21, lsl #1]
// CHECK-INST: ld1h {za0h.h[w14, 5]}, p5/z, [x10, x21, lsl #1]
// CHECK-ENCODING: [0x45,0x55,0x55,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 45 55 55 e0 <unknown>
// CHECK-UNKNOWN: e0555545 <unknown>

ld1h {za0h.h[w15, 7]}, p3/z, [x13, x8, lsl #1]
// CHECK-INST: ld1h {za0h.h[w15, 7]}, p3/z, [x13, x8, lsl #1]
// CHECK-ENCODING: [0xa7,0x6d,0x48,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a7 6d 48 e0 <unknown>
// CHECK-UNKNOWN: e0486da7 <unknown>

ld1h {za1h.h[w15, 7]}, p7/z, [sp]
// CHECK-INST: ld1h {za1h.h[w15, 7]}, p7/z, [sp]
// CHECK-ENCODING: [0xef,0x7f,0x5f,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: ef 7f 5f e0 <unknown>
// CHECK-UNKNOWN: e05f7fef <unknown>

ld1h {za0h.h[w12, 5]}, p3/z, [x17, x16, lsl #1]
// CHECK-INST: ld1h {za0h.h[w12, 5]}, p3/z, [x17, x16, lsl #1]
// CHECK-ENCODING: [0x25,0x0e,0x50,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 25 0e 50 e0 <unknown>
// CHECK-UNKNOWN: e0500e25 <unknown>

ld1h {za0h.h[w12, 1]}, p1/z, [x1, x30, lsl #1]
// CHECK-INST: ld1h {za0h.h[w12, 1]}, p1/z, [x1, x30, lsl #1]
// CHECK-ENCODING: [0x21,0x04,0x5e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 04 5e e0 <unknown>
// CHECK-UNKNOWN: e05e0421 <unknown>

ld1h {za1h.h[w14, 0]}, p5/z, [x19, x20, lsl #1]
// CHECK-INST: ld1h {za1h.h[w14, 0]}, p5/z, [x19, x20, lsl #1]
// CHECK-ENCODING: [0x68,0x56,0x54,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 68 56 54 e0 <unknown>
// CHECK-UNKNOWN: e0545668 <unknown>

ld1h {za0h.h[w12, 0]}, p6/z, [x12, x2, lsl #1]
// CHECK-INST: ld1h {za0h.h[w12, 0]}, p6/z, [x12, x2, lsl #1]
// CHECK-ENCODING: [0x80,0x19,0x42,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 19 42 e0 <unknown>
// CHECK-UNKNOWN: e0421980 <unknown>

ld1h {za0h.h[w14, 1]}, p2/z, [x1, x26, lsl #1]
// CHECK-INST: ld1h {za0h.h[w14, 1]}, p2/z, [x1, x26, lsl #1]
// CHECK-ENCODING: [0x21,0x48,0x5a,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 48 5a e0 <unknown>
// CHECK-UNKNOWN: e05a4821 <unknown>

ld1h {za1h.h[w12, 5]}, p2/z, [x22, x30, lsl #1]
// CHECK-INST: ld1h {za1h.h[w12, 5]}, p2/z, [x22, x30, lsl #1]
// CHECK-ENCODING: [0xcd,0x0a,0x5e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: cd 0a 5e e0 <unknown>
// CHECK-UNKNOWN: e05e0acd <unknown>

ld1h {za0h.h[w15, 2]}, p5/z, [x9, x1, lsl #1]
// CHECK-INST: ld1h {za0h.h[w15, 2]}, p5/z, [x9, x1, lsl #1]
// CHECK-ENCODING: [0x22,0x75,0x41,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 75 41 e0 <unknown>
// CHECK-UNKNOWN: e0417522 <unknown>

ld1h {za0h.h[w13, 7]}, p2/z, [x12, x11, lsl #1]
// CHECK-INST: ld1h {za0h.h[w13, 7]}, p2/z, [x12, x11, lsl #1]
// CHECK-ENCODING: [0x87,0x29,0x4b,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 87 29 4b e0 <unknown>
// CHECK-UNKNOWN: e04b2987 <unknown>

ld1h za0h.h[w12, 0], p0/z, [x0, x0, lsl #1]
// CHECK-INST: ld1h {za0h.h[w12, 0]}, p0/z, [x0, x0, lsl #1]
// CHECK-ENCODING: [0x00,0x00,0x40,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 00 40 e0 <unknown>
// CHECK-UNKNOWN: e0400000 <unknown>

ld1h za0h.h[w14, 5], p5/z, [x10, x21, lsl #1]
// CHECK-INST: ld1h {za0h.h[w14, 5]}, p5/z, [x10, x21, lsl #1]
// CHECK-ENCODING: [0x45,0x55,0x55,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 45 55 55 e0 <unknown>
// CHECK-UNKNOWN: e0555545 <unknown>

ld1h za0h.h[w15, 7], p3/z, [x13, x8, lsl #1]
// CHECK-INST: ld1h {za0h.h[w15, 7]}, p3/z, [x13, x8, lsl #1]
// CHECK-ENCODING: [0xa7,0x6d,0x48,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a7 6d 48 e0 <unknown>
// CHECK-UNKNOWN: e0486da7 <unknown>

ld1h za1h.h[w15, 7], p7/z, [sp]
// CHECK-INST: ld1h {za1h.h[w15, 7]}, p7/z, [sp]
// CHECK-ENCODING: [0xef,0x7f,0x5f,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: ef 7f 5f e0 <unknown>
// CHECK-UNKNOWN: e05f7fef <unknown>

ld1h za0h.h[w12, 5], p3/z, [x17, x16, lsl #1]
// CHECK-INST: ld1h {za0h.h[w12, 5]}, p3/z, [x17, x16, lsl #1]
// CHECK-ENCODING: [0x25,0x0e,0x50,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 25 0e 50 e0 <unknown>
// CHECK-UNKNOWN: e0500e25 <unknown>

ld1h za0h.h[w12, 1], p1/z, [x1, x30, lsl #1]
// CHECK-INST: ld1h {za0h.h[w12, 1]}, p1/z, [x1, x30, lsl #1]
// CHECK-ENCODING: [0x21,0x04,0x5e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 04 5e e0 <unknown>
// CHECK-UNKNOWN: e05e0421 <unknown>

ld1h za1h.h[w14, 0], p5/z, [x19, x20, lsl #1]
// CHECK-INST: ld1h {za1h.h[w14, 0]}, p5/z, [x19, x20, lsl #1]
// CHECK-ENCODING: [0x68,0x56,0x54,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 68 56 54 e0 <unknown>
// CHECK-UNKNOWN: e0545668 <unknown>

ld1h za0h.h[w12, 0], p6/z, [x12, x2, lsl #1]
// CHECK-INST: ld1h {za0h.h[w12, 0]}, p6/z, [x12, x2, lsl #1]
// CHECK-ENCODING: [0x80,0x19,0x42,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 19 42 e0 <unknown>
// CHECK-UNKNOWN: e0421980 <unknown>

ld1h za0h.h[w14, 1], p2/z, [x1, x26, lsl #1]
// CHECK-INST: ld1h {za0h.h[w14, 1]}, p2/z, [x1, x26, lsl #1]
// CHECK-ENCODING: [0x21,0x48,0x5a,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 48 5a e0 <unknown>
// CHECK-UNKNOWN: e05a4821 <unknown>

ld1h za1h.h[w12, 5], p2/z, [x22, x30, lsl #1]
// CHECK-INST: ld1h {za1h.h[w12, 5]}, p2/z, [x22, x30, lsl #1]
// CHECK-ENCODING: [0xcd,0x0a,0x5e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: cd 0a 5e e0 <unknown>
// CHECK-UNKNOWN: e05e0acd <unknown>

ld1h za0h.h[w15, 2], p5/z, [x9, x1, lsl #1]
// CHECK-INST: ld1h {za0h.h[w15, 2]}, p5/z, [x9, x1, lsl #1]
// CHECK-ENCODING: [0x22,0x75,0x41,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 75 41 e0 <unknown>
// CHECK-UNKNOWN: e0417522 <unknown>

ld1h za0h.h[w13, 7], p2/z, [x12, x11, lsl #1]
// CHECK-INST: ld1h {za0h.h[w13, 7]}, p2/z, [x12, x11, lsl #1]
// CHECK-ENCODING: [0x87,0x29,0x4b,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 87 29 4b e0 <unknown>
// CHECK-UNKNOWN: e04b2987 <unknown>

// --------------------------------------------------------------------------//
// Vertical
Expand All @@ -166,142 +166,142 @@ ld1h {za0v.h[w12, 0]}, p0/z, [x0, x0, lsl #1]
// CHECK-INST: ld1h {za0v.h[w12, 0]}, p0/z, [x0, x0, lsl #1]
// CHECK-ENCODING: [0x00,0x80,0x40,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 80 40 e0 <unknown>
// CHECK-UNKNOWN: e0408000 <unknown>

ld1h {za0v.h[w14, 5]}, p5/z, [x10, x21, lsl #1]
// CHECK-INST: ld1h {za0v.h[w14, 5]}, p5/z, [x10, x21, lsl #1]
// CHECK-ENCODING: [0x45,0xd5,0x55,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 45 d5 55 e0 <unknown>
// CHECK-UNKNOWN: e055d545 <unknown>

ld1h {za0v.h[w15, 7]}, p3/z, [x13, x8, lsl #1]
// CHECK-INST: ld1h {za0v.h[w15, 7]}, p3/z, [x13, x8, lsl #1]
// CHECK-ENCODING: [0xa7,0xed,0x48,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a7 ed 48 e0 <unknown>
// CHECK-UNKNOWN: e048eda7 <unknown>

ld1h {za1v.h[w15, 7]}, p7/z, [sp]
// CHECK-INST: ld1h {za1v.h[w15, 7]}, p7/z, [sp]
// CHECK-ENCODING: [0xef,0xff,0x5f,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: ef ff 5f e0 <unknown>
// CHECK-UNKNOWN: e05fffef <unknown>

ld1h {za0v.h[w12, 5]}, p3/z, [x17, x16, lsl #1]
// CHECK-INST: ld1h {za0v.h[w12, 5]}, p3/z, [x17, x16, lsl #1]
// CHECK-ENCODING: [0x25,0x8e,0x50,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 25 8e 50 e0 <unknown>
// CHECK-UNKNOWN: e0508e25 <unknown>

ld1h {za0v.h[w12, 1]}, p1/z, [x1, x30, lsl #1]
// CHECK-INST: ld1h {za0v.h[w12, 1]}, p1/z, [x1, x30, lsl #1]
// CHECK-ENCODING: [0x21,0x84,0x5e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 84 5e e0 <unknown>
// CHECK-UNKNOWN: e05e8421 <unknown>

ld1h {za1v.h[w14, 0]}, p5/z, [x19, x20, lsl #1]
// CHECK-INST: ld1h {za1v.h[w14, 0]}, p5/z, [x19, x20, lsl #1]
// CHECK-ENCODING: [0x68,0xd6,0x54,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 68 d6 54 e0 <unknown>
// CHECK-UNKNOWN: e054d668 <unknown>

ld1h {za0v.h[w12, 0]}, p6/z, [x12, x2, lsl #1]
// CHECK-INST: ld1h {za0v.h[w12, 0]}, p6/z, [x12, x2, lsl #1]
// CHECK-ENCODING: [0x80,0x99,0x42,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 99 42 e0 <unknown>
// CHECK-UNKNOWN: e0429980 <unknown>

ld1h {za0v.h[w14, 1]}, p2/z, [x1, x26, lsl #1]
// CHECK-INST: ld1h {za0v.h[w14, 1]}, p2/z, [x1, x26, lsl #1]
// CHECK-ENCODING: [0x21,0xc8,0x5a,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 c8 5a e0 <unknown>
// CHECK-UNKNOWN: e05ac821 <unknown>

ld1h {za1v.h[w12, 5]}, p2/z, [x22, x30, lsl #1]
// CHECK-INST: ld1h {za1v.h[w12, 5]}, p2/z, [x22, x30, lsl #1]
// CHECK-ENCODING: [0xcd,0x8a,0x5e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: cd 8a 5e e0 <unknown>
// CHECK-UNKNOWN: e05e8acd <unknown>

ld1h {za0v.h[w15, 2]}, p5/z, [x9, x1, lsl #1]
// CHECK-INST: ld1h {za0v.h[w15, 2]}, p5/z, [x9, x1, lsl #1]
// CHECK-ENCODING: [0x22,0xf5,0x41,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 f5 41 e0 <unknown>
// CHECK-UNKNOWN: e041f522 <unknown>

ld1h {za0v.h[w13, 7]}, p2/z, [x12, x11, lsl #1]
// CHECK-INST: ld1h {za0v.h[w13, 7]}, p2/z, [x12, x11, lsl #1]
// CHECK-ENCODING: [0x87,0xa9,0x4b,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 87 a9 4b e0 <unknown>
// CHECK-UNKNOWN: e04ba987 <unknown>

ld1h za0v.h[w12, 0], p0/z, [x0, x0, lsl #1]
// CHECK-INST: ld1h {za0v.h[w12, 0]}, p0/z, [x0, x0, lsl #1]
// CHECK-ENCODING: [0x00,0x80,0x40,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 80 40 e0 <unknown>
// CHECK-UNKNOWN: e0408000 <unknown>

ld1h za0v.h[w14, 5], p5/z, [x10, x21, lsl #1]
// CHECK-INST: ld1h {za0v.h[w14, 5]}, p5/z, [x10, x21, lsl #1]
// CHECK-ENCODING: [0x45,0xd5,0x55,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 45 d5 55 e0 <unknown>
// CHECK-UNKNOWN: e055d545 <unknown>

ld1h za0v.h[w15, 7], p3/z, [x13, x8, lsl #1]
// CHECK-INST: ld1h {za0v.h[w15, 7]}, p3/z, [x13, x8, lsl #1]
// CHECK-ENCODING: [0xa7,0xed,0x48,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a7 ed 48 e0 <unknown>
// CHECK-UNKNOWN: e048eda7 <unknown>

ld1h za1v.h[w15, 7], p7/z, [sp]
// CHECK-INST: ld1h {za1v.h[w15, 7]}, p7/z, [sp]
// CHECK-ENCODING: [0xef,0xff,0x5f,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: ef ff 5f e0 <unknown>
// CHECK-UNKNOWN: e05fffef <unknown>

ld1h za0v.h[w12, 5], p3/z, [x17, x16, lsl #1]
// CHECK-INST: ld1h {za0v.h[w12, 5]}, p3/z, [x17, x16, lsl #1]
// CHECK-ENCODING: [0x25,0x8e,0x50,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 25 8e 50 e0 <unknown>
// CHECK-UNKNOWN: e0508e25 <unknown>

ld1h za0v.h[w12, 1], p1/z, [x1, x30, lsl #1]
// CHECK-INST: ld1h {za0v.h[w12, 1]}, p1/z, [x1, x30, lsl #1]
// CHECK-ENCODING: [0x21,0x84,0x5e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 84 5e e0 <unknown>
// CHECK-UNKNOWN: e05e8421 <unknown>

ld1h za1v.h[w14, 0], p5/z, [x19, x20, lsl #1]
// CHECK-INST: ld1h {za1v.h[w14, 0]}, p5/z, [x19, x20, lsl #1]
// CHECK-ENCODING: [0x68,0xd6,0x54,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 68 d6 54 e0 <unknown>
// CHECK-UNKNOWN: e054d668 <unknown>

ld1h za0v.h[w12, 0], p6/z, [x12, x2, lsl #1]
// CHECK-INST: ld1h {za0v.h[w12, 0]}, p6/z, [x12, x2, lsl #1]
// CHECK-ENCODING: [0x80,0x99,0x42,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 99 42 e0 <unknown>
// CHECK-UNKNOWN: e0429980 <unknown>

ld1h za0v.h[w14, 1], p2/z, [x1, x26, lsl #1]
// CHECK-INST: ld1h {za0v.h[w14, 1]}, p2/z, [x1, x26, lsl #1]
// CHECK-ENCODING: [0x21,0xc8,0x5a,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 c8 5a e0 <unknown>
// CHECK-UNKNOWN: e05ac821 <unknown>

ld1h za1v.h[w12, 5], p2/z, [x22, x30, lsl #1]
// CHECK-INST: ld1h {za1v.h[w12, 5]}, p2/z, [x22, x30, lsl #1]
// CHECK-ENCODING: [0xcd,0x8a,0x5e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: cd 8a 5e e0 <unknown>
// CHECK-UNKNOWN: e05e8acd <unknown>

ld1h za0v.h[w15, 2], p5/z, [x9, x1, lsl #1]
// CHECK-INST: ld1h {za0v.h[w15, 2]}, p5/z, [x9, x1, lsl #1]
// CHECK-ENCODING: [0x22,0xf5,0x41,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 f5 41 e0 <unknown>
// CHECK-UNKNOWN: e041f522 <unknown>

ld1h za0v.h[w13, 7], p2/z, [x12, x11, lsl #1]
// CHECK-INST: ld1h {za0v.h[w13, 7]}, p2/z, [x12, x11, lsl #1]
// CHECK-ENCODING: [0x87,0xa9,0x4b,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 87 a9 4b e0 <unknown>
// CHECK-UNKNOWN: e04ba987 <unknown>
96 changes: 48 additions & 48 deletions llvm/test/MC/AArch64/SME/ld1q.s
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,145 +19,145 @@ ld1q {za0h.q[w12, 0]}, p0/z, [x0, x0, lsl #4]
// CHECK-INST: ld1q {za0h.q[w12, 0]}, p0/z, [x0, x0, lsl #4]
// CHECK-ENCODING: [0x00,0x00,0xc0,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 00 c0 e1 <unknown>
// CHECK-UNKNOWN: e1c00000 <unknown>

ld1q {za5h.q[w14, 0]}, p5/z, [x10, x21, lsl #4]
// CHECK-INST: ld1q {za5h.q[w14, 0]}, p5/z, [x10, x21, lsl #4]
// CHECK-ENCODING: [0x45,0x55,0xd5,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 45 55 d5 e1 <unknown>
// CHECK-UNKNOWN: e1d55545 <unknown>

ld1q {za7h.q[w15, 0]}, p3/z, [x13, x8, lsl #4]
// CHECK-INST: ld1q {za7h.q[w15, 0]}, p3/z, [x13, x8, lsl #4]
// CHECK-ENCODING: [0xa7,0x6d,0xc8,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a7 6d c8 e1 <unknown>
// CHECK-UNKNOWN: e1c86da7 <unknown>

ld1q {za15h.q[w15, 0]}, p7/z, [sp]
// CHECK-INST: ld1q {za15h.q[w15, 0]}, p7/z, [sp]
// CHECK-ENCODING: [0xef,0x7f,0xdf,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: ef 7f df e1 <unknown>
// CHECK-UNKNOWN: e1df7fef <unknown>

ld1q {za5h.q[w12, 0]}, p3/z, [x17, x16, lsl #4]
// CHECK-INST: ld1q {za5h.q[w12, 0]}, p3/z, [x17, x16, lsl #4]
// CHECK-ENCODING: [0x25,0x0e,0xd0,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 25 0e d0 e1 <unknown>
// CHECK-UNKNOWN: e1d00e25 <unknown>

ld1q {za1h.q[w12, 0]}, p1/z, [x1, x30, lsl #4]
// CHECK-INST: ld1q {za1h.q[w12, 0]}, p1/z, [x1, x30, lsl #4]
// CHECK-ENCODING: [0x21,0x04,0xde,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 04 de e1 <unknown>
// CHECK-UNKNOWN: e1de0421 <unknown>

ld1q {za8h.q[w14, 0]}, p5/z, [x19, x20, lsl #4]
// CHECK-INST: ld1q {za8h.q[w14, 0]}, p5/z, [x19, x20, lsl #4]
// CHECK-ENCODING: [0x68,0x56,0xd4,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 68 56 d4 e1 <unknown>
// CHECK-UNKNOWN: e1d45668 <unknown>

ld1q {za0h.q[w12, 0]}, p6/z, [x12, x2, lsl #4]
// CHECK-INST: ld1q {za0h.q[w12, 0]}, p6/z, [x12, x2, lsl #4]
// CHECK-ENCODING: [0x80,0x19,0xc2,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 19 c2 e1 <unknown>
// CHECK-UNKNOWN: e1c21980 <unknown>

ld1q {za1h.q[w14, 0]}, p2/z, [x1, x26, lsl #4]
// CHECK-INST: ld1q {za1h.q[w14, 0]}, p2/z, [x1, x26, lsl #4]
// CHECK-ENCODING: [0x21,0x48,0xda,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 48 da e1 <unknown>
// CHECK-UNKNOWN: e1da4821 <unknown>

ld1q {za13h.q[w12, 0]}, p2/z, [x22, x30, lsl #4]
// CHECK-INST: ld1q {za13h.q[w12, 0]}, p2/z, [x22, x30, lsl #4]
// CHECK-ENCODING: [0xcd,0x0a,0xde,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: cd 0a de e1 <unknown>
// CHECK-UNKNOWN: e1de0acd <unknown>

ld1q {za2h.q[w15, 0]}, p5/z, [x9, x1, lsl #4]
// CHECK-INST: ld1q {za2h.q[w15, 0]}, p5/z, [x9, x1, lsl #4]
// CHECK-ENCODING: [0x22,0x75,0xc1,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 75 c1 e1 <unknown>
// CHECK-UNKNOWN: e1c17522 <unknown>

ld1q {za7h.q[w13, 0]}, p2/z, [x12, x11, lsl #4]
// CHECK-INST: ld1q {za7h.q[w13, 0]}, p2/z, [x12, x11, lsl #4]
// CHECK-ENCODING: [0x87,0x29,0xcb,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 87 29 cb e1 <unknown>
// CHECK-UNKNOWN: e1cb2987 <unknown>

ld1q za0h.q[w12, 0], p0/z, [x0, x0, lsl #4]
// CHECK-INST: ld1q {za0h.q[w12, 0]}, p0/z, [x0, x0, lsl #4]
// CHECK-ENCODING: [0x00,0x00,0xc0,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 00 c0 e1 <unknown>
// CHECK-UNKNOWN: e1c00000 <unknown>

ld1q za5h.q[w14, 0], p5/z, [x10, x21, lsl #4]
// CHECK-INST: ld1q {za5h.q[w14, 0]}, p5/z, [x10, x21, lsl #4]
// CHECK-ENCODING: [0x45,0x55,0xd5,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 45 55 d5 e1 <unknown>
// CHECK-UNKNOWN: e1d55545 <unknown>

ld1q za7h.q[w15, 0], p3/z, [x13, x8, lsl #4]
// CHECK-INST: ld1q {za7h.q[w15, 0]}, p3/z, [x13, x8, lsl #4]
// CHECK-ENCODING: [0xa7,0x6d,0xc8,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a7 6d c8 e1 <unknown>
// CHECK-UNKNOWN: e1c86da7 <unknown>

ld1q za15h.q[w15, 0], p7/z, [sp]
// CHECK-INST: ld1q {za15h.q[w15, 0]}, p7/z, [sp]
// CHECK-ENCODING: [0xef,0x7f,0xdf,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: ef 7f df e1 <unknown>
// CHECK-UNKNOWN: e1df7fef <unknown>

ld1q za5h.q[w12, 0], p3/z, [x17, x16, lsl #4]
// CHECK-INST: ld1q {za5h.q[w12, 0]}, p3/z, [x17, x16, lsl #4]
// CHECK-ENCODING: [0x25,0x0e,0xd0,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 25 0e d0 e1 <unknown>
// CHECK-UNKNOWN: e1d00e25 <unknown>

ld1q za1h.q[w12, 0], p1/z, [x1, x30, lsl #4]
// CHECK-INST: ld1q {za1h.q[w12, 0]}, p1/z, [x1, x30, lsl #4]
// CHECK-ENCODING: [0x21,0x04,0xde,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 04 de e1 <unknown>
// CHECK-UNKNOWN: e1de0421 <unknown>

ld1q za8h.q[w14, 0], p5/z, [x19, x20, lsl #4]
// CHECK-INST: ld1q {za8h.q[w14, 0]}, p5/z, [x19, x20, lsl #4]
// CHECK-ENCODING: [0x68,0x56,0xd4,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 68 56 d4 e1 <unknown>
// CHECK-UNKNOWN: e1d45668 <unknown>

ld1q za0h.q[w12, 0], p6/z, [x12, x2, lsl #4]
// CHECK-INST: ld1q {za0h.q[w12, 0]}, p6/z, [x12, x2, lsl #4]
// CHECK-ENCODING: [0x80,0x19,0xc2,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 19 c2 e1 <unknown>
// CHECK-UNKNOWN: e1c21980 <unknown>

ld1q za1h.q[w14, 0], p2/z, [x1, x26, lsl #4]
// CHECK-INST: ld1q {za1h.q[w14, 0]}, p2/z, [x1, x26, lsl #4]
// CHECK-ENCODING: [0x21,0x48,0xda,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 48 da e1 <unknown>
// CHECK-UNKNOWN: e1da4821 <unknown>

ld1q za13h.q[w12, 0], p2/z, [x22, x30, lsl #4]
// CHECK-INST: ld1q {za13h.q[w12, 0]}, p2/z, [x22, x30, lsl #4]
// CHECK-ENCODING: [0xcd,0x0a,0xde,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: cd 0a de e1 <unknown>
// CHECK-UNKNOWN: e1de0acd <unknown>

ld1q za2h.q[w15, 0], p5/z, [x9, x1, lsl #4]
// CHECK-INST: ld1q {za2h.q[w15, 0]}, p5/z, [x9, x1, lsl #4]
// CHECK-ENCODING: [0x22,0x75,0xc1,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 75 c1 e1 <unknown>
// CHECK-UNKNOWN: e1c17522 <unknown>

ld1q za7h.q[w13, 0], p2/z, [x12, x11, lsl #4]
// CHECK-INST: ld1q {za7h.q[w13, 0]}, p2/z, [x12, x11, lsl #4]
// CHECK-ENCODING: [0x87,0x29,0xcb,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 87 29 cb e1 <unknown>
// CHECK-UNKNOWN: e1cb2987 <unknown>

// --------------------------------------------------------------------------//
// Vertical
Expand All @@ -166,142 +166,142 @@ ld1q {za0v.q[w12, 0]}, p0/z, [x0, x0, lsl #4]
// CHECK-INST: ld1q {za0v.q[w12, 0]}, p0/z, [x0, x0, lsl #4]
// CHECK-ENCODING: [0x00,0x80,0xc0,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 80 c0 e1 <unknown>
// CHECK-UNKNOWN: e1c08000 <unknown>

ld1q {za5v.q[w14, 0]}, p5/z, [x10, x21, lsl #4]
// CHECK-INST: ld1q {za5v.q[w14, 0]}, p5/z, [x10, x21, lsl #4]
// CHECK-ENCODING: [0x45,0xd5,0xd5,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 45 d5 d5 e1 <unknown>
// CHECK-UNKNOWN: e1d5d545 <unknown>

ld1q {za7v.q[w15, 0]}, p3/z, [x13, x8, lsl #4]
// CHECK-INST: ld1q {za7v.q[w15, 0]}, p3/z, [x13, x8, lsl #4]
// CHECK-ENCODING: [0xa7,0xed,0xc8,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a7 ed c8 e1 <unknown>
// CHECK-UNKNOWN: e1c8eda7 <unknown>

ld1q {za15v.q[w15, 0]}, p7/z, [sp]
// CHECK-INST: ld1q {za15v.q[w15, 0]}, p7/z, [sp]
// CHECK-ENCODING: [0xef,0xff,0xdf,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: ef ff df e1 <unknown>
// CHECK-UNKNOWN: e1dfffef <unknown>

ld1q {za5v.q[w12, 0]}, p3/z, [x17, x16, lsl #4]
// CHECK-INST: ld1q {za5v.q[w12, 0]}, p3/z, [x17, x16, lsl #4]
// CHECK-ENCODING: [0x25,0x8e,0xd0,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 25 8e d0 e1 <unknown>
// CHECK-UNKNOWN: e1d08e25 <unknown>

ld1q {za1v.q[w12, 0]}, p1/z, [x1, x30, lsl #4]
// CHECK-INST: ld1q {za1v.q[w12, 0]}, p1/z, [x1, x30, lsl #4]
// CHECK-ENCODING: [0x21,0x84,0xde,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 84 de e1 <unknown>
// CHECK-UNKNOWN: e1de8421 <unknown>

ld1q {za8v.q[w14, 0]}, p5/z, [x19, x20, lsl #4]
// CHECK-INST: ld1q {za8v.q[w14, 0]}, p5/z, [x19, x20, lsl #4]
// CHECK-ENCODING: [0x68,0xd6,0xd4,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 68 d6 d4 e1 <unknown>
// CHECK-UNKNOWN: e1d4d668 <unknown>

ld1q {za0v.q[w12, 0]}, p6/z, [x12, x2, lsl #4]
// CHECK-INST: ld1q {za0v.q[w12, 0]}, p6/z, [x12, x2, lsl #4]
// CHECK-ENCODING: [0x80,0x99,0xc2,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 99 c2 e1 <unknown>
// CHECK-UNKNOWN: e1c29980 <unknown>

ld1q {za1v.q[w14, 0]}, p2/z, [x1, x26, lsl #4]
// CHECK-INST: ld1q {za1v.q[w14, 0]}, p2/z, [x1, x26, lsl #4]
// CHECK-ENCODING: [0x21,0xc8,0xda,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 c8 da e1 <unknown>
// CHECK-UNKNOWN: e1dac821 <unknown>

ld1q {za13v.q[w12, 0]}, p2/z, [x22, x30, lsl #4]
// CHECK-INST: ld1q {za13v.q[w12, 0]}, p2/z, [x22, x30, lsl #4]
// CHECK-ENCODING: [0xcd,0x8a,0xde,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: cd 8a de e1 <unknown>
// CHECK-UNKNOWN: e1de8acd <unknown>

ld1q {za2v.q[w15, 0]}, p5/z, [x9, x1, lsl #4]
// CHECK-INST: ld1q {za2v.q[w15, 0]}, p5/z, [x9, x1, lsl #4]
// CHECK-ENCODING: [0x22,0xf5,0xc1,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 f5 c1 e1 <unknown>
// CHECK-UNKNOWN: e1c1f522 <unknown>

ld1q {za7v.q[w13, 0]}, p2/z, [x12, x11, lsl #4]
// CHECK-INST: ld1q {za7v.q[w13, 0]}, p2/z, [x12, x11, lsl #4]
// CHECK-ENCODING: [0x87,0xa9,0xcb,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 87 a9 cb e1 <unknown>
// CHECK-UNKNOWN: e1cba987 <unknown>

ld1q za0v.q[w12, 0], p0/z, [x0, x0, lsl #4]
// CHECK-INST: ld1q {za0v.q[w12, 0]}, p0/z, [x0, x0, lsl #4]
// CHECK-ENCODING: [0x00,0x80,0xc0,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 80 c0 e1 <unknown>
// CHECK-UNKNOWN: e1c08000 <unknown>

ld1q za5v.q[w14, 0], p5/z, [x10, x21, lsl #4]
// CHECK-INST: ld1q {za5v.q[w14, 0]}, p5/z, [x10, x21, lsl #4]
// CHECK-ENCODING: [0x45,0xd5,0xd5,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 45 d5 d5 e1 <unknown>
// CHECK-UNKNOWN: e1d5d545 <unknown>

ld1q za7v.q[w15, 0], p3/z, [x13, x8, lsl #4]
// CHECK-INST: ld1q {za7v.q[w15, 0]}, p3/z, [x13, x8, lsl #4]
// CHECK-ENCODING: [0xa7,0xed,0xc8,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a7 ed c8 e1 <unknown>
// CHECK-UNKNOWN: e1c8eda7 <unknown>

ld1q za15v.q[w15, 0], p7/z, [sp]
// CHECK-INST: ld1q {za15v.q[w15, 0]}, p7/z, [sp]
// CHECK-ENCODING: [0xef,0xff,0xdf,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: ef ff df e1 <unknown>
// CHECK-UNKNOWN: e1dfffef <unknown>

ld1q za5v.q[w12, 0], p3/z, [x17, x16, lsl #4]
// CHECK-INST: ld1q {za5v.q[w12, 0]}, p3/z, [x17, x16, lsl #4]
// CHECK-ENCODING: [0x25,0x8e,0xd0,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 25 8e d0 e1 <unknown>
// CHECK-UNKNOWN: e1d08e25 <unknown>

ld1q za1v.q[w12, 0], p1/z, [x1, x30, lsl #4]
// CHECK-INST: ld1q {za1v.q[w12, 0]}, p1/z, [x1, x30, lsl #4]
// CHECK-ENCODING: [0x21,0x84,0xde,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 84 de e1 <unknown>
// CHECK-UNKNOWN: e1de8421 <unknown>

ld1q za8v.q[w14, 0], p5/z, [x19, x20, lsl #4]
// CHECK-INST: ld1q {za8v.q[w14, 0]}, p5/z, [x19, x20, lsl #4]
// CHECK-ENCODING: [0x68,0xd6,0xd4,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 68 d6 d4 e1 <unknown>
// CHECK-UNKNOWN: e1d4d668 <unknown>

ld1q za0v.q[w12, 0], p6/z, [x12, x2, lsl #4]
// CHECK-INST: ld1q {za0v.q[w12, 0]}, p6/z, [x12, x2, lsl #4]
// CHECK-ENCODING: [0x80,0x99,0xc2,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 99 c2 e1 <unknown>
// CHECK-UNKNOWN: e1c29980 <unknown>

ld1q za1v.q[w14, 0], p2/z, [x1, x26, lsl #4]
// CHECK-INST: ld1q {za1v.q[w14, 0]}, p2/z, [x1, x26, lsl #4]
// CHECK-ENCODING: [0x21,0xc8,0xda,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 c8 da e1 <unknown>
// CHECK-UNKNOWN: e1dac821 <unknown>

ld1q za13v.q[w12, 0], p2/z, [x22, x30, lsl #4]
// CHECK-INST: ld1q {za13v.q[w12, 0]}, p2/z, [x22, x30, lsl #4]
// CHECK-ENCODING: [0xcd,0x8a,0xde,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: cd 8a de e1 <unknown>
// CHECK-UNKNOWN: e1de8acd <unknown>

ld1q za2v.q[w15, 0], p5/z, [x9, x1, lsl #4]
// CHECK-INST: ld1q {za2v.q[w15, 0]}, p5/z, [x9, x1, lsl #4]
// CHECK-ENCODING: [0x22,0xf5,0xc1,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 f5 c1 e1 <unknown>
// CHECK-UNKNOWN: e1c1f522 <unknown>

ld1q za7v.q[w13, 0], p2/z, [x12, x11, lsl #4]
// CHECK-INST: ld1q {za7v.q[w13, 0]}, p2/z, [x12, x11, lsl #4]
// CHECK-ENCODING: [0x87,0xa9,0xcb,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 87 a9 cb e1 <unknown>
// CHECK-UNKNOWN: e1cba987 <unknown>
96 changes: 48 additions & 48 deletions llvm/test/MC/AArch64/SME/ld1w.s
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,145 +19,145 @@ ld1w {za0h.s[w12, 0]}, p0/z, [x0, x0, lsl #2]
// CHECK-INST: ld1w {za0h.s[w12, 0]}, p0/z, [x0, x0, lsl #2]
// CHECK-ENCODING: [0x00,0x00,0x80,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 00 80 e0 <unknown>
// CHECK-UNKNOWN: e0800000 <unknown>

ld1w {za1h.s[w14, 1]}, p5/z, [x10, x21, lsl #2]
// CHECK-INST: ld1w {za1h.s[w14, 1]}, p5/z, [x10, x21, lsl #2]
// CHECK-ENCODING: [0x45,0x55,0x95,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 45 55 95 e0 <unknown>
// CHECK-UNKNOWN: e0955545 <unknown>

ld1w {za1h.s[w15, 3]}, p3/z, [x13, x8, lsl #2]
// CHECK-INST: ld1w {za1h.s[w15, 3]}, p3/z, [x13, x8, lsl #2]
// CHECK-ENCODING: [0xa7,0x6d,0x88,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a7 6d 88 e0 <unknown>
// CHECK-UNKNOWN: e0886da7 <unknown>

ld1w {za3h.s[w15, 3]}, p7/z, [sp]
// CHECK-INST: ld1w {za3h.s[w15, 3]}, p7/z, [sp]
// CHECK-ENCODING: [0xef,0x7f,0x9f,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: ef 7f 9f e0 <unknown>
// CHECK-UNKNOWN: e09f7fef <unknown>

ld1w {za1h.s[w12, 1]}, p3/z, [x17, x16, lsl #2]
// CHECK-INST: ld1w {za1h.s[w12, 1]}, p3/z, [x17, x16, lsl #2]
// CHECK-ENCODING: [0x25,0x0e,0x90,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 25 0e 90 e0 <unknown>
// CHECK-UNKNOWN: e0900e25 <unknown>

ld1w {za0h.s[w12, 1]}, p1/z, [x1, x30, lsl #2]
// CHECK-INST: ld1w {za0h.s[w12, 1]}, p1/z, [x1, x30, lsl #2]
// CHECK-ENCODING: [0x21,0x04,0x9e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 04 9e e0 <unknown>
// CHECK-UNKNOWN: e09e0421 <unknown>

ld1w {za2h.s[w14, 0]}, p5/z, [x19, x20, lsl #2]
// CHECK-INST: ld1w {za2h.s[w14, 0]}, p5/z, [x19, x20, lsl #2]
// CHECK-ENCODING: [0x68,0x56,0x94,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 68 56 94 e0 <unknown>
// CHECK-UNKNOWN: e0945668 <unknown>

ld1w {za0h.s[w12, 0]}, p6/z, [x12, x2, lsl #2]
// CHECK-INST: ld1w {za0h.s[w12, 0]}, p6/z, [x12, x2, lsl #2]
// CHECK-ENCODING: [0x80,0x19,0x82,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 19 82 e0 <unknown>
// CHECK-UNKNOWN: e0821980 <unknown>

ld1w {za0h.s[w14, 1]}, p2/z, [x1, x26, lsl #2]
// CHECK-INST: ld1w {za0h.s[w14, 1]}, p2/z, [x1, x26, lsl #2]
// CHECK-ENCODING: [0x21,0x48,0x9a,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 48 9a e0 <unknown>
// CHECK-UNKNOWN: e09a4821 <unknown>

ld1w {za3h.s[w12, 1]}, p2/z, [x22, x30, lsl #2]
// CHECK-INST: ld1w {za3h.s[w12, 1]}, p2/z, [x22, x30, lsl #2]
// CHECK-ENCODING: [0xcd,0x0a,0x9e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: cd 0a 9e e0 <unknown>
// CHECK-UNKNOWN: e09e0acd <unknown>

ld1w {za0h.s[w15, 2]}, p5/z, [x9, x1, lsl #2]
// CHECK-INST: ld1w {za0h.s[w15, 2]}, p5/z, [x9, x1, lsl #2]
// CHECK-ENCODING: [0x22,0x75,0x81,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 75 81 e0 <unknown>
// CHECK-UNKNOWN: e0817522 <unknown>

ld1w {za1h.s[w13, 3]}, p2/z, [x12, x11, lsl #2]
// CHECK-INST: ld1w {za1h.s[w13, 3]}, p2/z, [x12, x11, lsl #2]
// CHECK-ENCODING: [0x87,0x29,0x8b,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 87 29 8b e0 <unknown>
// CHECK-UNKNOWN: e08b2987 <unknown>

ld1w za0h.s[w12, 0], p0/z, [x0, x0, lsl #2]
// CHECK-INST: ld1w {za0h.s[w12, 0]}, p0/z, [x0, x0, lsl #2]
// CHECK-ENCODING: [0x00,0x00,0x80,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 00 80 e0 <unknown>
// CHECK-UNKNOWN: e0800000 <unknown>

ld1w za1h.s[w14, 1], p5/z, [x10, x21, lsl #2]
// CHECK-INST: ld1w {za1h.s[w14, 1]}, p5/z, [x10, x21, lsl #2]
// CHECK-ENCODING: [0x45,0x55,0x95,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 45 55 95 e0 <unknown>
// CHECK-UNKNOWN: e0955545 <unknown>

ld1w za1h.s[w15, 3], p3/z, [x13, x8, lsl #2]
// CHECK-INST: ld1w {za1h.s[w15, 3]}, p3/z, [x13, x8, lsl #2]
// CHECK-ENCODING: [0xa7,0x6d,0x88,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a7 6d 88 e0 <unknown>
// CHECK-UNKNOWN: e0886da7 <unknown>

ld1w za3h.s[w15, 3], p7/z, [sp]
// CHECK-INST: ld1w {za3h.s[w15, 3]}, p7/z, [sp]
// CHECK-ENCODING: [0xef,0x7f,0x9f,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: ef 7f 9f e0 <unknown>
// CHECK-UNKNOWN: e09f7fef <unknown>

ld1w za1h.s[w12, 1], p3/z, [x17, x16, lsl #2]
// CHECK-INST: ld1w {za1h.s[w12, 1]}, p3/z, [x17, x16, lsl #2]
// CHECK-ENCODING: [0x25,0x0e,0x90,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 25 0e 90 e0 <unknown>
// CHECK-UNKNOWN: e0900e25 <unknown>

ld1w za0h.s[w12, 1], p1/z, [x1, x30, lsl #2]
// CHECK-INST: ld1w {za0h.s[w12, 1]}, p1/z, [x1, x30, lsl #2]
// CHECK-ENCODING: [0x21,0x04,0x9e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 04 9e e0 <unknown>
// CHECK-UNKNOWN: e09e0421 <unknown>

ld1w za2h.s[w14, 0], p5/z, [x19, x20, lsl #2]
// CHECK-INST: ld1w {za2h.s[w14, 0]}, p5/z, [x19, x20, lsl #2]
// CHECK-ENCODING: [0x68,0x56,0x94,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 68 56 94 e0 <unknown>
// CHECK-UNKNOWN: e0945668 <unknown>

ld1w za0h.s[w12, 0], p6/z, [x12, x2, lsl #2]
// CHECK-INST: ld1w {za0h.s[w12, 0]}, p6/z, [x12, x2, lsl #2]
// CHECK-ENCODING: [0x80,0x19,0x82,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 19 82 e0 <unknown>
// CHECK-UNKNOWN: e0821980 <unknown>

ld1w za0h.s[w14, 1], p2/z, [x1, x26, lsl #2]
// CHECK-INST: ld1w {za0h.s[w14, 1]}, p2/z, [x1, x26, lsl #2]
// CHECK-ENCODING: [0x21,0x48,0x9a,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 48 9a e0 <unknown>
// CHECK-UNKNOWN: e09a4821 <unknown>

ld1w za3h.s[w12, 1], p2/z, [x22, x30, lsl #2]
// CHECK-INST: ld1w {za3h.s[w12, 1]}, p2/z, [x22, x30, lsl #2]
// CHECK-ENCODING: [0xcd,0x0a,0x9e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: cd 0a 9e e0 <unknown>
// CHECK-UNKNOWN: e09e0acd <unknown>

ld1w za0h.s[w15, 2], p5/z, [x9, x1, lsl #2]
// CHECK-INST: ld1w {za0h.s[w15, 2]}, p5/z, [x9, x1, lsl #2]
// CHECK-ENCODING: [0x22,0x75,0x81,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 75 81 e0 <unknown>
// CHECK-UNKNOWN: e0817522 <unknown>

ld1w za1h.s[w13, 3], p2/z, [x12, x11, lsl #2]
// CHECK-INST: ld1w {za1h.s[w13, 3]}, p2/z, [x12, x11, lsl #2]
// CHECK-ENCODING: [0x87,0x29,0x8b,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 87 29 8b e0 <unknown>
// CHECK-UNKNOWN: e08b2987 <unknown>

// --------------------------------------------------------------------------//
// Vertical
Expand All @@ -166,142 +166,142 @@ ld1w {za0v.s[w12, 0]}, p0/z, [x0, x0, lsl #2]
// CHECK-INST: ld1w {za0v.s[w12, 0]}, p0/z, [x0, x0, lsl #2]
// CHECK-ENCODING: [0x00,0x80,0x80,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 80 80 e0 <unknown>
// CHECK-UNKNOWN: e0808000 <unknown>

ld1w {za1v.s[w14, 1]}, p5/z, [x10, x21, lsl #2]
// CHECK-INST: ld1w {za1v.s[w14, 1]}, p5/z, [x10, x21, lsl #2]
// CHECK-ENCODING: [0x45,0xd5,0x95,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 45 d5 95 e0 <unknown>
// CHECK-UNKNOWN: e095d545 <unknown>

ld1w {za1v.s[w15, 3]}, p3/z, [x13, x8, lsl #2]
// CHECK-INST: ld1w {za1v.s[w15, 3]}, p3/z, [x13, x8, lsl #2]
// CHECK-ENCODING: [0xa7,0xed,0x88,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a7 ed 88 e0 <unknown>
// CHECK-UNKNOWN: e088eda7 <unknown>

ld1w {za3v.s[w15, 3]}, p7/z, [sp]
// CHECK-INST: ld1w {za3v.s[w15, 3]}, p7/z, [sp]
// CHECK-ENCODING: [0xef,0xff,0x9f,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: ef ff 9f e0 <unknown>
// CHECK-UNKNOWN: e09fffef <unknown>

ld1w {za1v.s[w12, 1]}, p3/z, [x17, x16, lsl #2]
// CHECK-INST: ld1w {za1v.s[w12, 1]}, p3/z, [x17, x16, lsl #2]
// CHECK-ENCODING: [0x25,0x8e,0x90,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 25 8e 90 e0 <unknown>
// CHECK-UNKNOWN: e0908e25 <unknown>

ld1w {za0v.s[w12, 1]}, p1/z, [x1, x30, lsl #2]
// CHECK-INST: ld1w {za0v.s[w12, 1]}, p1/z, [x1, x30, lsl #2]
// CHECK-ENCODING: [0x21,0x84,0x9e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 84 9e e0 <unknown>
// CHECK-UNKNOWN: e09e8421 <unknown>

ld1w {za2v.s[w14, 0]}, p5/z, [x19, x20, lsl #2]
// CHECK-INST: ld1w {za2v.s[w14, 0]}, p5/z, [x19, x20, lsl #2]
// CHECK-ENCODING: [0x68,0xd6,0x94,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 68 d6 94 e0 <unknown>
// CHECK-UNKNOWN: e094d668 <unknown>

ld1w {za0v.s[w12, 0]}, p6/z, [x12, x2, lsl #2]
// CHECK-INST: ld1w {za0v.s[w12, 0]}, p6/z, [x12, x2, lsl #2]
// CHECK-ENCODING: [0x80,0x99,0x82,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 99 82 e0 <unknown>
// CHECK-UNKNOWN: e0829980 <unknown>

ld1w {za0v.s[w14, 1]}, p2/z, [x1, x26, lsl #2]
// CHECK-INST: ld1w {za0v.s[w14, 1]}, p2/z, [x1, x26, lsl #2]
// CHECK-ENCODING: [0x21,0xc8,0x9a,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 c8 9a e0 <unknown>
// CHECK-UNKNOWN: e09ac821 <unknown>

ld1w {za3v.s[w12, 1]}, p2/z, [x22, x30, lsl #2]
// CHECK-INST: ld1w {za3v.s[w12, 1]}, p2/z, [x22, x30, lsl #2]
// CHECK-ENCODING: [0xcd,0x8a,0x9e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: cd 8a 9e e0 <unknown>
// CHECK-UNKNOWN: e09e8acd <unknown>

ld1w {za0v.s[w15, 2]}, p5/z, [x9, x1, lsl #2]
// CHECK-INST: ld1w {za0v.s[w15, 2]}, p5/z, [x9, x1, lsl #2]
// CHECK-ENCODING: [0x22,0xf5,0x81,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 f5 81 e0 <unknown>
// CHECK-UNKNOWN: e081f522 <unknown>

ld1w {za1v.s[w13, 3]}, p2/z, [x12, x11, lsl #2]
// CHECK-INST: ld1w {za1v.s[w13, 3]}, p2/z, [x12, x11, lsl #2]
// CHECK-ENCODING: [0x87,0xa9,0x8b,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 87 a9 8b e0 <unknown>
// CHECK-UNKNOWN: e08ba987 <unknown>

ld1w za0v.s[w12, 0], p0/z, [x0, x0, lsl #2]
// CHECK-INST: ld1w {za0v.s[w12, 0]}, p0/z, [x0, x0, lsl #2]
// CHECK-ENCODING: [0x00,0x80,0x80,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 80 80 e0 <unknown>
// CHECK-UNKNOWN: e0808000 <unknown>

ld1w za1v.s[w14, 1], p5/z, [x10, x21, lsl #2]
// CHECK-INST: ld1w {za1v.s[w14, 1]}, p5/z, [x10, x21, lsl #2]
// CHECK-ENCODING: [0x45,0xd5,0x95,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 45 d5 95 e0 <unknown>
// CHECK-UNKNOWN: e095d545 <unknown>

ld1w za1v.s[w15, 3], p3/z, [x13, x8, lsl #2]
// CHECK-INST: ld1w {za1v.s[w15, 3]}, p3/z, [x13, x8, lsl #2]
// CHECK-ENCODING: [0xa7,0xed,0x88,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a7 ed 88 e0 <unknown>
// CHECK-UNKNOWN: e088eda7 <unknown>

ld1w za3v.s[w15, 3], p7/z, [sp]
// CHECK-INST: ld1w {za3v.s[w15, 3]}, p7/z, [sp]
// CHECK-ENCODING: [0xef,0xff,0x9f,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: ef ff 9f e0 <unknown>
// CHECK-UNKNOWN: e09fffef <unknown>

ld1w za1v.s[w12, 1], p3/z, [x17, x16, lsl #2]
// CHECK-INST: ld1w {za1v.s[w12, 1]}, p3/z, [x17, x16, lsl #2]
// CHECK-ENCODING: [0x25,0x8e,0x90,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 25 8e 90 e0 <unknown>
// CHECK-UNKNOWN: e0908e25 <unknown>

ld1w za0v.s[w12, 1], p1/z, [x1, x30, lsl #2]
// CHECK-INST: ld1w {za0v.s[w12, 1]}, p1/z, [x1, x30, lsl #2]
// CHECK-ENCODING: [0x21,0x84,0x9e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 84 9e e0 <unknown>
// CHECK-UNKNOWN: e09e8421 <unknown>

ld1w za2v.s[w14, 0], p5/z, [x19, x20, lsl #2]
// CHECK-INST: ld1w {za2v.s[w14, 0]}, p5/z, [x19, x20, lsl #2]
// CHECK-ENCODING: [0x68,0xd6,0x94,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 68 d6 94 e0 <unknown>
// CHECK-UNKNOWN: e094d668 <unknown>

ld1w za0v.s[w12, 0], p6/z, [x12, x2, lsl #2]
// CHECK-INST: ld1w {za0v.s[w12, 0]}, p6/z, [x12, x2, lsl #2]
// CHECK-ENCODING: [0x80,0x99,0x82,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 99 82 e0 <unknown>
// CHECK-UNKNOWN: e0829980 <unknown>

ld1w za0v.s[w14, 1], p2/z, [x1, x26, lsl #2]
// CHECK-INST: ld1w {za0v.s[w14, 1]}, p2/z, [x1, x26, lsl #2]
// CHECK-ENCODING: [0x21,0xc8,0x9a,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 c8 9a e0 <unknown>
// CHECK-UNKNOWN: e09ac821 <unknown>

ld1w za3v.s[w12, 1], p2/z, [x22, x30, lsl #2]
// CHECK-INST: ld1w {za3v.s[w12, 1]}, p2/z, [x22, x30, lsl #2]
// CHECK-ENCODING: [0xcd,0x8a,0x9e,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: cd 8a 9e e0 <unknown>
// CHECK-UNKNOWN: e09e8acd <unknown>

ld1w za0v.s[w15, 2], p5/z, [x9, x1, lsl #2]
// CHECK-INST: ld1w {za0v.s[w15, 2]}, p5/z, [x9, x1, lsl #2]
// CHECK-ENCODING: [0x22,0xf5,0x81,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 f5 81 e0 <unknown>
// CHECK-UNKNOWN: e081f522 <unknown>

ld1w za1v.s[w13, 3], p2/z, [x12, x11, lsl #2]
// CHECK-INST: ld1w {za1v.s[w13, 3]}, p2/z, [x12, x11, lsl #2]
// CHECK-ENCODING: [0x87,0xa9,0x8b,0xe0]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 87 a9 8b e0 <unknown>
// CHECK-UNKNOWN: e08ba987 <unknown>
24 changes: 12 additions & 12 deletions llvm/test/MC/AArch64/SME/ldr.s
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,70 +16,70 @@ ldr za[w12, 0], [x0]
// CHECK-INST: ldr za[w12, 0], [x0]
// CHECK-ENCODING: [0x00,0x00,0x00,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 00 00 00 e1 <unknown>
// CHECK-UNKNOWN: e1000000 <unknown>

ldr za[w14, 5], [x10, #5, mul vl]
// CHECK-INST: ldr za[w14, 5], [x10, #5, mul vl]
// CHECK-ENCODING: [0x45,0x41,0x00,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 45 41 00 e1 <unknown>
// CHECK-UNKNOWN: e1004145 <unknown>

ldr za[w15, 7], [x13, #7, mul vl]
// CHECK-INST: ldr za[w15, 7], [x13, #7, mul vl]
// CHECK-ENCODING: [0xa7,0x61,0x00,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: a7 61 00 e1 <unknown>
// CHECK-UNKNOWN: e10061a7 <unknown>

ldr za[w15, 15], [sp, #15, mul vl]
// CHECK-INST: ldr za[w15, 15], [sp, #15, mul vl]
// CHECK-ENCODING: [0xef,0x63,0x00,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: ef 63 00 e1 <unknown>
// CHECK-UNKNOWN: e10063ef <unknown>

ldr za[w12, 5], [x17, #5, mul vl]
// CHECK-INST: ldr za[w12, 5], [x17, #5, mul vl]
// CHECK-ENCODING: [0x25,0x02,0x00,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 25 02 00 e1 <unknown>
// CHECK-UNKNOWN: e1000225 <unknown>

ldr za[w12, 1], [x1, #1, mul vl]
// CHECK-INST: ldr za[w12, 1], [x1, #1, mul vl]
// CHECK-ENCODING: [0x21,0x00,0x00,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 00 00 e1 <unknown>
// CHECK-UNKNOWN: e1000021 <unknown>

ldr za[w14, 8], [x19, #8, mul vl]
// CHECK-INST: ldr za[w14, 8], [x19, #8, mul vl]
// CHECK-ENCODING: [0x68,0x42,0x00,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 68 42 00 e1 <unknown>
// CHECK-UNKNOWN: e1004268 <unknown>

ldr za[w12, 0], [x12]
// CHECK-INST: ldr za[w12, 0], [x12]
// CHECK-ENCODING: [0x80,0x01,0x00,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 80 01 00 e1 <unknown>
// CHECK-UNKNOWN: e1000180 <unknown>

ldr za[w14, 1], [x1, #1, mul vl]
// CHECK-INST: ldr za[w14, 1], [x1, #1, mul vl]
// CHECK-ENCODING: [0x21,0x40,0x00,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 21 40 00 e1 <unknown>
// CHECK-UNKNOWN: e1004021 <unknown>

ldr za[w12, 13], [x22, #13, mul vl]
// CHECK-INST: ldr za[w12, 13], [x22, #13, mul vl]
// CHECK-ENCODING: [0xcd,0x02,0x00,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: cd 02 00 e1 <unknown>
// CHECK-UNKNOWN: e10002cd <unknown>

ldr za[w15, 2], [x9, #2, mul vl]
// CHECK-INST: ldr za[w15, 2], [x9, #2, mul vl]
// CHECK-ENCODING: [0x22,0x61,0x00,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 22 61 00 e1 <unknown>
// CHECK-UNKNOWN: e1006122 <unknown>

ldr za[w13, 7], [x12, #7, mul vl]
// CHECK-INST: ldr za[w13, 7], [x12, #7, mul vl]
// CHECK-ENCODING: [0x87,0x21,0x00,0xe1]
// CHECK-ERROR: instruction requires: sme
// CHECK-UNKNOWN: 87 21 00 e1 <unknown>
// CHECK-UNKNOWN: e1002187 <unknown>
Loading