diff --git a/llvm/lib/Target/AArch64/AArch64InstrFormats.td b/llvm/lib/Target/AArch64/AArch64InstrFormats.td --- a/llvm/lib/Target/AArch64/AArch64InstrFormats.td +++ b/llvm/lib/Target/AArch64/AArch64InstrFormats.td @@ -1428,11 +1428,39 @@ let ParserMethod = "tryParseImmRange"; } +// Implicit immediate ranges 0:1 and 0:3, scale has no meaning +// since the immediate is zero +def UImm0s2RangeOperand : UImmScaledMemoryIndexedRange<0, 2, 1>; +def UImm0s4RangeOperand : UImmScaledMemoryIndexedRange<0, 4, 3>; + +def UImm1s2RangeOperand : UImmScaledMemoryIndexedRange<1, 2, 1>; def UImm1s4RangeOperand : UImmScaledMemoryIndexedRange<1, 4, 3>; def UImm2s2RangeOperand : UImmScaledMemoryIndexedRange<2, 2, 1>; def UImm2s4RangeOperand : UImmScaledMemoryIndexedRange<2, 4, 3>; def UImm3s2RangeOperand : UImmScaledMemoryIndexedRange<3, 2, 1>; +def uimm0s2range : Operand, ImmLeaf { + let PrintMethod = "printImmRangeScale<2, 1>"; + let ParserMatchClass = UImm0s2RangeOperand; + let OperandNamespace = "AArch64"; + let OperandType = "OPERAND_IMPLICIT_IMM_0"; +} + +def uimm0s4range : Operand, ImmLeaf { + let PrintMethod = "printImmRangeScale<4, 3>"; + let ParserMatchClass = UImm0s4RangeOperand; + let OperandNamespace = "AArch64"; + let OperandType = "OPERAND_IMPLICIT_IMM_0"; +} + +def uimm1s2range : Operand, ImmLeaf= 0 && Imm <= 2 && ((Imm % 2) == 0); }], UImmS2XForm> { + let PrintMethod = "printImmRangeScale<2, 1>"; + let ParserMatchClass = UImm1s2RangeOperand; +} + def uimm1s4range : Operand, ImmLeaf= 0 && Imm <= 4 && ((Imm % 4) == 0); }], UImmS4XForm> { let PrintMethod = "printImmRangeScale<4, 3>"; diff --git a/llvm/lib/Target/AArch64/AArch64RegisterInfo.td b/llvm/lib/Target/AArch64/AArch64RegisterInfo.td --- a/llvm/lib/Target/AArch64/AArch64RegisterInfo.td +++ b/llvm/lib/Target/AArch64/AArch64RegisterInfo.td @@ -1542,6 +1542,8 @@ def MatrixOp : MatrixOperand; // SME2 register operands and classes +def MatrixOp8 : MatrixOperand; +def MatrixOp16 : MatrixOperand; def MatrixOp32 : MatrixOperand; def MatrixOp64 : MatrixOperand; diff --git a/llvm/lib/Target/AArch64/AArch64SMEInstrInfo.td b/llvm/lib/Target/AArch64/AArch64SMEInstrInfo.td --- a/llvm/lib/Target/AArch64/AArch64SMEInstrInfo.td +++ b/llvm/lib/Target/AArch64/AArch64SMEInstrInfo.td @@ -596,6 +596,16 @@ defm FRINTN_4Z4Z: sme2_frint_vector_vg4_multi<"frintn", 0b1000000>; defm FRINTP_2Z2Z: sme2_frint_vector_vg2_multi<"frintp", 0b10010>; defm FRINTP_4Z4Z: sme2_frint_vector_vg4_multi<"frintp", 0b1001000>; + +defm MOVA_MXI2Z : sme2_mova_vec_to_tile_vg2_multi<"mova">; +defm MOVA_MXI4Z : sme2_mova_vec_to_tile_vg4_multi<"mova">; +defm MOVA_2ZMXI : sme2_mova_tile_to_vec_vg2_multi<"mova">; +defm MOVA_4ZMXI : sme2_mova_tile_to_vec_vg4_multi<"mova">; + +defm MOVA_VG2_MXI2Z : sme2_mova_vec_to_array_vg2_multi<"mova">; +defm MOVA_VG4_MXI4Z : sme2_mova_vec_to_array_vg4_multi<"mova">; +defm MOVA_VG2_2ZMXI : sme2_mova_array_to_vec_vg2_multi<"mova">; +defm MOVA_VG4_4ZMXI : sme2_mova_array_to_vec_vg4_multi<"mova">; } let Predicates = [HasSME2, HasSMEI16I64] in { diff --git a/llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp b/llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp --- a/llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp +++ b/llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp @@ -3167,6 +3167,14 @@ // Eat ',' Lex(); + StringRef VecGroup; + if (!parseOptionalVGOperand(Operands, VecGroup)) { + Operands.push_back( + AArch64Operand::CreateImm(Imm, S, getLoc(), getContext())); + Operands.push_back( + AArch64Operand::CreateToken(VecGroup, getLoc(), getContext())); + return MatchOperand_Success; + } // The optional operand must be "lsl #N" where N is non-negative. if (!getTok().is(AsmToken::Identifier) || @@ -5570,6 +5578,13 @@ return Error(Loc, "immediate must be an integer in range [1, 32]."); case Match_InvalidImm1_64: return Error(Loc, "immediate must be an integer in range [1, 64]."); + case Match_InvalidMemoryIndexedRange2UImm0: + return Error(Loc, "vector select offset must be the immediate range 0:1."); + case Match_InvalidMemoryIndexedRange2UImm1: + return Error(Loc, "vector select offset must be an immediate range of the " + "form :, where the first " + "immediate is a multiple of 2 in the range [0, 2], and " + "the second immediate is immf + 1."); case Match_InvalidMemoryIndexedRange2UImm2: case Match_InvalidMemoryIndexedRange2UImm3: return Error( @@ -5579,6 +5594,8 @@ "where the first immediate is a multiple of 2 in the range [0, 6] or " "[0, 14] " "depending on the instruction, and the second immediate is immf + 1."); + case Match_InvalidMemoryIndexedRange4UImm0: + return Error(Loc, "vector select offset must be the immediate range 0:3."); case Match_InvalidMemoryIndexedRange4UImm1: case Match_InvalidMemoryIndexedRange4UImm2: return Error( @@ -5794,6 +5811,10 @@ return Error(Loc, "invalid matrix operand, expected za[0-7].d"); case Match_InvalidMatrix: return Error(Loc, "invalid matrix operand, expected za"); + case Match_InvalidMatrix8: + return Error(Loc, "invalid matrix operand, expected suffix .b"); + case Match_InvalidMatrix16: + return Error(Loc, "invalid matrix operand, expected suffix .h"); case Match_InvalidMatrix32: return Error(Loc, "invalid matrix operand, expected suffix .s"); case Match_InvalidMatrix64: @@ -6260,8 +6281,11 @@ case Match_InvalidImm1_16: case Match_InvalidImm1_32: case Match_InvalidImm1_64: + case Match_InvalidMemoryIndexedRange2UImm0: + case Match_InvalidMemoryIndexedRange2UImm1: case Match_InvalidMemoryIndexedRange2UImm2: case Match_InvalidMemoryIndexedRange2UImm3: + case Match_InvalidMemoryIndexedRange4UImm0: case Match_InvalidMemoryIndexedRange4UImm1: case Match_InvalidMemoryIndexedRange4UImm2: case Match_InvalidSVEAddSubImm8: @@ -6360,6 +6384,8 @@ case Match_InvalidMatrixTile32: case Match_InvalidMatrixTile64: case Match_InvalidMatrix: + case Match_InvalidMatrix8: + case Match_InvalidMatrix16: case Match_InvalidMatrix32: case Match_InvalidMatrix64: case Match_InvalidMatrixTileVectorH8: diff --git a/llvm/lib/Target/AArch64/SMEInstrFormats.td b/llvm/lib/Target/AArch64/SMEInstrFormats.td --- a/llvm/lib/Target/AArch64/SMEInstrFormats.td +++ b/llvm/lib/Target/AArch64/SMEInstrFormats.td @@ -2670,3 +2670,902 @@ def _S : sme2_luti4_vector_vg4_index<0b10, ZZZZ_s_mul_r, mnemonic>; } +//===----------------------------------------------------------------------===// +// SME2 MOV +class sme2_mova_vec_to_tile_vg2_multi_base sz, bit v, + RegisterOperand tile_ty, + Operand index_ty, + RegisterOperand vector_ty, + string mnemonic> + : I<(outs tile_ty:$ZAd), + (ins tile_ty:$_ZAd, MatrixIndexGPR32Op12_15:$Rs, index_ty:$imm, vector_ty:$Zn), + mnemonic, "\t$ZAd[$Rs, $imm, vgx2], $Zn", + "", []>, Sched<[]> { + bits<2> Rs; + bits<4> Zn; + let Inst{31-24} = 0b11000000; + let Inst{23-22} = sz; + let Inst{21-16} = 0b000100; + let Inst{15} = v; + let Inst{14-13} = Rs; + let Inst{12-10} = 0b000; + let Inst{9-6} = Zn; + let Inst{5-3} = 0b000; + + let Constraints = "$ZAd = $_ZAd"; +} + +multiclass sme2_mova_vec_to_tile_or_array_aliases { + def : InstAlias; + +} + +// SME2 move vector to tile, two registers +multiclass sme2_mova_vec_to_tile_vg2_multi_base { + + def _B : sme2_mova_vec_to_tile_vg2_multi_base<0b00, v, + !if(v, TileVectorOpV8, + TileVectorOpH8), + uimm3s2range, ZZ_b_mul_r, + mnemonic> { + bits<3> imm; + let Inst{2-0} = imm; + } + + def _H : sme2_mova_vec_to_tile_vg2_multi_base<0b01, v, + !if(v, TileVectorOpV16, + TileVectorOpH16), + uimm2s2range, ZZ_h_mul_r, + mnemonic> { + bits<1> ZAd; + bits<2> imm; + let Inst{2} = ZAd; + let Inst{1-0} = imm; + } + + def _S : sme2_mova_vec_to_tile_vg2_multi_base<0b10, v, + !if(v, TileVectorOpV32, + TileVectorOpH32), + uimm1s2range, ZZ_s_mul_r, + mnemonic> { + bits<2> ZAd; + bits<1> imm; + let Inst{2-1} = ZAd; + let Inst{0} = imm; + } + + def _D : sme2_mova_vec_to_tile_vg2_multi_base<0b11, v, + !if(v, TileVectorOpV64, + TileVectorOpH64), + uimm0s2range, ZZ_d_mul_r, + mnemonic> { + bits<3> ZAd; + let Inst{2-0} = ZAd; + } + + defm : sme2_mova_vec_to_tile_or_array_aliases<1, !cast(NAME # _B), + !if(v, TileVectorOpV8, + TileVectorOpH8), + MatrixIndexGPR32Op12_15, + uimm3s2range, ZZ_b_mul_r, + "mov">; + defm : sme2_mova_vec_to_tile_or_array_aliases<1, !cast(NAME # _H), + !if(v, TileVectorOpV16, + TileVectorOpH16), + MatrixIndexGPR32Op12_15, + uimm2s2range, ZZ_h_mul_r, + "mov">; + defm : sme2_mova_vec_to_tile_or_array_aliases<1, !cast(NAME # _S), + !if(v, TileVectorOpV32, + TileVectorOpH32), + MatrixIndexGPR32Op12_15, + uimm1s2range, ZZ_s_mul_r, + "mov">; + defm : sme2_mova_vec_to_tile_or_array_aliases<1, !cast(NAME # _D), + !if(v, TileVectorOpV64, + TileVectorOpH64), + MatrixIndexGPR32Op12_15, + uimm0s2range, ZZ_d_mul_r, + "mov">; + + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME # _B), + !if(v, TileVectorOpV8, + TileVectorOpH8), + MatrixIndexGPR32Op12_15, + uimm3s2range, ZZ_b_mul_r, + "mova">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME # _H), + !if(v, TileVectorOpV16, + TileVectorOpH16), + MatrixIndexGPR32Op12_15, + uimm2s2range, ZZ_h_mul_r, + "mova">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME # _S), + !if(v, TileVectorOpV32, + TileVectorOpH32), + MatrixIndexGPR32Op12_15, + uimm1s2range, ZZ_s_mul_r, + "mova">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME # _D), + !if(v, TileVectorOpV64, + TileVectorOpH64), + MatrixIndexGPR32Op12_15, + uimm0s2range, ZZ_d_mul_r, + "mova">; + + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME # _B), + !if(v, TileVectorOpV8, + TileVectorOpH8), + MatrixIndexGPR32Op12_15, + uimm3s2range, ZZ_b_mul_r, + "mova">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME # _H), + !if(v, TileVectorOpV16, + TileVectorOpH16), + MatrixIndexGPR32Op12_15, + uimm2s2range, ZZ_h_mul_r, + "mova">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME # _S), + !if(v, TileVectorOpV32, + TileVectorOpH32), + MatrixIndexGPR32Op12_15, + uimm1s2range, ZZ_s_mul_r, + "mova">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME # _D), + !if(v, TileVectorOpV64, + TileVectorOpH64), + MatrixIndexGPR32Op12_15, + uimm0s2range, ZZ_d_mul_r, + "mova">; +} + +multiclass sme2_mova_vec_to_tile_vg2_multi{ + defm _H : sme2_mova_vec_to_tile_vg2_multi_base<0b0, mnemonic>; + defm _V : sme2_mova_vec_to_tile_vg2_multi_base<0b1, mnemonic>; +} + +class sme2_mova_vec_to_tile_vg4_multi_base sz, bit v, bits<3> op, + RegisterOperand tile_ty, + Operand index_ty, + RegisterOperand vector_ty, + string mnemonic> + : I<(outs tile_ty:$ZAd), + (ins tile_ty:$_ZAd, MatrixIndexGPR32Op12_15:$Rs, index_ty:$imm, + vector_ty:$Zn), + mnemonic, + "\t$ZAd[$Rs, $imm, vgx4], $Zn", + "", []>, Sched<[]> { + bits<2> Rs; + bits<3> Zn; + let Inst{31-24} = 0b11000000; + let Inst{23-22} = sz; + let Inst{21-16} = 0b000100; + let Inst{15} = v; + let Inst{14-13} = Rs; + let Inst{12-10} = 0b001; + let Inst{9-7} = Zn; + let Inst{6-3} = 0b0000; + let Inst{2-0} = op; + let Constraints = "$ZAd = $_ZAd"; +} + +// SME2 move vector to tile, four registers +multiclass sme2_mova_vec_to_tile_vg4_multi_base { + + def _B : sme2_mova_vec_to_tile_vg4_multi_base<0b00, v, {0,?,?}, + !if(v, TileVectorOpV8, + TileVectorOpH8), + uimm2s4range, ZZZZ_b_mul_r, + mnemonic> { + bits<2> imm; + let Inst{1-0} = imm; + } + + def _H : sme2_mova_vec_to_tile_vg4_multi_base<0b01, v, {0,?,?}, + !if(v, TileVectorOpV16, + TileVectorOpH16), + uimm1s4range, ZZZZ_h_mul_r, + mnemonic> { + bits<1> ZAd; + bits<1> imm; + let Inst{1} = ZAd; + let Inst{0} = imm; + } + + def _S : sme2_mova_vec_to_tile_vg4_multi_base<0b10, v, {0,?,?}, + !if(v, TileVectorOpV32, + TileVectorOpH32), + uimm0s4range, ZZZZ_s_mul_r, + mnemonic> { + bits<2> ZAd; + let Inst{1-0} = ZAd; + } + + def _D : sme2_mova_vec_to_tile_vg4_multi_base<0b11, v, {?,?,?}, + !if(v, TileVectorOpV64, + TileVectorOpH64), + uimm0s4range, ZZZZ_d_mul_r, + mnemonic> { + bits<3> ZAd; + let Inst{2-0} = ZAd; + } + + defm : sme2_mova_vec_to_tile_or_array_aliases<1, !cast(NAME # _B), + !if(v, TileVectorOpV8, + TileVectorOpH8), + MatrixIndexGPR32Op12_15, + uimm2s4range, ZZZZ_b_mul_r, + "mov">; + defm : sme2_mova_vec_to_tile_or_array_aliases<1, !cast(NAME # _H), + !if(v, TileVectorOpV16, + TileVectorOpH16), + MatrixIndexGPR32Op12_15, + uimm1s4range, ZZZZ_h_mul_r, + "mov">; + defm : sme2_mova_vec_to_tile_or_array_aliases<1, !cast(NAME # _S), + !if(v, TileVectorOpV32, + TileVectorOpH32), + MatrixIndexGPR32Op12_15, + uimm0s4range, ZZZZ_s_mul_r, + "mov">; + defm : sme2_mova_vec_to_tile_or_array_aliases<1, !cast(NAME # _D), + !if(v, TileVectorOpV64, + TileVectorOpH64), + MatrixIndexGPR32Op12_15, + uimm0s4range, ZZZZ_d_mul_r, + "mov">; + + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME # _B), + !if(v, TileVectorOpV8, + TileVectorOpH8), + MatrixIndexGPR32Op12_15, + uimm2s4range, ZZZZ_b_mul_r, + "mova">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME # _H), + !if(v, TileVectorOpV16, + TileVectorOpH16), + MatrixIndexGPR32Op12_15, + uimm1s4range, ZZZZ_h_mul_r, + "mova">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME # _S), + !if(v, TileVectorOpV32, + TileVectorOpH32), + MatrixIndexGPR32Op12_15, + uimm0s4range, ZZZZ_s_mul_r, + "mova">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME # _D), + !if(v, TileVectorOpV64, + TileVectorOpH64), + MatrixIndexGPR32Op12_15, + uimm0s4range, ZZZZ_d_mul_r, + "mova">; + +} + +multiclass sme2_mova_vec_to_tile_vg4_multi{ + defm _H : sme2_mova_vec_to_tile_vg4_multi_base<0b0, mnemonic>; + defm _V : sme2_mova_vec_to_tile_vg4_multi_base<0b1, mnemonic>; +} + +// SME Move into Array +class sme2_mova_vec_to_array_vg24_multi< bits<5> op, RegisterOperand array_ty, + RegisterOperand vector_ty, + string mnemonic, + string vg_acronym=""> + : I<(outs array_ty:$ZAd), + (ins array_ty:$_ZAd, MatrixIndexGPR32Op8_11:$Rs, sme_elm_idx0_7:$imm, + vector_ty:$Zn), + mnemonic, "\t$ZAd[$Rs, $imm, " # vg_acronym # "], $Zn", + "", []>, Sched<[]> { + bits<2> Rs; + bits<3> imm; + let Inst{31-15} = 0b11000000000001000; + let Inst{14-13} = Rs; + let Inst{12-11} = 0b01; + let Inst{10-6} = op; + let Inst{5-3} = 0b000; + let Inst{2-0} = imm; + + let Constraints = "$ZAd = $_ZAd"; +} + +// MOVA (vector to array, two registers) +multiclass sme2_mova_vec_to_array_vg2_multi { + def NAME : sme2_mova_vec_to_array_vg24_multi<{0,?,?,?,?}, MatrixOp64, + ZZ_d_mul_r, mnemonic, "vgx2">{ + bits<4> Zn; + let Inst{9-6} = Zn; + } + + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp8, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZ_b_mul_r, + "mova">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp16, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZ_h_mul_r, + "mova">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp32, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZ_s_mul_r, + "mova">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp64, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZ_d_mul_r, + "mova">; + + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp8, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZ_b_mul_r, + "mova", "vgx2">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp16, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZ_h_mul_r, + "mova", "vgx2">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp32, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZ_s_mul_r, + "mova", "vgx2">; + + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp8, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZ_b_mul_r, + "mov">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp16, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZ_h_mul_r, + "mov">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp32, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZ_s_mul_r, + "mov">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp64, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZ_d_mul_r, + "mov">; + + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp8, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZ_b_mul_r, + "mov", "vgx2">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp16, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZ_h_mul_r, + "mov", "vgx2">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp32, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZ_s_mul_r, + "mov", "vgx2">; + defm : sme2_mova_vec_to_tile_or_array_aliases<1, !cast(NAME), + MatrixOp64, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZ_d_mul_r, + "mov", "vgx2">; +} + +// MOVA (vector to array, four registers) +multiclass sme2_mova_vec_to_array_vg4_multi { + def NAME : sme2_mova_vec_to_array_vg24_multi<{1,?,?,?,0}, MatrixOp64, + ZZZZ_d_mul_r, mnemonic, "vgx4"> { + bits<3> Zn; + let Inst{9-7} = Zn; + } + + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp8, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZZZ_b_mul_r, + "mova">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp16, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZZZ_h_mul_r, + "mova">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp32, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZZZ_s_mul_r, + "mova">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp64, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZZZ_d_mul_r, + "mova">; + + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp8, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZZZ_b_mul_r, + "mova", "vgx4">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp16, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZZZ_h_mul_r, + "mova", "vgx4">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp32, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZZZ_s_mul_r, + "mova", "vgx4">; + + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp8, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZZZ_b_mul_r, + "mov">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp16, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZZZ_h_mul_r, + "mov">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp32, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZZZ_s_mul_r, + "mov">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp64, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZZZ_d_mul_r, + "mov">; + + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp8, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZZZ_b_mul_r, + "mov", "vgx4">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp16, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZZZ_h_mul_r, + "mov", "vgx4">; + defm : sme2_mova_vec_to_tile_or_array_aliases<0, !cast(NAME), + MatrixOp32, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZZZ_s_mul_r, + "mov", "vgx4">; + defm : sme2_mova_vec_to_tile_or_array_aliases<1, !cast(NAME), + MatrixOp64, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, ZZZZ_d_mul_r, + "mov", "vgx4">; + +} + +class sme2_mova_tile_to_vec_vg2_multi_base sz, bit v, + RegisterOperand vector_ty, + RegisterOperand tile_ty, + Operand index_ty, + string mnemonic> + : I<(outs vector_ty:$Zd), + (ins tile_ty:$ZAn, MatrixIndexGPR32Op12_15:$Rs, index_ty:$imm), + mnemonic, + "\t$Zd, $ZAn[$Rs, $imm, vgx2]", + "", []>, Sched<[]> { + bits<4> Zd; + bits<2> Rs; + let Inst{31-24} = 0b11000000; + let Inst{23-22} = sz; + let Inst{21-16} = 0b000110; + let Inst{15} = v; + let Inst{14-13} = Rs; + let Inst{12-8} = 0b00000; + let Inst{4-1} = Zd; + let Inst{0} = 0b0; +} + +multiclass sme2_mova_tile_or_array_to_vec_aliases { +def : InstAlias; + +} + +// SME2 move tile to vector, two registers +multiclass sme2_mova_tile_to_vec_vg2_multi_inst { + + def _B : sme2_mova_tile_to_vec_vg2_multi_base<0b00, v, ZZ_b_mul_r, + !if(v, TileVectorOpV8, + TileVectorOpH8), + uimm3s2range, mnemonic> { + bits<3> imm; + let Inst{7-5} = imm; + } + + def _H : sme2_mova_tile_to_vec_vg2_multi_base<0b01, v, ZZ_h_mul_r, + !if(v, TileVectorOpV16, + TileVectorOpH16), + uimm2s2range, mnemonic> { + bits<1> ZAn; + bits<2> imm; + let Inst{7} = ZAn; + let Inst{6-5} = imm; + } + + def _S : sme2_mova_tile_to_vec_vg2_multi_base<0b10, v, ZZ_s_mul_r, + !if(v, TileVectorOpV32, + TileVectorOpH32), + uimm1s2range, mnemonic> { + bits<2> ZAn; + bits<1> imm; + let Inst{7-6} = ZAn; + let Inst{5} = imm; + } + + def _D : sme2_mova_tile_to_vec_vg2_multi_base<0b11, v, ZZ_d_mul_r, + !if(v, TileVectorOpV64, + TileVectorOpH64), + uimm0s2range, mnemonic> { + bits<3> ZAn; + let Inst{7-5} = ZAn; + } + + defm : sme2_mova_tile_or_array_to_vec_aliases<1,!cast(NAME # _B), + ZZ_b_mul_r, + !if(v, TileVectorOpV8, + TileVectorOpH8), + MatrixIndexGPR32Op12_15, + uimm3s2range, "mov">; + defm : sme2_mova_tile_or_array_to_vec_aliases<1,!cast(NAME # _H), + ZZ_h_mul_r, + !if(v, TileVectorOpV16, + TileVectorOpH16), + MatrixIndexGPR32Op12_15, + uimm2s2range, "mov">; + defm : sme2_mova_tile_or_array_to_vec_aliases<1, !cast(NAME # _S), + ZZ_s_mul_r, + !if(v, TileVectorOpV32, + TileVectorOpH32), + MatrixIndexGPR32Op12_15, + uimm1s2range, "mov">; + defm : sme2_mova_tile_or_array_to_vec_aliases<1, !cast(NAME # _D), + ZZ_d_mul_r, + !if(v, TileVectorOpV64, + TileVectorOpH64), + MatrixIndexGPR32Op12_15, + uimm0s2range, "mov">; + + defm : sme2_mova_tile_or_array_to_vec_aliases<0,!cast(NAME # _B), + ZZ_b_mul_r, + !if(v, TileVectorOpV8, + TileVectorOpH8), + MatrixIndexGPR32Op12_15, + uimm3s2range, "mova">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0,!cast(NAME # _H), + ZZ_h_mul_r, + !if(v, TileVectorOpV16, + TileVectorOpH16), + MatrixIndexGPR32Op12_15, + uimm2s2range, "mova">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME # _S), + ZZ_s_mul_r, + !if(v, TileVectorOpV32, + TileVectorOpH32), + MatrixIndexGPR32Op12_15, + uimm1s2range, "mova">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME # _D), + ZZ_d_mul_r, + !if(v, TileVectorOpV64, + TileVectorOpH64), + MatrixIndexGPR32Op12_15, + uimm0s2range, "mova">; + +} + +multiclass sme2_mova_tile_to_vec_vg2_multi{ + defm _H : sme2_mova_tile_to_vec_vg2_multi_inst<0b0, mnemonic>; + defm _V : sme2_mova_tile_to_vec_vg2_multi_inst<0b1, mnemonic>; +} + +// SME2 move tile to vector, four registers +class sme2_mova_tile_to_vec_vg4_multi_base sz, bit v, bits<3> op, + RegisterOperand vector_ty, + RegisterOperand tile_ty, + Operand index_ty, + string mnemonic> + : I<(outs vector_ty:$Zd), + (ins tile_ty:$ZAn, MatrixIndexGPR32Op12_15:$Rs, index_ty:$imm), + mnemonic, + "\t$Zd, $ZAn[$Rs, $imm, vgx4]", + "", []>, Sched<[]> { + bits<3> Zd; + bits<2> Rs; + let Inst{31-24} = 0b11000000; + let Inst{23-22} = sz; + let Inst{21-16} = 0b000110; + let Inst{15} = v; + let Inst{14-13} = Rs; + let Inst{12-8} = 0b00100; + let Inst{7-5} = op; + let Inst{4-2} = Zd; + let Inst{1-0} = 0b00; +} + +multiclass sme2_mova_tile_to_vec_vg4_multi_base { + + def _B : sme2_mova_tile_to_vec_vg4_multi_base<0b00, v, {0,?,?}, + ZZZZ_b_mul_r, + !if(v, TileVectorOpV8, + TileVectorOpH8), + uimm2s4range, mnemonic> { + bits<2> imm; + let Inst{6-5} = imm; + } + + def _H : sme2_mova_tile_to_vec_vg4_multi_base<0b01, v, {0,?,?}, + ZZZZ_h_mul_r, + !if(v, TileVectorOpV16, + TileVectorOpH16), + uimm1s4range, mnemonic> { + bits<1> ZAn; + bits<1> imm; + let Inst{6} = ZAn; + let Inst{5} = imm; + } + + def _S : sme2_mova_tile_to_vec_vg4_multi_base<0b10, v, {0,?,?}, + ZZZZ_s_mul_r, + !if(v, TileVectorOpV32, + TileVectorOpH32), + uimm0s4range, mnemonic> { + bits<2> ZAn; + let Inst{6-5} = ZAn; + } + + def _D : sme2_mova_tile_to_vec_vg4_multi_base<0b11, v, {?,?,?}, + ZZZZ_d_mul_r, + !if(v, TileVectorOpV64, + TileVectorOpH64), + uimm0s4range, mnemonic> { + bits<3> ZAn; + let Inst{7-5} = ZAn; + } + + defm : sme2_mova_tile_or_array_to_vec_aliases<1, !cast(NAME # _B), + ZZZZ_b_mul_r, + !if(v, TileVectorOpV8, + TileVectorOpH8), + MatrixIndexGPR32Op12_15, + uimm2s4range, "mov">; + defm : sme2_mova_tile_or_array_to_vec_aliases<1, !cast(NAME # _H), + ZZZZ_h_mul_r, + !if(v, TileVectorOpV16, + TileVectorOpH16), + MatrixIndexGPR32Op12_15, + uimm1s4range, "mov">; + defm : sme2_mova_tile_or_array_to_vec_aliases<1, !cast(NAME # _S), + ZZZZ_s_mul_r, + !if(v, TileVectorOpV32, + TileVectorOpH32), + MatrixIndexGPR32Op12_15, + uimm0s4range, "mov">; + defm : sme2_mova_tile_or_array_to_vec_aliases<1, !cast(NAME # _D), + ZZZZ_d_mul_r, + !if(v, TileVectorOpV64, + TileVectorOpH64), + MatrixIndexGPR32Op12_15, + uimm0s4range, "mov">; + + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME # _B), + ZZZZ_b_mul_r, + !if(v, TileVectorOpV8, + TileVectorOpH8), + MatrixIndexGPR32Op12_15, + uimm2s4range, "mova">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME # _H), + ZZZZ_h_mul_r, + !if(v, TileVectorOpV16, + TileVectorOpH16), + MatrixIndexGPR32Op12_15, + uimm1s4range, "mova">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME # _S), + ZZZZ_s_mul_r, + !if(v, TileVectorOpV32, + TileVectorOpH32), + MatrixIndexGPR32Op12_15, + uimm0s4range, "mova">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME # _D), + ZZZZ_d_mul_r, + !if(v, TileVectorOpV64, + TileVectorOpH64), + MatrixIndexGPR32Op12_15, + uimm0s4range, "mova">; + +} +multiclass sme2_mova_tile_to_vec_vg4_multi{ + defm _H : sme2_mova_tile_to_vec_vg4_multi_base<0b0, mnemonic>; + defm _V : sme2_mova_tile_to_vec_vg4_multi_base<0b1, mnemonic>; +} + +// SME Move from Array +class sme2_mova_array_to_vec_vg24_multi op, RegisterOperand vector_ty, + RegisterOperand array_ty, + string mnemonic, string vg_acronym> + : I<(outs vector_ty:$Zd), + (ins array_ty:$ZAn, MatrixIndexGPR32Op8_11:$Rs, sme_elm_idx0_7:$imm), + mnemonic, + "\t$Zd, $ZAn[$Rs, $imm, " # vg_acronym # "]", + "", []>, Sched<[]> { + bits<2> Rs; + bits<3> imm; + let Inst{31-15} = 0b11000000000001100; + let Inst{14-13} = Rs; + let Inst{12-11} = 0b01; + let Inst{10} = op{3}; + let Inst{9-8} = op{2-1}; + let Inst{7-5} = imm; + let Inst{1} = op{0}; + let Inst{0} = 0b0; +} + +// MOVA (array to vector, two registers) +multiclass sme2_mova_array_to_vec_vg2_multi { + def NAME : sme2_mova_array_to_vec_vg24_multi<{0b000,?}, ZZ_d_mul_r, MatrixOp64, + mnemonic, "vgx2">{ + bits<4> Zd; + let Inst{4-1} = Zd; + } + + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZ_b_mul_r, MatrixOp8, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mova">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZ_h_mul_r, MatrixOp16, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mova">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZ_s_mul_r, MatrixOp32, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mova">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZ_d_mul_r, MatrixOp64, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mova">; + + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZ_b_mul_r, MatrixOp8, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mova", "vgx2">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZ_h_mul_r, MatrixOp16, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mova", "vgx2">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZ_s_mul_r, MatrixOp32, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mova", "vgx2">; + + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZ_b_mul_r, MatrixOp8, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mov">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZ_h_mul_r, MatrixOp16, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mov">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZ_s_mul_r, MatrixOp32, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mov">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZ_d_mul_r, MatrixOp64, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mov">; + + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZ_b_mul_r, MatrixOp8, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mov", "vgx2">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZ_h_mul_r, MatrixOp16, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mov", "vgx2">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZ_s_mul_r, MatrixOp32, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mov", "vgx2">; + defm : sme2_mova_tile_or_array_to_vec_aliases<1, !cast(NAME), + ZZ_d_mul_r, MatrixOp64, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mov", "vgx2">; +} + +// MOVA (array to vector, four registers) +multiclass sme2_mova_array_to_vec_vg4_multi { + def NAME : sme2_mova_array_to_vec_vg24_multi<0b1000, ZZZZ_d_mul_r, MatrixOp64, + mnemonic, "vgx4">{ + bits<3> Zd; + let Inst{4-2} = Zd; + } + + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZZZ_b_mul_r, MatrixOp8, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mova">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZZZ_h_mul_r, MatrixOp16, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mova">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZZZ_s_mul_r, MatrixOp32, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mova">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZZZ_d_mul_r, MatrixOp64, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mova">; + + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZZZ_b_mul_r, MatrixOp8, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mova", "vgx4">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZZZ_h_mul_r, MatrixOp16, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mova", "vgx4">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZZZ_s_mul_r, MatrixOp32, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mova", "vgx4">; + + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZZZ_b_mul_r, MatrixOp8, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mov">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZZZ_h_mul_r, MatrixOp16, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mov">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZZZ_s_mul_r, MatrixOp32, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mov">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZZZ_d_mul_r, MatrixOp64, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mov">; + + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZZZ_b_mul_r, MatrixOp8, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mov", "vgx4">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZZZ_h_mul_r, MatrixOp16, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mov", "vgx4">; + defm : sme2_mova_tile_or_array_to_vec_aliases<0, !cast(NAME), + ZZZZ_s_mul_r, MatrixOp32, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mov", "vgx4">; + defm : sme2_mova_tile_or_array_to_vec_aliases<1, !cast(NAME), + ZZZZ_d_mul_r, MatrixOp64, + MatrixIndexGPR32Op8_11, + sme_elm_idx0_7, "mov", "vgx4">; +} diff --git a/llvm/test/MC/AArch64/SME2/mova-diagnostics.s b/llvm/test/MC/AArch64/SME2/mova-diagnostics.s new file mode 100644 --- /dev/null +++ b/llvm/test/MC/AArch64/SME2/mova-diagnostics.s @@ -0,0 +1,73 @@ +// RUN: not llvm-mc -triple=aarch64 -show-encoding -mattr=+sme2 2>&1 < %s | FileCheck %s + +// --------------------------------------------------------------------------// +// Multi-vector sequence constraints + +mova {z1.d-z2.d}, za.d[w12] +// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: Invalid vector list, expected list with 2 consecutive SVE vectors, where the first vector is a multiple of 2 and with matching element types +// CHECK-NEXT: mova {z1.d-z2.d}, za.d[w12] +// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}: + +mova {z1.d-z4.d}, za.d[w12] +// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: Invalid vector list, expected list with 4 consecutive SVE vectors, where the first vector is a multiple of 4 and with matching element types +// CHECK-NEXT: mova {z1.d-z4.d}, za.d[w12] +// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}: + +// --------------------------------------------------------------------------// +// Invalid index offset + +mova {z0.s, z1.s}, za0h.s[w12, 1:2] +// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: vector select offset must be an immediate range of the form :, where the first immediate is a multiple of 2 in the range [0, 2], and the second immediate is immf + 1. +// CHECK-NEXT: mova {z0.s, z1.s}, za0h.s[w12, 1:2] +// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}: + +mova {z0.s, z1.s}, za0h.s[w12, 3:4] +// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: vector select offset must be an immediate range of the form :, where the first immediate is a multiple of 2 in the range [0, 2], and the second immediate is immf + 1. +// CHECK-NEXT: mova {z0.s, z1.s}, za0h.s[w12, 3:4] +// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}: + +mova {z0.s, z1.s}, za0h.s[w12, 0:2] +// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: invalid operand for instruction +// CHECK-NEXT: mova {z0.s, z1.s}, za0h.s[w12, 0:2] +// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}: + +mova {z20.d-z21.d}, za2h.d[w14, 0:3] +// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: invalid operand for instruction +// CHECK-NEXT: mova {z20.d-z21.d}, za2h.d[w14, 0:3] +// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}: + +mova {z16.s-z19.s}, za1h.s[w14, 0:1] +// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: invalid operand for instruction +// CHECK-NEXT: mova {z16.s-z19.s}, za1h.s[w14, 0:1] +// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}: + +// --------------------------------------------------------------------------// +// Invalid index (expected range) + +mova {z0.b-z3.b}, za0h.b[w13, 0] +// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: invalid operand for instruction +// CHECK-NEXT: mova {z0.b-z3.b}, za0h.b[w13, 0] +// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}: + +// --------------------------------------------------------------------------// +// Operands are not consistent + +mova za.h[w8, 0], {z0.s-z3.s} +// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: invalid operand for instruction +// CHECK-NEXT: mova za.h[w8, 0], {z0.s-z3.s} +// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}: + +mov za.h[w8, 0], {z0.s-z3.s} +// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: invalid operand for instruction +// CHECK-NEXT:mov za.h[w8, 0], {z0.s-z3.s} +// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}: + +mova {z0.s-z3.s}, za.b[w8, 0] +// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: invalid matrix operand, expected suffix .s +// CHECK-NEXT: mova {z0.s-z3.s}, za.b[w8, 0] +// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}: + +mov {z0.h-z3.h}, za.d[w8, 0] +// CHECK: [[@LINE-1]]:{{[0-9]+}}: error: invalid matrix operand, expected suffix .h +// CHECK-NEXT: mov {z0.h-z3.h}, za.d[w8, 0] +// CHECK-NOT: [[@LINE-1]]:{{[0-9]+}}: diff --git a/llvm/test/MC/AArch64/SME2/mova.s b/llvm/test/MC/AArch64/SME2/mova.s new file mode 100644 --- /dev/null +++ b/llvm/test/MC/AArch64/SME2/mova.s @@ -0,0 +1,5521 @@ +// RUN: llvm-mc -triple=aarch64 -show-encoding -mattr=+sme2 < %s \ +// RUN: | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST +// RUN: not llvm-mc -triple=aarch64 -show-encoding < %s 2>&1 \ +// RUN: | FileCheck %s --check-prefix=CHECK-ERROR +// RUN: llvm-mc -triple=aarch64 -filetype=obj -mattr=+sme2 < %s \ +// RUN: | llvm-objdump --no-print-imm-hex -d --mattr=+sme2 - | FileCheck %s --check-prefix=CHECK-INST +// RUN: llvm-mc -triple=aarch64 -filetype=obj -mattr=+sme2 < %s \ +// RUN: | llvm-objdump --no-print-imm-hex -d --mattr=-sme2 - | FileCheck %s --check-prefix=CHECK-UNKNOWN +// RUN: llvm-mc -triple=aarch64 -show-encoding -mattr=+sme2 < %s \ +// RUN: | sed '/.text/d' | sed 's/.*encoding: //g' \ +// RUN: | llvm-mc -triple=aarch64 -mattr=+sme2 -disassemble -show-encoding \ +// RUN: | FileCheck %s --check-prefixes=CHECK-ENCODING,CHECK-INST + + +mova {z0.h, z1.h}, za0h.h[w12, 0:1] // 11000000-01000110-00000000-00000000 +// CHECK-INST: mov { z0.h, z1.h }, za0h.h[w12, 0:1] +// CHECK-ENCODING: [0x00,0x00,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0460000 + +mova {z20.h, z21.h}, za0h.h[w14, 4:5] // 11000000-01000110-01000000-01010100 +// CHECK-INST: mov { z20.h, z21.h }, za0h.h[w14, 4:5] +// CHECK-ENCODING: [0x54,0x40,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0464054 + +mova {z22.h, z23.h}, za1h.h[w15, 2:3] // 11000000-01000110-01100000-10110110 +// CHECK-INST: mov { z22.h, z23.h }, za1h.h[w15, 2:3] +// CHECK-ENCODING: [0xb6,0x60,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c04660b6 + +mova {z30.h, z31.h}, za1h.h[w15, 6:7] // 11000000-01000110-01100000-11111110 +// CHECK-INST: mov { z30.h, z31.h }, za1h.h[w15, 6:7] +// CHECK-ENCODING: [0xfe,0x60,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c04660fe + +mova {z4.h, z5.h}, za0h.h[w12, 2:3] // 11000000-01000110-00000000-00100100 +// CHECK-INST: mov { z4.h, z5.h }, za0h.h[w12, 2:3] +// CHECK-ENCODING: [0x24,0x00,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0460024 + +mova {z0.h, z1.h}, za0h.h[w12, 2:3] // 11000000-01000110-00000000-00100000 +// CHECK-INST: mov { z0.h, z1.h }, za0h.h[w12, 2:3] +// CHECK-ENCODING: [0x20,0x00,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0460020 + +mova {z24.h, z25.h}, za0h.h[w14, 6:7] // 11000000-01000110-01000000-01111000 +// CHECK-INST: mov { z24.h, z25.h }, za0h.h[w14, 6:7] +// CHECK-ENCODING: [0x78,0x40,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0464078 + +mova {z0.h, z1.h}, za1h.h[w12, 0:1] // 11000000-01000110-00000000-10000000 +// CHECK-INST: mov { z0.h, z1.h }, za1h.h[w12, 0:1] +// CHECK-ENCODING: [0x80,0x00,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0460080 + +mova {z16.h, z17.h}, za0h.h[w14, 2:3] // 11000000-01000110-01000000-00110000 +// CHECK-INST: mov { z16.h, z17.h }, za0h.h[w14, 2:3] +// CHECK-ENCODING: [0x30,0x40,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0464030 + +mova {z28.h, z29.h}, za1h.h[w12, 4:5] // 11000000-01000110-00000000-11011100 +// CHECK-INST: mov { z28.h, z29.h }, za1h.h[w12, 4:5] +// CHECK-ENCODING: [0xdc,0x00,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c04600dc + +mova {z2.h, z3.h}, za0h.h[w15, 2:3] // 11000000-01000110-01100000-00100010 +// CHECK-INST: mov { z2.h, z3.h }, za0h.h[w15, 2:3] +// CHECK-ENCODING: [0x22,0x60,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0466022 + +mova {z6.h, z7.h}, za1h.h[w13, 0:1] // 11000000-01000110-00100000-10000110 +// CHECK-INST: mov { z6.h, z7.h }, za1h.h[w13, 0:1] +// CHECK-ENCODING: [0x86,0x20,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0462086 + +// Aliases + +mov {z0.h, z1.h}, za0h.h[w12, 0:1] // 11000000-01000110-00000000-00000000 +// CHECK-INST: mov { z0.h, z1.h }, za0h.h[w12, 0:1] +// CHECK-ENCODING: [0x00,0x00,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0460000 + +mov {z20.h, z21.h}, za0h.h[w14, 4:5] // 11000000-01000110-01000000-01010100 +// CHECK-INST: mov { z20.h, z21.h }, za0h.h[w14, 4:5] +// CHECK-ENCODING: [0x54,0x40,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0464054 + +mov {z22.h, z23.h}, za1h.h[w15, 2:3] // 11000000-01000110-01100000-10110110 +// CHECK-INST: mov { z22.h, z23.h }, za1h.h[w15, 2:3] +// CHECK-ENCODING: [0xb6,0x60,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c04660b6 + +mov {z30.h, z31.h}, za1h.h[w15, 6:7] // 11000000-01000110-01100000-11111110 +// CHECK-INST: mov { z30.h, z31.h }, za1h.h[w15, 6:7] +// CHECK-ENCODING: [0xfe,0x60,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c04660fe + +mov {z4.h, z5.h}, za0h.h[w12, 2:3] // 11000000-01000110-00000000-00100100 +// CHECK-INST: mov { z4.h, z5.h }, za0h.h[w12, 2:3] +// CHECK-ENCODING: [0x24,0x00,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0460024 + +mov {z0.h, z1.h}, za0h.h[w12, 2:3] // 11000000-01000110-00000000-00100000 +// CHECK-INST: mov { z0.h, z1.h }, za0h.h[w12, 2:3] +// CHECK-ENCODING: [0x20,0x00,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0460020 + +mov {z24.h, z25.h}, za0h.h[w14, 6:7] // 11000000-01000110-01000000-01111000 +// CHECK-INST: mov { z24.h, z25.h }, za0h.h[w14, 6:7] +// CHECK-ENCODING: [0x78,0x40,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0464078 + +mov {z0.h, z1.h}, za1h.h[w12, 0:1] // 11000000-01000110-00000000-10000000 +// CHECK-INST: mov { z0.h, z1.h }, za1h.h[w12, 0:1] +// CHECK-ENCODING: [0x80,0x00,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0460080 + +mov {z16.h, z17.h}, za0h.h[w14, 2:3] // 11000000-01000110-01000000-00110000 +// CHECK-INST: mov { z16.h, z17.h }, za0h.h[w14, 2:3] +// CHECK-ENCODING: [0x30,0x40,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0464030 + +mov {z28.h, z29.h}, za1h.h[w12, 4:5] // 11000000-01000110-00000000-11011100 +// CHECK-INST: mov { z28.h, z29.h }, za1h.h[w12, 4:5] +// CHECK-ENCODING: [0xdc,0x00,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c04600dc + +mov {z2.h, z3.h}, za0h.h[w15, 2:3] // 11000000-01000110-01100000-00100010 +// CHECK-INST: mov { z2.h, z3.h }, za0h.h[w15, 2:3] +// CHECK-ENCODING: [0x22,0x60,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0466022 + +mov {z6.h, z7.h}, za1h.h[w13, 0:1] // 11000000-01000110-00100000-10000110 +// CHECK-INST: mov { z6.h, z7.h }, za1h.h[w13, 0:1] +// CHECK-ENCODING: [0x86,0x20,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0462086 + + +mova {z0.h, z1.h}, za0v.h[w12, 0:1] // 11000000-01000110-10000000-00000000 +// CHECK-INST: mov { z0.h, z1.h }, za0v.h[w12, 0:1] +// CHECK-ENCODING: [0x00,0x80,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0468000 + +mova {z20.h, z21.h}, za0v.h[w14, 4:5] // 11000000-01000110-11000000-01010100 +// CHECK-INST: mov { z20.h, z21.h }, za0v.h[w14, 4:5] +// CHECK-ENCODING: [0x54,0xc0,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046c054 + +mova {z22.h, z23.h}, za1v.h[w15, 2:3] // 11000000-01000110-11100000-10110110 +// CHECK-INST: mov { z22.h, z23.h }, za1v.h[w15, 2:3] +// CHECK-ENCODING: [0xb6,0xe0,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046e0b6 + +mova {z30.h, z31.h}, za1v.h[w15, 6:7] // 11000000-01000110-11100000-11111110 +// CHECK-INST: mov { z30.h, z31.h }, za1v.h[w15, 6:7] +// CHECK-ENCODING: [0xfe,0xe0,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046e0fe + +mova {z4.h, z5.h}, za0v.h[w12, 2:3] // 11000000-01000110-10000000-00100100 +// CHECK-INST: mov { z4.h, z5.h }, za0v.h[w12, 2:3] +// CHECK-ENCODING: [0x24,0x80,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0468024 + +mova {z0.h, z1.h}, za0v.h[w12, 2:3] // 11000000-01000110-10000000-00100000 +// CHECK-INST: mov { z0.h, z1.h }, za0v.h[w12, 2:3] +// CHECK-ENCODING: [0x20,0x80,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0468020 + +mova {z24.h, z25.h}, za0v.h[w14, 6:7] // 11000000-01000110-11000000-01111000 +// CHECK-INST: mov { z24.h, z25.h }, za0v.h[w14, 6:7] +// CHECK-ENCODING: [0x78,0xc0,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046c078 + +mova {z0.h, z1.h}, za1v.h[w12, 0:1] // 11000000-01000110-10000000-10000000 +// CHECK-INST: mov { z0.h, z1.h }, za1v.h[w12, 0:1] +// CHECK-ENCODING: [0x80,0x80,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0468080 + +mova {z16.h, z17.h}, za0v.h[w14, 2:3] // 11000000-01000110-11000000-00110000 +// CHECK-INST: mov { z16.h, z17.h }, za0v.h[w14, 2:3] +// CHECK-ENCODING: [0x30,0xc0,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046c030 + +mova {z28.h, z29.h}, za1v.h[w12, 4:5] // 11000000-01000110-10000000-11011100 +// CHECK-INST: mov { z28.h, z29.h }, za1v.h[w12, 4:5] +// CHECK-ENCODING: [0xdc,0x80,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c04680dc + +mova {z2.h, z3.h}, za0v.h[w15, 2:3] // 11000000-01000110-11100000-00100010 +// CHECK-INST: mov { z2.h, z3.h }, za0v.h[w15, 2:3] +// CHECK-ENCODING: [0x22,0xe0,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046e022 + +mova {z6.h, z7.h}, za1v.h[w13, 0:1] // 11000000-01000110-10100000-10000110 +// CHECK-INST: mov { z6.h, z7.h }, za1v.h[w13, 0:1] +// CHECK-ENCODING: [0x86,0xa0,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046a086 + +// Aliases + +mov {z0.h, z1.h}, za0v.h[w12, 0:1] // 11000000-01000110-10000000-00000000 +// CHECK-INST: mov { z0.h, z1.h }, za0v.h[w12, 0:1] +// CHECK-ENCODING: [0x00,0x80,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0468000 + +mov {z20.h, z21.h}, za0v.h[w14, 4:5] // 11000000-01000110-11000000-01010100 +// CHECK-INST: mov { z20.h, z21.h }, za0v.h[w14, 4:5] +// CHECK-ENCODING: [0x54,0xc0,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046c054 + +mov {z22.h, z23.h}, za1v.h[w15, 2:3] // 11000000-01000110-11100000-10110110 +// CHECK-INST: mov { z22.h, z23.h }, za1v.h[w15, 2:3] +// CHECK-ENCODING: [0xb6,0xe0,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046e0b6 + +mov {z30.h, z31.h}, za1v.h[w15, 6:7] // 11000000-01000110-11100000-11111110 +// CHECK-INST: mov { z30.h, z31.h }, za1v.h[w15, 6:7] +// CHECK-ENCODING: [0xfe,0xe0,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046e0fe + +mov {z4.h, z5.h}, za0v.h[w12, 2:3] // 11000000-01000110-10000000-00100100 +// CHECK-INST: mov { z4.h, z5.h }, za0v.h[w12, 2:3] +// CHECK-ENCODING: [0x24,0x80,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0468024 + +mov {z0.h, z1.h}, za0v.h[w12, 2:3] // 11000000-01000110-10000000-00100000 +// CHECK-INST: mov { z0.h, z1.h }, za0v.h[w12, 2:3] +// CHECK-ENCODING: [0x20,0x80,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0468020 + +mov {z24.h, z25.h}, za0v.h[w14, 6:7] // 11000000-01000110-11000000-01111000 +// CHECK-INST: mov { z24.h, z25.h }, za0v.h[w14, 6:7] +// CHECK-ENCODING: [0x78,0xc0,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046c078 + +mov {z0.h, z1.h}, za1v.h[w12, 0:1] // 11000000-01000110-10000000-10000000 +// CHECK-INST: mov { z0.h, z1.h }, za1v.h[w12, 0:1] +// CHECK-ENCODING: [0x80,0x80,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0468080 + +mov {z16.h, z17.h}, za0v.h[w14, 2:3] // 11000000-01000110-11000000-00110000 +// CHECK-INST: mov { z16.h, z17.h }, za0v.h[w14, 2:3] +// CHECK-ENCODING: [0x30,0xc0,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046c030 + +mov {z28.h, z29.h}, za1v.h[w12, 4:5] // 11000000-01000110-10000000-11011100 +// CHECK-INST: mov { z28.h, z29.h }, za1v.h[w12, 4:5] +// CHECK-ENCODING: [0xdc,0x80,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c04680dc + +mov {z2.h, z3.h}, za0v.h[w15, 2:3] // 11000000-01000110-11100000-00100010 +// CHECK-INST: mov { z2.h, z3.h }, za0v.h[w15, 2:3] +// CHECK-ENCODING: [0x22,0xe0,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046e022 + +mov {z6.h, z7.h}, za1v.h[w13, 0:1] // 11000000-01000110-10100000-10000110 +// CHECK-INST: mov { z6.h, z7.h }, za1v.h[w13, 0:1] +// CHECK-ENCODING: [0x86,0xa0,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046a086 + + +mova za0h.h[w12, 0:1], {z0.h, z1.h} // 11000000-01000100-00000000-00000000 +// CHECK-INST: mov za0h.h[w12, 0:1], { z0.h, z1.h } +// CHECK-ENCODING: [0x00,0x00,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0440000 + +mova za1h.h[w14, 2:3], {z10.h, z11.h} // 11000000-01000100-01000001-01000101 +// CHECK-INST: mov za1h.h[w14, 2:3], { z10.h, z11.h } +// CHECK-ENCODING: [0x45,0x41,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0444145 + +mova za1h.h[w15, 6:7], {z12.h, z13.h} // 11000000-01000100-01100001-10000111 +// CHECK-INST: mov za1h.h[w15, 6:7], { z12.h, z13.h } +// CHECK-ENCODING: [0x87,0x61,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0446187 + +mova za1h.h[w15, 6:7], {z30.h, z31.h} // 11000000-01000100-01100011-11000111 +// CHECK-INST: mov za1h.h[w15, 6:7], { z30.h, z31.h } +// CHECK-ENCODING: [0xc7,0x63,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c04463c7 + +mova za1h.h[w12, 2:3], {z16.h, z17.h} // 11000000-01000100-00000010-00000101 +// CHECK-INST: mov za1h.h[w12, 2:3], { z16.h, z17.h } +// CHECK-ENCODING: [0x05,0x02,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0440205 + +mova za0h.h[w12, 2:3], {z0.h, z1.h} // 11000000-01000100-00000000-00000001 +// CHECK-INST: mov za0h.h[w12, 2:3], { z0.h, z1.h } +// CHECK-ENCODING: [0x01,0x00,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0440001 + +mova za0h.h[w14, 0:1], {z18.h, z19.h} // 11000000-01000100-01000010-01000000 +// CHECK-INST: mov za0h.h[w14, 0:1], { z18.h, z19.h } +// CHECK-ENCODING: [0x40,0x42,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0444240 + +mova za0h.h[w12, 0:1], {z12.h, z13.h} // 11000000-01000100-00000001-10000000 +// CHECK-INST: mov za0h.h[w12, 0:1], { z12.h, z13.h } +// CHECK-ENCODING: [0x80,0x01,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0440180 + +mova za0h.h[w14, 2:3], {z0.h, z1.h} // 11000000-01000100-01000000-00000001 +// CHECK-INST: mov za0h.h[w14, 2:3], { z0.h, z1.h } +// CHECK-ENCODING: [0x01,0x40,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0444001 + +mova za1h.h[w12, 2:3], {z22.h, z23.h} // 11000000-01000100-00000010-11000101 +// CHECK-INST: mov za1h.h[w12, 2:3], { z22.h, z23.h } +// CHECK-ENCODING: [0xc5,0x02,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c04402c5 + +mova za0h.h[w15, 4:5], {z8.h, z9.h} // 11000000-01000100-01100001-00000010 +// CHECK-INST: mov za0h.h[w15, 4:5], { z8.h, z9.h } +// CHECK-ENCODING: [0x02,0x61,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0446102 + +mova za1h.h[w13, 6:7], {z12.h, z13.h} // 11000000-01000100-00100001-10000111 +// CHECK-INST: mov za1h.h[w13, 6:7], { z12.h, z13.h } +// CHECK-ENCODING: [0x87,0x21,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0442187 + +// Aliases + +mov za0h.h[w12, 0:1], {z0.h, z1.h} // 11000000-01000100-00000000-00000000 +// CHECK-INST: mov za0h.h[w12, 0:1], { z0.h, z1.h } +// CHECK-ENCODING: [0x00,0x00,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0440000 + +mov za1h.h[w14, 2:3], {z10.h, z11.h} // 11000000-01000100-01000001-01000101 +// CHECK-INST: mov za1h.h[w14, 2:3], { z10.h, z11.h } +// CHECK-ENCODING: [0x45,0x41,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0444145 + +mov za1h.h[w15, 6:7], {z12.h, z13.h} // 11000000-01000100-01100001-10000111 +// CHECK-INST: mov za1h.h[w15, 6:7], { z12.h, z13.h } +// CHECK-ENCODING: [0x87,0x61,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0446187 + +mov za1h.h[w15, 6:7], {z30.h, z31.h} // 11000000-01000100-01100011-11000111 +// CHECK-INST: mov za1h.h[w15, 6:7], { z30.h, z31.h } +// CHECK-ENCODING: [0xc7,0x63,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c04463c7 + +mov za1h.h[w12, 2:3], {z16.h, z17.h} // 11000000-01000100-00000010-00000101 +// CHECK-INST: mov za1h.h[w12, 2:3], { z16.h, z17.h } +// CHECK-ENCODING: [0x05,0x02,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0440205 + +mov za0h.h[w12, 2:3], {z0.h, z1.h} // 11000000-01000100-00000000-00000001 +// CHECK-INST: mov za0h.h[w12, 2:3], { z0.h, z1.h } +// CHECK-ENCODING: [0x01,0x00,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0440001 + +mov za0h.h[w14, 0:1], {z18.h, z19.h} // 11000000-01000100-01000010-01000000 +// CHECK-INST: mov za0h.h[w14, 0:1], { z18.h, z19.h } +// CHECK-ENCODING: [0x40,0x42,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0444240 + +mov za0h.h[w12, 0:1], {z12.h, z13.h} // 11000000-01000100-00000001-10000000 +// CHECK-INST: mov za0h.h[w12, 0:1], { z12.h, z13.h } +// CHECK-ENCODING: [0x80,0x01,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0440180 + +mov za0h.h[w14, 2:3], {z0.h, z1.h} // 11000000-01000100-01000000-00000001 +// CHECK-INST: mov za0h.h[w14, 2:3], { z0.h, z1.h } +// CHECK-ENCODING: [0x01,0x40,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0444001 + +mov za1h.h[w12, 2:3], {z22.h, z23.h} // 11000000-01000100-00000010-11000101 +// CHECK-INST: mov za1h.h[w12, 2:3], { z22.h, z23.h } +// CHECK-ENCODING: [0xc5,0x02,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c04402c5 + +mov za0h.h[w15, 4:5], {z8.h, z9.h} // 11000000-01000100-01100001-00000010 +// CHECK-INST: mov za0h.h[w15, 4:5], { z8.h, z9.h } +// CHECK-ENCODING: [0x02,0x61,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0446102 + +mov za1h.h[w13, 6:7], {z12.h, z13.h} // 11000000-01000100-00100001-10000111 +// CHECK-INST: mov za1h.h[w13, 6:7], { z12.h, z13.h } +// CHECK-ENCODING: [0x87,0x21,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0442187 + + +mova za0v.h[w12, 0:1], {z0.h, z1.h} // 11000000-01000100-10000000-00000000 +// CHECK-INST: mov za0v.h[w12, 0:1], { z0.h, z1.h } +// CHECK-ENCODING: [0x00,0x80,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0448000 + +mova za1v.h[w14, 2:3], {z10.h, z11.h} // 11000000-01000100-11000001-01000101 +// CHECK-INST: mov za1v.h[w14, 2:3], { z10.h, z11.h } +// CHECK-ENCODING: [0x45,0xc1,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044c145 + +mova za1v.h[w15, 6:7], {z12.h, z13.h} // 11000000-01000100-11100001-10000111 +// CHECK-INST: mov za1v.h[w15, 6:7], { z12.h, z13.h } +// CHECK-ENCODING: [0x87,0xe1,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044e187 + +mova za1v.h[w15, 6:7], {z30.h, z31.h} // 11000000-01000100-11100011-11000111 +// CHECK-INST: mov za1v.h[w15, 6:7], { z30.h, z31.h } +// CHECK-ENCODING: [0xc7,0xe3,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044e3c7 + +mova za1v.h[w12, 2:3], {z16.h, z17.h} // 11000000-01000100-10000010-00000101 +// CHECK-INST: mov za1v.h[w12, 2:3], { z16.h, z17.h } +// CHECK-ENCODING: [0x05,0x82,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0448205 + +mova za0v.h[w12, 2:3], {z0.h, z1.h} // 11000000-01000100-10000000-00000001 +// CHECK-INST: mov za0v.h[w12, 2:3], { z0.h, z1.h } +// CHECK-ENCODING: [0x01,0x80,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0448001 + +mova za0v.h[w14, 0:1], {z18.h, z19.h} // 11000000-01000100-11000010-01000000 +// CHECK-INST: mov za0v.h[w14, 0:1], { z18.h, z19.h } +// CHECK-ENCODING: [0x40,0xc2,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044c240 + +mova za0v.h[w12, 0:1], {z12.h, z13.h} // 11000000-01000100-10000001-10000000 +// CHECK-INST: mov za0v.h[w12, 0:1], { z12.h, z13.h } +// CHECK-ENCODING: [0x80,0x81,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0448180 + +mova za0v.h[w14, 2:3], {z0.h, z1.h} // 11000000-01000100-11000000-00000001 +// CHECK-INST: mov za0v.h[w14, 2:3], { z0.h, z1.h } +// CHECK-ENCODING: [0x01,0xc0,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044c001 + +mova za1v.h[w12, 2:3], {z22.h, z23.h} // 11000000-01000100-10000010-11000101 +// CHECK-INST: mov za1v.h[w12, 2:3], { z22.h, z23.h } +// CHECK-ENCODING: [0xc5,0x82,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c04482c5 + +mova za0v.h[w15, 4:5], {z8.h, z9.h} // 11000000-01000100-11100001-00000010 +// CHECK-INST: mov za0v.h[w15, 4:5], { z8.h, z9.h } +// CHECK-ENCODING: [0x02,0xe1,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044e102 + +mova za1v.h[w13, 6:7], {z12.h, z13.h} // 11000000-01000100-10100001-10000111 +// CHECK-INST: mov za1v.h[w13, 6:7], { z12.h, z13.h } +// CHECK-ENCODING: [0x87,0xa1,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044a187 + +// Aliases + +mov za0v.h[w12, 0:1], {z0.h, z1.h} // 11000000-01000100-10000000-00000000 +// CHECK-INST: mov za0v.h[w12, 0:1], { z0.h, z1.h } +// CHECK-ENCODING: [0x00,0x80,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0448000 + +mov za1v.h[w14, 2:3], {z10.h, z11.h} // 11000000-01000100-11000001-01000101 +// CHECK-INST: mov za1v.h[w14, 2:3], { z10.h, z11.h } +// CHECK-ENCODING: [0x45,0xc1,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044c145 + +mov za1v.h[w15, 6:7], {z12.h, z13.h} // 11000000-01000100-11100001-10000111 +// CHECK-INST: mov za1v.h[w15, 6:7], { z12.h, z13.h } +// CHECK-ENCODING: [0x87,0xe1,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044e187 + +mov za1v.h[w15, 6:7], {z30.h, z31.h} // 11000000-01000100-11100011-11000111 +// CHECK-INST: mov za1v.h[w15, 6:7], { z30.h, z31.h } +// CHECK-ENCODING: [0xc7,0xe3,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044e3c7 + +mov za1v.h[w12, 2:3], {z16.h, z17.h} // 11000000-01000100-10000010-00000101 +// CHECK-INST: mov za1v.h[w12, 2:3], { z16.h, z17.h } +// CHECK-ENCODING: [0x05,0x82,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0448205 + +mov za0v.h[w12, 2:3], {z0.h, z1.h} // 11000000-01000100-10000000-00000001 +// CHECK-INST: mov za0v.h[w12, 2:3], { z0.h, z1.h } +// CHECK-ENCODING: [0x01,0x80,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0448001 + +mov za0v.h[w14, 0:1], {z18.h, z19.h} // 11000000-01000100-11000010-01000000 +// CHECK-INST: mov za0v.h[w14, 0:1], { z18.h, z19.h } +// CHECK-ENCODING: [0x40,0xc2,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044c240 + +mov za0v.h[w12, 0:1], {z12.h, z13.h} // 11000000-01000100-10000001-10000000 +// CHECK-INST: mov za0v.h[w12, 0:1], { z12.h, z13.h } +// CHECK-ENCODING: [0x80,0x81,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0448180 + +mov za0v.h[w14, 2:3], {z0.h, z1.h} // 11000000-01000100-11000000-00000001 +// CHECK-INST: mov za0v.h[w14, 2:3], { z0.h, z1.h } +// CHECK-ENCODING: [0x01,0xc0,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044c001 + +mov za1v.h[w12, 2:3], {z22.h, z23.h} // 11000000-01000100-10000010-11000101 +// CHECK-INST: mov za1v.h[w12, 2:3], { z22.h, z23.h } +// CHECK-ENCODING: [0xc5,0x82,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c04482c5 + +mov za0v.h[w15, 4:5], {z8.h, z9.h} // 11000000-01000100-11100001-00000010 +// CHECK-INST: mov za0v.h[w15, 4:5], { z8.h, z9.h } +// CHECK-ENCODING: [0x02,0xe1,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044e102 + +mov za1v.h[w13, 6:7], {z12.h, z13.h} // 11000000-01000100-10100001-10000111 +// CHECK-INST: mov za1v.h[w13, 6:7], { z12.h, z13.h } +// CHECK-ENCODING: [0x87,0xa1,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044a187 + + +mova {z0.s, z1.s}, za0h.s[w12, 0:1] // 11000000-10000110-00000000-00000000 +// CHECK-INST: mov { z0.s, z1.s }, za0h.s[w12, 0:1] +// CHECK-ENCODING: [0x00,0x00,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0860000 + +mova {z20.s, z21.s}, za1h.s[w14, 0:1] // 11000000-10000110-01000000-01010100 +// CHECK-INST: mov { z20.s, z21.s }, za1h.s[w14, 0:1] +// CHECK-ENCODING: [0x54,0x40,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0864054 + +mova {z22.s, z23.s}, za2h.s[w15, 2:3] // 11000000-10000110-01100000-10110110 +// CHECK-INST: mov { z22.s, z23.s }, za2h.s[w15, 2:3] +// CHECK-ENCODING: [0xb6,0x60,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c08660b6 + +mova {z30.s, z31.s}, za3h.s[w15, 2:3] // 11000000-10000110-01100000-11111110 +// CHECK-INST: mov { z30.s, z31.s }, za3h.s[w15, 2:3] +// CHECK-ENCODING: [0xfe,0x60,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c08660fe + +mova {z4.s, z5.s}, za0h.s[w12, 2:3] // 11000000-10000110-00000000-00100100 +// CHECK-INST: mov { z4.s, z5.s }, za0h.s[w12, 2:3] +// CHECK-ENCODING: [0x24,0x00,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0860024 + +mova {z0.s, z1.s}, za0h.s[w12, 2:3] // 11000000-10000110-00000000-00100000 +// CHECK-INST: mov { z0.s, z1.s }, za0h.s[w12, 2:3] +// CHECK-ENCODING: [0x20,0x00,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0860020 + +mova {z24.s, z25.s}, za1h.s[w14, 2:3] // 11000000-10000110-01000000-01111000 +// CHECK-INST: mov { z24.s, z25.s }, za1h.s[w14, 2:3] +// CHECK-ENCODING: [0x78,0x40,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0864078 + +mova {z0.s, z1.s}, za2h.s[w12, 0:1] // 11000000-10000110-00000000-10000000 +// CHECK-INST: mov { z0.s, z1.s }, za2h.s[w12, 0:1] +// CHECK-ENCODING: [0x80,0x00,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0860080 + +mova {z16.s, z17.s}, za0h.s[w14, 2:3] // 11000000-10000110-01000000-00110000 +// CHECK-INST: mov { z16.s, z17.s }, za0h.s[w14, 2:3] +// CHECK-ENCODING: [0x30,0x40,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0864030 + +mova {z28.s, z29.s}, za3h.s[w12, 0:1] // 11000000-10000110-00000000-11011100 +// CHECK-INST: mov { z28.s, z29.s }, za3h.s[w12, 0:1] +// CHECK-ENCODING: [0xdc,0x00,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c08600dc + +mova {z2.s, z3.s}, za0h.s[w15, 2:3] // 11000000-10000110-01100000-00100010 +// CHECK-INST: mov { z2.s, z3.s }, za0h.s[w15, 2:3] +// CHECK-ENCODING: [0x22,0x60,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0866022 + +mova {z6.s, z7.s}, za2h.s[w13, 0:1] // 11000000-10000110-00100000-10000110 +// CHECK-INST: mov { z6.s, z7.s }, za2h.s[w13, 0:1] +// CHECK-ENCODING: [0x86,0x20,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0862086 + +// Aliases + +mov {z0.s, z1.s}, za0h.s[w12, 0:1] // 11000000-10000110-00000000-00000000 +// CHECK-INST: mov { z0.s, z1.s }, za0h.s[w12, 0:1] +// CHECK-ENCODING: [0x00,0x00,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0860000 + +mov {z20.s, z21.s}, za1h.s[w14, 0:1] // 11000000-10000110-01000000-01010100 +// CHECK-INST: mov { z20.s, z21.s }, za1h.s[w14, 0:1] +// CHECK-ENCODING: [0x54,0x40,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0864054 + +mov {z22.s, z23.s}, za2h.s[w15, 2:3] // 11000000-10000110-01100000-10110110 +// CHECK-INST: mov { z22.s, z23.s }, za2h.s[w15, 2:3] +// CHECK-ENCODING: [0xb6,0x60,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c08660b6 + +mov {z30.s, z31.s}, za3h.s[w15, 2:3] // 11000000-10000110-01100000-11111110 +// CHECK-INST: mov { z30.s, z31.s }, za3h.s[w15, 2:3] +// CHECK-ENCODING: [0xfe,0x60,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c08660fe + +mov {z4.s, z5.s}, za0h.s[w12, 2:3] // 11000000-10000110-00000000-00100100 +// CHECK-INST: mov { z4.s, z5.s }, za0h.s[w12, 2:3] +// CHECK-ENCODING: [0x24,0x00,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0860024 + +mov {z0.s, z1.s}, za0h.s[w12, 2:3] // 11000000-10000110-00000000-00100000 +// CHECK-INST: mov { z0.s, z1.s }, za0h.s[w12, 2:3] +// CHECK-ENCODING: [0x20,0x00,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0860020 + +mov {z24.s, z25.s}, za1h.s[w14, 2:3] // 11000000-10000110-01000000-01111000 +// CHECK-INST: mov { z24.s, z25.s }, za1h.s[w14, 2:3] +// CHECK-ENCODING: [0x78,0x40,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0864078 + +mov {z0.s, z1.s}, za2h.s[w12, 0:1] // 11000000-10000110-00000000-10000000 +// CHECK-INST: mov { z0.s, z1.s }, za2h.s[w12, 0:1] +// CHECK-ENCODING: [0x80,0x00,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0860080 + +mov {z16.s, z17.s}, za0h.s[w14, 2:3] // 11000000-10000110-01000000-00110000 +// CHECK-INST: mov { z16.s, z17.s }, za0h.s[w14, 2:3] +// CHECK-ENCODING: [0x30,0x40,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0864030 + +mov {z28.s, z29.s}, za3h.s[w12, 0:1] // 11000000-10000110-00000000-11011100 +// CHECK-INST: mov { z28.s, z29.s }, za3h.s[w12, 0:1] +// CHECK-ENCODING: [0xdc,0x00,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c08600dc + +mov {z2.s, z3.s}, za0h.s[w15, 2:3] // 11000000-10000110-01100000-00100010 +// CHECK-INST: mov { z2.s, z3.s }, za0h.s[w15, 2:3] +// CHECK-ENCODING: [0x22,0x60,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0866022 + +mov {z6.s, z7.s}, za2h.s[w13, 0:1] // 11000000-10000110-00100000-10000110 +// CHECK-INST: mov { z6.s, z7.s }, za2h.s[w13, 0:1] +// CHECK-ENCODING: [0x86,0x20,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0862086 + + +mova {z0.s, z1.s}, za0v.s[w12, 0:1] // 11000000-10000110-10000000-00000000 +// CHECK-INST: mov { z0.s, z1.s }, za0v.s[w12, 0:1] +// CHECK-ENCODING: [0x00,0x80,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0868000 + +mova {z20.s, z21.s}, za1v.s[w14, 0:1] // 11000000-10000110-11000000-01010100 +// CHECK-INST: mov { z20.s, z21.s }, za1v.s[w14, 0:1] +// CHECK-ENCODING: [0x54,0xc0,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086c054 + +mova {z22.s, z23.s}, za2v.s[w15, 2:3] // 11000000-10000110-11100000-10110110 +// CHECK-INST: mov { z22.s, z23.s }, za2v.s[w15, 2:3] +// CHECK-ENCODING: [0xb6,0xe0,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086e0b6 + +mova {z30.s, z31.s}, za3v.s[w15, 2:3] // 11000000-10000110-11100000-11111110 +// CHECK-INST: mov { z30.s, z31.s }, za3v.s[w15, 2:3] +// CHECK-ENCODING: [0xfe,0xe0,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086e0fe + +mova {z4.s, z5.s}, za0v.s[w12, 2:3] // 11000000-10000110-10000000-00100100 +// CHECK-INST: mov { z4.s, z5.s }, za0v.s[w12, 2:3] +// CHECK-ENCODING: [0x24,0x80,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0868024 + +mova {z0.s, z1.s}, za0v.s[w12, 2:3] // 11000000-10000110-10000000-00100000 +// CHECK-INST: mov { z0.s, z1.s }, za0v.s[w12, 2:3] +// CHECK-ENCODING: [0x20,0x80,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0868020 + +mova {z24.s, z25.s}, za1v.s[w14, 2:3] // 11000000-10000110-11000000-01111000 +// CHECK-INST: mov { z24.s, z25.s }, za1v.s[w14, 2:3] +// CHECK-ENCODING: [0x78,0xc0,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086c078 + +mova {z0.s, z1.s}, za2v.s[w12, 0:1] // 11000000-10000110-10000000-10000000 +// CHECK-INST: mov { z0.s, z1.s }, za2v.s[w12, 0:1] +// CHECK-ENCODING: [0x80,0x80,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0868080 + +mova {z16.s, z17.s}, za0v.s[w14, 2:3] // 11000000-10000110-11000000-00110000 +// CHECK-INST: mov { z16.s, z17.s }, za0v.s[w14, 2:3] +// CHECK-ENCODING: [0x30,0xc0,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086c030 + +mova {z28.s, z29.s}, za3v.s[w12, 0:1] // 11000000-10000110-10000000-11011100 +// CHECK-INST: mov { z28.s, z29.s }, za3v.s[w12, 0:1] +// CHECK-ENCODING: [0xdc,0x80,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c08680dc + +mova {z2.s, z3.s}, za0v.s[w15, 2:3] // 11000000-10000110-11100000-00100010 +// CHECK-INST: mov { z2.s, z3.s }, za0v.s[w15, 2:3] +// CHECK-ENCODING: [0x22,0xe0,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086e022 + +mova {z6.s, z7.s}, za2v.s[w13, 0:1] // 11000000-10000110-10100000-10000110 +// CHECK-INST: mov { z6.s, z7.s }, za2v.s[w13, 0:1] +// CHECK-ENCODING: [0x86,0xa0,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086a086 + +// Aliases + +mov {z0.s, z1.s}, za0v.s[w12, 0:1] // 11000000-10000110-10000000-00000000 +// CHECK-INST: mov { z0.s, z1.s }, za0v.s[w12, 0:1] +// CHECK-ENCODING: [0x00,0x80,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0868000 + +mov {z20.s, z21.s}, za1v.s[w14, 0:1] // 11000000-10000110-11000000-01010100 +// CHECK-INST: mov { z20.s, z21.s }, za1v.s[w14, 0:1] +// CHECK-ENCODING: [0x54,0xc0,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086c054 + +mov {z22.s, z23.s}, za2v.s[w15, 2:3] // 11000000-10000110-11100000-10110110 +// CHECK-INST: mov { z22.s, z23.s }, za2v.s[w15, 2:3] +// CHECK-ENCODING: [0xb6,0xe0,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086e0b6 + +mov {z30.s, z31.s}, za3v.s[w15, 2:3] // 11000000-10000110-11100000-11111110 +// CHECK-INST: mov { z30.s, z31.s }, za3v.s[w15, 2:3] +// CHECK-ENCODING: [0xfe,0xe0,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086e0fe + +mov {z4.s, z5.s}, za0v.s[w12, 2:3] // 11000000-10000110-10000000-00100100 +// CHECK-INST: mov { z4.s, z5.s }, za0v.s[w12, 2:3] +// CHECK-ENCODING: [0x24,0x80,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0868024 + +mov {z0.s, z1.s}, za0v.s[w12, 2:3] // 11000000-10000110-10000000-00100000 +// CHECK-INST: mov { z0.s, z1.s }, za0v.s[w12, 2:3] +// CHECK-ENCODING: [0x20,0x80,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0868020 + +mov {z24.s, z25.s}, za1v.s[w14, 2:3] // 11000000-10000110-11000000-01111000 +// CHECK-INST: mov { z24.s, z25.s }, za1v.s[w14, 2:3] +// CHECK-ENCODING: [0x78,0xc0,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086c078 + +mov {z0.s, z1.s}, za2v.s[w12, 0:1] // 11000000-10000110-10000000-10000000 +// CHECK-INST: mov { z0.s, z1.s }, za2v.s[w12, 0:1] +// CHECK-ENCODING: [0x80,0x80,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0868080 + +mov {z16.s, z17.s}, za0v.s[w14, 2:3] // 11000000-10000110-11000000-00110000 +// CHECK-INST: mov { z16.s, z17.s }, za0v.s[w14, 2:3] +// CHECK-ENCODING: [0x30,0xc0,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086c030 + +mov {z28.s, z29.s}, za3v.s[w12, 0:1] // 11000000-10000110-10000000-11011100 +// CHECK-INST: mov { z28.s, z29.s }, za3v.s[w12, 0:1] +// CHECK-ENCODING: [0xdc,0x80,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c08680dc + +mov {z2.s, z3.s}, za0v.s[w15, 2:3] // 11000000-10000110-11100000-00100010 +// CHECK-INST: mov { z2.s, z3.s }, za0v.s[w15, 2:3] +// CHECK-ENCODING: [0x22,0xe0,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086e022 + +mov {z6.s, z7.s}, za2v.s[w13, 0:1] // 11000000-10000110-10100000-10000110 +// CHECK-INST: mov { z6.s, z7.s }, za2v.s[w13, 0:1] +// CHECK-ENCODING: [0x86,0xa0,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086a086 + + +mova za0h.s[w12, 0:1], {z0.s, z1.s} // 11000000-10000100-00000000-00000000 +// CHECK-INST: mov za0h.s[w12, 0:1], { z0.s, z1.s } +// CHECK-ENCODING: [0x00,0x00,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0840000 + +mova za2h.s[w14, 2:3], {z10.s, z11.s} // 11000000-10000100-01000001-01000101 +// CHECK-INST: mov za2h.s[w14, 2:3], { z10.s, z11.s } +// CHECK-ENCODING: [0x45,0x41,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0844145 + +mova za3h.s[w15, 2:3], {z12.s, z13.s} // 11000000-10000100-01100001-10000111 +// CHECK-INST: mov za3h.s[w15, 2:3], { z12.s, z13.s } +// CHECK-ENCODING: [0x87,0x61,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0846187 + +mova za3h.s[w15, 2:3], {z30.s, z31.s} // 11000000-10000100-01100011-11000111 +// CHECK-INST: mov za3h.s[w15, 2:3], { z30.s, z31.s } +// CHECK-ENCODING: [0xc7,0x63,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c08463c7 + +mova za2h.s[w12, 2:3], {z16.s, z17.s} // 11000000-10000100-00000010-00000101 +// CHECK-INST: mov za2h.s[w12, 2:3], { z16.s, z17.s } +// CHECK-ENCODING: [0x05,0x02,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0840205 + +mova za0h.s[w12, 2:3], {z0.s, z1.s} // 11000000-10000100-00000000-00000001 +// CHECK-INST: mov za0h.s[w12, 2:3], { z0.s, z1.s } +// CHECK-ENCODING: [0x01,0x00,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0840001 + +mova za0h.s[w14, 0:1], {z18.s, z19.s} // 11000000-10000100-01000010-01000000 +// CHECK-INST: mov za0h.s[w14, 0:1], { z18.s, z19.s } +// CHECK-ENCODING: [0x40,0x42,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0844240 + +mova za0h.s[w12, 0:1], {z12.s, z13.s} // 11000000-10000100-00000001-10000000 +// CHECK-INST: mov za0h.s[w12, 0:1], { z12.s, z13.s } +// CHECK-ENCODING: [0x80,0x01,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0840180 + +mova za0h.s[w14, 2:3], {z0.s, z1.s} // 11000000-10000100-01000000-00000001 +// CHECK-INST: mov za0h.s[w14, 2:3], { z0.s, z1.s } +// CHECK-ENCODING: [0x01,0x40,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0844001 + +mova za2h.s[w12, 2:3], {z22.s, z23.s} // 11000000-10000100-00000010-11000101 +// CHECK-INST: mov za2h.s[w12, 2:3], { z22.s, z23.s } +// CHECK-ENCODING: [0xc5,0x02,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c08402c5 + +mova za1h.s[w15, 0:1], {z8.s, z9.s} // 11000000-10000100-01100001-00000010 +// CHECK-INST: mov za1h.s[w15, 0:1], { z8.s, z9.s } +// CHECK-ENCODING: [0x02,0x61,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0846102 + +mova za3h.s[w13, 2:3], {z12.s, z13.s} // 11000000-10000100-00100001-10000111 +// CHECK-INST: mov za3h.s[w13, 2:3], { z12.s, z13.s } +// CHECK-ENCODING: [0x87,0x21,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0842187 + +// Aliases + +mov za0h.s[w12, 0:1], {z0.s, z1.s} // 11000000-10000100-00000000-00000000 +// CHECK-INST: mov za0h.s[w12, 0:1], { z0.s, z1.s } +// CHECK-ENCODING: [0x00,0x00,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0840000 + +mov za2h.s[w14, 2:3], {z10.s, z11.s} // 11000000-10000100-01000001-01000101 +// CHECK-INST: mov za2h.s[w14, 2:3], { z10.s, z11.s } +// CHECK-ENCODING: [0x45,0x41,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0844145 + +mov za3h.s[w15, 2:3], {z12.s, z13.s} // 11000000-10000100-01100001-10000111 +// CHECK-INST: mov za3h.s[w15, 2:3], { z12.s, z13.s } +// CHECK-ENCODING: [0x87,0x61,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0846187 + +mov za3h.s[w15, 2:3], {z30.s, z31.s} // 11000000-10000100-01100011-11000111 +// CHECK-INST: mov za3h.s[w15, 2:3], { z30.s, z31.s } +// CHECK-ENCODING: [0xc7,0x63,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c08463c7 + +mov za2h.s[w12, 2:3], {z16.s, z17.s} // 11000000-10000100-00000010-00000101 +// CHECK-INST: mov za2h.s[w12, 2:3], { z16.s, z17.s } +// CHECK-ENCODING: [0x05,0x02,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0840205 + +mov za0h.s[w12, 2:3], {z0.s, z1.s} // 11000000-10000100-00000000-00000001 +// CHECK-INST: mov za0h.s[w12, 2:3], { z0.s, z1.s } +// CHECK-ENCODING: [0x01,0x00,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0840001 + +mov za0h.s[w14, 0:1], {z18.s, z19.s} // 11000000-10000100-01000010-01000000 +// CHECK-INST: mov za0h.s[w14, 0:1], { z18.s, z19.s } +// CHECK-ENCODING: [0x40,0x42,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0844240 + +mov za0h.s[w12, 0:1], {z12.s, z13.s} // 11000000-10000100-00000001-10000000 +// CHECK-INST: mov za0h.s[w12, 0:1], { z12.s, z13.s } +// CHECK-ENCODING: [0x80,0x01,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0840180 + +mov za0h.s[w14, 2:3], {z0.s, z1.s} // 11000000-10000100-01000000-00000001 +// CHECK-INST: mov za0h.s[w14, 2:3], { z0.s, z1.s } +// CHECK-ENCODING: [0x01,0x40,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0844001 + +mov za2h.s[w12, 2:3], {z22.s, z23.s} // 11000000-10000100-00000010-11000101 +// CHECK-INST: mov za2h.s[w12, 2:3], { z22.s, z23.s } +// CHECK-ENCODING: [0xc5,0x02,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c08402c5 + +mov za1h.s[w15, 0:1], {z8.s, z9.s} // 11000000-10000100-01100001-00000010 +// CHECK-INST: mov za1h.s[w15, 0:1], { z8.s, z9.s } +// CHECK-ENCODING: [0x02,0x61,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0846102 + +mov za3h.s[w13, 2:3], {z12.s, z13.s} // 11000000-10000100-00100001-10000111 +// CHECK-INST: mov za3h.s[w13, 2:3], { z12.s, z13.s } +// CHECK-ENCODING: [0x87,0x21,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0842187 + + +mova za0v.s[w12, 0:1], {z0.s, z1.s} // 11000000-10000100-10000000-00000000 +// CHECK-INST: mov za0v.s[w12, 0:1], { z0.s, z1.s } +// CHECK-ENCODING: [0x00,0x80,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0848000 + +mova za2v.s[w14, 2:3], {z10.s, z11.s} // 11000000-10000100-11000001-01000101 +// CHECK-INST: mov za2v.s[w14, 2:3], { z10.s, z11.s } +// CHECK-ENCODING: [0x45,0xc1,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084c145 + +mova za3v.s[w15, 2:3], {z12.s, z13.s} // 11000000-10000100-11100001-10000111 +// CHECK-INST: mov za3v.s[w15, 2:3], { z12.s, z13.s } +// CHECK-ENCODING: [0x87,0xe1,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084e187 + +mova za3v.s[w15, 2:3], {z30.s, z31.s} // 11000000-10000100-11100011-11000111 +// CHECK-INST: mov za3v.s[w15, 2:3], { z30.s, z31.s } +// CHECK-ENCODING: [0xc7,0xe3,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084e3c7 + +mova za2v.s[w12, 2:3], {z16.s, z17.s} // 11000000-10000100-10000010-00000101 +// CHECK-INST: mov za2v.s[w12, 2:3], { z16.s, z17.s } +// CHECK-ENCODING: [0x05,0x82,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0848205 + +mova za0v.s[w12, 2:3], {z0.s, z1.s} // 11000000-10000100-10000000-00000001 +// CHECK-INST: mov za0v.s[w12, 2:3], { z0.s, z1.s } +// CHECK-ENCODING: [0x01,0x80,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0848001 + +mova za0v.s[w14, 0:1], {z18.s, z19.s} // 11000000-10000100-11000010-01000000 +// CHECK-INST: mov za0v.s[w14, 0:1], { z18.s, z19.s } +// CHECK-ENCODING: [0x40,0xc2,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084c240 + +mova za0v.s[w12, 0:1], {z12.s, z13.s} // 11000000-10000100-10000001-10000000 +// CHECK-INST: mov za0v.s[w12, 0:1], { z12.s, z13.s } +// CHECK-ENCODING: [0x80,0x81,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0848180 + +mova za0v.s[w14, 2:3], {z0.s, z1.s} // 11000000-10000100-11000000-00000001 +// CHECK-INST: mov za0v.s[w14, 2:3], { z0.s, z1.s } +// CHECK-ENCODING: [0x01,0xc0,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084c001 + +mova za2v.s[w12, 2:3], {z22.s, z23.s} // 11000000-10000100-10000010-11000101 +// CHECK-INST: mov za2v.s[w12, 2:3], { z22.s, z23.s } +// CHECK-ENCODING: [0xc5,0x82,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c08482c5 + +mova za1v.s[w15, 0:1], {z8.s, z9.s} // 11000000-10000100-11100001-00000010 +// CHECK-INST: mov za1v.s[w15, 0:1], { z8.s, z9.s } +// CHECK-ENCODING: [0x02,0xe1,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084e102 + +mova za3v.s[w13, 2:3], {z12.s, z13.s} // 11000000-10000100-10100001-10000111 +// CHECK-INST: mov za3v.s[w13, 2:3], { z12.s, z13.s } +// CHECK-ENCODING: [0x87,0xa1,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084a187 + +// Aliases + +mov za0v.s[w12, 0:1], {z0.s, z1.s} // 11000000-10000100-10000000-00000000 +// CHECK-INST: mov za0v.s[w12, 0:1], { z0.s, z1.s } +// CHECK-ENCODING: [0x00,0x80,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0848000 + +mov za2v.s[w14, 2:3], {z10.s, z11.s} // 11000000-10000100-11000001-01000101 +// CHECK-INST: mov za2v.s[w14, 2:3], { z10.s, z11.s } +// CHECK-ENCODING: [0x45,0xc1,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084c145 + +mov za3v.s[w15, 2:3], {z12.s, z13.s} // 11000000-10000100-11100001-10000111 +// CHECK-INST: mov za3v.s[w15, 2:3], { z12.s, z13.s } +// CHECK-ENCODING: [0x87,0xe1,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084e187 + +mov za3v.s[w15, 2:3], {z30.s, z31.s} // 11000000-10000100-11100011-11000111 +// CHECK-INST: mov za3v.s[w15, 2:3], { z30.s, z31.s } +// CHECK-ENCODING: [0xc7,0xe3,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084e3c7 + +mov za2v.s[w12, 2:3], {z16.s, z17.s} // 11000000-10000100-10000010-00000101 +// CHECK-INST: mov za2v.s[w12, 2:3], { z16.s, z17.s } +// CHECK-ENCODING: [0x05,0x82,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0848205 + +mov za0v.s[w12, 2:3], {z0.s, z1.s} // 11000000-10000100-10000000-00000001 +// CHECK-INST: mov za0v.s[w12, 2:3], { z0.s, z1.s } +// CHECK-ENCODING: [0x01,0x80,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0848001 + +mov za0v.s[w14, 0:1], {z18.s, z19.s} // 11000000-10000100-11000010-01000000 +// CHECK-INST: mov za0v.s[w14, 0:1], { z18.s, z19.s } +// CHECK-ENCODING: [0x40,0xc2,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084c240 + +mov za0v.s[w12, 0:1], {z12.s, z13.s} // 11000000-10000100-10000001-10000000 +// CHECK-INST: mov za0v.s[w12, 0:1], { z12.s, z13.s } +// CHECK-ENCODING: [0x80,0x81,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0848180 + +mov za0v.s[w14, 2:3], {z0.s, z1.s} // 11000000-10000100-11000000-00000001 +// CHECK-INST: mov za0v.s[w14, 2:3], { z0.s, z1.s } +// CHECK-ENCODING: [0x01,0xc0,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084c001 + +mov za2v.s[w12, 2:3], {z22.s, z23.s} // 11000000-10000100-10000010-11000101 +// CHECK-INST: mov za2v.s[w12, 2:3], { z22.s, z23.s } +// CHECK-ENCODING: [0xc5,0x82,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c08482c5 + +mov za1v.s[w15, 0:1], {z8.s, z9.s} // 11000000-10000100-11100001-00000010 +// CHECK-INST: mov za1v.s[w15, 0:1], { z8.s, z9.s } +// CHECK-ENCODING: [0x02,0xe1,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084e102 + +mov za3v.s[w13, 2:3], {z12.s, z13.s} // 11000000-10000100-10100001-10000111 +// CHECK-INST: mov za3v.s[w13, 2:3], { z12.s, z13.s } +// CHECK-ENCODING: [0x87,0xa1,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084a187 + + +mova {z0.d, z1.d}, za0h.d[w12, 0:1] // 11000000-11000110-00000000-00000000 +// CHECK-INST: mov { z0.d, z1.d }, za0h.d[w12, 0:1] +// CHECK-ENCODING: [0x00,0x00,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c60000 + +mova {z20.d, z21.d}, za2h.d[w14, 0:1] // 11000000-11000110-01000000-01010100 +// CHECK-INST: mov { z20.d, z21.d }, za2h.d[w14, 0:1] +// CHECK-ENCODING: [0x54,0x40,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c64054 + +mova {z22.d, z23.d}, za5h.d[w15, 0:1] // 11000000-11000110-01100000-10110110 +// CHECK-INST: mov { z22.d, z23.d }, za5h.d[w15, 0:1] +// CHECK-ENCODING: [0xb6,0x60,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c660b6 + +mova {z30.d, z31.d}, za7h.d[w15, 0:1] // 11000000-11000110-01100000-11111110 +// CHECK-INST: mov { z30.d, z31.d }, za7h.d[w15, 0:1] +// CHECK-ENCODING: [0xfe,0x60,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c660fe + +mova {z4.d, z5.d}, za1h.d[w12, 0:1] // 11000000-11000110-00000000-00100100 +// CHECK-INST: mov { z4.d, z5.d }, za1h.d[w12, 0:1] +// CHECK-ENCODING: [0x24,0x00,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c60024 + +mova {z0.d, z1.d}, za1h.d[w12, 0:1] // 11000000-11000110-00000000-00100000 +// CHECK-INST: mov { z0.d, z1.d }, za1h.d[w12, 0:1] +// CHECK-ENCODING: [0x20,0x00,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c60020 + +mova {z24.d, z25.d}, za3h.d[w14, 0:1] // 11000000-11000110-01000000-01111000 +// CHECK-INST: mov { z24.d, z25.d }, za3h.d[w14, 0:1] +// CHECK-ENCODING: [0x78,0x40,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c64078 + +mova {z0.d, z1.d}, za4h.d[w12, 0:1] // 11000000-11000110-00000000-10000000 +// CHECK-INST: mov { z0.d, z1.d }, za4h.d[w12, 0:1] +// CHECK-ENCODING: [0x80,0x00,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c60080 + +mova {z16.d, z17.d}, za1h.d[w14, 0:1] // 11000000-11000110-01000000-00110000 +// CHECK-INST: mov { z16.d, z17.d }, za1h.d[w14, 0:1] +// CHECK-ENCODING: [0x30,0x40,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c64030 + +mova {z28.d, z29.d}, za6h.d[w12, 0:1] // 11000000-11000110-00000000-11011100 +// CHECK-INST: mov { z28.d, z29.d }, za6h.d[w12, 0:1] +// CHECK-ENCODING: [0xdc,0x00,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c600dc + +mova {z2.d, z3.d}, za1h.d[w15, 0:1] // 11000000-11000110-01100000-00100010 +// CHECK-INST: mov { z2.d, z3.d }, za1h.d[w15, 0:1] +// CHECK-ENCODING: [0x22,0x60,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c66022 + +mova {z6.d, z7.d}, za4h.d[w13, 0:1] // 11000000-11000110-00100000-10000110 +// CHECK-INST: mov { z6.d, z7.d }, za4h.d[w13, 0:1] +// CHECK-ENCODING: [0x86,0x20,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c62086 + +// Aliases + +mov {z0.d, z1.d}, za0h.d[w12, 0:1] // 11000000-11000110-00000000-00000000 +// CHECK-INST: mov { z0.d, z1.d }, za0h.d[w12, 0:1] +// CHECK-ENCODING: [0x00,0x00,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c60000 + +mov {z20.d, z21.d}, za2h.d[w14, 0:1] // 11000000-11000110-01000000-01010100 +// CHECK-INST: mov { z20.d, z21.d }, za2h.d[w14, 0:1] +// CHECK-ENCODING: [0x54,0x40,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c64054 + +mov {z22.d, z23.d}, za5h.d[w15, 0:1] // 11000000-11000110-01100000-10110110 +// CHECK-INST: mov { z22.d, z23.d }, za5h.d[w15, 0:1] +// CHECK-ENCODING: [0xb6,0x60,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c660b6 + +mov {z30.d, z31.d}, za7h.d[w15, 0:1] // 11000000-11000110-01100000-11111110 +// CHECK-INST: mov { z30.d, z31.d }, za7h.d[w15, 0:1] +// CHECK-ENCODING: [0xfe,0x60,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c660fe + +mov {z4.d, z5.d}, za1h.d[w12, 0:1] // 11000000-11000110-00000000-00100100 +// CHECK-INST: mov { z4.d, z5.d }, za1h.d[w12, 0:1] +// CHECK-ENCODING: [0x24,0x00,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c60024 + +mov {z0.d, z1.d}, za1h.d[w12, 0:1] // 11000000-11000110-00000000-00100000 +// CHECK-INST: mov { z0.d, z1.d }, za1h.d[w12, 0:1] +// CHECK-ENCODING: [0x20,0x00,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c60020 + +mov {z24.d, z25.d}, za3h.d[w14, 0:1] // 11000000-11000110-01000000-01111000 +// CHECK-INST: mov { z24.d, z25.d }, za3h.d[w14, 0:1] +// CHECK-ENCODING: [0x78,0x40,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c64078 + +mov {z0.d, z1.d}, za4h.d[w12, 0:1] // 11000000-11000110-00000000-10000000 +// CHECK-INST: mov { z0.d, z1.d }, za4h.d[w12, 0:1] +// CHECK-ENCODING: [0x80,0x00,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c60080 + +mov {z16.d, z17.d}, za1h.d[w14, 0:1] // 11000000-11000110-01000000-00110000 +// CHECK-INST: mov { z16.d, z17.d }, za1h.d[w14, 0:1] +// CHECK-ENCODING: [0x30,0x40,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c64030 + +mov {z28.d, z29.d}, za6h.d[w12, 0:1] // 11000000-11000110-00000000-11011100 +// CHECK-INST: mov { z28.d, z29.d }, za6h.d[w12, 0:1] +// CHECK-ENCODING: [0xdc,0x00,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c600dc + +mov {z2.d, z3.d}, za1h.d[w15, 0:1] // 11000000-11000110-01100000-00100010 +// CHECK-INST: mov { z2.d, z3.d }, za1h.d[w15, 0:1] +// CHECK-ENCODING: [0x22,0x60,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c66022 + +mov {z6.d, z7.d}, za4h.d[w13, 0:1] // 11000000-11000110-00100000-10000110 +// CHECK-INST: mov { z6.d, z7.d }, za4h.d[w13, 0:1] +// CHECK-ENCODING: [0x86,0x20,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c62086 + + +mova {z0.d, z1.d}, za0v.d[w12, 0:1] // 11000000-11000110-10000000-00000000 +// CHECK-INST: mov { z0.d, z1.d }, za0v.d[w12, 0:1] +// CHECK-ENCODING: [0x00,0x80,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c68000 + +mova {z20.d, z21.d}, za2v.d[w14, 0:1] // 11000000-11000110-11000000-01010100 +// CHECK-INST: mov { z20.d, z21.d }, za2v.d[w14, 0:1] +// CHECK-ENCODING: [0x54,0xc0,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6c054 + +mova {z22.d, z23.d}, za5v.d[w15, 0:1] // 11000000-11000110-11100000-10110110 +// CHECK-INST: mov { z22.d, z23.d }, za5v.d[w15, 0:1] +// CHECK-ENCODING: [0xb6,0xe0,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6e0b6 + +mova {z30.d, z31.d}, za7v.d[w15, 0:1] // 11000000-11000110-11100000-11111110 +// CHECK-INST: mov { z30.d, z31.d }, za7v.d[w15, 0:1] +// CHECK-ENCODING: [0xfe,0xe0,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6e0fe + +mova {z4.d, z5.d}, za1v.d[w12, 0:1] // 11000000-11000110-10000000-00100100 +// CHECK-INST: mov { z4.d, z5.d }, za1v.d[w12, 0:1] +// CHECK-ENCODING: [0x24,0x80,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c68024 + +mova {z0.d, z1.d}, za1v.d[w12, 0:1] // 11000000-11000110-10000000-00100000 +// CHECK-INST: mov { z0.d, z1.d }, za1v.d[w12, 0:1] +// CHECK-ENCODING: [0x20,0x80,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c68020 + +mova {z24.d, z25.d}, za3v.d[w14, 0:1] // 11000000-11000110-11000000-01111000 +// CHECK-INST: mov { z24.d, z25.d }, za3v.d[w14, 0:1] +// CHECK-ENCODING: [0x78,0xc0,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6c078 + +mova {z0.d, z1.d}, za4v.d[w12, 0:1] // 11000000-11000110-10000000-10000000 +// CHECK-INST: mov { z0.d, z1.d }, za4v.d[w12, 0:1] +// CHECK-ENCODING: [0x80,0x80,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c68080 + +mova {z16.d, z17.d}, za1v.d[w14, 0:1] // 11000000-11000110-11000000-00110000 +// CHECK-INST: mov { z16.d, z17.d }, za1v.d[w14, 0:1] +// CHECK-ENCODING: [0x30,0xc0,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6c030 + +mova {z28.d, z29.d}, za6v.d[w12, 0:1] // 11000000-11000110-10000000-11011100 +// CHECK-INST: mov { z28.d, z29.d }, za6v.d[w12, 0:1] +// CHECK-ENCODING: [0xdc,0x80,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c680dc + +mova {z2.d, z3.d}, za1v.d[w15, 0:1] // 11000000-11000110-11100000-00100010 +// CHECK-INST: mov { z2.d, z3.d }, za1v.d[w15, 0:1] +// CHECK-ENCODING: [0x22,0xe0,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6e022 + +mova {z6.d, z7.d}, za4v.d[w13, 0:1] // 11000000-11000110-10100000-10000110 +// CHECK-INST: mov { z6.d, z7.d }, za4v.d[w13, 0:1] +// CHECK-ENCODING: [0x86,0xa0,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6a086 + +// Aliases + +mov {z0.d, z1.d}, za0v.d[w12, 0:1] // 11000000-11000110-10000000-00000000 +// CHECK-INST: mov { z0.d, z1.d }, za0v.d[w12, 0:1] +// CHECK-ENCODING: [0x00,0x80,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c68000 + +mov {z20.d, z21.d}, za2v.d[w14, 0:1] // 11000000-11000110-11000000-01010100 +// CHECK-INST: mov { z20.d, z21.d }, za2v.d[w14, 0:1] +// CHECK-ENCODING: [0x54,0xc0,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6c054 + +mov {z22.d, z23.d}, za5v.d[w15, 0:1] // 11000000-11000110-11100000-10110110 +// CHECK-INST: mov { z22.d, z23.d }, za5v.d[w15, 0:1] +// CHECK-ENCODING: [0xb6,0xe0,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6e0b6 + +mov {z30.d, z31.d}, za7v.d[w15, 0:1] // 11000000-11000110-11100000-11111110 +// CHECK-INST: mov { z30.d, z31.d }, za7v.d[w15, 0:1] +// CHECK-ENCODING: [0xfe,0xe0,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6e0fe + +mov {z4.d, z5.d}, za1v.d[w12, 0:1] // 11000000-11000110-10000000-00100100 +// CHECK-INST: mov { z4.d, z5.d }, za1v.d[w12, 0:1] +// CHECK-ENCODING: [0x24,0x80,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c68024 + +mov {z0.d, z1.d}, za1v.d[w12, 0:1] // 11000000-11000110-10000000-00100000 +// CHECK-INST: mov { z0.d, z1.d }, za1v.d[w12, 0:1] +// CHECK-ENCODING: [0x20,0x80,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c68020 + +mov {z24.d, z25.d}, za3v.d[w14, 0:1] // 11000000-11000110-11000000-01111000 +// CHECK-INST: mov { z24.d, z25.d }, za3v.d[w14, 0:1] +// CHECK-ENCODING: [0x78,0xc0,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6c078 + +mov {z0.d, z1.d}, za4v.d[w12, 0:1] // 11000000-11000110-10000000-10000000 +// CHECK-INST: mov { z0.d, z1.d }, za4v.d[w12, 0:1] +// CHECK-ENCODING: [0x80,0x80,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c68080 + +mov {z16.d, z17.d}, za1v.d[w14, 0:1] // 11000000-11000110-11000000-00110000 +// CHECK-INST: mov { z16.d, z17.d }, za1v.d[w14, 0:1] +// CHECK-ENCODING: [0x30,0xc0,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6c030 + +mov {z28.d, z29.d}, za6v.d[w12, 0:1] // 11000000-11000110-10000000-11011100 +// CHECK-INST: mov { z28.d, z29.d }, za6v.d[w12, 0:1] +// CHECK-ENCODING: [0xdc,0x80,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c680dc + +mov {z2.d, z3.d}, za1v.d[w15, 0:1] // 11000000-11000110-11100000-00100010 +// CHECK-INST: mov { z2.d, z3.d }, za1v.d[w15, 0:1] +// CHECK-ENCODING: [0x22,0xe0,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6e022 + +mov {z6.d, z7.d}, za4v.d[w13, 0:1] // 11000000-11000110-10100000-10000110 +// CHECK-INST: mov { z6.d, z7.d }, za4v.d[w13, 0:1] +// CHECK-ENCODING: [0x86,0xa0,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6a086 + + +mova {z0.d, z1.d}, za.d[w8, 0, vgx2] // 11000000-00000110-00001000-00000000 +// CHECK-INST: mov { z0.d, z1.d }, za.d[w8, 0, vgx2] +// CHECK-ENCODING: [0x00,0x08,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060800 + +mova {z0.d, z1.d}, za.d[w8, 0] // 11000000-00000110-00001000-00000000 +// CHECK-INST: mov { z0.d, z1.d }, za.d[w8, 0, vgx2] +// CHECK-ENCODING: [0x00,0x08,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060800 + +mova {z20.d, z21.d}, za.d[w10, 2, vgx2] // 11000000-00000110-01001000-01010100 +// CHECK-INST: mov { z20.d, z21.d }, za.d[w10, 2, vgx2] +// CHECK-ENCODING: [0x54,0x48,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064854 + +mova {z20.d, z21.d}, za.d[w10, 2] // 11000000-00000110-01001000-01010100 +// CHECK-INST: mov { z20.d, z21.d }, za.d[w10, 2, vgx2] +// CHECK-ENCODING: [0x54,0x48,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064854 + +mova {z22.d, z23.d}, za.d[w11, 5, vgx2] // 11000000-00000110-01101000-10110110 +// CHECK-INST: mov { z22.d, z23.d }, za.d[w11, 5, vgx2] +// CHECK-ENCODING: [0xb6,0x68,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00668b6 + +mova {z22.d, z23.d}, za.d[w11, 5] // 11000000-00000110-01101000-10110110 +// CHECK-INST: mov { z22.d, z23.d }, za.d[w11, 5, vgx2] +// CHECK-ENCODING: [0xb6,0x68,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00668b6 + +mova {z30.d, z31.d}, za.d[w11, 7, vgx2] // 11000000-00000110-01101000-11111110 +// CHECK-INST: mov { z30.d, z31.d }, za.d[w11, 7, vgx2] +// CHECK-ENCODING: [0xfe,0x68,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00668fe + +mova {z30.d, z31.d}, za.d[w11, 7] // 11000000-00000110-01101000-11111110 +// CHECK-INST: mov { z30.d, z31.d }, za.d[w11, 7, vgx2] +// CHECK-ENCODING: [0xfe,0x68,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00668fe + +mova {z4.d, z5.d}, za.d[w8, 1, vgx2] // 11000000-00000110-00001000-00100100 +// CHECK-INST: mov { z4.d, z5.d }, za.d[w8, 1, vgx2] +// CHECK-ENCODING: [0x24,0x08,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060824 + +mova {z4.d, z5.d}, za.d[w8, 1] // 11000000-00000110-00001000-00100100 +// CHECK-INST: mov { z4.d, z5.d }, za.d[w8, 1, vgx2] +// CHECK-ENCODING: [0x24,0x08,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060824 + +mova {z0.d, z1.d}, za.d[w8, 1, vgx2] // 11000000-00000110-00001000-00100000 +// CHECK-INST: mov { z0.d, z1.d }, za.d[w8, 1, vgx2] +// CHECK-ENCODING: [0x20,0x08,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060820 + +mova {z0.d, z1.d}, za.d[w8, 1] // 11000000-00000110-00001000-00100000 +// CHECK-INST: mov { z0.d, z1.d }, za.d[w8, 1, vgx2] +// CHECK-ENCODING: [0x20,0x08,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060820 + +mova {z24.d, z25.d}, za.d[w10, 3, vgx2] // 11000000-00000110-01001000-01111000 +// CHECK-INST: mov { z24.d, z25.d }, za.d[w10, 3, vgx2] +// CHECK-ENCODING: [0x78,0x48,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064878 + +mova {z24.d, z25.d}, za.d[w10, 3] // 11000000-00000110-01001000-01111000 +// CHECK-INST: mov { z24.d, z25.d }, za.d[w10, 3, vgx2] +// CHECK-ENCODING: [0x78,0x48,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064878 + +mova {z0.d, z1.d}, za.d[w8, 4, vgx2] // 11000000-00000110-00001000-10000000 +// CHECK-INST: mov { z0.d, z1.d }, za.d[w8, 4, vgx2] +// CHECK-ENCODING: [0x80,0x08,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060880 + +mova {z0.d, z1.d}, za.d[w8, 4] // 11000000-00000110-00001000-10000000 +// CHECK-INST: mov { z0.d, z1.d }, za.d[w8, 4, vgx2] +// CHECK-ENCODING: [0x80,0x08,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060880 + +mova {z16.d, z17.d}, za.d[w10, 1, vgx2] // 11000000-00000110-01001000-00110000 +// CHECK-INST: mov { z16.d, z17.d }, za.d[w10, 1, vgx2] +// CHECK-ENCODING: [0x30,0x48,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064830 + +mova {z16.d, z17.d}, za.d[w10, 1] // 11000000-00000110-01001000-00110000 +// CHECK-INST: mov { z16.d, z17.d }, za.d[w10, 1, vgx2] +// CHECK-ENCODING: [0x30,0x48,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064830 + +mova {z28.d, z29.d}, za.d[w8, 6, vgx2] // 11000000-00000110-00001000-11011100 +// CHECK-INST: mov { z28.d, z29.d }, za.d[w8, 6, vgx2] +// CHECK-ENCODING: [0xdc,0x08,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00608dc + +mova {z28.d, z29.d}, za.d[w8, 6] // 11000000-00000110-00001000-11011100 +// CHECK-INST: mov { z28.d, z29.d }, za.d[w8, 6, vgx2] +// CHECK-ENCODING: [0xdc,0x08,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00608dc + +mova {z2.d, z3.d}, za.d[w11, 1, vgx2] // 11000000-00000110-01101000-00100010 +// CHECK-INST: mov { z2.d, z3.d }, za.d[w11, 1, vgx2] +// CHECK-ENCODING: [0x22,0x68,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0066822 + +mova {z2.d, z3.d}, za.d[w11, 1] // 11000000-00000110-01101000-00100010 +// CHECK-INST: mov { z2.d, z3.d }, za.d[w11, 1, vgx2] +// CHECK-ENCODING: [0x22,0x68,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0066822 + +mova {z6.d, z7.d}, za.d[w9, 4, vgx2] // 11000000-00000110-00101000-10000110 +// CHECK-INST: mov { z6.d, z7.d }, za.d[w9, 4, vgx2] +// CHECK-ENCODING: [0x86,0x28,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0062886 + +mova {z6.d, z7.d}, za.d[w9, 4] // 11000000-00000110-00101000-10000110 +// CHECK-INST: mov { z6.d, z7.d }, za.d[w9, 4, vgx2] +// CHECK-ENCODING: [0x86,0x28,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0062886 + +// Aliases + +mov {z0.d, z1.d}, za.d[w8, 0, vgx2] // 11000000-00000110-00001000-00000000 +// CHECK-INST: mov { z0.d, z1.d }, za.d[w8, 0, vgx2] +// CHECK-ENCODING: [0x00,0x08,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060800 + +mov {z20.d, z21.d}, za.d[w10, 2, vgx2] // 11000000-00000110-01001000-01010100 +// CHECK-INST: mov { z20.d, z21.d }, za.d[w10, 2, vgx2] +// CHECK-ENCODING: [0x54,0x48,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064854 + +mov {z22.d, z23.d}, za.d[w11, 5, vgx2] // 11000000-00000110-01101000-10110110 +// CHECK-INST: mov { z22.d, z23.d }, za.d[w11, 5, vgx2] +// CHECK-ENCODING: [0xb6,0x68,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00668b6 + +mov {z30.d, z31.d}, za.d[w11, 7, vgx2] // 11000000-00000110-01101000-11111110 +// CHECK-INST: mov { z30.d, z31.d }, za.d[w11, 7, vgx2] +// CHECK-ENCODING: [0xfe,0x68,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00668fe + +mov {z4.d, z5.d}, za.d[w8, 1, vgx2] // 11000000-00000110-00001000-00100100 +// CHECK-INST: mov { z4.d, z5.d }, za.d[w8, 1, vgx2] +// CHECK-ENCODING: [0x24,0x08,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060824 + +mov {z0.d, z1.d}, za.d[w8, 1, vgx2] // 11000000-00000110-00001000-00100000 +// CHECK-INST: mov { z0.d, z1.d }, za.d[w8, 1, vgx2] +// CHECK-ENCODING: [0x20,0x08,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060820 + +mov {z24.d, z25.d}, za.d[w10, 3, vgx2] // 11000000-00000110-01001000-01111000 +// CHECK-INST: mov { z24.d, z25.d }, za.d[w10, 3, vgx2] +// CHECK-ENCODING: [0x78,0x48,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064878 + +mov {z0.d, z1.d}, za.d[w8, 4, vgx2] // 11000000-00000110-00001000-10000000 +// CHECK-INST: mov { z0.d, z1.d }, za.d[w8, 4, vgx2] +// CHECK-ENCODING: [0x80,0x08,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060880 + +mov {z16.d, z17.d}, za.d[w10, 1, vgx2] // 11000000-00000110-01001000-00110000 +// CHECK-INST: mov { z16.d, z17.d }, za.d[w10, 1, vgx2] +// CHECK-ENCODING: [0x30,0x48,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064830 + +mov {z28.d, z29.d}, za.d[w8, 6, vgx2] // 11000000-00000110-00001000-11011100 +// CHECK-INST: mov { z28.d, z29.d }, za.d[w8, 6, vgx2] +// CHECK-ENCODING: [0xdc,0x08,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00608dc + +mov {z2.d, z3.d}, za.d[w11, 1, vgx2] // 11000000-00000110-01101000-00100010 +// CHECK-INST: mov { z2.d, z3.d }, za.d[w11, 1, vgx2] +// CHECK-ENCODING: [0x22,0x68,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0066822 + +mov {z6.d, z7.d}, za.d[w9, 4, vgx2] // 11000000-00000110-00101000-10000110 +// CHECK-INST: mov { z6.d, z7.d }, za.d[w9, 4, vgx2] +// CHECK-ENCODING: [0x86,0x28,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0062886 + + +mova za0h.d[w12, 0:1], {z0.d, z1.d} // 11000000-11000100-00000000-00000000 +// CHECK-INST: mov za0h.d[w12, 0:1], { z0.d, z1.d } +// CHECK-ENCODING: [0x00,0x00,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c40000 + +mova za5h.d[w14, 0:1], {z10.d, z11.d} // 11000000-11000100-01000001-01000101 +// CHECK-INST: mov za5h.d[w14, 0:1], { z10.d, z11.d } +// CHECK-ENCODING: [0x45,0x41,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c44145 + +mova za7h.d[w15, 0:1], {z12.d, z13.d} // 11000000-11000100-01100001-10000111 +// CHECK-INST: mov za7h.d[w15, 0:1], { z12.d, z13.d } +// CHECK-ENCODING: [0x87,0x61,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c46187 + +mova za7h.d[w15, 0:1], {z30.d, z31.d} // 11000000-11000100-01100011-11000111 +// CHECK-INST: mov za7h.d[w15, 0:1], { z30.d, z31.d } +// CHECK-ENCODING: [0xc7,0x63,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c463c7 + +mova za5h.d[w12, 0:1], {z16.d, z17.d} // 11000000-11000100-00000010-00000101 +// CHECK-INST: mov za5h.d[w12, 0:1], { z16.d, z17.d } +// CHECK-ENCODING: [0x05,0x02,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c40205 + +mova za1h.d[w12, 0:1], {z0.d, z1.d} // 11000000-11000100-00000000-00000001 +// CHECK-INST: mov za1h.d[w12, 0:1], { z0.d, z1.d } +// CHECK-ENCODING: [0x01,0x00,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c40001 + +mova za0h.d[w14, 0:1], {z18.d, z19.d} // 11000000-11000100-01000010-01000000 +// CHECK-INST: mov za0h.d[w14, 0:1], { z18.d, z19.d } +// CHECK-ENCODING: [0x40,0x42,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c44240 + +mova za0h.d[w12, 0:1], {z12.d, z13.d} // 11000000-11000100-00000001-10000000 +// CHECK-INST: mov za0h.d[w12, 0:1], { z12.d, z13.d } +// CHECK-ENCODING: [0x80,0x01,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c40180 + +mova za1h.d[w14, 0:1], {z0.d, z1.d} // 11000000-11000100-01000000-00000001 +// CHECK-INST: mov za1h.d[w14, 0:1], { z0.d, z1.d } +// CHECK-ENCODING: [0x01,0x40,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c44001 + +mova za5h.d[w12, 0:1], {z22.d, z23.d} // 11000000-11000100-00000010-11000101 +// CHECK-INST: mov za5h.d[w12, 0:1], { z22.d, z23.d } +// CHECK-ENCODING: [0xc5,0x02,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c402c5 + +mova za2h.d[w15, 0:1], {z8.d, z9.d} // 11000000-11000100-01100001-00000010 +// CHECK-INST: mov za2h.d[w15, 0:1], { z8.d, z9.d } +// CHECK-ENCODING: [0x02,0x61,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c46102 + +mova za7h.d[w13, 0:1], {z12.d, z13.d} // 11000000-11000100-00100001-10000111 +// CHECK-INST: mov za7h.d[w13, 0:1], { z12.d, z13.d } +// CHECK-ENCODING: [0x87,0x21,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c42187 + +// Aliases + +mov za0h.d[w12, 0:1], {z0.d, z1.d} // 11000000-11000100-00000000-00000000 +// CHECK-INST: mov za0h.d[w12, 0:1], { z0.d, z1.d } +// CHECK-ENCODING: [0x00,0x00,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c40000 + +mov za5h.d[w14, 0:1], {z10.d, z11.d} // 11000000-11000100-01000001-01000101 +// CHECK-INST: mov za5h.d[w14, 0:1], { z10.d, z11.d } +// CHECK-ENCODING: [0x45,0x41,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c44145 + +mov za7h.d[w15, 0:1], {z12.d, z13.d} // 11000000-11000100-01100001-10000111 +// CHECK-INST: mov za7h.d[w15, 0:1], { z12.d, z13.d } +// CHECK-ENCODING: [0x87,0x61,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c46187 + +mov za7h.d[w15, 0:1], {z30.d, z31.d} // 11000000-11000100-01100011-11000111 +// CHECK-INST: mov za7h.d[w15, 0:1], { z30.d, z31.d } +// CHECK-ENCODING: [0xc7,0x63,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c463c7 + +mov za5h.d[w12, 0:1], {z16.d, z17.d} // 11000000-11000100-00000010-00000101 +// CHECK-INST: mov za5h.d[w12, 0:1], { z16.d, z17.d } +// CHECK-ENCODING: [0x05,0x02,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c40205 + +mov za1h.d[w12, 0:1], {z0.d, z1.d} // 11000000-11000100-00000000-00000001 +// CHECK-INST: mov za1h.d[w12, 0:1], { z0.d, z1.d } +// CHECK-ENCODING: [0x01,0x00,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c40001 + +mov za0h.d[w14, 0:1], {z18.d, z19.d} // 11000000-11000100-01000010-01000000 +// CHECK-INST: mov za0h.d[w14, 0:1], { z18.d, z19.d } +// CHECK-ENCODING: [0x40,0x42,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c44240 + +mov za0h.d[w12, 0:1], {z12.d, z13.d} // 11000000-11000100-00000001-10000000 +// CHECK-INST: mov za0h.d[w12, 0:1], { z12.d, z13.d } +// CHECK-ENCODING: [0x80,0x01,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c40180 + +mov za1h.d[w14, 0:1], {z0.d, z1.d} // 11000000-11000100-01000000-00000001 +// CHECK-INST: mov za1h.d[w14, 0:1], { z0.d, z1.d } +// CHECK-ENCODING: [0x01,0x40,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c44001 + +mov za5h.d[w12, 0:1], {z22.d, z23.d} // 11000000-11000100-00000010-11000101 +// CHECK-INST: mov za5h.d[w12, 0:1], { z22.d, z23.d } +// CHECK-ENCODING: [0xc5,0x02,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c402c5 + +mov za2h.d[w15, 0:1], {z8.d, z9.d} // 11000000-11000100-01100001-00000010 +// CHECK-INST: mov za2h.d[w15, 0:1], { z8.d, z9.d } +// CHECK-ENCODING: [0x02,0x61,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c46102 + +mov za7h.d[w13, 0:1], {z12.d, z13.d} // 11000000-11000100-00100001-10000111 +// CHECK-INST: mov za7h.d[w13, 0:1], { z12.d, z13.d } +// CHECK-ENCODING: [0x87,0x21,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c42187 + + +mova za0v.d[w12, 0:1], {z0.d, z1.d} // 11000000-11000100-10000000-00000000 +// CHECK-INST: mov za0v.d[w12, 0:1], { z0.d, z1.d } +// CHECK-ENCODING: [0x00,0x80,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c48000 + +mova za5v.d[w14, 0:1], {z10.d, z11.d} // 11000000-11000100-11000001-01000101 +// CHECK-INST: mov za5v.d[w14, 0:1], { z10.d, z11.d } +// CHECK-ENCODING: [0x45,0xc1,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4c145 + +mova za7v.d[w15, 0:1], {z12.d, z13.d} // 11000000-11000100-11100001-10000111 +// CHECK-INST: mov za7v.d[w15, 0:1], { z12.d, z13.d } +// CHECK-ENCODING: [0x87,0xe1,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4e187 + +mova za7v.d[w15, 0:1], {z30.d, z31.d} // 11000000-11000100-11100011-11000111 +// CHECK-INST: mov za7v.d[w15, 0:1], { z30.d, z31.d } +// CHECK-ENCODING: [0xc7,0xe3,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4e3c7 + +mova za5v.d[w12, 0:1], {z16.d, z17.d} // 11000000-11000100-10000010-00000101 +// CHECK-INST: mov za5v.d[w12, 0:1], { z16.d, z17.d } +// CHECK-ENCODING: [0x05,0x82,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c48205 + +mova za1v.d[w12, 0:1], {z0.d, z1.d} // 11000000-11000100-10000000-00000001 +// CHECK-INST: mov za1v.d[w12, 0:1], { z0.d, z1.d } +// CHECK-ENCODING: [0x01,0x80,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c48001 + +mova za0v.d[w14, 0:1], {z18.d, z19.d} // 11000000-11000100-11000010-01000000 +// CHECK-INST: mov za0v.d[w14, 0:1], { z18.d, z19.d } +// CHECK-ENCODING: [0x40,0xc2,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4c240 + +mova za0v.d[w12, 0:1], {z12.d, z13.d} // 11000000-11000100-10000001-10000000 +// CHECK-INST: mov za0v.d[w12, 0:1], { z12.d, z13.d } +// CHECK-ENCODING: [0x80,0x81,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c48180 + +mova za1v.d[w14, 0:1], {z0.d, z1.d} // 11000000-11000100-11000000-00000001 +// CHECK-INST: mov za1v.d[w14, 0:1], { z0.d, z1.d } +// CHECK-ENCODING: [0x01,0xc0,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4c001 + +mova za5v.d[w12, 0:1], {z22.d, z23.d} // 11000000-11000100-10000010-11000101 +// CHECK-INST: mov za5v.d[w12, 0:1], { z22.d, z23.d } +// CHECK-ENCODING: [0xc5,0x82,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c482c5 + +mova za2v.d[w15, 0:1], {z8.d, z9.d} // 11000000-11000100-11100001-00000010 +// CHECK-INST: mov za2v.d[w15, 0:1], { z8.d, z9.d } +// CHECK-ENCODING: [0x02,0xe1,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4e102 + +mova za7v.d[w13, 0:1], {z12.d, z13.d} // 11000000-11000100-10100001-10000111 +// CHECK-INST: mov za7v.d[w13, 0:1], { z12.d, z13.d } +// CHECK-ENCODING: [0x87,0xa1,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4a187 + +// Aliases + +mov za0v.d[w12, 0:1], {z0.d, z1.d} // 11000000-11000100-10000000-00000000 +// CHECK-INST: mov za0v.d[w12, 0:1], { z0.d, z1.d } +// CHECK-ENCODING: [0x00,0x80,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c48000 + +mov za5v.d[w14, 0:1], {z10.d, z11.d} // 11000000-11000100-11000001-01000101 +// CHECK-INST: mov za5v.d[w14, 0:1], { z10.d, z11.d } +// CHECK-ENCODING: [0x45,0xc1,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4c145 + +mov za7v.d[w15, 0:1], {z12.d, z13.d} // 11000000-11000100-11100001-10000111 +// CHECK-INST: mov za7v.d[w15, 0:1], { z12.d, z13.d } +// CHECK-ENCODING: [0x87,0xe1,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4e187 + +mov za7v.d[w15, 0:1], {z30.d, z31.d} // 11000000-11000100-11100011-11000111 +// CHECK-INST: mov za7v.d[w15, 0:1], { z30.d, z31.d } +// CHECK-ENCODING: [0xc7,0xe3,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4e3c7 + +mov za5v.d[w12, 0:1], {z16.d, z17.d} // 11000000-11000100-10000010-00000101 +// CHECK-INST: mov za5v.d[w12, 0:1], { z16.d, z17.d } +// CHECK-ENCODING: [0x05,0x82,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c48205 + +mov za1v.d[w12, 0:1], {z0.d, z1.d} // 11000000-11000100-10000000-00000001 +// CHECK-INST: mov za1v.d[w12, 0:1], { z0.d, z1.d } +// CHECK-ENCODING: [0x01,0x80,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c48001 + +mov za0v.d[w14, 0:1], {z18.d, z19.d} // 11000000-11000100-11000010-01000000 +// CHECK-INST: mov za0v.d[w14, 0:1], { z18.d, z19.d } +// CHECK-ENCODING: [0x40,0xc2,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4c240 + +mov za0v.d[w12, 0:1], {z12.d, z13.d} // 11000000-11000100-10000001-10000000 +// CHECK-INST: mov za0v.d[w12, 0:1], { z12.d, z13.d } +// CHECK-ENCODING: [0x80,0x81,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c48180 + +mov za1v.d[w14, 0:1], {z0.d, z1.d} // 11000000-11000100-11000000-00000001 +// CHECK-INST: mov za1v.d[w14, 0:1], { z0.d, z1.d } +// CHECK-ENCODING: [0x01,0xc0,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4c001 + +mov za5v.d[w12, 0:1], {z22.d, z23.d} // 11000000-11000100-10000010-11000101 +// CHECK-INST: mov za5v.d[w12, 0:1], { z22.d, z23.d } +// CHECK-ENCODING: [0xc5,0x82,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c482c5 + +mov za2v.d[w15, 0:1], {z8.d, z9.d} // 11000000-11000100-11100001-00000010 +// CHECK-INST: mov za2v.d[w15, 0:1], { z8.d, z9.d } +// CHECK-ENCODING: [0x02,0xe1,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4e102 + +mov za7v.d[w13, 0:1], {z12.d, z13.d} // 11000000-11000100-10100001-10000111 +// CHECK-INST: mov za7v.d[w13, 0:1], { z12.d, z13.d } +// CHECK-ENCODING: [0x87,0xa1,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4a187 + + +mova za.d[w8, 0, vgx2], {z0.d, z1.d} // 11000000-00000100-00001000-00000000 +// CHECK-INST: mov za.d[w8, 0, vgx2], { z0.d, z1.d } +// CHECK-ENCODING: [0x00,0x08,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040800 + +mova za.d[w8, 0], {z0.d, z1.d} // 11000000-00000100-00001000-00000000 +// CHECK-INST: mov za.d[w8, 0, vgx2], { z0.d, z1.d } +// CHECK-ENCODING: [0x00,0x08,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040800 + +mova za.d[w10, 5, vgx2], {z10.d, z11.d} // 11000000-00000100-01001001-01000101 +// CHECK-INST: mov za.d[w10, 5, vgx2], { z10.d, z11.d } +// CHECK-ENCODING: [0x45,0x49,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044945 + +mova za.d[w10, 5], {z10.d, z11.d} // 11000000-00000100-01001001-01000101 +// CHECK-INST: mov za.d[w10, 5, vgx2], { z10.d, z11.d } +// CHECK-ENCODING: [0x45,0x49,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044945 + +mova za.d[w11, 7, vgx2], {z12.d, z13.d} // 11000000-00000100-01101001-10000111 +// CHECK-INST: mov za.d[w11, 7, vgx2], { z12.d, z13.d } +// CHECK-ENCODING: [0x87,0x69,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046987 + +mova za.d[w11, 7], {z12.d, z13.d} // 11000000-00000100-01101001-10000111 +// CHECK-INST: mov za.d[w11, 7, vgx2], { z12.d, z13.d } +// CHECK-ENCODING: [0x87,0x69,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046987 + +mova za.d[w11, 7, vgx2], {z30.d, z31.d} // 11000000-00000100-01101011-11000111 +// CHECK-INST: mov za.d[w11, 7, vgx2], { z30.d, z31.d } +// CHECK-ENCODING: [0xc7,0x6b,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046bc7 + +mova za.d[w11, 7], {z30.d, z31.d} // 11000000-00000100-01101011-11000111 +// CHECK-INST: mov za.d[w11, 7, vgx2], { z30.d, z31.d } +// CHECK-ENCODING: [0xc7,0x6b,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046bc7 + +mova za.d[w8, 5, vgx2], {z16.d, z17.d} // 11000000-00000100-00001010-00000101 +// CHECK-INST: mov za.d[w8, 5, vgx2], { z16.d, z17.d } +// CHECK-ENCODING: [0x05,0x0a,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040a05 + +mova za.d[w8, 5], {z16.d, z17.d} // 11000000-00000100-00001010-00000101 +// CHECK-INST: mov za.d[w8, 5, vgx2], { z16.d, z17.d } +// CHECK-ENCODING: [0x05,0x0a,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040a05 + +mova za.d[w8, 1, vgx2], {z0.d, z1.d} // 11000000-00000100-00001000-00000001 +// CHECK-INST: mov za.d[w8, 1, vgx2], { z0.d, z1.d } +// CHECK-ENCODING: [0x01,0x08,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040801 + +mova za.d[w8, 1], {z0.d, z1.d} // 11000000-00000100-00001000-00000001 +// CHECK-INST: mov za.d[w8, 1, vgx2], { z0.d, z1.d } +// CHECK-ENCODING: [0x01,0x08,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040801 + +mova za.d[w10, 0, vgx2], {z18.d, z19.d} // 11000000-00000100-01001010-01000000 +// CHECK-INST: mov za.d[w10, 0, vgx2], { z18.d, z19.d } +// CHECK-ENCODING: [0x40,0x4a,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044a40 + +mova za.d[w10, 0], {z18.d, z19.d} // 11000000-00000100-01001010-01000000 +// CHECK-INST: mov za.d[w10, 0, vgx2], { z18.d, z19.d } +// CHECK-ENCODING: [0x40,0x4a,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044a40 + +mova za.d[w8, 0, vgx2], {z12.d, z13.d} // 11000000-00000100-00001001-10000000 +// CHECK-INST: mov za.d[w8, 0, vgx2], { z12.d, z13.d } +// CHECK-ENCODING: [0x80,0x09,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040980 + +mova za.d[w8, 0], {z12.d, z13.d} // 11000000-00000100-00001001-10000000 +// CHECK-INST: mov za.d[w8, 0, vgx2], { z12.d, z13.d } +// CHECK-ENCODING: [0x80,0x09,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040980 + +mova za.d[w10, 1, vgx2], {z0.d, z1.d} // 11000000-00000100-01001000-00000001 +// CHECK-INST: mov za.d[w10, 1, vgx2], { z0.d, z1.d } +// CHECK-ENCODING: [0x01,0x48,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044801 + +mova za.d[w10, 1], {z0.d, z1.d} // 11000000-00000100-01001000-00000001 +// CHECK-INST: mov za.d[w10, 1, vgx2], { z0.d, z1.d } +// CHECK-ENCODING: [0x01,0x48,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044801 + +mova za.d[w8, 5, vgx2], {z22.d, z23.d} // 11000000-00000100-00001010-11000101 +// CHECK-INST: mov za.d[w8, 5, vgx2], { z22.d, z23.d } +// CHECK-ENCODING: [0xc5,0x0a,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040ac5 + +mova za.d[w8, 5], {z22.d, z23.d} // 11000000-00000100-00001010-11000101 +// CHECK-INST: mov za.d[w8, 5, vgx2], { z22.d, z23.d } +// CHECK-ENCODING: [0xc5,0x0a,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040ac5 + +mova za.d[w11, 2, vgx2], {z8.d, z9.d} // 11000000-00000100-01101001-00000010 +// CHECK-INST: mov za.d[w11, 2, vgx2], { z8.d, z9.d } +// CHECK-ENCODING: [0x02,0x69,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046902 + +mova za.d[w11, 2], {z8.d, z9.d} // 11000000-00000100-01101001-00000010 +// CHECK-INST: mov za.d[w11, 2, vgx2], { z8.d, z9.d } +// CHECK-ENCODING: [0x02,0x69,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046902 + +mova za.d[w9, 7, vgx2], {z12.d, z13.d} // 11000000-00000100-00101001-10000111 +// CHECK-INST: mov za.d[w9, 7, vgx2], { z12.d, z13.d } +// CHECK-ENCODING: [0x87,0x29,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0042987 + +mova za.d[w9, 7], {z12.d, z13.d} // 11000000-00000100-00101001-10000111 +// CHECK-INST: mov za.d[w9, 7, vgx2], { z12.d, z13.d } +// CHECK-ENCODING: [0x87,0x29,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0042987 + +// Aliases + +mov za.d[w8, 0, vgx2], {z0.d, z1.d} // 11000000-00000100-00001000-00000000 +// CHECK-INST: mov za.d[w8, 0, vgx2], { z0.d, z1.d } +// CHECK-ENCODING: [0x00,0x08,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040800 + +mov za.d[w10, 5, vgx2], {z10.d, z11.d} // 11000000-00000100-01001001-01000101 +// CHECK-INST: mov za.d[w10, 5, vgx2], { z10.d, z11.d } +// CHECK-ENCODING: [0x45,0x49,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044945 + +mov za.d[w11, 7, vgx2], {z12.d, z13.d} // 11000000-00000100-01101001-10000111 +// CHECK-INST: mov za.d[w11, 7, vgx2], { z12.d, z13.d } +// CHECK-ENCODING: [0x87,0x69,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046987 + +mov za.d[w11, 7, vgx2], {z30.d, z31.d} // 11000000-00000100-01101011-11000111 +// CHECK-INST: mov za.d[w11, 7, vgx2], { z30.d, z31.d } +// CHECK-ENCODING: [0xc7,0x6b,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046bc7 + +mov za.d[w8, 5, vgx2], {z16.d, z17.d} // 11000000-00000100-00001010-00000101 +// CHECK-INST: mov za.d[w8, 5, vgx2], { z16.d, z17.d } +// CHECK-ENCODING: [0x05,0x0a,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040a05 + +mov za.d[w8, 1, vgx2], {z0.d, z1.d} // 11000000-00000100-00001000-00000001 +// CHECK-INST: mov za.d[w8, 1, vgx2], { z0.d, z1.d } +// CHECK-ENCODING: [0x01,0x08,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040801 + +mov za.d[w10, 0, vgx2], {z18.d, z19.d} // 11000000-00000100-01001010-01000000 +// CHECK-INST: mov za.d[w10, 0, vgx2], { z18.d, z19.d } +// CHECK-ENCODING: [0x40,0x4a,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044a40 + +mov za.d[w8, 0, vgx2], {z12.d, z13.d} // 11000000-00000100-00001001-10000000 +// CHECK-INST: mov za.d[w8, 0, vgx2], { z12.d, z13.d } +// CHECK-ENCODING: [0x80,0x09,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040980 + +mov za.d[w10, 1, vgx2], {z0.d, z1.d} // 11000000-00000100-01001000-00000001 +// CHECK-INST: mov za.d[w10, 1, vgx2], { z0.d, z1.d } +// CHECK-ENCODING: [0x01,0x48,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044801 + +mov za.d[w8, 5, vgx2], {z22.d, z23.d} // 11000000-00000100-00001010-11000101 +// CHECK-INST: mov za.d[w8, 5, vgx2], { z22.d, z23.d } +// CHECK-ENCODING: [0xc5,0x0a,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040ac5 + +mov za.d[w11, 2, vgx2], {z8.d, z9.d} // 11000000-00000100-01101001-00000010 +// CHECK-INST: mov za.d[w11, 2, vgx2], { z8.d, z9.d } +// CHECK-ENCODING: [0x02,0x69,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046902 + +mov za.d[w9, 7, vgx2], {z12.d, z13.d} // 11000000-00000100-00101001-10000111 +// CHECK-INST: mov za.d[w9, 7, vgx2], { z12.d, z13.d } +// CHECK-ENCODING: [0x87,0x29,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0042987 + + +mova {z0.b, z1.b}, za0h.b[w12, 0:1] // 11000000-00000110-00000000-00000000 +// CHECK-INST: mov { z0.b, z1.b }, za0h.b[w12, 0:1] +// CHECK-ENCODING: [0x00,0x00,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060000 + +mova {z20.b, z21.b}, za0h.b[w14, 4:5] // 11000000-00000110-01000000-01010100 +// CHECK-INST: mov { z20.b, z21.b }, za0h.b[w14, 4:5] +// CHECK-ENCODING: [0x54,0x40,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064054 + +mova {z22.b, z23.b}, za0h.b[w15, 10:11] // 11000000-00000110-01100000-10110110 +// CHECK-INST: mov { z22.b, z23.b }, za0h.b[w15, 10:11] +// CHECK-ENCODING: [0xb6,0x60,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00660b6 + +mova {z30.b, z31.b}, za0h.b[w15, 14:15] // 11000000-00000110-01100000-11111110 +// CHECK-INST: mov { z30.b, z31.b }, za0h.b[w15, 14:15] +// CHECK-ENCODING: [0xfe,0x60,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00660fe + +mova {z4.b, z5.b}, za0h.b[w12, 2:3] // 11000000-00000110-00000000-00100100 +// CHECK-INST: mov { z4.b, z5.b }, za0h.b[w12, 2:3] +// CHECK-ENCODING: [0x24,0x00,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060024 + +mova {z0.b, z1.b}, za0h.b[w12, 2:3] // 11000000-00000110-00000000-00100000 +// CHECK-INST: mov { z0.b, z1.b }, za0h.b[w12, 2:3] +// CHECK-ENCODING: [0x20,0x00,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060020 + +mova {z24.b, z25.b}, za0h.b[w14, 6:7] // 11000000-00000110-01000000-01111000 +// CHECK-INST: mov { z24.b, z25.b }, za0h.b[w14, 6:7] +// CHECK-ENCODING: [0x78,0x40,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064078 + +mova {z0.b, z1.b}, za0h.b[w12, 8:9] // 11000000-00000110-00000000-10000000 +// CHECK-INST: mov { z0.b, z1.b }, za0h.b[w12, 8:9] +// CHECK-ENCODING: [0x80,0x00,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060080 + +mova {z16.b, z17.b}, za0h.b[w14, 2:3] // 11000000-00000110-01000000-00110000 +// CHECK-INST: mov { z16.b, z17.b }, za0h.b[w14, 2:3] +// CHECK-ENCODING: [0x30,0x40,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064030 + +mova {z28.b, z29.b}, za0h.b[w12, 12:13] // 11000000-00000110-00000000-11011100 +// CHECK-INST: mov { z28.b, z29.b }, za0h.b[w12, 12:13] +// CHECK-ENCODING: [0xdc,0x00,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00600dc + +mova {z2.b, z3.b}, za0h.b[w15, 2:3] // 11000000-00000110-01100000-00100010 +// CHECK-INST: mov { z2.b, z3.b }, za0h.b[w15, 2:3] +// CHECK-ENCODING: [0x22,0x60,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0066022 + +mova {z6.b, z7.b}, za0h.b[w13, 8:9] // 11000000-00000110-00100000-10000110 +// CHECK-INST: mov { z6.b, z7.b }, za0h.b[w13, 8:9] +// CHECK-ENCODING: [0x86,0x20,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0062086 + +// Aliases + +mov {z0.b, z1.b}, za0h.b[w12, 0:1] // 11000000-00000110-00000000-00000000 +// CHECK-INST: mov { z0.b, z1.b }, za0h.b[w12, 0:1] +// CHECK-ENCODING: [0x00,0x00,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060000 + +mov {z20.b, z21.b}, za0h.b[w14, 4:5] // 11000000-00000110-01000000-01010100 +// CHECK-INST: mov { z20.b, z21.b }, za0h.b[w14, 4:5] +// CHECK-ENCODING: [0x54,0x40,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064054 + +mov {z22.b, z23.b}, za0h.b[w15, 10:11] // 11000000-00000110-01100000-10110110 +// CHECK-INST: mov { z22.b, z23.b }, za0h.b[w15, 10:11] +// CHECK-ENCODING: [0xb6,0x60,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00660b6 + +mov {z30.b, z31.b}, za0h.b[w15, 14:15] // 11000000-00000110-01100000-11111110 +// CHECK-INST: mov { z30.b, z31.b }, za0h.b[w15, 14:15] +// CHECK-ENCODING: [0xfe,0x60,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00660fe + +mov {z4.b, z5.b}, za0h.b[w12, 2:3] // 11000000-00000110-00000000-00100100 +// CHECK-INST: mov { z4.b, z5.b }, za0h.b[w12, 2:3] +// CHECK-ENCODING: [0x24,0x00,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060024 + +mov {z0.b, z1.b}, za0h.b[w12, 2:3] // 11000000-00000110-00000000-00100000 +// CHECK-INST: mov { z0.b, z1.b }, za0h.b[w12, 2:3] +// CHECK-ENCODING: [0x20,0x00,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060020 + +mov {z24.b, z25.b}, za0h.b[w14, 6:7] // 11000000-00000110-01000000-01111000 +// CHECK-INST: mov { z24.b, z25.b }, za0h.b[w14, 6:7] +// CHECK-ENCODING: [0x78,0x40,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064078 + +mov {z0.b, z1.b}, za0h.b[w12, 8:9] // 11000000-00000110-00000000-10000000 +// CHECK-INST: mov { z0.b, z1.b }, za0h.b[w12, 8:9] +// CHECK-ENCODING: [0x80,0x00,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060080 + +mov {z16.b, z17.b}, za0h.b[w14, 2:3] // 11000000-00000110-01000000-00110000 +// CHECK-INST: mov { z16.b, z17.b }, za0h.b[w14, 2:3] +// CHECK-ENCODING: [0x30,0x40,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064030 + +mov {z28.b, z29.b}, za0h.b[w12, 12:13] // 11000000-00000110-00000000-11011100 +// CHECK-INST: mov { z28.b, z29.b }, za0h.b[w12, 12:13] +// CHECK-ENCODING: [0xdc,0x00,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00600dc + +mov {z2.b, z3.b}, za0h.b[w15, 2:3] // 11000000-00000110-01100000-00100010 +// CHECK-INST: mov { z2.b, z3.b }, za0h.b[w15, 2:3] +// CHECK-ENCODING: [0x22,0x60,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0066022 + +mov {z6.b, z7.b}, za0h.b[w13, 8:9] // 11000000-00000110-00100000-10000110 +// CHECK-INST: mov { z6.b, z7.b }, za0h.b[w13, 8:9] +// CHECK-ENCODING: [0x86,0x20,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0062086 + + +mova {z0.b, z1.b}, za0v.b[w12, 0:1] // 11000000-00000110-10000000-00000000 +// CHECK-INST: mov { z0.b, z1.b }, za0v.b[w12, 0:1] +// CHECK-ENCODING: [0x00,0x80,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0068000 + +mova {z20.b, z21.b}, za0v.b[w14, 4:5] // 11000000-00000110-11000000-01010100 +// CHECK-INST: mov { z20.b, z21.b }, za0v.b[w14, 4:5] +// CHECK-ENCODING: [0x54,0xc0,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006c054 + +mova {z22.b, z23.b}, za0v.b[w15, 10:11] // 11000000-00000110-11100000-10110110 +// CHECK-INST: mov { z22.b, z23.b }, za0v.b[w15, 10:11] +// CHECK-ENCODING: [0xb6,0xe0,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006e0b6 + +mova {z30.b, z31.b}, za0v.b[w15, 14:15] // 11000000-00000110-11100000-11111110 +// CHECK-INST: mov { z30.b, z31.b }, za0v.b[w15, 14:15] +// CHECK-ENCODING: [0xfe,0xe0,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006e0fe + +mova {z4.b, z5.b}, za0v.b[w12, 2:3] // 11000000-00000110-10000000-00100100 +// CHECK-INST: mov { z4.b, z5.b }, za0v.b[w12, 2:3] +// CHECK-ENCODING: [0x24,0x80,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0068024 + +mova {z0.b, z1.b}, za0v.b[w12, 2:3] // 11000000-00000110-10000000-00100000 +// CHECK-INST: mov { z0.b, z1.b }, za0v.b[w12, 2:3] +// CHECK-ENCODING: [0x20,0x80,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0068020 + +mova {z24.b, z25.b}, za0v.b[w14, 6:7] // 11000000-00000110-11000000-01111000 +// CHECK-INST: mov { z24.b, z25.b }, za0v.b[w14, 6:7] +// CHECK-ENCODING: [0x78,0xc0,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006c078 + +mova {z0.b, z1.b}, za0v.b[w12, 8:9] // 11000000-00000110-10000000-10000000 +// CHECK-INST: mov { z0.b, z1.b }, za0v.b[w12, 8:9] +// CHECK-ENCODING: [0x80,0x80,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0068080 + +mova {z16.b, z17.b}, za0v.b[w14, 2:3] // 11000000-00000110-11000000-00110000 +// CHECK-INST: mov { z16.b, z17.b }, za0v.b[w14, 2:3] +// CHECK-ENCODING: [0x30,0xc0,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006c030 + +mova {z28.b, z29.b}, za0v.b[w12, 12:13] // 11000000-00000110-10000000-11011100 +// CHECK-INST: mov { z28.b, z29.b }, za0v.b[w12, 12:13] +// CHECK-ENCODING: [0xdc,0x80,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00680dc + +mova {z2.b, z3.b}, za0v.b[w15, 2:3] // 11000000-00000110-11100000-00100010 +// CHECK-INST: mov { z2.b, z3.b }, za0v.b[w15, 2:3] +// CHECK-ENCODING: [0x22,0xe0,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006e022 + +mova {z6.b, z7.b}, za0v.b[w13, 8:9] // 11000000-00000110-10100000-10000110 +// CHECK-INST: mov { z6.b, z7.b }, za0v.b[w13, 8:9] +// CHECK-ENCODING: [0x86,0xa0,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006a086 + +// Aliases + +mov {z0.b, z1.b}, za0v.b[w12, 0:1] // 11000000-00000110-10000000-00000000 +// CHECK-INST: mov { z0.b, z1.b }, za0v.b[w12, 0:1] +// CHECK-ENCODING: [0x00,0x80,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0068000 + +mov {z20.b, z21.b}, za0v.b[w14, 4:5] // 11000000-00000110-11000000-01010100 +// CHECK-INST: mov { z20.b, z21.b }, za0v.b[w14, 4:5] +// CHECK-ENCODING: [0x54,0xc0,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006c054 + +mov {z22.b, z23.b}, za0v.b[w15, 10:11] // 11000000-00000110-11100000-10110110 +// CHECK-INST: mov { z22.b, z23.b }, za0v.b[w15, 10:11] +// CHECK-ENCODING: [0xb6,0xe0,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006e0b6 + +mov {z30.b, z31.b}, za0v.b[w15, 14:15] // 11000000-00000110-11100000-11111110 +// CHECK-INST: mov { z30.b, z31.b }, za0v.b[w15, 14:15] +// CHECK-ENCODING: [0xfe,0xe0,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006e0fe + +mov {z4.b, z5.b}, za0v.b[w12, 2:3] // 11000000-00000110-10000000-00100100 +// CHECK-INST: mov { z4.b, z5.b }, za0v.b[w12, 2:3] +// CHECK-ENCODING: [0x24,0x80,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0068024 + +mov {z0.b, z1.b}, za0v.b[w12, 2:3] // 11000000-00000110-10000000-00100000 +// CHECK-INST: mov { z0.b, z1.b }, za0v.b[w12, 2:3] +// CHECK-ENCODING: [0x20,0x80,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0068020 + +mov {z24.b, z25.b}, za0v.b[w14, 6:7] // 11000000-00000110-11000000-01111000 +// CHECK-INST: mov { z24.b, z25.b }, za0v.b[w14, 6:7] +// CHECK-ENCODING: [0x78,0xc0,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006c078 + +mov {z0.b, z1.b}, za0v.b[w12, 8:9] // 11000000-00000110-10000000-10000000 +// CHECK-INST: mov { z0.b, z1.b }, za0v.b[w12, 8:9] +// CHECK-ENCODING: [0x80,0x80,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0068080 + +mov {z16.b, z17.b}, za0v.b[w14, 2:3] // 11000000-00000110-11000000-00110000 +// CHECK-INST: mov { z16.b, z17.b }, za0v.b[w14, 2:3] +// CHECK-ENCODING: [0x30,0xc0,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006c030 + +mov {z28.b, z29.b}, za0v.b[w12, 12:13] // 11000000-00000110-10000000-11011100 +// CHECK-INST: mov { z28.b, z29.b }, za0v.b[w12, 12:13] +// CHECK-ENCODING: [0xdc,0x80,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00680dc + +mov {z2.b, z3.b}, za0v.b[w15, 2:3] // 11000000-00000110-11100000-00100010 +// CHECK-INST: mov { z2.b, z3.b }, za0v.b[w15, 2:3] +// CHECK-ENCODING: [0x22,0xe0,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006e022 + +mov {z6.b, z7.b}, za0v.b[w13, 8:9] // 11000000-00000110-10100000-10000110 +// CHECK-INST: mov { z6.b, z7.b }, za0v.b[w13, 8:9] +// CHECK-ENCODING: [0x86,0xa0,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006a086 + + +mova za0h.b[w12, 0:1], {z0.b, z1.b} // 11000000-00000100-00000000-00000000 +// CHECK-INST: mov za0h.b[w12, 0:1], { z0.b, z1.b } +// CHECK-ENCODING: [0x00,0x00,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040000 + +mova za0h.b[w14, 10:11], {z10.b, z11.b} // 11000000-00000100-01000001-01000101 +// CHECK-INST: mov za0h.b[w14, 10:11], { z10.b, z11.b } +// CHECK-ENCODING: [0x45,0x41,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044145 + +mova za0h.b[w15, 14:15], {z12.b, z13.b} // 11000000-00000100-01100001-10000111 +// CHECK-INST: mov za0h.b[w15, 14:15], { z12.b, z13.b } +// CHECK-ENCODING: [0x87,0x61,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046187 + +mova za0h.b[w15, 14:15], {z30.b, z31.b} // 11000000-00000100-01100011-11000111 +// CHECK-INST: mov za0h.b[w15, 14:15], { z30.b, z31.b } +// CHECK-ENCODING: [0xc7,0x63,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00463c7 + +mova za0h.b[w12, 10:11], {z16.b, z17.b} // 11000000-00000100-00000010-00000101 +// CHECK-INST: mov za0h.b[w12, 10:11], { z16.b, z17.b } +// CHECK-ENCODING: [0x05,0x02,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040205 + +mova za0h.b[w12, 2:3], {z0.b, z1.b} // 11000000-00000100-00000000-00000001 +// CHECK-INST: mov za0h.b[w12, 2:3], { z0.b, z1.b } +// CHECK-ENCODING: [0x01,0x00,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040001 + +mova za0h.b[w14, 0:1], {z18.b, z19.b} // 11000000-00000100-01000010-01000000 +// CHECK-INST: mov za0h.b[w14, 0:1], { z18.b, z19.b } +// CHECK-ENCODING: [0x40,0x42,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044240 + +mova za0h.b[w12, 0:1], {z12.b, z13.b} // 11000000-00000100-00000001-10000000 +// CHECK-INST: mov za0h.b[w12, 0:1], { z12.b, z13.b } +// CHECK-ENCODING: [0x80,0x01,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040180 + +mova za0h.b[w14, 2:3], {z0.b, z1.b} // 11000000-00000100-01000000-00000001 +// CHECK-INST: mov za0h.b[w14, 2:3], { z0.b, z1.b } +// CHECK-ENCODING: [0x01,0x40,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044001 + +mova za0h.b[w12, 10:11], {z22.b, z23.b} // 11000000-00000100-00000010-11000101 +// CHECK-INST: mov za0h.b[w12, 10:11], { z22.b, z23.b } +// CHECK-ENCODING: [0xc5,0x02,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00402c5 + +mova za0h.b[w15, 4:5], {z8.b, z9.b} // 11000000-00000100-01100001-00000010 +// CHECK-INST: mov za0h.b[w15, 4:5], { z8.b, z9.b } +// CHECK-ENCODING: [0x02,0x61,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046102 + +mova za0h.b[w13, 14:15], {z12.b, z13.b} // 11000000-00000100-00100001-10000111 +// CHECK-INST: mov za0h.b[w13, 14:15], { z12.b, z13.b } +// CHECK-ENCODING: [0x87,0x21,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0042187 + +// Aliases + +mov za0h.b[w12, 0:1], {z0.b, z1.b} // 11000000-00000100-00000000-00000000 +// CHECK-INST: mov za0h.b[w12, 0:1], { z0.b, z1.b } +// CHECK-ENCODING: [0x00,0x00,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040000 + +mov za0h.b[w14, 10:11], {z10.b, z11.b} // 11000000-00000100-01000001-01000101 +// CHECK-INST: mov za0h.b[w14, 10:11], { z10.b, z11.b } +// CHECK-ENCODING: [0x45,0x41,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044145 + +mov za0h.b[w15, 14:15], {z12.b, z13.b} // 11000000-00000100-01100001-10000111 +// CHECK-INST: mov za0h.b[w15, 14:15], { z12.b, z13.b } +// CHECK-ENCODING: [0x87,0x61,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046187 + +mov za0h.b[w15, 14:15], {z30.b, z31.b} // 11000000-00000100-01100011-11000111 +// CHECK-INST: mov za0h.b[w15, 14:15], { z30.b, z31.b } +// CHECK-ENCODING: [0xc7,0x63,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00463c7 + +mov za0h.b[w12, 10:11], {z16.b, z17.b} // 11000000-00000100-00000010-00000101 +// CHECK-INST: mov za0h.b[w12, 10:11], { z16.b, z17.b } +// CHECK-ENCODING: [0x05,0x02,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040205 + +mov za0h.b[w12, 2:3], {z0.b, z1.b} // 11000000-00000100-00000000-00000001 +// CHECK-INST: mov za0h.b[w12, 2:3], { z0.b, z1.b } +// CHECK-ENCODING: [0x01,0x00,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040001 + +mov za0h.b[w14, 0:1], {z18.b, z19.b} // 11000000-00000100-01000010-01000000 +// CHECK-INST: mov za0h.b[w14, 0:1], { z18.b, z19.b } +// CHECK-ENCODING: [0x40,0x42,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044240 + +mov za0h.b[w12, 0:1], {z12.b, z13.b} // 11000000-00000100-00000001-10000000 +// CHECK-INST: mov za0h.b[w12, 0:1], { z12.b, z13.b } +// CHECK-ENCODING: [0x80,0x01,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040180 + +mov za0h.b[w14, 2:3], {z0.b, z1.b} // 11000000-00000100-01000000-00000001 +// CHECK-INST: mov za0h.b[w14, 2:3], { z0.b, z1.b } +// CHECK-ENCODING: [0x01,0x40,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044001 + +mov za0h.b[w12, 10:11], {z22.b, z23.b} // 11000000-00000100-00000010-11000101 +// CHECK-INST: mov za0h.b[w12, 10:11], { z22.b, z23.b } +// CHECK-ENCODING: [0xc5,0x02,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00402c5 + +mov za0h.b[w15, 4:5], {z8.b, z9.b} // 11000000-00000100-01100001-00000010 +// CHECK-INST: mov za0h.b[w15, 4:5], { z8.b, z9.b } +// CHECK-ENCODING: [0x02,0x61,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046102 + +mov za0h.b[w13, 14:15], {z12.b, z13.b} // 11000000-00000100-00100001-10000111 +// CHECK-INST: mov za0h.b[w13, 14:15], { z12.b, z13.b } +// CHECK-ENCODING: [0x87,0x21,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0042187 + + +mova za0v.b[w12, 0:1], {z0.b, z1.b} // 11000000-00000100-10000000-00000000 +// CHECK-INST: mov za0v.b[w12, 0:1], { z0.b, z1.b } +// CHECK-ENCODING: [0x00,0x80,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0048000 + +mova za0v.b[w14, 10:11], {z10.b, z11.b} // 11000000-00000100-11000001-01000101 +// CHECK-INST: mov za0v.b[w14, 10:11], { z10.b, z11.b } +// CHECK-ENCODING: [0x45,0xc1,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004c145 + +mova za0v.b[w15, 14:15], {z12.b, z13.b} // 11000000-00000100-11100001-10000111 +// CHECK-INST: mov za0v.b[w15, 14:15], { z12.b, z13.b } +// CHECK-ENCODING: [0x87,0xe1,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004e187 + +mova za0v.b[w15, 14:15], {z30.b, z31.b} // 11000000-00000100-11100011-11000111 +// CHECK-INST: mov za0v.b[w15, 14:15], { z30.b, z31.b } +// CHECK-ENCODING: [0xc7,0xe3,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004e3c7 + +mova za0v.b[w12, 10:11], {z16.b, z17.b} // 11000000-00000100-10000010-00000101 +// CHECK-INST: mov za0v.b[w12, 10:11], { z16.b, z17.b } +// CHECK-ENCODING: [0x05,0x82,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0048205 + +mova za0v.b[w12, 2:3], {z0.b, z1.b} // 11000000-00000100-10000000-00000001 +// CHECK-INST: mov za0v.b[w12, 2:3], { z0.b, z1.b } +// CHECK-ENCODING: [0x01,0x80,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0048001 + +mova za0v.b[w14, 0:1], {z18.b, z19.b} // 11000000-00000100-11000010-01000000 +// CHECK-INST: mov za0v.b[w14, 0:1], { z18.b, z19.b } +// CHECK-ENCODING: [0x40,0xc2,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004c240 + +mova za0v.b[w12, 0:1], {z12.b, z13.b} // 11000000-00000100-10000001-10000000 +// CHECK-INST: mov za0v.b[w12, 0:1], { z12.b, z13.b } +// CHECK-ENCODING: [0x80,0x81,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0048180 + +mova za0v.b[w14, 2:3], {z0.b, z1.b} // 11000000-00000100-11000000-00000001 +// CHECK-INST: mov za0v.b[w14, 2:3], { z0.b, z1.b } +// CHECK-ENCODING: [0x01,0xc0,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004c001 + +mova za0v.b[w12, 10:11], {z22.b, z23.b} // 11000000-00000100-10000010-11000101 +// CHECK-INST: mov za0v.b[w12, 10:11], { z22.b, z23.b } +// CHECK-ENCODING: [0xc5,0x82,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00482c5 + +mova za0v.b[w15, 4:5], {z8.b, z9.b} // 11000000-00000100-11100001-00000010 +// CHECK-INST: mov za0v.b[w15, 4:5], { z8.b, z9.b } +// CHECK-ENCODING: [0x02,0xe1,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004e102 + +mova za0v.b[w13, 14:15], {z12.b, z13.b} // 11000000-00000100-10100001-10000111 +// CHECK-INST: mov za0v.b[w13, 14:15], { z12.b, z13.b } +// CHECK-ENCODING: [0x87,0xa1,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004a187 + +// Aliases + +mov za0v.b[w12, 0:1], {z0.b, z1.b} // 11000000-00000100-10000000-00000000 +// CHECK-INST: mov za0v.b[w12, 0:1], { z0.b, z1.b } +// CHECK-ENCODING: [0x00,0x80,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0048000 + +mov za0v.b[w14, 10:11], {z10.b, z11.b} // 11000000-00000100-11000001-01000101 +// CHECK-INST: mov za0v.b[w14, 10:11], { z10.b, z11.b } +// CHECK-ENCODING: [0x45,0xc1,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004c145 + +mov za0v.b[w15, 14:15], {z12.b, z13.b} // 11000000-00000100-11100001-10000111 +// CHECK-INST: mov za0v.b[w15, 14:15], { z12.b, z13.b } +// CHECK-ENCODING: [0x87,0xe1,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004e187 + +mov za0v.b[w15, 14:15], {z30.b, z31.b} // 11000000-00000100-11100011-11000111 +// CHECK-INST: mov za0v.b[w15, 14:15], { z30.b, z31.b } +// CHECK-ENCODING: [0xc7,0xe3,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004e3c7 + +mov za0v.b[w12, 10:11], {z16.b, z17.b} // 11000000-00000100-10000010-00000101 +// CHECK-INST: mov za0v.b[w12, 10:11], { z16.b, z17.b } +// CHECK-ENCODING: [0x05,0x82,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0048205 + +mov za0v.b[w12, 2:3], {z0.b, z1.b} // 11000000-00000100-10000000-00000001 +// CHECK-INST: mov za0v.b[w12, 2:3], { z0.b, z1.b } +// CHECK-ENCODING: [0x01,0x80,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0048001 + +mov za0v.b[w14, 0:1], {z18.b, z19.b} // 11000000-00000100-11000010-01000000 +// CHECK-INST: mov za0v.b[w14, 0:1], { z18.b, z19.b } +// CHECK-ENCODING: [0x40,0xc2,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004c240 + +mov za0v.b[w12, 0:1], {z12.b, z13.b} // 11000000-00000100-10000001-10000000 +// CHECK-INST: mov za0v.b[w12, 0:1], { z12.b, z13.b } +// CHECK-ENCODING: [0x80,0x81,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0048180 + +mov za0v.b[w14, 2:3], {z0.b, z1.b} // 11000000-00000100-11000000-00000001 +// CHECK-INST: mov za0v.b[w14, 2:3], { z0.b, z1.b } +// CHECK-ENCODING: [0x01,0xc0,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004c001 + +mov za0v.b[w12, 10:11], {z22.b, z23.b} // 11000000-00000100-10000010-11000101 +// CHECK-INST: mov za0v.b[w12, 10:11], { z22.b, z23.b } +// CHECK-ENCODING: [0xc5,0x82,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c00482c5 + +mov za0v.b[w15, 4:5], {z8.b, z9.b} // 11000000-00000100-11100001-00000010 +// CHECK-INST: mov za0v.b[w15, 4:5], { z8.b, z9.b } +// CHECK-ENCODING: [0x02,0xe1,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004e102 + +mov za0v.b[w13, 14:15], {z12.b, z13.b} // 11000000-00000100-10100001-10000111 +// CHECK-INST: mov za0v.b[w13, 14:15], { z12.b, z13.b } +// CHECK-ENCODING: [0x87,0xa1,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004a187 + + +mova {z0.h - z3.h}, za0h.h[w12, 0:3] // 11000000-01000110-00000100-00000000 +// CHECK-INST: mov { z0.h - z3.h }, za0h.h[w12, 0:3] +// CHECK-ENCODING: [0x00,0x04,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0460400 + +mova {z20.h - z23.h}, za1h.h[w14, 0:3] // 11000000-01000110-01000100-01010100 +// CHECK-INST: mov { z20.h - z23.h }, za1h.h[w14, 0:3] +// CHECK-ENCODING: [0x54,0x44,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0464454 + +mova {z20.h - z23.h}, za0h.h[w15, 4:7] // 11000000-01000110-01100100-00110100 +// CHECK-INST: mov { z20.h - z23.h }, za0h.h[w15, 4:7] +// CHECK-ENCODING: [0x34,0x64,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0466434 + +mova {z28.h - z31.h}, za1h.h[w15, 4:7] // 11000000-01000110-01100100-01111100 +// CHECK-INST: mov { z28.h - z31.h }, za1h.h[w15, 4:7] +// CHECK-ENCODING: [0x7c,0x64,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046647c + +mova {z4.h - z7.h}, za0h.h[w12, 4:7] // 11000000-01000110-00000100-00100100 +// CHECK-INST: mov { z4.h - z7.h }, za0h.h[w12, 4:7] +// CHECK-ENCODING: [0x24,0x04,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0460424 + +mova {z0.h - z3.h}, za0h.h[w12, 4:7] // 11000000-01000110-00000100-00100000 +// CHECK-INST: mov { z0.h - z3.h }, za0h.h[w12, 4:7] +// CHECK-ENCODING: [0x20,0x04,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0460420 + +mova {z24.h - z27.h}, za1h.h[w14, 4:7] // 11000000-01000110-01000100-01111000 +// CHECK-INST: mov { z24.h - z27.h }, za1h.h[w14, 4:7] +// CHECK-ENCODING: [0x78,0x44,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0464478 + +mova {z16.h - z19.h}, za0h.h[w14, 4:7] // 11000000-01000110-01000100-00110000 +// CHECK-INST: mov { z16.h - z19.h }, za0h.h[w14, 4:7] +// CHECK-ENCODING: [0x30,0x44,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0464430 + +mova {z28.h - z31.h}, za1h.h[w12, 0:3] // 11000000-01000110-00000100-01011100 +// CHECK-INST: mov { z28.h - z31.h }, za1h.h[w12, 0:3] +// CHECK-ENCODING: [0x5c,0x04,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046045c + +mova {z0.h - z3.h}, za0h.h[w15, 4:7] // 11000000-01000110-01100100-00100000 +// CHECK-INST: mov { z0.h - z3.h }, za0h.h[w15, 4:7] +// CHECK-ENCODING: [0x20,0x64,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0466420 + +mova {z4.h - z7.h}, za0h.h[w13, 0:3] // 11000000-01000110-00100100-00000100 +// CHECK-INST: mov { z4.h - z7.h }, za0h.h[w13, 0:3] +// CHECK-ENCODING: [0x04,0x24,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0462404 + +// Aliases + +mov {z0.h - z3.h}, za0h.h[w12, 0:3] // 11000000-01000110-00000100-00000000 +// CHECK-INST: mov { z0.h - z3.h }, za0h.h[w12, 0:3] +// CHECK-ENCODING: [0x00,0x04,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0460400 + +mov {z20.h - z23.h}, za1h.h[w14, 0:3] // 11000000-01000110-01000100-01010100 +// CHECK-INST: mov { z20.h - z23.h }, za1h.h[w14, 0:3] +// CHECK-ENCODING: [0x54,0x44,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0464454 + +mov {z20.h - z23.h}, za0h.h[w15, 4:7] // 11000000-01000110-01100100-00110100 +// CHECK-INST: mov { z20.h - z23.h }, za0h.h[w15, 4:7] +// CHECK-ENCODING: [0x34,0x64,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0466434 + +mov {z28.h - z31.h}, za1h.h[w15, 4:7] // 11000000-01000110-01100100-01111100 +// CHECK-INST: mov { z28.h - z31.h }, za1h.h[w15, 4:7] +// CHECK-ENCODING: [0x7c,0x64,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046647c + +mov {z4.h - z7.h}, za0h.h[w12, 4:7] // 11000000-01000110-00000100-00100100 +// CHECK-INST: mov { z4.h - z7.h }, za0h.h[w12, 4:7] +// CHECK-ENCODING: [0x24,0x04,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0460424 + +mov {z0.h - z3.h}, za0h.h[w12, 4:7] // 11000000-01000110-00000100-00100000 +// CHECK-INST: mov { z0.h - z3.h }, za0h.h[w12, 4:7] +// CHECK-ENCODING: [0x20,0x04,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0460420 + +mov {z24.h - z27.h}, za1h.h[w14, 4:7] // 11000000-01000110-01000100-01111000 +// CHECK-INST: mov { z24.h - z27.h }, za1h.h[w14, 4:7] +// CHECK-ENCODING: [0x78,0x44,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0464478 + +mov {z16.h - z19.h}, za0h.h[w14, 4:7] // 11000000-01000110-01000100-00110000 +// CHECK-INST: mov { z16.h - z19.h }, za0h.h[w14, 4:7] +// CHECK-ENCODING: [0x30,0x44,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0464430 + +mov {z28.h - z31.h}, za1h.h[w12, 0:3] // 11000000-01000110-00000100-01011100 +// CHECK-INST: mov { z28.h - z31.h }, za1h.h[w12, 0:3] +// CHECK-ENCODING: [0x5c,0x04,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046045c + +mov {z0.h - z3.h}, za0h.h[w15, 4:7] // 11000000-01000110-01100100-00100000 +// CHECK-INST: mov { z0.h - z3.h }, za0h.h[w15, 4:7] +// CHECK-ENCODING: [0x20,0x64,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0466420 + +mov {z4.h - z7.h}, za0h.h[w13, 0:3] // 11000000-01000110-00100100-00000100 +// CHECK-INST: mov { z4.h - z7.h }, za0h.h[w13, 0:3] +// CHECK-ENCODING: [0x04,0x24,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0462404 + + +mova {z0.h - z3.h}, za0v.h[w12, 0:3] // 11000000-01000110-10000100-00000000 +// CHECK-INST: mov { z0.h - z3.h }, za0v.h[w12, 0:3] +// CHECK-ENCODING: [0x00,0x84,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0468400 + +mova {z20.h - z23.h}, za1v.h[w14, 0:3] // 11000000-01000110-11000100-01010100 +// CHECK-INST: mov { z20.h - z23.h }, za1v.h[w14, 0:3] +// CHECK-ENCODING: [0x54,0xc4,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046c454 + +mova {z20.h - z23.h}, za0v.h[w15, 4:7] // 11000000-01000110-11100100-00110100 +// CHECK-INST: mov { z20.h - z23.h }, za0v.h[w15, 4:7] +// CHECK-ENCODING: [0x34,0xe4,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046e434 + +mova {z28.h - z31.h}, za1v.h[w15, 4:7] // 11000000-01000110-11100100-01111100 +// CHECK-INST: mov { z28.h - z31.h }, za1v.h[w15, 4:7] +// CHECK-ENCODING: [0x7c,0xe4,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046e47c + +mova {z4.h - z7.h}, za0v.h[w12, 4:7] // 11000000-01000110-10000100-00100100 +// CHECK-INST: mov { z4.h - z7.h }, za0v.h[w12, 4:7] +// CHECK-ENCODING: [0x24,0x84,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0468424 + +mova {z0.h - z3.h}, za0v.h[w12, 4:7] // 11000000-01000110-10000100-00100000 +// CHECK-INST: mov { z0.h - z3.h }, za0v.h[w12, 4:7] +// CHECK-ENCODING: [0x20,0x84,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0468420 + +mova {z24.h - z27.h}, za1v.h[w14, 4:7] // 11000000-01000110-11000100-01111000 +// CHECK-INST: mov { z24.h - z27.h }, za1v.h[w14, 4:7] +// CHECK-ENCODING: [0x78,0xc4,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046c478 + +mova {z16.h - z19.h}, za0v.h[w14, 4:7] // 11000000-01000110-11000100-00110000 +// CHECK-INST: mov { z16.h - z19.h }, za0v.h[w14, 4:7] +// CHECK-ENCODING: [0x30,0xc4,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046c430 + +mova {z28.h - z31.h}, za1v.h[w12, 0:3] // 11000000-01000110-10000100-01011100 +// CHECK-INST: mov { z28.h - z31.h }, za1v.h[w12, 0:3] +// CHECK-ENCODING: [0x5c,0x84,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046845c + +mova {z0.h - z3.h}, za0v.h[w15, 4:7] // 11000000-01000110-11100100-00100000 +// CHECK-INST: mov { z0.h - z3.h }, za0v.h[w15, 4:7] +// CHECK-ENCODING: [0x20,0xe4,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046e420 + +mova {z4.h - z7.h}, za0v.h[w13, 0:3] // 11000000-01000110-10100100-00000100 +// CHECK-INST: mov { z4.h - z7.h }, za0v.h[w13, 0:3] +// CHECK-ENCODING: [0x04,0xa4,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046a404 + +// Aliases + +mov {z0.h - z3.h}, za0v.h[w12, 0:3] // 11000000-01000110-10000100-00000000 +// CHECK-INST: mov { z0.h - z3.h }, za0v.h[w12, 0:3] +// CHECK-ENCODING: [0x00,0x84,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0468400 + +mov {z20.h - z23.h}, za1v.h[w14, 0:3] // 11000000-01000110-11000100-01010100 +// CHECK-INST: mov { z20.h - z23.h }, za1v.h[w14, 0:3] +// CHECK-ENCODING: [0x54,0xc4,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046c454 + +mov {z20.h - z23.h}, za0v.h[w15, 4:7] // 11000000-01000110-11100100-00110100 +// CHECK-INST: mov { z20.h - z23.h }, za0v.h[w15, 4:7] +// CHECK-ENCODING: [0x34,0xe4,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046e434 + +mov {z28.h - z31.h}, za1v.h[w15, 4:7] // 11000000-01000110-11100100-01111100 +// CHECK-INST: mov { z28.h - z31.h }, za1v.h[w15, 4:7] +// CHECK-ENCODING: [0x7c,0xe4,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046e47c + +mov {z4.h - z7.h}, za0v.h[w12, 4:7] // 11000000-01000110-10000100-00100100 +// CHECK-INST: mov { z4.h - z7.h }, za0v.h[w12, 4:7] +// CHECK-ENCODING: [0x24,0x84,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0468424 + +mov {z0.h - z3.h}, za0v.h[w12, 4:7] // 11000000-01000110-10000100-00100000 +// CHECK-INST: mov { z0.h - z3.h }, za0v.h[w12, 4:7] +// CHECK-ENCODING: [0x20,0x84,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0468420 + +mov {z24.h - z27.h}, za1v.h[w14, 4:7] // 11000000-01000110-11000100-01111000 +// CHECK-INST: mov { z24.h - z27.h }, za1v.h[w14, 4:7] +// CHECK-ENCODING: [0x78,0xc4,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046c478 + +mov {z16.h - z19.h}, za0v.h[w14, 4:7] // 11000000-01000110-11000100-00110000 +// CHECK-INST: mov { z16.h - z19.h }, za0v.h[w14, 4:7] +// CHECK-ENCODING: [0x30,0xc4,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046c430 + +mov {z28.h - z31.h}, za1v.h[w12, 0:3] // 11000000-01000110-10000100-01011100 +// CHECK-INST: mov { z28.h - z31.h }, za1v.h[w12, 0:3] +// CHECK-ENCODING: [0x5c,0x84,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046845c + +mov {z0.h - z3.h}, za0v.h[w15, 4:7] // 11000000-01000110-11100100-00100000 +// CHECK-INST: mov { z0.h - z3.h }, za0v.h[w15, 4:7] +// CHECK-ENCODING: [0x20,0xe4,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046e420 + +mov {z4.h - z7.h}, za0v.h[w13, 0:3] // 11000000-01000110-10100100-00000100 +// CHECK-INST: mov { z4.h - z7.h }, za0v.h[w13, 0:3] +// CHECK-ENCODING: [0x04,0xa4,0x46,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c046a404 + + +mova za0h.h[w12, 0:3], {z0.h - z3.h} // 11000000-01000100-00000100-00000000 +// CHECK-INST: mov za0h.h[w12, 0:3], { z0.h - z3.h } +// CHECK-ENCODING: [0x00,0x04,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0440400 + +mova za0h.h[w14, 4:7], {z8.h - z11.h} // 11000000-01000100-01000101-00000001 +// CHECK-INST: mov za0h.h[w14, 4:7], { z8.h - z11.h } +// CHECK-ENCODING: [0x01,0x45,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0444501 + +mova za1h.h[w15, 4:7], {z12.h - z15.h} // 11000000-01000100-01100101-10000011 +// CHECK-INST: mov za1h.h[w15, 4:7], { z12.h - z15.h } +// CHECK-ENCODING: [0x83,0x65,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0446583 + +mova za1h.h[w15, 4:7], {z28.h - z31.h} // 11000000-01000100-01100111-10000011 +// CHECK-INST: mov za1h.h[w15, 4:7], { z28.h - z31.h } +// CHECK-ENCODING: [0x83,0x67,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0446783 + +mova za0h.h[w12, 4:7], {z16.h - z19.h} // 11000000-01000100-00000110-00000001 +// CHECK-INST: mov za0h.h[w12, 4:7], { z16.h - z19.h } +// CHECK-ENCODING: [0x01,0x06,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0440601 + +mova za0h.h[w12, 4:7], {z0.h - z3.h} // 11000000-01000100-00000100-00000001 +// CHECK-INST: mov za0h.h[w12, 4:7], { z0.h - z3.h } +// CHECK-ENCODING: [0x01,0x04,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0440401 + +mova za0h.h[w14, 0:3], {z16.h - z19.h} // 11000000-01000100-01000110-00000000 +// CHECK-INST: mov za0h.h[w14, 0:3], { z16.h - z19.h } +// CHECK-ENCODING: [0x00,0x46,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0444600 + +mova za0h.h[w12, 0:3], {z12.h - z15.h} // 11000000-01000100-00000101-10000000 +// CHECK-INST: mov za0h.h[w12, 0:3], { z12.h - z15.h } +// CHECK-ENCODING: [0x80,0x05,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0440580 + +mova za0h.h[w14, 4:7], {z0.h - z3.h} // 11000000-01000100-01000100-00000001 +// CHECK-INST: mov za0h.h[w14, 4:7], { z0.h - z3.h } +// CHECK-ENCODING: [0x01,0x44,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0444401 + +mova za0h.h[w12, 4:7], {z20.h - z23.h} // 11000000-01000100-00000110-10000001 +// CHECK-INST: mov za0h.h[w12, 4:7], { z20.h - z23.h } +// CHECK-ENCODING: [0x81,0x06,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0440681 + +mova za1h.h[w15, 0:3], {z8.h - z11.h} // 11000000-01000100-01100101-00000010 +// CHECK-INST: mov za1h.h[w15, 0:3], { z8.h - z11.h } +// CHECK-ENCODING: [0x02,0x65,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0446502 + +mova za1h.h[w13, 4:7], {z12.h - z15.h} // 11000000-01000100-00100101-10000011 +// CHECK-INST: mov za1h.h[w13, 4:7], { z12.h - z15.h } +// CHECK-ENCODING: [0x83,0x25,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0442583 + +// Aliases + +mov za0h.h[w12, 0:3], {z0.h - z3.h} // 11000000-01000100-00000100-00000000 +// CHECK-INST: mov za0h.h[w12, 0:3], { z0.h - z3.h } +// CHECK-ENCODING: [0x00,0x04,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0440400 + +mov za0h.h[w14, 4:7], {z8.h - z11.h} // 11000000-01000100-01000101-00000001 +// CHECK-INST: mov za0h.h[w14, 4:7], { z8.h - z11.h } +// CHECK-ENCODING: [0x01,0x45,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0444501 + +mov za1h.h[w15, 4:7], {z12.h - z15.h} // 11000000-01000100-01100101-10000011 +// CHECK-INST: mov za1h.h[w15, 4:7], { z12.h - z15.h } +// CHECK-ENCODING: [0x83,0x65,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0446583 + +mov za1h.h[w15, 4:7], {z28.h - z31.h} // 11000000-01000100-01100111-10000011 +// CHECK-INST: mov za1h.h[w15, 4:7], { z28.h - z31.h } +// CHECK-ENCODING: [0x83,0x67,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0446783 + +mov za0h.h[w12, 4:7], {z16.h - z19.h} // 11000000-01000100-00000110-00000001 +// CHECK-INST: mov za0h.h[w12, 4:7], { z16.h - z19.h } +// CHECK-ENCODING: [0x01,0x06,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0440601 + +mov za0h.h[w12, 4:7], {z0.h - z3.h} // 11000000-01000100-00000100-00000001 +// CHECK-INST: mov za0h.h[w12, 4:7], { z0.h - z3.h } +// CHECK-ENCODING: [0x01,0x04,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0440401 + +mov za0h.h[w14, 0:3], {z16.h - z19.h} // 11000000-01000100-01000110-00000000 +// CHECK-INST: mov za0h.h[w14, 0:3], { z16.h - z19.h } +// CHECK-ENCODING: [0x00,0x46,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0444600 + +mov za0h.h[w12, 0:3], {z12.h - z15.h} // 11000000-01000100-00000101-10000000 +// CHECK-INST: mov za0h.h[w12, 0:3], { z12.h - z15.h } +// CHECK-ENCODING: [0x80,0x05,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0440580 + +mov za0h.h[w14, 4:7], {z0.h - z3.h} // 11000000-01000100-01000100-00000001 +// CHECK-INST: mov za0h.h[w14, 4:7], { z0.h - z3.h } +// CHECK-ENCODING: [0x01,0x44,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0444401 + +mov za0h.h[w12, 4:7], {z20.h - z23.h} // 11000000-01000100-00000110-10000001 +// CHECK-INST: mov za0h.h[w12, 4:7], { z20.h - z23.h } +// CHECK-ENCODING: [0x81,0x06,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0440681 + +mov za1h.h[w15, 0:3], {z8.h - z11.h} // 11000000-01000100-01100101-00000010 +// CHECK-INST: mov za1h.h[w15, 0:3], { z8.h - z11.h } +// CHECK-ENCODING: [0x02,0x65,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0446502 + +mov za1h.h[w13, 4:7], {z12.h - z15.h} // 11000000-01000100-00100101-10000011 +// CHECK-INST: mov za1h.h[w13, 4:7], { z12.h - z15.h } +// CHECK-ENCODING: [0x83,0x25,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0442583 + + +mova za0v.h[w12, 0:3], {z0.h - z3.h} // 11000000-01000100-10000100-00000000 +// CHECK-INST: mov za0v.h[w12, 0:3], { z0.h - z3.h } +// CHECK-ENCODING: [0x00,0x84,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0448400 + +mova za0v.h[w14, 4:7], {z8.h - z11.h} // 11000000-01000100-11000101-00000001 +// CHECK-INST: mov za0v.h[w14, 4:7], { z8.h - z11.h } +// CHECK-ENCODING: [0x01,0xc5,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044c501 + +mova za1v.h[w15, 4:7], {z12.h - z15.h} // 11000000-01000100-11100101-10000011 +// CHECK-INST: mov za1v.h[w15, 4:7], { z12.h - z15.h } +// CHECK-ENCODING: [0x83,0xe5,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044e583 + +mova za1v.h[w15, 4:7], {z28.h - z31.h} // 11000000-01000100-11100111-10000011 +// CHECK-INST: mov za1v.h[w15, 4:7], { z28.h - z31.h } +// CHECK-ENCODING: [0x83,0xe7,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044e783 + +mova za0v.h[w12, 4:7], {z16.h - z19.h} // 11000000-01000100-10000110-00000001 +// CHECK-INST: mov za0v.h[w12, 4:7], { z16.h - z19.h } +// CHECK-ENCODING: [0x01,0x86,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0448601 + +mova za0v.h[w12, 4:7], {z0.h - z3.h} // 11000000-01000100-10000100-00000001 +// CHECK-INST: mov za0v.h[w12, 4:7], { z0.h - z3.h } +// CHECK-ENCODING: [0x01,0x84,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0448401 + +mova za0v.h[w14, 0:3], {z16.h - z19.h} // 11000000-01000100-11000110-00000000 +// CHECK-INST: mov za0v.h[w14, 0:3], { z16.h - z19.h } +// CHECK-ENCODING: [0x00,0xc6,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044c600 + +mova za0v.h[w12, 0:3], {z12.h - z15.h} // 11000000-01000100-10000101-10000000 +// CHECK-INST: mov za0v.h[w12, 0:3], { z12.h - z15.h } +// CHECK-ENCODING: [0x80,0x85,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0448580 + +mova za0v.h[w14, 4:7], {z0.h - z3.h} // 11000000-01000100-11000100-00000001 +// CHECK-INST: mov za0v.h[w14, 4:7], { z0.h - z3.h } +// CHECK-ENCODING: [0x01,0xc4,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044c401 + +mova za0v.h[w12, 4:7], {z20.h - z23.h} // 11000000-01000100-10000110-10000001 +// CHECK-INST: mov za0v.h[w12, 4:7], { z20.h - z23.h } +// CHECK-ENCODING: [0x81,0x86,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0448681 + +mova za1v.h[w15, 0:3], {z8.h - z11.h} // 11000000-01000100-11100101-00000010 +// CHECK-INST: mov za1v.h[w15, 0:3], { z8.h - z11.h } +// CHECK-ENCODING: [0x02,0xe5,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044e502 + +mova za1v.h[w13, 4:7], {z12.h - z15.h} // 11000000-01000100-10100101-10000011 +// CHECK-INST: mov za1v.h[w13, 4:7], { z12.h - z15.h } +// CHECK-ENCODING: [0x83,0xa5,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044a583 + +// Aliases + +mov za0v.h[w12, 0:3], {z0.h - z3.h} // 11000000-01000100-10000100-00000000 +// CHECK-INST: mov za0v.h[w12, 0:3], { z0.h - z3.h } +// CHECK-ENCODING: [0x00,0x84,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0448400 + +mov za0v.h[w14, 4:7], {z8.h - z11.h} // 11000000-01000100-11000101-00000001 +// CHECK-INST: mov za0v.h[w14, 4:7], { z8.h - z11.h } +// CHECK-ENCODING: [0x01,0xc5,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044c501 + +mov za1v.h[w15, 4:7], {z12.h - z15.h} // 11000000-01000100-11100101-10000011 +// CHECK-INST: mov za1v.h[w15, 4:7], { z12.h - z15.h } +// CHECK-ENCODING: [0x83,0xe5,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044e583 + +mov za1v.h[w15, 4:7], {z28.h - z31.h} // 11000000-01000100-11100111-10000011 +// CHECK-INST: mov za1v.h[w15, 4:7], { z28.h - z31.h } +// CHECK-ENCODING: [0x83,0xe7,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044e783 + +mov za0v.h[w12, 4:7], {z16.h - z19.h} // 11000000-01000100-10000110-00000001 +// CHECK-INST: mov za0v.h[w12, 4:7], { z16.h - z19.h } +// CHECK-ENCODING: [0x01,0x86,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0448601 + +mov za0v.h[w12, 4:7], {z0.h - z3.h} // 11000000-01000100-10000100-00000001 +// CHECK-INST: mov za0v.h[w12, 4:7], { z0.h - z3.h } +// CHECK-ENCODING: [0x01,0x84,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0448401 + +mov za0v.h[w14, 0:3], {z16.h - z19.h} // 11000000-01000100-11000110-00000000 +// CHECK-INST: mov za0v.h[w14, 0:3], { z16.h - z19.h } +// CHECK-ENCODING: [0x00,0xc6,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044c600 + +mov za0v.h[w12, 0:3], {z12.h - z15.h} // 11000000-01000100-10000101-10000000 +// CHECK-INST: mov za0v.h[w12, 0:3], { z12.h - z15.h } +// CHECK-ENCODING: [0x80,0x85,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0448580 + +mov za0v.h[w14, 4:7], {z0.h - z3.h} // 11000000-01000100-11000100-00000001 +// CHECK-INST: mov za0v.h[w14, 4:7], { z0.h - z3.h } +// CHECK-ENCODING: [0x01,0xc4,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044c401 + +mov za0v.h[w12, 4:7], {z20.h - z23.h} // 11000000-01000100-10000110-10000001 +// CHECK-INST: mov za0v.h[w12, 4:7], { z20.h - z23.h } +// CHECK-ENCODING: [0x81,0x86,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0448681 + +mov za1v.h[w15, 0:3], {z8.h - z11.h} // 11000000-01000100-11100101-00000010 +// CHECK-INST: mov za1v.h[w15, 0:3], { z8.h - z11.h } +// CHECK-ENCODING: [0x02,0xe5,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044e502 + +mov za1v.h[w13, 4:7], {z12.h - z15.h} // 11000000-01000100-10100101-10000011 +// CHECK-INST: mov za1v.h[w13, 4:7], { z12.h - z15.h } +// CHECK-ENCODING: [0x83,0xa5,0x44,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c044a583 + + +mova {z0.s - z3.s}, za0h.s[w12, 0:3] // 11000000-10000110-00000100-00000000 +// CHECK-INST: mov { z0.s - z3.s }, za0h.s[w12, 0:3] +// CHECK-ENCODING: [0x00,0x04,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0860400 + +mova {z20.s - z23.s}, za2h.s[w14, 0:3] // 11000000-10000110-01000100-01010100 +// CHECK-INST: mov { z20.s - z23.s }, za2h.s[w14, 0:3] +// CHECK-ENCODING: [0x54,0x44,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0864454 + +mova {z20.s - z23.s}, za1h.s[w15, 0:3] // 11000000-10000110-01100100-00110100 +// CHECK-INST: mov { z20.s - z23.s }, za1h.s[w15, 0:3] +// CHECK-ENCODING: [0x34,0x64,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0866434 + +mova {z28.s - z31.s}, za3h.s[w15, 0:3] // 11000000-10000110-01100100-01111100 +// CHECK-INST: mov { z28.s - z31.s }, za3h.s[w15, 0:3] +// CHECK-ENCODING: [0x7c,0x64,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086647c + +mova {z4.s - z7.s}, za1h.s[w12, 0:3] // 11000000-10000110-00000100-00100100 +// CHECK-INST: mov { z4.s - z7.s }, za1h.s[w12, 0:3] +// CHECK-ENCODING: [0x24,0x04,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0860424 + +mova {z0.s - z3.s}, za1h.s[w12, 0:3] // 11000000-10000110-00000100-00100000 +// CHECK-INST: mov { z0.s - z3.s }, za1h.s[w12, 0:3] +// CHECK-ENCODING: [0x20,0x04,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0860420 + +mova {z24.s - z27.s}, za3h.s[w14, 0:3] // 11000000-10000110-01000100-01111000 +// CHECK-INST: mov { z24.s - z27.s }, za3h.s[w14, 0:3] +// CHECK-ENCODING: [0x78,0x44,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0864478 + +mova {z16.s - z19.s}, za1h.s[w14, 0:3] // 11000000-10000110-01000100-00110000 +// CHECK-INST: mov { z16.s - z19.s }, za1h.s[w14, 0:3] +// CHECK-ENCODING: [0x30,0x44,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0864430 + +mova {z28.s - z31.s}, za2h.s[w12, 0:3] // 11000000-10000110-00000100-01011100 +// CHECK-INST: mov { z28.s - z31.s }, za2h.s[w12, 0:3] +// CHECK-ENCODING: [0x5c,0x04,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086045c + +mova {z0.s - z3.s}, za1h.s[w15, 0:3] // 11000000-10000110-01100100-00100000 +// CHECK-INST: mov { z0.s - z3.s }, za1h.s[w15, 0:3] +// CHECK-ENCODING: [0x20,0x64,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0866420 + +mova {z4.s - z7.s}, za0h.s[w13, 0:3] // 11000000-10000110-00100100-00000100 +// CHECK-INST: mov { z4.s - z7.s }, za0h.s[w13, 0:3] +// CHECK-ENCODING: [0x04,0x24,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0862404 + +// Aliases + +mov {z0.s - z3.s}, za0h.s[w12, 0:3] // 11000000-10000110-00000100-00000000 +// CHECK-INST: mov { z0.s - z3.s }, za0h.s[w12, 0:3] +// CHECK-ENCODING: [0x00,0x04,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0860400 + +mov {z20.s - z23.s}, za2h.s[w14, 0:3] // 11000000-10000110-01000100-01010100 +// CHECK-INST: mov { z20.s - z23.s }, za2h.s[w14, 0:3] +// CHECK-ENCODING: [0x54,0x44,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0864454 + +mov {z20.s - z23.s}, za1h.s[w15, 0:3] // 11000000-10000110-01100100-00110100 +// CHECK-INST: mov { z20.s - z23.s }, za1h.s[w15, 0:3] +// CHECK-ENCODING: [0x34,0x64,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0866434 + +mov {z28.s - z31.s}, za3h.s[w15, 0:3] // 11000000-10000110-01100100-01111100 +// CHECK-INST: mov { z28.s - z31.s }, za3h.s[w15, 0:3] +// CHECK-ENCODING: [0x7c,0x64,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086647c + +mov {z4.s - z7.s}, za1h.s[w12, 0:3] // 11000000-10000110-00000100-00100100 +// CHECK-INST: mov { z4.s - z7.s }, za1h.s[w12, 0:3] +// CHECK-ENCODING: [0x24,0x04,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0860424 + +mov {z0.s - z3.s}, za1h.s[w12, 0:3] // 11000000-10000110-00000100-00100000 +// CHECK-INST: mov { z0.s - z3.s }, za1h.s[w12, 0:3] +// CHECK-ENCODING: [0x20,0x04,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0860420 + +mov {z24.s - z27.s}, za3h.s[w14, 0:3] // 11000000-10000110-01000100-01111000 +// CHECK-INST: mov { z24.s - z27.s }, za3h.s[w14, 0:3] +// CHECK-ENCODING: [0x78,0x44,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0864478 + +mov {z16.s - z19.s}, za1h.s[w14, 0:3] // 11000000-10000110-01000100-00110000 +// CHECK-INST: mov { z16.s - z19.s }, za1h.s[w14, 0:3] +// CHECK-ENCODING: [0x30,0x44,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0864430 + +mov {z28.s - z31.s}, za2h.s[w12, 0:3] // 11000000-10000110-00000100-01011100 +// CHECK-INST: mov { z28.s - z31.s }, za2h.s[w12, 0:3] +// CHECK-ENCODING: [0x5c,0x04,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086045c + +mov {z0.s - z3.s}, za1h.s[w15, 0:3] // 11000000-10000110-01100100-00100000 +// CHECK-INST: mov { z0.s - z3.s }, za1h.s[w15, 0:3] +// CHECK-ENCODING: [0x20,0x64,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0866420 + +mov {z4.s - z7.s}, za0h.s[w13, 0:3] // 11000000-10000110-00100100-00000100 +// CHECK-INST: mov { z4.s - z7.s }, za0h.s[w13, 0:3] +// CHECK-ENCODING: [0x04,0x24,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0862404 + + +mova {z0.s - z3.s}, za0v.s[w12, 0:3] // 11000000-10000110-10000100-00000000 +// CHECK-INST: mov { z0.s - z3.s }, za0v.s[w12, 0:3] +// CHECK-ENCODING: [0x00,0x84,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0868400 + +mova {z20.s - z23.s}, za2v.s[w14, 0:3] // 11000000-10000110-11000100-01010100 +// CHECK-INST: mov { z20.s - z23.s }, za2v.s[w14, 0:3] +// CHECK-ENCODING: [0x54,0xc4,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086c454 + +mova {z20.s - z23.s}, za1v.s[w15, 0:3] // 11000000-10000110-11100100-00110100 +// CHECK-INST: mov { z20.s - z23.s }, za1v.s[w15, 0:3] +// CHECK-ENCODING: [0x34,0xe4,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086e434 + +mova {z28.s - z31.s}, za3v.s[w15, 0:3] // 11000000-10000110-11100100-01111100 +// CHECK-INST: mov { z28.s - z31.s }, za3v.s[w15, 0:3] +// CHECK-ENCODING: [0x7c,0xe4,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086e47c + +mova {z4.s - z7.s}, za1v.s[w12, 0:3] // 11000000-10000110-10000100-00100100 +// CHECK-INST: mov { z4.s - z7.s }, za1v.s[w12, 0:3] +// CHECK-ENCODING: [0x24,0x84,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0868424 + +mova {z0.s - z3.s}, za1v.s[w12, 0:3] // 11000000-10000110-10000100-00100000 +// CHECK-INST: mov { z0.s - z3.s }, za1v.s[w12, 0:3] +// CHECK-ENCODING: [0x20,0x84,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0868420 + +mova {z24.s - z27.s}, za3v.s[w14, 0:3] // 11000000-10000110-11000100-01111000 +// CHECK-INST: mov { z24.s - z27.s }, za3v.s[w14, 0:3] +// CHECK-ENCODING: [0x78,0xc4,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086c478 + +mova {z16.s - z19.s}, za1v.s[w14, 0:3] // 11000000-10000110-11000100-00110000 +// CHECK-INST: mov { z16.s - z19.s }, za1v.s[w14, 0:3] +// CHECK-ENCODING: [0x30,0xc4,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086c430 + +mova {z28.s - z31.s}, za2v.s[w12, 0:3] // 11000000-10000110-10000100-01011100 +// CHECK-INST: mov { z28.s - z31.s }, za2v.s[w12, 0:3] +// CHECK-ENCODING: [0x5c,0x84,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086845c + +mova {z0.s - z3.s}, za1v.s[w15, 0:3] // 11000000-10000110-11100100-00100000 +// CHECK-INST: mov { z0.s - z3.s }, za1v.s[w15, 0:3] +// CHECK-ENCODING: [0x20,0xe4,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086e420 + +mova {z4.s - z7.s}, za0v.s[w13, 0:3] // 11000000-10000110-10100100-00000100 +// CHECK-INST: mov { z4.s - z7.s }, za0v.s[w13, 0:3] +// CHECK-ENCODING: [0x04,0xa4,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086a404 + +// Aliases + +mov {z0.s - z3.s}, za0v.s[w12, 0:3] // 11000000-10000110-10000100-00000000 +// CHECK-INST: mov { z0.s - z3.s }, za0v.s[w12, 0:3] +// CHECK-ENCODING: [0x00,0x84,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0868400 + +mov {z20.s - z23.s}, za2v.s[w14, 0:3] // 11000000-10000110-11000100-01010100 +// CHECK-INST: mov { z20.s - z23.s }, za2v.s[w14, 0:3] +// CHECK-ENCODING: [0x54,0xc4,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086c454 + +mov {z20.s - z23.s}, za1v.s[w15, 0:3] // 11000000-10000110-11100100-00110100 +// CHECK-INST: mov { z20.s - z23.s }, za1v.s[w15, 0:3] +// CHECK-ENCODING: [0x34,0xe4,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086e434 + +mov {z28.s - z31.s}, za3v.s[w15, 0:3] // 11000000-10000110-11100100-01111100 +// CHECK-INST: mov { z28.s - z31.s }, za3v.s[w15, 0:3] +// CHECK-ENCODING: [0x7c,0xe4,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086e47c + +mov {z4.s - z7.s}, za1v.s[w12, 0:3] // 11000000-10000110-10000100-00100100 +// CHECK-INST: mov { z4.s - z7.s }, za1v.s[w12, 0:3] +// CHECK-ENCODING: [0x24,0x84,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0868424 + +mov {z0.s - z3.s}, za1v.s[w12, 0:3] // 11000000-10000110-10000100-00100000 +// CHECK-INST: mov { z0.s - z3.s }, za1v.s[w12, 0:3] +// CHECK-ENCODING: [0x20,0x84,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0868420 + +mov {z24.s - z27.s}, za3v.s[w14, 0:3] // 11000000-10000110-11000100-01111000 +// CHECK-INST: mov { z24.s - z27.s }, za3v.s[w14, 0:3] +// CHECK-ENCODING: [0x78,0xc4,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086c478 + +mov {z16.s - z19.s}, za1v.s[w14, 0:3] // 11000000-10000110-11000100-00110000 +// CHECK-INST: mov { z16.s - z19.s }, za1v.s[w14, 0:3] +// CHECK-ENCODING: [0x30,0xc4,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086c430 + +mov {z28.s - z31.s}, za2v.s[w12, 0:3] // 11000000-10000110-10000100-01011100 +// CHECK-INST: mov { z28.s - z31.s }, za2v.s[w12, 0:3] +// CHECK-ENCODING: [0x5c,0x84,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086845c + +mov {z0.s - z3.s}, za1v.s[w15, 0:3] // 11000000-10000110-11100100-00100000 +// CHECK-INST: mov { z0.s - z3.s }, za1v.s[w15, 0:3] +// CHECK-ENCODING: [0x20,0xe4,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086e420 + +mov {z4.s - z7.s}, za0v.s[w13, 0:3] // 11000000-10000110-10100100-00000100 +// CHECK-INST: mov { z4.s - z7.s }, za0v.s[w13, 0:3] +// CHECK-ENCODING: [0x04,0xa4,0x86,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c086a404 + + +mova za0h.s[w12, 0:3], {z0.s - z3.s} // 11000000-10000100-00000100-00000000 +// CHECK-INST: mov za0h.s[w12, 0:3], { z0.s - z3.s } +// CHECK-ENCODING: [0x00,0x04,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0840400 + +mova za1h.s[w14, 0:3], {z8.s - z11.s} // 11000000-10000100-01000101-00000001 +// CHECK-INST: mov za1h.s[w14, 0:3], { z8.s - z11.s } +// CHECK-ENCODING: [0x01,0x45,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0844501 + +mova za3h.s[w15, 0:3], {z12.s - z15.s} // 11000000-10000100-01100101-10000011 +// CHECK-INST: mov za3h.s[w15, 0:3], { z12.s - z15.s } +// CHECK-ENCODING: [0x83,0x65,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0846583 + +mova za3h.s[w15, 0:3], {z28.s - z31.s} // 11000000-10000100-01100111-10000011 +// CHECK-INST: mov za3h.s[w15, 0:3], { z28.s - z31.s } +// CHECK-ENCODING: [0x83,0x67,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0846783 + +mova za1h.s[w12, 0:3], {z16.s - z19.s} // 11000000-10000100-00000110-00000001 +// CHECK-INST: mov za1h.s[w12, 0:3], { z16.s - z19.s } +// CHECK-ENCODING: [0x01,0x06,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0840601 + +mova za1h.s[w12, 0:3], {z0.s - z3.s} // 11000000-10000100-00000100-00000001 +// CHECK-INST: mov za1h.s[w12, 0:3], { z0.s - z3.s } +// CHECK-ENCODING: [0x01,0x04,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0840401 + +mova za0h.s[w14, 0:3], {z16.s - z19.s} // 11000000-10000100-01000110-00000000 +// CHECK-INST: mov za0h.s[w14, 0:3], { z16.s - z19.s } +// CHECK-ENCODING: [0x00,0x46,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0844600 + +mova za0h.s[w12, 0:3], {z12.s - z15.s} // 11000000-10000100-00000101-10000000 +// CHECK-INST: mov za0h.s[w12, 0:3], { z12.s - z15.s } +// CHECK-ENCODING: [0x80,0x05,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0840580 + +mova za1h.s[w14, 0:3], {z0.s - z3.s} // 11000000-10000100-01000100-00000001 +// CHECK-INST: mov za1h.s[w14, 0:3], { z0.s - z3.s } +// CHECK-ENCODING: [0x01,0x44,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0844401 + +mova za1h.s[w12, 0:3], {z20.s - z23.s} // 11000000-10000100-00000110-10000001 +// CHECK-INST: mov za1h.s[w12, 0:3], { z20.s - z23.s } +// CHECK-ENCODING: [0x81,0x06,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0840681 + +mova za2h.s[w15, 0:3], {z8.s - z11.s} // 11000000-10000100-01100101-00000010 +// CHECK-INST: mov za2h.s[w15, 0:3], { z8.s - z11.s } +// CHECK-ENCODING: [0x02,0x65,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0846502 + +mova za3h.s[w13, 0:3], {z12.s - z15.s} // 11000000-10000100-00100101-10000011 +// CHECK-INST: mov za3h.s[w13, 0:3], { z12.s - z15.s } +// CHECK-ENCODING: [0x83,0x25,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0842583 + +// Aliases + +mov za0h.s[w12, 0:3], {z0.s - z3.s} // 11000000-10000100-00000100-00000000 +// CHECK-INST: mov za0h.s[w12, 0:3], { z0.s - z3.s } +// CHECK-ENCODING: [0x00,0x04,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0840400 + +mov za1h.s[w14, 0:3], {z8.s - z11.s} // 11000000-10000100-01000101-00000001 +// CHECK-INST: mov za1h.s[w14, 0:3], { z8.s - z11.s } +// CHECK-ENCODING: [0x01,0x45,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0844501 + +mov za3h.s[w15, 0:3], {z12.s - z15.s} // 11000000-10000100-01100101-10000011 +// CHECK-INST: mov za3h.s[w15, 0:3], { z12.s - z15.s } +// CHECK-ENCODING: [0x83,0x65,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0846583 + +mov za3h.s[w15, 0:3], {z28.s - z31.s} // 11000000-10000100-01100111-10000011 +// CHECK-INST: mov za3h.s[w15, 0:3], { z28.s - z31.s } +// CHECK-ENCODING: [0x83,0x67,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0846783 + +mov za1h.s[w12, 0:3], {z16.s - z19.s} // 11000000-10000100-00000110-00000001 +// CHECK-INST: mov za1h.s[w12, 0:3], { z16.s - z19.s } +// CHECK-ENCODING: [0x01,0x06,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0840601 + +mov za1h.s[w12, 0:3], {z0.s - z3.s} // 11000000-10000100-00000100-00000001 +// CHECK-INST: mov za1h.s[w12, 0:3], { z0.s - z3.s } +// CHECK-ENCODING: [0x01,0x04,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0840401 + +mov za0h.s[w14, 0:3], {z16.s - z19.s} // 11000000-10000100-01000110-00000000 +// CHECK-INST: mov za0h.s[w14, 0:3], { z16.s - z19.s } +// CHECK-ENCODING: [0x00,0x46,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0844600 + +mov za0h.s[w12, 0:3], {z12.s - z15.s} // 11000000-10000100-00000101-10000000 +// CHECK-INST: mov za0h.s[w12, 0:3], { z12.s - z15.s } +// CHECK-ENCODING: [0x80,0x05,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0840580 + +mov za1h.s[w14, 0:3], {z0.s - z3.s} // 11000000-10000100-01000100-00000001 +// CHECK-INST: mov za1h.s[w14, 0:3], { z0.s - z3.s } +// CHECK-ENCODING: [0x01,0x44,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0844401 + +mov za1h.s[w12, 0:3], {z20.s - z23.s} // 11000000-10000100-00000110-10000001 +// CHECK-INST: mov za1h.s[w12, 0:3], { z20.s - z23.s } +// CHECK-ENCODING: [0x81,0x06,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0840681 + +mov za2h.s[w15, 0:3], {z8.s - z11.s} // 11000000-10000100-01100101-00000010 +// CHECK-INST: mov za2h.s[w15, 0:3], { z8.s - z11.s } +// CHECK-ENCODING: [0x02,0x65,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0846502 + +mov za3h.s[w13, 0:3], {z12.s - z15.s} // 11000000-10000100-00100101-10000011 +// CHECK-INST: mov za3h.s[w13, 0:3], { z12.s - z15.s } +// CHECK-ENCODING: [0x83,0x25,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0842583 + + +mova za0v.s[w12, 0:3], {z0.s - z3.s} // 11000000-10000100-10000100-00000000 +// CHECK-INST: mov za0v.s[w12, 0:3], { z0.s - z3.s } +// CHECK-ENCODING: [0x00,0x84,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0848400 + +mova za1v.s[w14, 0:3], {z8.s - z11.s} // 11000000-10000100-11000101-00000001 +// CHECK-INST: mov za1v.s[w14, 0:3], { z8.s - z11.s } +// CHECK-ENCODING: [0x01,0xc5,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084c501 + +mova za3v.s[w15, 0:3], {z12.s - z15.s} // 11000000-10000100-11100101-10000011 +// CHECK-INST: mov za3v.s[w15, 0:3], { z12.s - z15.s } +// CHECK-ENCODING: [0x83,0xe5,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084e583 + +mova za3v.s[w15, 0:3], {z28.s - z31.s} // 11000000-10000100-11100111-10000011 +// CHECK-INST: mov za3v.s[w15, 0:3], { z28.s - z31.s } +// CHECK-ENCODING: [0x83,0xe7,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084e783 + +mova za1v.s[w12, 0:3], {z16.s - z19.s} // 11000000-10000100-10000110-00000001 +// CHECK-INST: mov za1v.s[w12, 0:3], { z16.s - z19.s } +// CHECK-ENCODING: [0x01,0x86,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0848601 + +mova za1v.s[w12, 0:3], {z0.s - z3.s} // 11000000-10000100-10000100-00000001 +// CHECK-INST: mov za1v.s[w12, 0:3], { z0.s - z3.s } +// CHECK-ENCODING: [0x01,0x84,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0848401 + +mova za0v.s[w14, 0:3], {z16.s - z19.s} // 11000000-10000100-11000110-00000000 +// CHECK-INST: mov za0v.s[w14, 0:3], { z16.s - z19.s } +// CHECK-ENCODING: [0x00,0xc6,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084c600 + +mova za0v.s[w12, 0:3], {z12.s - z15.s} // 11000000-10000100-10000101-10000000 +// CHECK-INST: mov za0v.s[w12, 0:3], { z12.s - z15.s } +// CHECK-ENCODING: [0x80,0x85,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0848580 + +mova za1v.s[w14, 0:3], {z0.s - z3.s} // 11000000-10000100-11000100-00000001 +// CHECK-INST: mov za1v.s[w14, 0:3], { z0.s - z3.s } +// CHECK-ENCODING: [0x01,0xc4,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084c401 + +mova za1v.s[w12, 0:3], {z20.s - z23.s} // 11000000-10000100-10000110-10000001 +// CHECK-INST: mov za1v.s[w12, 0:3], { z20.s - z23.s } +// CHECK-ENCODING: [0x81,0x86,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0848681 + +mova za2v.s[w15, 0:3], {z8.s - z11.s} // 11000000-10000100-11100101-00000010 +// CHECK-INST: mov za2v.s[w15, 0:3], { z8.s - z11.s } +// CHECK-ENCODING: [0x02,0xe5,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084e502 + +mova za3v.s[w13, 0:3], {z12.s - z15.s} // 11000000-10000100-10100101-10000011 +// CHECK-INST: mov za3v.s[w13, 0:3], { z12.s - z15.s } +// CHECK-ENCODING: [0x83,0xa5,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084a583 + +// Aliases + +mov za0v.s[w12, 0:3], {z0.s - z3.s} // 11000000-10000100-10000100-00000000 +// CHECK-INST: mov za0v.s[w12, 0:3], { z0.s - z3.s } +// CHECK-ENCODING: [0x00,0x84,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0848400 + +mov za1v.s[w14, 0:3], {z8.s - z11.s} // 11000000-10000100-11000101-00000001 +// CHECK-INST: mov za1v.s[w14, 0:3], { z8.s - z11.s } +// CHECK-ENCODING: [0x01,0xc5,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084c501 + +mov za3v.s[w15, 0:3], {z12.s - z15.s} // 11000000-10000100-11100101-10000011 +// CHECK-INST: mov za3v.s[w15, 0:3], { z12.s - z15.s } +// CHECK-ENCODING: [0x83,0xe5,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084e583 + +mov za3v.s[w15, 0:3], {z28.s - z31.s} // 11000000-10000100-11100111-10000011 +// CHECK-INST: mov za3v.s[w15, 0:3], { z28.s - z31.s } +// CHECK-ENCODING: [0x83,0xe7,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084e783 + +mov za1v.s[w12, 0:3], {z16.s - z19.s} // 11000000-10000100-10000110-00000001 +// CHECK-INST: mov za1v.s[w12, 0:3], { z16.s - z19.s } +// CHECK-ENCODING: [0x01,0x86,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0848601 + +mov za1v.s[w12, 0:3], {z0.s - z3.s} // 11000000-10000100-10000100-00000001 +// CHECK-INST: mov za1v.s[w12, 0:3], { z0.s - z3.s } +// CHECK-ENCODING: [0x01,0x84,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0848401 + +mov za0v.s[w14, 0:3], {z16.s - z19.s} // 11000000-10000100-11000110-00000000 +// CHECK-INST: mov za0v.s[w14, 0:3], { z16.s - z19.s } +// CHECK-ENCODING: [0x00,0xc6,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084c600 + +mov za0v.s[w12, 0:3], {z12.s - z15.s} // 11000000-10000100-10000101-10000000 +// CHECK-INST: mov za0v.s[w12, 0:3], { z12.s - z15.s } +// CHECK-ENCODING: [0x80,0x85,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0848580 + +mov za1v.s[w14, 0:3], {z0.s - z3.s} // 11000000-10000100-11000100-00000001 +// CHECK-INST: mov za1v.s[w14, 0:3], { z0.s - z3.s } +// CHECK-ENCODING: [0x01,0xc4,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084c401 + +mov za1v.s[w12, 0:3], {z20.s - z23.s} // 11000000-10000100-10000110-10000001 +// CHECK-INST: mov za1v.s[w12, 0:3], { z20.s - z23.s } +// CHECK-ENCODING: [0x81,0x86,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0848681 + +mov za2v.s[w15, 0:3], {z8.s - z11.s} // 11000000-10000100-11100101-00000010 +// CHECK-INST: mov za2v.s[w15, 0:3], { z8.s - z11.s } +// CHECK-ENCODING: [0x02,0xe5,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084e502 + +mov za3v.s[w13, 0:3], {z12.s - z15.s} // 11000000-10000100-10100101-10000011 +// CHECK-INST: mov za3v.s[w13, 0:3], { z12.s - z15.s } +// CHECK-ENCODING: [0x83,0xa5,0x84,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c084a583 + + +mova {z0.d - z3.d}, za0h.d[w12, 0:3] // 11000000-11000110-00000100-00000000 +// CHECK-INST: mov { z0.d - z3.d }, za0h.d[w12, 0:3] +// CHECK-ENCODING: [0x00,0x04,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c60400 + +mova {z20.d - z23.d}, za2h.d[w14, 0:3] // 11000000-11000110-01000100-01010100 +// CHECK-INST: mov { z20.d - z23.d }, za2h.d[w14, 0:3] +// CHECK-ENCODING: [0x54,0x44,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c64454 + +mova {z20.d - z23.d}, za5h.d[w15, 0:3] // 11000000-11000110-01100100-10110100 +// CHECK-INST: mov { z20.d - z23.d }, za5h.d[w15, 0:3] +// CHECK-ENCODING: [0xb4,0x64,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c664b4 + +mova {z28.d - z31.d}, za7h.d[w15, 0:3] // 11000000-11000110-01100100-11111100 +// CHECK-INST: mov { z28.d - z31.d }, za7h.d[w15, 0:3] +// CHECK-ENCODING: [0xfc,0x64,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c664fc + +mova {z4.d - z7.d}, za1h.d[w12, 0:3] // 11000000-11000110-00000100-00100100 +// CHECK-INST: mov { z4.d - z7.d }, za1h.d[w12, 0:3] +// CHECK-ENCODING: [0x24,0x04,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c60424 + +mova {z0.d - z3.d}, za1h.d[w12, 0:3] // 11000000-11000110-00000100-00100000 +// CHECK-INST: mov { z0.d - z3.d }, za1h.d[w12, 0:3] +// CHECK-ENCODING: [0x20,0x04,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c60420 + +mova {z24.d - z27.d}, za3h.d[w14, 0:3] // 11000000-11000110-01000100-01111000 +// CHECK-INST: mov { z24.d - z27.d }, za3h.d[w14, 0:3] +// CHECK-ENCODING: [0x78,0x44,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c64478 + +mova {z0.d - z3.d}, za4h.d[w12, 0:3] // 11000000-11000110-00000100-10000000 +// CHECK-INST: mov { z0.d - z3.d }, za4h.d[w12, 0:3] +// CHECK-ENCODING: [0x80,0x04,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c60480 + +mova {z16.d - z19.d}, za1h.d[w14, 0:3] // 11000000-11000110-01000100-00110000 +// CHECK-INST: mov { z16.d - z19.d }, za1h.d[w14, 0:3] +// CHECK-ENCODING: [0x30,0x44,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c64430 + +mova {z28.d - z31.d}, za6h.d[w12, 0:3] // 11000000-11000110-00000100-11011100 +// CHECK-INST: mov { z28.d - z31.d }, za6h.d[w12, 0:3] +// CHECK-ENCODING: [0xdc,0x04,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c604dc + +mova {z0.d - z3.d}, za1h.d[w15, 0:3] // 11000000-11000110-01100100-00100000 +// CHECK-INST: mov { z0.d - z3.d }, za1h.d[w15, 0:3] +// CHECK-ENCODING: [0x20,0x64,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c66420 + +mova {z4.d - z7.d}, za4h.d[w13, 0:3] // 11000000-11000110-00100100-10000100 +// CHECK-INST: mov { z4.d - z7.d }, za4h.d[w13, 0:3] +// CHECK-ENCODING: [0x84,0x24,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c62484 + +// Aliases + +mov {z0.d - z3.d}, za0h.d[w12, 0:3] // 11000000-11000110-00000100-00000000 +// CHECK-INST: mov { z0.d - z3.d }, za0h.d[w12, 0:3] +// CHECK-ENCODING: [0x00,0x04,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c60400 + +mov {z20.d - z23.d}, za2h.d[w14, 0:3] // 11000000-11000110-01000100-01010100 +// CHECK-INST: mov { z20.d - z23.d }, za2h.d[w14, 0:3] +// CHECK-ENCODING: [0x54,0x44,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c64454 + +mov {z20.d - z23.d}, za5h.d[w15, 0:3] // 11000000-11000110-01100100-10110100 +// CHECK-INST: mov { z20.d - z23.d }, za5h.d[w15, 0:3] +// CHECK-ENCODING: [0xb4,0x64,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c664b4 + +mov {z28.d - z31.d}, za7h.d[w15, 0:3] // 11000000-11000110-01100100-11111100 +// CHECK-INST: mov { z28.d - z31.d }, za7h.d[w15, 0:3] +// CHECK-ENCODING: [0xfc,0x64,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c664fc + +mov {z4.d - z7.d}, za1h.d[w12, 0:3] // 11000000-11000110-00000100-00100100 +// CHECK-INST: mov { z4.d - z7.d }, za1h.d[w12, 0:3] +// CHECK-ENCODING: [0x24,0x04,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c60424 + +mov {z0.d - z3.d}, za1h.d[w12, 0:3] // 11000000-11000110-00000100-00100000 +// CHECK-INST: mov { z0.d - z3.d }, za1h.d[w12, 0:3] +// CHECK-ENCODING: [0x20,0x04,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c60420 + +mov {z24.d - z27.d}, za3h.d[w14, 0:3] // 11000000-11000110-01000100-01111000 +// CHECK-INST: mov { z24.d - z27.d }, za3h.d[w14, 0:3] +// CHECK-ENCODING: [0x78,0x44,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c64478 + +mov {z0.d - z3.d}, za4h.d[w12, 0:3] // 11000000-11000110-00000100-10000000 +// CHECK-INST: mov { z0.d - z3.d }, za4h.d[w12, 0:3] +// CHECK-ENCODING: [0x80,0x04,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c60480 + +mov {z16.d - z19.d}, za1h.d[w14, 0:3] // 11000000-11000110-01000100-00110000 +// CHECK-INST: mov { z16.d - z19.d }, za1h.d[w14, 0:3] +// CHECK-ENCODING: [0x30,0x44,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c64430 + +mov {z28.d - z31.d}, za6h.d[w12, 0:3] // 11000000-11000110-00000100-11011100 +// CHECK-INST: mov { z28.d - z31.d }, za6h.d[w12, 0:3] +// CHECK-ENCODING: [0xdc,0x04,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c604dc + +mov {z0.d - z3.d}, za1h.d[w15, 0:3] // 11000000-11000110-01100100-00100000 +// CHECK-INST: mov { z0.d - z3.d }, za1h.d[w15, 0:3] +// CHECK-ENCODING: [0x20,0x64,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c66420 + +mov {z4.d - z7.d}, za4h.d[w13, 0:3] // 11000000-11000110-00100100-10000100 +// CHECK-INST: mov { z4.d - z7.d }, za4h.d[w13, 0:3] +// CHECK-ENCODING: [0x84,0x24,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c62484 + + +mova {z0.d - z3.d}, za0v.d[w12, 0:3] // 11000000-11000110-10000100-00000000 +// CHECK-INST: mov { z0.d - z3.d }, za0v.d[w12, 0:3] +// CHECK-ENCODING: [0x00,0x84,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c68400 + +mova {z20.d - z23.d}, za2v.d[w14, 0:3] // 11000000-11000110-11000100-01010100 +// CHECK-INST: mov { z20.d - z23.d }, za2v.d[w14, 0:3] +// CHECK-ENCODING: [0x54,0xc4,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6c454 + +mova {z20.d - z23.d}, za5v.d[w15, 0:3] // 11000000-11000110-11100100-10110100 +// CHECK-INST: mov { z20.d - z23.d }, za5v.d[w15, 0:3] +// CHECK-ENCODING: [0xb4,0xe4,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6e4b4 + +mova {z28.d - z31.d}, za7v.d[w15, 0:3] // 11000000-11000110-11100100-11111100 +// CHECK-INST: mov { z28.d - z31.d }, za7v.d[w15, 0:3] +// CHECK-ENCODING: [0xfc,0xe4,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6e4fc + +mova {z4.d - z7.d}, za1v.d[w12, 0:3] // 11000000-11000110-10000100-00100100 +// CHECK-INST: mov { z4.d - z7.d }, za1v.d[w12, 0:3] +// CHECK-ENCODING: [0x24,0x84,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c68424 + +mova {z0.d - z3.d}, za1v.d[w12, 0:3] // 11000000-11000110-10000100-00100000 +// CHECK-INST: mov { z0.d - z3.d }, za1v.d[w12, 0:3] +// CHECK-ENCODING: [0x20,0x84,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c68420 + +mova {z24.d - z27.d}, za3v.d[w14, 0:3] // 11000000-11000110-11000100-01111000 +// CHECK-INST: mov { z24.d - z27.d }, za3v.d[w14, 0:3] +// CHECK-ENCODING: [0x78,0xc4,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6c478 + +mova {z0.d - z3.d}, za4v.d[w12, 0:3] // 11000000-11000110-10000100-10000000 +// CHECK-INST: mov { z0.d - z3.d }, za4v.d[w12, 0:3] +// CHECK-ENCODING: [0x80,0x84,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c68480 + +mova {z16.d - z19.d}, za1v.d[w14, 0:3] // 11000000-11000110-11000100-00110000 +// CHECK-INST: mov { z16.d - z19.d }, za1v.d[w14, 0:3] +// CHECK-ENCODING: [0x30,0xc4,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6c430 + +mova {z28.d - z31.d}, za6v.d[w12, 0:3] // 11000000-11000110-10000100-11011100 +// CHECK-INST: mov { z28.d - z31.d }, za6v.d[w12, 0:3] +// CHECK-ENCODING: [0xdc,0x84,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c684dc + +mova {z0.d - z3.d}, za1v.d[w15, 0:3] // 11000000-11000110-11100100-00100000 +// CHECK-INST: mov { z0.d - z3.d }, za1v.d[w15, 0:3] +// CHECK-ENCODING: [0x20,0xe4,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6e420 + +mova {z4.d - z7.d}, za4v.d[w13, 0:3] // 11000000-11000110-10100100-10000100 +// CHECK-INST: mov { z4.d - z7.d }, za4v.d[w13, 0:3] +// CHECK-ENCODING: [0x84,0xa4,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6a484 + +// Aliases + +mov {z0.d - z3.d}, za0v.d[w12, 0:3] // 11000000-11000110-10000100-00000000 +// CHECK-INST: mov { z0.d - z3.d }, za0v.d[w12, 0:3] +// CHECK-ENCODING: [0x00,0x84,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c68400 + +mov {z20.d - z23.d}, za2v.d[w14, 0:3] // 11000000-11000110-11000100-01010100 +// CHECK-INST: mov { z20.d - z23.d }, za2v.d[w14, 0:3] +// CHECK-ENCODING: [0x54,0xc4,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6c454 + +mov {z20.d - z23.d}, za5v.d[w15, 0:3] // 11000000-11000110-11100100-10110100 +// CHECK-INST: mov { z20.d - z23.d }, za5v.d[w15, 0:3] +// CHECK-ENCODING: [0xb4,0xe4,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6e4b4 + +mov {z28.d - z31.d}, za7v.d[w15, 0:3] // 11000000-11000110-11100100-11111100 +// CHECK-INST: mov { z28.d - z31.d }, za7v.d[w15, 0:3] +// CHECK-ENCODING: [0xfc,0xe4,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6e4fc + +mov {z4.d - z7.d}, za1v.d[w12, 0:3] // 11000000-11000110-10000100-00100100 +// CHECK-INST: mov { z4.d - z7.d }, za1v.d[w12, 0:3] +// CHECK-ENCODING: [0x24,0x84,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c68424 + +mov {z0.d - z3.d}, za1v.d[w12, 0:3] // 11000000-11000110-10000100-00100000 +// CHECK-INST: mov { z0.d - z3.d }, za1v.d[w12, 0:3] +// CHECK-ENCODING: [0x20,0x84,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c68420 + +mov {z24.d - z27.d}, za3v.d[w14, 0:3] // 11000000-11000110-11000100-01111000 +// CHECK-INST: mov { z24.d - z27.d }, za3v.d[w14, 0:3] +// CHECK-ENCODING: [0x78,0xc4,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6c478 + +mov {z0.d - z3.d}, za4v.d[w12, 0:3] // 11000000-11000110-10000100-10000000 +// CHECK-INST: mov { z0.d - z3.d }, za4v.d[w12, 0:3] +// CHECK-ENCODING: [0x80,0x84,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c68480 + +mov {z16.d - z19.d}, za1v.d[w14, 0:3] // 11000000-11000110-11000100-00110000 +// CHECK-INST: mov { z16.d - z19.d }, za1v.d[w14, 0:3] +// CHECK-ENCODING: [0x30,0xc4,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6c430 + +mov {z28.d - z31.d}, za6v.d[w12, 0:3] // 11000000-11000110-10000100-11011100 +// CHECK-INST: mov { z28.d - z31.d }, za6v.d[w12, 0:3] +// CHECK-ENCODING: [0xdc,0x84,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c684dc + +mov {z0.d - z3.d}, za1v.d[w15, 0:3] // 11000000-11000110-11100100-00100000 +// CHECK-INST: mov { z0.d - z3.d }, za1v.d[w15, 0:3] +// CHECK-ENCODING: [0x20,0xe4,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6e420 + +mov {z4.d - z7.d}, za4v.d[w13, 0:3] // 11000000-11000110-10100100-10000100 +// CHECK-INST: mov { z4.d - z7.d }, za4v.d[w13, 0:3] +// CHECK-ENCODING: [0x84,0xa4,0xc6,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c6a484 + + +mova {z0.d - z3.d}, za.d[w8, 0, vgx4] // 11000000-00000110-00001100-00000000 +// CHECK-INST: mov { z0.d - z3.d }, za.d[w8, 0, vgx4] +// CHECK-ENCODING: [0x00,0x0c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060c00 + +mova {z0.d - z3.d}, za.d[w8, 0] // 11000000-00000110-00001100-00000000 +// CHECK-INST: mov { z0.d - z3.d }, za.d[w8, 0, vgx4] +// CHECK-ENCODING: [0x00,0x0c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060c00 + +mova {z20.d - z23.d}, za.d[w10, 2, vgx4] // 11000000-00000110-01001100-01010100 +// CHECK-INST: mov { z20.d - z23.d }, za.d[w10, 2, vgx4] +// CHECK-ENCODING: [0x54,0x4c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064c54 + +mova {z20.d - z23.d}, za.d[w10, 2] // 11000000-00000110-01001100-01010100 +// CHECK-INST: mov { z20.d - z23.d }, za.d[w10, 2, vgx4] +// CHECK-ENCODING: [0x54,0x4c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064c54 + +mova {z20.d - z23.d}, za.d[w11, 5, vgx4] // 11000000-00000110-01101100-10110100 +// CHECK-INST: mov { z20.d - z23.d }, za.d[w11, 5, vgx4] +// CHECK-ENCODING: [0xb4,0x6c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0066cb4 + +mova {z20.d - z23.d}, za.d[w11, 5] // 11000000-00000110-01101100-10110100 +// CHECK-INST: mov { z20.d - z23.d }, za.d[w11, 5, vgx4] +// CHECK-ENCODING: [0xb4,0x6c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0066cb4 + +mova {z28.d - z31.d}, za.d[w11, 7, vgx4] // 11000000-00000110-01101100-11111100 +// CHECK-INST: mov { z28.d - z31.d }, za.d[w11, 7, vgx4] +// CHECK-ENCODING: [0xfc,0x6c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0066cfc + +mova {z28.d - z31.d}, za.d[w11, 7] // 11000000-00000110-01101100-11111100 +// CHECK-INST: mov { z28.d - z31.d }, za.d[w11, 7, vgx4] +// CHECK-ENCODING: [0xfc,0x6c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0066cfc + +mova {z4.d - z7.d}, za.d[w8, 1, vgx4] // 11000000-00000110-00001100-00100100 +// CHECK-INST: mov { z4.d - z7.d }, za.d[w8, 1, vgx4] +// CHECK-ENCODING: [0x24,0x0c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060c24 + +mova {z4.d - z7.d}, za.d[w8, 1] // 11000000-00000110-00001100-00100100 +// CHECK-INST: mov { z4.d - z7.d }, za.d[w8, 1, vgx4] +// CHECK-ENCODING: [0x24,0x0c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060c24 + +mova {z0.d - z3.d}, za.d[w8, 1, vgx4] // 11000000-00000110-00001100-00100000 +// CHECK-INST: mov { z0.d - z3.d }, za.d[w8, 1, vgx4] +// CHECK-ENCODING: [0x20,0x0c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060c20 + +mova {z0.d - z3.d}, za.d[w8, 1] // 11000000-00000110-00001100-00100000 +// CHECK-INST: mov { z0.d - z3.d }, za.d[w8, 1, vgx4] +// CHECK-ENCODING: [0x20,0x0c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060c20 + +mova {z24.d - z27.d}, za.d[w10, 3, vgx4] // 11000000-00000110-01001100-01111000 +// CHECK-INST: mov { z24.d - z27.d }, za.d[w10, 3, vgx4] +// CHECK-ENCODING: [0x78,0x4c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064c78 + +mova {z24.d - z27.d}, za.d[w10, 3] // 11000000-00000110-01001100-01111000 +// CHECK-INST: mov { z24.d - z27.d }, za.d[w10, 3, vgx4] +// CHECK-ENCODING: [0x78,0x4c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064c78 + +mova {z0.d - z3.d}, za.d[w8, 4, vgx4] // 11000000-00000110-00001100-10000000 +// CHECK-INST: mov { z0.d - z3.d }, za.d[w8, 4, vgx4] +// CHECK-ENCODING: [0x80,0x0c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060c80 + +mova {z0.d - z3.d}, za.d[w8, 4] // 11000000-00000110-00001100-10000000 +// CHECK-INST: mov { z0.d - z3.d }, za.d[w8, 4, vgx4] +// CHECK-ENCODING: [0x80,0x0c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060c80 + +mova {z16.d - z19.d}, za.d[w10, 1, vgx4] // 11000000-00000110-01001100-00110000 +// CHECK-INST: mov { z16.d - z19.d }, za.d[w10, 1, vgx4] +// CHECK-ENCODING: [0x30,0x4c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064c30 + +mova {z16.d - z19.d}, za.d[w10, 1] // 11000000-00000110-01001100-00110000 +// CHECK-INST: mov { z16.d - z19.d }, za.d[w10, 1, vgx4] +// CHECK-ENCODING: [0x30,0x4c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064c30 + +mova {z28.d - z31.d}, za.d[w8, 6, vgx4] // 11000000-00000110-00001100-11011100 +// CHECK-INST: mov { z28.d - z31.d }, za.d[w8, 6, vgx4] +// CHECK-ENCODING: [0xdc,0x0c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060cdc + +mova {z28.d - z31.d}, za.d[w8, 6] // 11000000-00000110-00001100-11011100 +// CHECK-INST: mov { z28.d - z31.d }, za.d[w8, 6, vgx4] +// CHECK-ENCODING: [0xdc,0x0c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060cdc + +mova {z0.d - z3.d}, za.d[w11, 1, vgx4] // 11000000-00000110-01101100-00100000 +// CHECK-INST: mov { z0.d - z3.d }, za.d[w11, 1, vgx4] +// CHECK-ENCODING: [0x20,0x6c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0066c20 + +mova {z0.d - z3.d}, za.d[w11, 1] // 11000000-00000110-01101100-00100000 +// CHECK-INST: mov { z0.d - z3.d }, za.d[w11, 1, vgx4] +// CHECK-ENCODING: [0x20,0x6c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0066c20 + +mova {z4.d - z7.d}, za.d[w9, 4, vgx4] // 11000000-00000110-00101100-10000100 +// CHECK-INST: mov { z4.d - z7.d }, za.d[w9, 4, vgx4] +// CHECK-ENCODING: [0x84,0x2c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0062c84 + +mova {z4.d - z7.d}, za.d[w9, 4] // 11000000-00000110-00101100-10000100 +// CHECK-INST: mov { z4.d - z7.d }, za.d[w9, 4, vgx4] +// CHECK-ENCODING: [0x84,0x2c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0062c84 + +// Aliases + +mov {z0.d - z3.d}, za.d[w8, 0, vgx4] // 11000000-00000110-00001100-00000000 +// CHECK-INST: mov { z0.d - z3.d }, za.d[w8, 0, vgx4] +// CHECK-ENCODING: [0x00,0x0c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060c00 + +mov {z20.d - z23.d}, za.d[w10, 2, vgx4] // 11000000-00000110-01001100-01010100 +// CHECK-INST: mov { z20.d - z23.d }, za.d[w10, 2, vgx4] +// CHECK-ENCODING: [0x54,0x4c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064c54 + +mov {z20.d - z23.d}, za.d[w11, 5, vgx4] // 11000000-00000110-01101100-10110100 +// CHECK-INST: mov { z20.d - z23.d }, za.d[w11, 5, vgx4] +// CHECK-ENCODING: [0xb4,0x6c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0066cb4 + +mov {z28.d - z31.d}, za.d[w11, 7, vgx4] // 11000000-00000110-01101100-11111100 +// CHECK-INST: mov { z28.d - z31.d }, za.d[w11, 7, vgx4] +// CHECK-ENCODING: [0xfc,0x6c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0066cfc + +mov {z4.d - z7.d}, za.d[w8, 1, vgx4] // 11000000-00000110-00001100-00100100 +// CHECK-INST: mov { z4.d - z7.d }, za.d[w8, 1, vgx4] +// CHECK-ENCODING: [0x24,0x0c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060c24 + +mov {z0.d - z3.d}, za.d[w8, 1, vgx4] // 11000000-00000110-00001100-00100000 +// CHECK-INST: mov { z0.d - z3.d }, za.d[w8, 1, vgx4] +// CHECK-ENCODING: [0x20,0x0c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060c20 + +mov {z24.d - z27.d}, za.d[w10, 3, vgx4] // 11000000-00000110-01001100-01111000 +// CHECK-INST: mov { z24.d - z27.d }, za.d[w10, 3, vgx4] +// CHECK-ENCODING: [0x78,0x4c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064c78 + +mov {z0.d - z3.d}, za.d[w8, 4, vgx4] // 11000000-00000110-00001100-10000000 +// CHECK-INST: mov { z0.d - z3.d }, za.d[w8, 4, vgx4] +// CHECK-ENCODING: [0x80,0x0c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060c80 + +mov {z16.d - z19.d}, za.d[w10, 1, vgx4] // 11000000-00000110-01001100-00110000 +// CHECK-INST: mov { z16.d - z19.d }, za.d[w10, 1, vgx4] +// CHECK-ENCODING: [0x30,0x4c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064c30 + +mov {z28.d - z31.d}, za.d[w8, 6, vgx4] // 11000000-00000110-00001100-11011100 +// CHECK-INST: mov { z28.d - z31.d }, za.d[w8, 6, vgx4] +// CHECK-ENCODING: [0xdc,0x0c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060cdc + +mov {z0.d - z3.d}, za.d[w11, 1, vgx4] // 11000000-00000110-01101100-00100000 +// CHECK-INST: mov { z0.d - z3.d }, za.d[w11, 1, vgx4] +// CHECK-ENCODING: [0x20,0x6c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0066c20 + +mov {z4.d - z7.d}, za.d[w9, 4, vgx4] // 11000000-00000110-00101100-10000100 +// CHECK-INST: mov { z4.d - z7.d }, za.d[w9, 4, vgx4] +// CHECK-ENCODING: [0x84,0x2c,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0062c84 + + +mova za0h.d[w12, 0:3], {z0.d - z3.d} // 11000000-11000100-00000100-00000000 +// CHECK-INST: mov za0h.d[w12, 0:3], { z0.d - z3.d } +// CHECK-ENCODING: [0x00,0x04,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c40400 + +mova za5h.d[w14, 0:3], {z8.d - z11.d} // 11000000-11000100-01000101-00000101 +// CHECK-INST: mov za5h.d[w14, 0:3], { z8.d - z11.d } +// CHECK-ENCODING: [0x05,0x45,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c44505 + +mova za7h.d[w15, 0:3], {z12.d - z15.d} // 11000000-11000100-01100101-10000111 +// CHECK-INST: mov za7h.d[w15, 0:3], { z12.d - z15.d } +// CHECK-ENCODING: [0x87,0x65,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c46587 + +mova za7h.d[w15, 0:3], {z28.d - z31.d} // 11000000-11000100-01100111-10000111 +// CHECK-INST: mov za7h.d[w15, 0:3], { z28.d - z31.d } +// CHECK-ENCODING: [0x87,0x67,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c46787 + +mova za5h.d[w12, 0:3], {z16.d - z19.d} // 11000000-11000100-00000110-00000101 +// CHECK-INST: mov za5h.d[w12, 0:3], { z16.d - z19.d } +// CHECK-ENCODING: [0x05,0x06,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c40605 + +mova za1h.d[w12, 0:3], {z0.d - z3.d} // 11000000-11000100-00000100-00000001 +// CHECK-INST: mov za1h.d[w12, 0:3], { z0.d - z3.d } +// CHECK-ENCODING: [0x01,0x04,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c40401 + +mova za0h.d[w14, 0:3], {z16.d - z19.d} // 11000000-11000100-01000110-00000000 +// CHECK-INST: mov za0h.d[w14, 0:3], { z16.d - z19.d } +// CHECK-ENCODING: [0x00,0x46,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c44600 + +mova za0h.d[w12, 0:3], {z12.d - z15.d} // 11000000-11000100-00000101-10000000 +// CHECK-INST: mov za0h.d[w12, 0:3], { z12.d - z15.d } +// CHECK-ENCODING: [0x80,0x05,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c40580 + +mova za1h.d[w14, 0:3], {z0.d - z3.d} // 11000000-11000100-01000100-00000001 +// CHECK-INST: mov za1h.d[w14, 0:3], { z0.d - z3.d } +// CHECK-ENCODING: [0x01,0x44,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c44401 + +mova za5h.d[w12, 0:3], {z20.d - z23.d} // 11000000-11000100-00000110-10000101 +// CHECK-INST: mov za5h.d[w12, 0:3], { z20.d - z23.d } +// CHECK-ENCODING: [0x85,0x06,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c40685 + +mova za2h.d[w15, 0:3], {z8.d - z11.d} // 11000000-11000100-01100101-00000010 +// CHECK-INST: mov za2h.d[w15, 0:3], { z8.d - z11.d } +// CHECK-ENCODING: [0x02,0x65,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c46502 + +mova za7h.d[w13, 0:3], {z12.d - z15.d} // 11000000-11000100-00100101-10000111 +// CHECK-INST: mov za7h.d[w13, 0:3], { z12.d - z15.d } +// CHECK-ENCODING: [0x87,0x25,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c42587 + +// Aliases + +mov za0h.d[w12, 0:3], {z0.d - z3.d} // 11000000-11000100-00000100-00000000 +// CHECK-INST: mov za0h.d[w12, 0:3], { z0.d - z3.d } +// CHECK-ENCODING: [0x00,0x04,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c40400 + +mov za5h.d[w14, 0:3], {z8.d - z11.d} // 11000000-11000100-01000101-00000101 +// CHECK-INST: mov za5h.d[w14, 0:3], { z8.d - z11.d } +// CHECK-ENCODING: [0x05,0x45,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c44505 + +mov za7h.d[w15, 0:3], {z12.d - z15.d} // 11000000-11000100-01100101-10000111 +// CHECK-INST: mov za7h.d[w15, 0:3], { z12.d - z15.d } +// CHECK-ENCODING: [0x87,0x65,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c46587 + +mov za7h.d[w15, 0:3], {z28.d - z31.d} // 11000000-11000100-01100111-10000111 +// CHECK-INST: mov za7h.d[w15, 0:3], { z28.d - z31.d } +// CHECK-ENCODING: [0x87,0x67,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c46787 + +mov za5h.d[w12, 0:3], {z16.d - z19.d} // 11000000-11000100-00000110-00000101 +// CHECK-INST: mov za5h.d[w12, 0:3], { z16.d - z19.d } +// CHECK-ENCODING: [0x05,0x06,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c40605 + +mov za1h.d[w12, 0:3], {z0.d - z3.d} // 11000000-11000100-00000100-00000001 +// CHECK-INST: mov za1h.d[w12, 0:3], { z0.d - z3.d } +// CHECK-ENCODING: [0x01,0x04,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c40401 + +mov za0h.d[w14, 0:3], {z16.d - z19.d} // 11000000-11000100-01000110-00000000 +// CHECK-INST: mov za0h.d[w14, 0:3], { z16.d - z19.d } +// CHECK-ENCODING: [0x00,0x46,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c44600 + +mov za0h.d[w12, 0:3], {z12.d - z15.d} // 11000000-11000100-00000101-10000000 +// CHECK-INST: mov za0h.d[w12, 0:3], { z12.d - z15.d } +// CHECK-ENCODING: [0x80,0x05,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c40580 + +mov za1h.d[w14, 0:3], {z0.d - z3.d} // 11000000-11000100-01000100-00000001 +// CHECK-INST: mov za1h.d[w14, 0:3], { z0.d - z3.d } +// CHECK-ENCODING: [0x01,0x44,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c44401 + +mov za5h.d[w12, 0:3], {z20.d - z23.d} // 11000000-11000100-00000110-10000101 +// CHECK-INST: mov za5h.d[w12, 0:3], { z20.d - z23.d } +// CHECK-ENCODING: [0x85,0x06,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c40685 + +mov za2h.d[w15, 0:3], {z8.d - z11.d} // 11000000-11000100-01100101-00000010 +// CHECK-INST: mov za2h.d[w15, 0:3], { z8.d - z11.d } +// CHECK-ENCODING: [0x02,0x65,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c46502 + +mov za7h.d[w13, 0:3], {z12.d - z15.d} // 11000000-11000100-00100101-10000111 +// CHECK-INST: mov za7h.d[w13, 0:3], { z12.d - z15.d } +// CHECK-ENCODING: [0x87,0x25,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c42587 + + +mova za0v.d[w12, 0:3], {z0.d - z3.d} // 11000000-11000100-10000100-00000000 +// CHECK-INST: mov za0v.d[w12, 0:3], { z0.d - z3.d } +// CHECK-ENCODING: [0x00,0x84,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c48400 + +mova za5v.d[w14, 0:3], {z8.d - z11.d} // 11000000-11000100-11000101-00000101 +// CHECK-INST: mov za5v.d[w14, 0:3], { z8.d - z11.d } +// CHECK-ENCODING: [0x05,0xc5,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4c505 + +mova za7v.d[w15, 0:3], {z12.d - z15.d} // 11000000-11000100-11100101-10000111 +// CHECK-INST: mov za7v.d[w15, 0:3], { z12.d - z15.d } +// CHECK-ENCODING: [0x87,0xe5,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4e587 + +mova za7v.d[w15, 0:3], {z28.d - z31.d} // 11000000-11000100-11100111-10000111 +// CHECK-INST: mov za7v.d[w15, 0:3], { z28.d - z31.d } +// CHECK-ENCODING: [0x87,0xe7,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4e787 + +mova za5v.d[w12, 0:3], {z16.d - z19.d} // 11000000-11000100-10000110-00000101 +// CHECK-INST: mov za5v.d[w12, 0:3], { z16.d - z19.d } +// CHECK-ENCODING: [0x05,0x86,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c48605 + +mova za1v.d[w12, 0:3], {z0.d - z3.d} // 11000000-11000100-10000100-00000001 +// CHECK-INST: mov za1v.d[w12, 0:3], { z0.d - z3.d } +// CHECK-ENCODING: [0x01,0x84,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c48401 + +mova za0v.d[w14, 0:3], {z16.d - z19.d} // 11000000-11000100-11000110-00000000 +// CHECK-INST: mov za0v.d[w14, 0:3], { z16.d - z19.d } +// CHECK-ENCODING: [0x00,0xc6,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4c600 + +mova za0v.d[w12, 0:3], {z12.d - z15.d} // 11000000-11000100-10000101-10000000 +// CHECK-INST: mov za0v.d[w12, 0:3], { z12.d - z15.d } +// CHECK-ENCODING: [0x80,0x85,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c48580 + +mova za1v.d[w14, 0:3], {z0.d - z3.d} // 11000000-11000100-11000100-00000001 +// CHECK-INST: mov za1v.d[w14, 0:3], { z0.d - z3.d } +// CHECK-ENCODING: [0x01,0xc4,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4c401 + +mova za5v.d[w12, 0:3], {z20.d - z23.d} // 11000000-11000100-10000110-10000101 +// CHECK-INST: mov za5v.d[w12, 0:3], { z20.d - z23.d } +// CHECK-ENCODING: [0x85,0x86,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c48685 + +mova za2v.d[w15, 0:3], {z8.d - z11.d} // 11000000-11000100-11100101-00000010 +// CHECK-INST: mov za2v.d[w15, 0:3], { z8.d - z11.d } +// CHECK-ENCODING: [0x02,0xe5,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4e502 + +mova za7v.d[w13, 0:3], {z12.d - z15.d} // 11000000-11000100-10100101-10000111 +// CHECK-INST: mov za7v.d[w13, 0:3], { z12.d - z15.d } +// CHECK-ENCODING: [0x87,0xa5,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4a587 + +// Aliases + +mov za0v.d[w12, 0:3], {z0.d - z3.d} // 11000000-11000100-10000100-00000000 +// CHECK-INST: mov za0v.d[w12, 0:3], { z0.d - z3.d } +// CHECK-ENCODING: [0x00,0x84,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c48400 + +mov za5v.d[w14, 0:3], {z8.d - z11.d} // 11000000-11000100-11000101-00000101 +// CHECK-INST: mov za5v.d[w14, 0:3], { z8.d - z11.d } +// CHECK-ENCODING: [0x05,0xc5,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4c505 + +mov za7v.d[w15, 0:3], {z12.d - z15.d} // 11000000-11000100-11100101-10000111 +// CHECK-INST: mov za7v.d[w15, 0:3], { z12.d - z15.d } +// CHECK-ENCODING: [0x87,0xe5,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4e587 + +mov za7v.d[w15, 0:3], {z28.d - z31.d} // 11000000-11000100-11100111-10000111 +// CHECK-INST: mov za7v.d[w15, 0:3], { z28.d - z31.d } +// CHECK-ENCODING: [0x87,0xe7,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4e787 + +mov za5v.d[w12, 0:3], {z16.d - z19.d} // 11000000-11000100-10000110-00000101 +// CHECK-INST: mov za5v.d[w12, 0:3], { z16.d - z19.d } +// CHECK-ENCODING: [0x05,0x86,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c48605 + +mov za1v.d[w12, 0:3], {z0.d - z3.d} // 11000000-11000100-10000100-00000001 +// CHECK-INST: mov za1v.d[w12, 0:3], { z0.d - z3.d } +// CHECK-ENCODING: [0x01,0x84,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c48401 + +mov za0v.d[w14, 0:3], {z16.d - z19.d} // 11000000-11000100-11000110-00000000 +// CHECK-INST: mov za0v.d[w14, 0:3], { z16.d - z19.d } +// CHECK-ENCODING: [0x00,0xc6,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4c600 + +mov za0v.d[w12, 0:3], {z12.d - z15.d} // 11000000-11000100-10000101-10000000 +// CHECK-INST: mov za0v.d[w12, 0:3], { z12.d - z15.d } +// CHECK-ENCODING: [0x80,0x85,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c48580 + +mov za1v.d[w14, 0:3], {z0.d - z3.d} // 11000000-11000100-11000100-00000001 +// CHECK-INST: mov za1v.d[w14, 0:3], { z0.d - z3.d } +// CHECK-ENCODING: [0x01,0xc4,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4c401 + +mov za5v.d[w12, 0:3], {z20.d - z23.d} // 11000000-11000100-10000110-10000101 +// CHECK-INST: mov za5v.d[w12, 0:3], { z20.d - z23.d } +// CHECK-ENCODING: [0x85,0x86,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c48685 + +mov za2v.d[w15, 0:3], {z8.d - z11.d} // 11000000-11000100-11100101-00000010 +// CHECK-INST: mov za2v.d[w15, 0:3], { z8.d - z11.d } +// CHECK-ENCODING: [0x02,0xe5,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4e502 + +mov za7v.d[w13, 0:3], {z12.d - z15.d} // 11000000-11000100-10100101-10000111 +// CHECK-INST: mov za7v.d[w13, 0:3], { z12.d - z15.d } +// CHECK-ENCODING: [0x87,0xa5,0xc4,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0c4a587 + + +mova za.d[w8, 0, vgx4], {z0.d - z3.d} // 11000000-00000100-00001100-00000000 +// CHECK-INST: mov za.d[w8, 0, vgx4], { z0.d - z3.d } +// CHECK-ENCODING: [0x00,0x0c,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040c00 + +mova za.d[w8, 0], {z0.d - z3.d} // 11000000-00000100-00001100-00000000 +// CHECK-INST: mov za.d[w8, 0, vgx4], { z0.d - z3.d } +// CHECK-ENCODING: [0x00,0x0c,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040c00 + +mova za.d[w10, 5, vgx4], {z8.d - z11.d} // 11000000-00000100-01001101-00000101 +// CHECK-INST: mov za.d[w10, 5, vgx4], { z8.d - z11.d } +// CHECK-ENCODING: [0x05,0x4d,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044d05 + +mova za.d[w10, 5], {z8.d - z11.d} // 11000000-00000100-01001101-00000101 +// CHECK-INST: mov za.d[w10, 5, vgx4], { z8.d - z11.d } +// CHECK-ENCODING: [0x05,0x4d,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044d05 + +mova za.d[w11, 7, vgx4], {z12.d - z15.d} // 11000000-00000100-01101101-10000111 +// CHECK-INST: mov za.d[w11, 7, vgx4], { z12.d - z15.d } +// CHECK-ENCODING: [0x87,0x6d,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046d87 + +mova za.d[w11, 7], {z12.d - z15.d} // 11000000-00000100-01101101-10000111 +// CHECK-INST: mov za.d[w11, 7, vgx4], { z12.d - z15.d } +// CHECK-ENCODING: [0x87,0x6d,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046d87 + +mova za.d[w11, 7, vgx4], {z28.d - z31.d} // 11000000-00000100-01101111-10000111 +// CHECK-INST: mov za.d[w11, 7, vgx4], { z28.d - z31.d } +// CHECK-ENCODING: [0x87,0x6f,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046f87 + +mova za.d[w11, 7], {z28.d - z31.d} // 11000000-00000100-01101111-10000111 +// CHECK-INST: mov za.d[w11, 7, vgx4], { z28.d - z31.d } +// CHECK-ENCODING: [0x87,0x6f,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046f87 + +mova za.d[w8, 5, vgx4], {z16.d - z19.d} // 11000000-00000100-00001110-00000101 +// CHECK-INST: mov za.d[w8, 5, vgx4], { z16.d - z19.d } +// CHECK-ENCODING: [0x05,0x0e,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040e05 + +mova za.d[w8, 5], {z16.d - z19.d} // 11000000-00000100-00001110-00000101 +// CHECK-INST: mov za.d[w8, 5, vgx4], { z16.d - z19.d } +// CHECK-ENCODING: [0x05,0x0e,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040e05 + +mova za.d[w8, 1, vgx4], {z0.d - z3.d} // 11000000-00000100-00001100-00000001 +// CHECK-INST: mov za.d[w8, 1, vgx4], { z0.d - z3.d } +// CHECK-ENCODING: [0x01,0x0c,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040c01 + +mova za.d[w8, 1], {z0.d - z3.d} // 11000000-00000100-00001100-00000001 +// CHECK-INST: mov za.d[w8, 1, vgx4], { z0.d - z3.d } +// CHECK-ENCODING: [0x01,0x0c,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040c01 + +mova za.d[w10, 0, vgx4], {z16.d - z19.d} // 11000000-00000100-01001110-00000000 +// CHECK-INST: mov za.d[w10, 0, vgx4], { z16.d - z19.d } +// CHECK-ENCODING: [0x00,0x4e,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044e00 + +mova za.d[w10, 0], {z16.d - z19.d} // 11000000-00000100-01001110-00000000 +// CHECK-INST: mov za.d[w10, 0, vgx4], { z16.d - z19.d } +// CHECK-ENCODING: [0x00,0x4e,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044e00 + +mova za.d[w8, 0, vgx4], {z12.d - z15.d} // 11000000-00000100-00001101-10000000 +// CHECK-INST: mov za.d[w8, 0, vgx4], { z12.d - z15.d } +// CHECK-ENCODING: [0x80,0x0d,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040d80 + +mova za.d[w8, 0], {z12.d - z15.d} // 11000000-00000100-00001101-10000000 +// CHECK-INST: mov za.d[w8, 0, vgx4], { z12.d - z15.d } +// CHECK-ENCODING: [0x80,0x0d,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040d80 + +mova za.d[w10, 1, vgx4], {z0.d - z3.d} // 11000000-00000100-01001100-00000001 +// CHECK-INST: mov za.d[w10, 1, vgx4], { z0.d - z3.d } +// CHECK-ENCODING: [0x01,0x4c,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044c01 + +mova za.d[w10, 1], {z0.d - z3.d} // 11000000-00000100-01001100-00000001 +// CHECK-INST: mov za.d[w10, 1, vgx4], { z0.d - z3.d } +// CHECK-ENCODING: [0x01,0x4c,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044c01 + +mova za.d[w8, 5, vgx4], {z20.d - z23.d} // 11000000-00000100-00001110-10000101 +// CHECK-INST: mov za.d[w8, 5, vgx4], { z20.d - z23.d } +// CHECK-ENCODING: [0x85,0x0e,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040e85 + +mova za.d[w8, 5], {z20.d - z23.d} // 11000000-00000100-00001110-10000101 +// CHECK-INST: mov za.d[w8, 5, vgx4], { z20.d - z23.d } +// CHECK-ENCODING: [0x85,0x0e,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040e85 + +mova za.d[w11, 2, vgx4], {z8.d - z11.d} // 11000000-00000100-01101101-00000010 +// CHECK-INST: mov za.d[w11, 2, vgx4], { z8.d - z11.d } +// CHECK-ENCODING: [0x02,0x6d,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046d02 + +mova za.d[w11, 2], {z8.d - z11.d} // 11000000-00000100-01101101-00000010 +// CHECK-INST: mov za.d[w11, 2, vgx4], { z8.d - z11.d } +// CHECK-ENCODING: [0x02,0x6d,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046d02 + +mova za.d[w9, 7, vgx4], {z12.d - z15.d} // 11000000-00000100-00101101-10000111 +// CHECK-INST: mov za.d[w9, 7, vgx4], { z12.d - z15.d } +// CHECK-ENCODING: [0x87,0x2d,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0042d87 + +mova za.d[w9, 7], {z12.d - z15.d} // 11000000-00000100-00101101-10000111 +// CHECK-INST: mov za.d[w9, 7, vgx4], { z12.d - z15.d } +// CHECK-ENCODING: [0x87,0x2d,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0042d87 + +// Aliases + +mov za.d[w8, 0, vgx4], {z0.d - z3.d} // 11000000-00000100-00001100-00000000 +// CHECK-INST: mov za.d[w8, 0, vgx4], { z0.d - z3.d } +// CHECK-ENCODING: [0x00,0x0c,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040c00 + +mov za.d[w10, 5, vgx4], {z8.d - z11.d} // 11000000-00000100-01001101-00000101 +// CHECK-INST: mov za.d[w10, 5, vgx4], { z8.d - z11.d } +// CHECK-ENCODING: [0x05,0x4d,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044d05 + +mov za.d[w11, 7, vgx4], {z12.d - z15.d} // 11000000-00000100-01101101-10000111 +// CHECK-INST: mov za.d[w11, 7, vgx4], { z12.d - z15.d } +// CHECK-ENCODING: [0x87,0x6d,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046d87 + +mov za.d[w11, 7, vgx4], {z28.d - z31.d} // 11000000-00000100-01101111-10000111 +// CHECK-INST: mov za.d[w11, 7, vgx4], { z28.d - z31.d } +// CHECK-ENCODING: [0x87,0x6f,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046f87 + +mov za.d[w8, 5, vgx4], {z16.d - z19.d} // 11000000-00000100-00001110-00000101 +// CHECK-INST: mov za.d[w8, 5, vgx4], { z16.d - z19.d } +// CHECK-ENCODING: [0x05,0x0e,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040e05 + +mov za.d[w8, 1, vgx4], {z0.d - z3.d} // 11000000-00000100-00001100-00000001 +// CHECK-INST: mov za.d[w8, 1, vgx4], { z0.d - z3.d } +// CHECK-ENCODING: [0x01,0x0c,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040c01 + +mov za.d[w10, 0, vgx4], {z16.d - z19.d} // 11000000-00000100-01001110-00000000 +// CHECK-INST: mov za.d[w10, 0, vgx4], { z16.d - z19.d } +// CHECK-ENCODING: [0x00,0x4e,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044e00 + +mov za.d[w8, 0, vgx4], {z12.d - z15.d} // 11000000-00000100-00001101-10000000 +// CHECK-INST: mov za.d[w8, 0, vgx4], { z12.d - z15.d } +// CHECK-ENCODING: [0x80,0x0d,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040d80 + +mov za.d[w10, 1, vgx4], {z0.d - z3.d} // 11000000-00000100-01001100-00000001 +// CHECK-INST: mov za.d[w10, 1, vgx4], { z0.d - z3.d } +// CHECK-ENCODING: [0x01,0x4c,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044c01 + +mov za.d[w8, 5, vgx4], {z20.d - z23.d} // 11000000-00000100-00001110-10000101 +// CHECK-INST: mov za.d[w8, 5, vgx4], { z20.d - z23.d } +// CHECK-ENCODING: [0x85,0x0e,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040e85 + +mov za.d[w11, 2, vgx4], {z8.d - z11.d} // 11000000-00000100-01101101-00000010 +// CHECK-INST: mov za.d[w11, 2, vgx4], { z8.d - z11.d } +// CHECK-ENCODING: [0x02,0x6d,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046d02 + +mov za.d[w9, 7, vgx4], {z12.d - z15.d} // 11000000-00000100-00101101-10000111 +// CHECK-INST: mov za.d[w9, 7, vgx4], { z12.d - z15.d } +// CHECK-ENCODING: [0x87,0x2d,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0042d87 + + +mova {z0.b - z3.b}, za0h.b[w12, 0:3] // 11000000-00000110-00000100-00000000 +// CHECK-INST: mov { z0.b - z3.b }, za0h.b[w12, 0:3] +// CHECK-ENCODING: [0x00,0x04,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060400 + +mova {z20.b - z23.b}, za0h.b[w14, 8:11] // 11000000-00000110-01000100-01010100 +// CHECK-INST: mov { z20.b - z23.b }, za0h.b[w14, 8:11] +// CHECK-ENCODING: [0x54,0x44,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064454 + +mova {z20.b - z23.b}, za0h.b[w15, 4:7] // 11000000-00000110-01100100-00110100 +// CHECK-INST: mov { z20.b - z23.b }, za0h.b[w15, 4:7] +// CHECK-ENCODING: [0x34,0x64,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0066434 + +mova {z28.b - z31.b}, za0h.b[w15, 12:15] // 11000000-00000110-01100100-01111100 +// CHECK-INST: mov { z28.b - z31.b }, za0h.b[w15, 12:15] +// CHECK-ENCODING: [0x7c,0x64,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006647c + +mova {z4.b - z7.b}, za0h.b[w12, 4:7] // 11000000-00000110-00000100-00100100 +// CHECK-INST: mov { z4.b - z7.b }, za0h.b[w12, 4:7] +// CHECK-ENCODING: [0x24,0x04,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060424 + +mova {z0.b - z3.b}, za0h.b[w12, 4:7] // 11000000-00000110-00000100-00100000 +// CHECK-INST: mov { z0.b - z3.b }, za0h.b[w12, 4:7] +// CHECK-ENCODING: [0x20,0x04,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060420 + +mova {z24.b - z27.b}, za0h.b[w14, 12:15] // 11000000-00000110-01000100-01111000 +// CHECK-INST: mov { z24.b - z27.b }, za0h.b[w14, 12:15] +// CHECK-ENCODING: [0x78,0x44,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064478 + +mova {z16.b - z19.b}, za0h.b[w14, 4:7] // 11000000-00000110-01000100-00110000 +// CHECK-INST: mov { z16.b - z19.b }, za0h.b[w14, 4:7] +// CHECK-ENCODING: [0x30,0x44,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064430 + +mova {z28.b - z31.b}, za0h.b[w12, 8:11] // 11000000-00000110-00000100-01011100 +// CHECK-INST: mov { z28.b - z31.b }, za0h.b[w12, 8:11] +// CHECK-ENCODING: [0x5c,0x04,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006045c + +mova {z0.b - z3.b}, za0h.b[w15, 4:7] // 11000000-00000110-01100100-00100000 +// CHECK-INST: mov { z0.b - z3.b }, za0h.b[w15, 4:7] +// CHECK-ENCODING: [0x20,0x64,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0066420 + +mova {z4.b - z7.b}, za0h.b[w13, 0:3] // 11000000-00000110-00100100-00000100 +// CHECK-INST: mov { z4.b - z7.b }, za0h.b[w13, 0:3] +// CHECK-ENCODING: [0x04,0x24,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0062404 + +// Aliases + +mov {z0.b - z3.b}, za0h.b[w12, 0:3] // 11000000-00000110-00000100-00000000 +// CHECK-INST: mov { z0.b - z3.b }, za0h.b[w12, 0:3] +// CHECK-ENCODING: [0x00,0x04,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060400 + +mov {z20.b - z23.b}, za0h.b[w14, 8:11] // 11000000-00000110-01000100-01010100 +// CHECK-INST: mov { z20.b - z23.b }, za0h.b[w14, 8:11] +// CHECK-ENCODING: [0x54,0x44,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064454 + +mov {z20.b - z23.b}, za0h.b[w15, 4:7] // 11000000-00000110-01100100-00110100 +// CHECK-INST: mov { z20.b - z23.b }, za0h.b[w15, 4:7] +// CHECK-ENCODING: [0x34,0x64,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0066434 + +mov {z28.b - z31.b}, za0h.b[w15, 12:15] // 11000000-00000110-01100100-01111100 +// CHECK-INST: mov { z28.b - z31.b }, za0h.b[w15, 12:15] +// CHECK-ENCODING: [0x7c,0x64,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006647c + +mov {z4.b - z7.b}, za0h.b[w12, 4:7] // 11000000-00000110-00000100-00100100 +// CHECK-INST: mov { z4.b - z7.b }, za0h.b[w12, 4:7] +// CHECK-ENCODING: [0x24,0x04,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060424 + +mov {z0.b - z3.b}, za0h.b[w12, 4:7] // 11000000-00000110-00000100-00100000 +// CHECK-INST: mov { z0.b - z3.b }, za0h.b[w12, 4:7] +// CHECK-ENCODING: [0x20,0x04,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0060420 + +mov {z24.b - z27.b}, za0h.b[w14, 12:15] // 11000000-00000110-01000100-01111000 +// CHECK-INST: mov { z24.b - z27.b }, za0h.b[w14, 12:15] +// CHECK-ENCODING: [0x78,0x44,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064478 + +mov {z16.b - z19.b}, za0h.b[w14, 4:7] // 11000000-00000110-01000100-00110000 +// CHECK-INST: mov { z16.b - z19.b }, za0h.b[w14, 4:7] +// CHECK-ENCODING: [0x30,0x44,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0064430 + +mov {z28.b - z31.b}, za0h.b[w12, 8:11] // 11000000-00000110-00000100-01011100 +// CHECK-INST: mov { z28.b - z31.b }, za0h.b[w12, 8:11] +// CHECK-ENCODING: [0x5c,0x04,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006045c + +mov {z0.b - z3.b}, za0h.b[w15, 4:7] // 11000000-00000110-01100100-00100000 +// CHECK-INST: mov { z0.b - z3.b }, za0h.b[w15, 4:7] +// CHECK-ENCODING: [0x20,0x64,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0066420 + +mov {z4.b - z7.b}, za0h.b[w13, 0:3] // 11000000-00000110-00100100-00000100 +// CHECK-INST: mov { z4.b - z7.b }, za0h.b[w13, 0:3] +// CHECK-ENCODING: [0x04,0x24,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0062404 + + +mova {z0.b - z3.b}, za0v.b[w12, 0:3] // 11000000-00000110-10000100-00000000 +// CHECK-INST: mov { z0.b - z3.b }, za0v.b[w12, 0:3] +// CHECK-ENCODING: [0x00,0x84,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0068400 + +mova {z20.b - z23.b}, za0v.b[w14, 8:11] // 11000000-00000110-11000100-01010100 +// CHECK-INST: mov { z20.b - z23.b }, za0v.b[w14, 8:11] +// CHECK-ENCODING: [0x54,0xc4,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006c454 + +mova {z20.b - z23.b}, za0v.b[w15, 4:7] // 11000000-00000110-11100100-00110100 +// CHECK-INST: mov { z20.b - z23.b }, za0v.b[w15, 4:7] +// CHECK-ENCODING: [0x34,0xe4,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006e434 + +mova {z28.b - z31.b}, za0v.b[w15, 12:15] // 11000000-00000110-11100100-01111100 +// CHECK-INST: mov { z28.b - z31.b }, za0v.b[w15, 12:15] +// CHECK-ENCODING: [0x7c,0xe4,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006e47c + +mova {z4.b - z7.b}, za0v.b[w12, 4:7] // 11000000-00000110-10000100-00100100 +// CHECK-INST: mov { z4.b - z7.b }, za0v.b[w12, 4:7] +// CHECK-ENCODING: [0x24,0x84,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0068424 + +mova {z0.b - z3.b}, za0v.b[w12, 4:7] // 11000000-00000110-10000100-00100000 +// CHECK-INST: mov { z0.b - z3.b }, za0v.b[w12, 4:7] +// CHECK-ENCODING: [0x20,0x84,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0068420 + +mova {z24.b - z27.b}, za0v.b[w14, 12:15] // 11000000-00000110-11000100-01111000 +// CHECK-INST: mov { z24.b - z27.b }, za0v.b[w14, 12:15] +// CHECK-ENCODING: [0x78,0xc4,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006c478 + +mova {z16.b - z19.b}, za0v.b[w14, 4:7] // 11000000-00000110-11000100-00110000 +// CHECK-INST: mov { z16.b - z19.b }, za0v.b[w14, 4:7] +// CHECK-ENCODING: [0x30,0xc4,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006c430 + +mova {z28.b - z31.b}, za0v.b[w12, 8:11] // 11000000-00000110-10000100-01011100 +// CHECK-INST: mov { z28.b - z31.b }, za0v.b[w12, 8:11] +// CHECK-ENCODING: [0x5c,0x84,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006845c + +mova {z0.b - z3.b}, za0v.b[w15, 4:7] // 11000000-00000110-11100100-00100000 +// CHECK-INST: mov { z0.b - z3.b }, za0v.b[w15, 4:7] +// CHECK-ENCODING: [0x20,0xe4,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006e420 + +mova {z4.b - z7.b}, za0v.b[w13, 0:3] // 11000000-00000110-10100100-00000100 +// CHECK-INST: mov { z4.b - z7.b }, za0v.b[w13, 0:3] +// CHECK-ENCODING: [0x04,0xa4,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006a404 + +// Aliases + +mov {z0.b - z3.b}, za0v.b[w12, 0:3] // 11000000-00000110-10000100-00000000 +// CHECK-INST: mov { z0.b - z3.b }, za0v.b[w12, 0:3] +// CHECK-ENCODING: [0x00,0x84,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0068400 + +mov {z20.b - z23.b}, za0v.b[w14, 8:11] // 11000000-00000110-11000100-01010100 +// CHECK-INST: mov { z20.b - z23.b }, za0v.b[w14, 8:11] +// CHECK-ENCODING: [0x54,0xc4,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006c454 + +mov {z20.b - z23.b}, za0v.b[w15, 4:7] // 11000000-00000110-11100100-00110100 +// CHECK-INST: mov { z20.b - z23.b }, za0v.b[w15, 4:7] +// CHECK-ENCODING: [0x34,0xe4,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006e434 + +mov {z28.b - z31.b}, za0v.b[w15, 12:15] // 11000000-00000110-11100100-01111100 +// CHECK-INST: mov { z28.b - z31.b }, za0v.b[w15, 12:15] +// CHECK-ENCODING: [0x7c,0xe4,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006e47c + +mov {z4.b - z7.b}, za0v.b[w12, 4:7] // 11000000-00000110-10000100-00100100 +// CHECK-INST: mov { z4.b - z7.b }, za0v.b[w12, 4:7] +// CHECK-ENCODING: [0x24,0x84,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0068424 + +mov {z0.b - z3.b}, za0v.b[w12, 4:7] // 11000000-00000110-10000100-00100000 +// CHECK-INST: mov { z0.b - z3.b }, za0v.b[w12, 4:7] +// CHECK-ENCODING: [0x20,0x84,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0068420 + +mov {z24.b - z27.b}, za0v.b[w14, 12:15] // 11000000-00000110-11000100-01111000 +// CHECK-INST: mov { z24.b - z27.b }, za0v.b[w14, 12:15] +// CHECK-ENCODING: [0x78,0xc4,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006c478 + +mov {z16.b - z19.b}, za0v.b[w14, 4:7] // 11000000-00000110-11000100-00110000 +// CHECK-INST: mov { z16.b - z19.b }, za0v.b[w14, 4:7] +// CHECK-ENCODING: [0x30,0xc4,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006c430 + +mov {z28.b - z31.b}, za0v.b[w12, 8:11] // 11000000-00000110-10000100-01011100 +// CHECK-INST: mov { z28.b - z31.b }, za0v.b[w12, 8:11] +// CHECK-ENCODING: [0x5c,0x84,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006845c + +mov {z0.b - z3.b}, za0v.b[w15, 4:7] // 11000000-00000110-11100100-00100000 +// CHECK-INST: mov { z0.b - z3.b }, za0v.b[w15, 4:7] +// CHECK-ENCODING: [0x20,0xe4,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006e420 + +mov {z4.b - z7.b}, za0v.b[w13, 0:3] // 11000000-00000110-10100100-00000100 +// CHECK-INST: mov { z4.b - z7.b }, za0v.b[w13, 0:3] +// CHECK-ENCODING: [0x04,0xa4,0x06,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c006a404 + + +mova za0h.b[w12, 0:3], {z0.b - z3.b} // 11000000-00000100-00000100-00000000 +// CHECK-INST: mov za0h.b[w12, 0:3], { z0.b - z3.b } +// CHECK-ENCODING: [0x00,0x04,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040400 + +mova za0h.b[w14, 4:7], {z8.b - z11.b} // 11000000-00000100-01000101-00000001 +// CHECK-INST: mov za0h.b[w14, 4:7], { z8.b - z11.b } +// CHECK-ENCODING: [0x01,0x45,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044501 + +mova za0h.b[w15, 12:15], {z12.b - z15.b} // 11000000-00000100-01100101-10000011 +// CHECK-INST: mov za0h.b[w15, 12:15], { z12.b - z15.b } +// CHECK-ENCODING: [0x83,0x65,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046583 + +mova za0h.b[w15, 12:15], {z28.b - z31.b} // 11000000-00000100-01100111-10000011 +// CHECK-INST: mov za0h.b[w15, 12:15], { z28.b - z31.b } +// CHECK-ENCODING: [0x83,0x67,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046783 + +mova za0h.b[w12, 4:7], {z16.b - z19.b} // 11000000-00000100-00000110-00000001 +// CHECK-INST: mov za0h.b[w12, 4:7], { z16.b - z19.b } +// CHECK-ENCODING: [0x01,0x06,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040601 + +mova za0h.b[w12, 4:7], {z0.b - z3.b} // 11000000-00000100-00000100-00000001 +// CHECK-INST: mov za0h.b[w12, 4:7], { z0.b - z3.b } +// CHECK-ENCODING: [0x01,0x04,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040401 + +mova za0h.b[w14, 0:3], {z16.b - z19.b} // 11000000-00000100-01000110-00000000 +// CHECK-INST: mov za0h.b[w14, 0:3], { z16.b - z19.b } +// CHECK-ENCODING: [0x00,0x46,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044600 + +mova za0h.b[w12, 0:3], {z12.b - z15.b} // 11000000-00000100-00000101-10000000 +// CHECK-INST: mov za0h.b[w12, 0:3], { z12.b - z15.b } +// CHECK-ENCODING: [0x80,0x05,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040580 + +mova za0h.b[w14, 4:7], {z0.b - z3.b} // 11000000-00000100-01000100-00000001 +// CHECK-INST: mov za0h.b[w14, 4:7], { z0.b - z3.b } +// CHECK-ENCODING: [0x01,0x44,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044401 + +mova za0h.b[w12, 4:7], {z20.b - z23.b} // 11000000-00000100-00000110-10000001 +// CHECK-INST: mov za0h.b[w12, 4:7], { z20.b - z23.b } +// CHECK-ENCODING: [0x81,0x06,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040681 + +mova za0h.b[w15, 8:11], {z8.b - z11.b} // 11000000-00000100-01100101-00000010 +// CHECK-INST: mov za0h.b[w15, 8:11], { z8.b - z11.b } +// CHECK-ENCODING: [0x02,0x65,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046502 + +mova za0h.b[w13, 12:15], {z12.b - z15.b} // 11000000-00000100-00100101-10000011 +// CHECK-INST: mov za0h.b[w13, 12:15], { z12.b - z15.b } +// CHECK-ENCODING: [0x83,0x25,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0042583 + +// Aliases + +mov za0h.b[w12, 0:3], {z0.b - z3.b} // 11000000-00000100-00000100-00000000 +// CHECK-INST: mov za0h.b[w12, 0:3], { z0.b - z3.b } +// CHECK-ENCODING: [0x00,0x04,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040400 + +mov za0h.b[w14, 4:7], {z8.b - z11.b} // 11000000-00000100-01000101-00000001 +// CHECK-INST: mov za0h.b[w14, 4:7], { z8.b - z11.b } +// CHECK-ENCODING: [0x01,0x45,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044501 + +mov za0h.b[w15, 12:15], {z12.b - z15.b} // 11000000-00000100-01100101-10000011 +// CHECK-INST: mov za0h.b[w15, 12:15], { z12.b - z15.b } +// CHECK-ENCODING: [0x83,0x65,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046583 + +mov za0h.b[w15, 12:15], {z28.b - z31.b} // 11000000-00000100-01100111-10000011 +// CHECK-INST: mov za0h.b[w15, 12:15], { z28.b - z31.b } +// CHECK-ENCODING: [0x83,0x67,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046783 + +mov za0h.b[w12, 4:7], {z16.b - z19.b} // 11000000-00000100-00000110-00000001 +// CHECK-INST: mov za0h.b[w12, 4:7], { z16.b - z19.b } +// CHECK-ENCODING: [0x01,0x06,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040601 + +mov za0h.b[w12, 4:7], {z0.b - z3.b} // 11000000-00000100-00000100-00000001 +// CHECK-INST: mov za0h.b[w12, 4:7], { z0.b - z3.b } +// CHECK-ENCODING: [0x01,0x04,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040401 + +mov za0h.b[w14, 0:3], {z16.b - z19.b} // 11000000-00000100-01000110-00000000 +// CHECK-INST: mov za0h.b[w14, 0:3], { z16.b - z19.b } +// CHECK-ENCODING: [0x00,0x46,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044600 + +mov za0h.b[w12, 0:3], {z12.b - z15.b} // 11000000-00000100-00000101-10000000 +// CHECK-INST: mov za0h.b[w12, 0:3], { z12.b - z15.b } +// CHECK-ENCODING: [0x80,0x05,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040580 + +mov za0h.b[w14, 4:7], {z0.b - z3.b} // 11000000-00000100-01000100-00000001 +// CHECK-INST: mov za0h.b[w14, 4:7], { z0.b - z3.b } +// CHECK-ENCODING: [0x01,0x44,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0044401 + +mov za0h.b[w12, 4:7], {z20.b - z23.b} // 11000000-00000100-00000110-10000001 +// CHECK-INST: mov za0h.b[w12, 4:7], { z20.b - z23.b } +// CHECK-ENCODING: [0x81,0x06,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0040681 + +mov za0h.b[w15, 8:11], {z8.b - z11.b} // 11000000-00000100-01100101-00000010 +// CHECK-INST: mov za0h.b[w15, 8:11], { z8.b - z11.b } +// CHECK-ENCODING: [0x02,0x65,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0046502 + +mov za0h.b[w13, 12:15], {z12.b - z15.b} // 11000000-00000100-00100101-10000011 +// CHECK-INST: mov za0h.b[w13, 12:15], { z12.b - z15.b } +// CHECK-ENCODING: [0x83,0x25,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0042583 + + +mova za0v.b[w12, 0:3], {z0.b - z3.b} // 11000000-00000100-10000100-00000000 +// CHECK-INST: mov za0v.b[w12, 0:3], { z0.b - z3.b } +// CHECK-ENCODING: [0x00,0x84,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0048400 + +mova za0v.b[w14, 4:7], {z8.b - z11.b} // 11000000-00000100-11000101-00000001 +// CHECK-INST: mov za0v.b[w14, 4:7], { z8.b - z11.b } +// CHECK-ENCODING: [0x01,0xc5,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004c501 + +mova za0v.b[w15, 12:15], {z12.b - z15.b} // 11000000-00000100-11100101-10000011 +// CHECK-INST: mov za0v.b[w15, 12:15], { z12.b - z15.b } +// CHECK-ENCODING: [0x83,0xe5,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004e583 + +mova za0v.b[w15, 12:15], {z28.b - z31.b} // 11000000-00000100-11100111-10000011 +// CHECK-INST: mov za0v.b[w15, 12:15], { z28.b - z31.b } +// CHECK-ENCODING: [0x83,0xe7,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004e783 + +mova za0v.b[w12, 4:7], {z16.b - z19.b} // 11000000-00000100-10000110-00000001 +// CHECK-INST: mov za0v.b[w12, 4:7], { z16.b - z19.b } +// CHECK-ENCODING: [0x01,0x86,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0048601 + +mova za0v.b[w12, 4:7], {z0.b - z3.b} // 11000000-00000100-10000100-00000001 +// CHECK-INST: mov za0v.b[w12, 4:7], { z0.b - z3.b } +// CHECK-ENCODING: [0x01,0x84,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0048401 + +mova za0v.b[w14, 0:3], {z16.b - z19.b} // 11000000-00000100-11000110-00000000 +// CHECK-INST: mov za0v.b[w14, 0:3], { z16.b - z19.b } +// CHECK-ENCODING: [0x00,0xc6,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004c600 + +mova za0v.b[w12, 0:3], {z12.b - z15.b} // 11000000-00000100-10000101-10000000 +// CHECK-INST: mov za0v.b[w12, 0:3], { z12.b - z15.b } +// CHECK-ENCODING: [0x80,0x85,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0048580 + +mova za0v.b[w14, 4:7], {z0.b - z3.b} // 11000000-00000100-11000100-00000001 +// CHECK-INST: mov za0v.b[w14, 4:7], { z0.b - z3.b } +// CHECK-ENCODING: [0x01,0xc4,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004c401 + +mova za0v.b[w12, 4:7], {z20.b - z23.b} // 11000000-00000100-10000110-10000001 +// CHECK-INST: mov za0v.b[w12, 4:7], { z20.b - z23.b } +// CHECK-ENCODING: [0x81,0x86,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0048681 + +mova za0v.b[w15, 8:11], {z8.b - z11.b} // 11000000-00000100-11100101-00000010 +// CHECK-INST: mov za0v.b[w15, 8:11], { z8.b - z11.b } +// CHECK-ENCODING: [0x02,0xe5,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004e502 + +mova za0v.b[w13, 12:15], {z12.b - z15.b} // 11000000-00000100-10100101-10000011 +// CHECK-INST: mov za0v.b[w13, 12:15], { z12.b - z15.b } +// CHECK-ENCODING: [0x83,0xa5,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004a583 + +// Aliases + +mov za0v.b[w12, 0:3], {z0.b - z3.b} // 11000000-00000100-10000100-00000000 +// CHECK-INST: mov za0v.b[w12, 0:3], { z0.b - z3.b } +// CHECK-ENCODING: [0x00,0x84,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0048400 + +mov za0v.b[w14, 4:7], {z8.b - z11.b} // 11000000-00000100-11000101-00000001 +// CHECK-INST: mov za0v.b[w14, 4:7], { z8.b - z11.b } +// CHECK-ENCODING: [0x01,0xc5,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004c501 + +mov za0v.b[w15, 12:15], {z12.b - z15.b} // 11000000-00000100-11100101-10000011 +// CHECK-INST: mov za0v.b[w15, 12:15], { z12.b - z15.b } +// CHECK-ENCODING: [0x83,0xe5,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004e583 + +mov za0v.b[w15, 12:15], {z28.b - z31.b} // 11000000-00000100-11100111-10000011 +// CHECK-INST: mov za0v.b[w15, 12:15], { z28.b - z31.b } +// CHECK-ENCODING: [0x83,0xe7,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004e783 + +mov za0v.b[w12, 4:7], {z16.b - z19.b} // 11000000-00000100-10000110-00000001 +// CHECK-INST: mov za0v.b[w12, 4:7], { z16.b - z19.b } +// CHECK-ENCODING: [0x01,0x86,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0048601 + +mov za0v.b[w12, 4:7], {z0.b - z3.b} // 11000000-00000100-10000100-00000001 +// CHECK-INST: mov za0v.b[w12, 4:7], { z0.b - z3.b } +// CHECK-ENCODING: [0x01,0x84,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0048401 + +mov za0v.b[w14, 0:3], {z16.b - z19.b} // 11000000-00000100-11000110-00000000 +// CHECK-INST: mov za0v.b[w14, 0:3], { z16.b - z19.b } +// CHECK-ENCODING: [0x00,0xc6,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004c600 + +mov za0v.b[w12, 0:3], {z12.b - z15.b} // 11000000-00000100-10000101-10000000 +// CHECK-INST: mov za0v.b[w12, 0:3], { z12.b - z15.b } +// CHECK-ENCODING: [0x80,0x85,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0048580 + +mov za0v.b[w14, 4:7], {z0.b - z3.b} // 11000000-00000100-11000100-00000001 +// CHECK-INST: mov za0v.b[w14, 4:7], { z0.b - z3.b } +// CHECK-ENCODING: [0x01,0xc4,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004c401 + +mov za0v.b[w12, 4:7], {z20.b - z23.b} // 11000000-00000100-10000110-10000001 +// CHECK-INST: mov za0v.b[w12, 4:7], { z20.b - z23.b } +// CHECK-ENCODING: [0x81,0x86,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c0048681 + +mov za0v.b[w15, 8:11], {z8.b - z11.b} // 11000000-00000100-11100101-00000010 +// CHECK-INST: mov za0v.b[w15, 8:11], { z8.b - z11.b } +// CHECK-ENCODING: [0x02,0xe5,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004e502 + +mov za0v.b[w13, 12:15], {z12.b - z15.b} // 11000000-00000100-10100101-10000011 +// CHECK-INST: mov za0v.b[w13, 12:15], { z12.b - z15.b } +// CHECK-ENCODING: [0x83,0xa5,0x04,0xc0] +// CHECK-ERROR: instruction requires: sme2 +// CHECK-UNKNOWN: c004a583 +