1 //===-- ARMInstrMVE.td - MVE support for ARM ---------------*- tablegen -*-===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 // This file describes the ARM MVE instruction set.
11 //===----------------------------------------------------------------------===//
13 class ExpandImmAsmOp<string shift> : AsmOperandClass {
14 let Name = !strconcat("ExpandImm", shift);
15 let PredicateMethod = !strconcat("isExpImm<", shift, ">");
16 let RenderMethod = "addImmOperands";
18 class InvertedExpandImmAsmOp<string shift, string size> : AsmOperandClass {
19 let Name = !strconcat("InvertedExpandImm", shift, "_", size);
20 let PredicateMethod = !strconcat("isInvertedExpImm<", shift, ",", size, ">");
21 let RenderMethod = "addImmOperands";
24 class ExpandImm<string shift> : Operand<i32> {
25 let ParserMatchClass = ExpandImmAsmOp<shift>;
26 let EncoderMethod = !strconcat("getExpandedImmOpValue<",shift,",false>");
27 let DecoderMethod = !strconcat("DecodeExpandedImmOperand<",shift,">");
28 let PrintMethod = "printExpandedImmOperand";
30 class InvertedExpandImm<string shift, string size> : Operand<i32> {
31 let ParserMatchClass = InvertedExpandImmAsmOp<shift, size>;
32 let EncoderMethod = !strconcat("getExpandedImmOpValue<",shift,",true>");
33 let PrintMethod = "printExpandedImmOperand";
34 // No decoder method needed, because this operand type is only used
35 // by aliases (VAND and VORN)
38 def expzero00 : ExpandImm<"0">;
39 def expzero08 : ExpandImm<"8">;
40 def expzero16 : ExpandImm<"16">;
41 def expzero24 : ExpandImm<"24">;
43 def expzero00inv16 : InvertedExpandImm<"0", "16">;
44 def expzero08inv16 : InvertedExpandImm<"8", "16">;
46 def expzero00inv32 : InvertedExpandImm<"0", "32">;
47 def expzero08inv32 : InvertedExpandImm<"8", "32">;
48 def expzero16inv32 : InvertedExpandImm<"16", "32">;
49 def expzero24inv32 : InvertedExpandImm<"24", "32">;
52 def vpt_mask : Operand<i32> {
53 let PrintMethod = "printVPTMask";
54 let ParserMatchClass = it_mask_asmoperand;
55 let EncoderMethod = "getVPTMaskOpValue";
56 let DecoderMethod = "DecodeVPTMaskOperand";
59 // VPT/VCMP restricted predicate for sign invariant types
60 def pred_restricted_i_asmoperand : AsmOperandClass {
61 let Name = "CondCodeRestrictedI";
62 let RenderMethod = "addITCondCodeOperands";
63 let PredicateMethod = "isITCondCodeRestrictedI";
64 let ParserMethod = "parseITCondCode";
65 let DiagnosticString = "condition code for sign-independent integer "#
66 "comparison must be EQ or NE";
69 // VPT/VCMP restricted predicate for signed types
70 def pred_restricted_s_asmoperand : AsmOperandClass {
71 let Name = "CondCodeRestrictedS";
72 let RenderMethod = "addITCondCodeOperands";
73 let PredicateMethod = "isITCondCodeRestrictedS";
74 let ParserMethod = "parseITCondCode";
75 let DiagnosticString = "condition code for signed integer "#
76 "comparison must be EQ, NE, LT, GT, LE or GE";
79 // VPT/VCMP restricted predicate for unsigned types
80 def pred_restricted_u_asmoperand : AsmOperandClass {
81 let Name = "CondCodeRestrictedU";
82 let RenderMethod = "addITCondCodeOperands";
83 let PredicateMethod = "isITCondCodeRestrictedU";
84 let ParserMethod = "parseITCondCode";
85 let DiagnosticString = "condition code for unsigned integer "#
86 "comparison must be EQ, NE, HS or HI";
89 // VPT/VCMP restricted predicate for floating point
90 def pred_restricted_fp_asmoperand : AsmOperandClass {
91 let Name = "CondCodeRestrictedFP";
92 let RenderMethod = "addITCondCodeOperands";
93 let PredicateMethod = "isITCondCodeRestrictedFP";
94 let ParserMethod = "parseITCondCode";
95 let DiagnosticString = "condition code for floating-point "#
96 "comparison must be EQ, NE, LT, GT, LE or GE";
99 class VCMPPredicateOperand : Operand<i32>;
101 def pred_basic_i : VCMPPredicateOperand {
102 let PrintMethod = "printMandatoryRestrictedPredicateOperand";
103 let ParserMatchClass = pred_restricted_i_asmoperand;
104 let DecoderMethod = "DecodeRestrictedIPredicateOperand";
105 let EncoderMethod = "getRestrictedCondCodeOpValue";
108 def pred_basic_u : VCMPPredicateOperand {
109 let PrintMethod = "printMandatoryRestrictedPredicateOperand";
110 let ParserMatchClass = pred_restricted_u_asmoperand;
111 let DecoderMethod = "DecodeRestrictedUPredicateOperand";
112 let EncoderMethod = "getRestrictedCondCodeOpValue";
115 def pred_basic_s : VCMPPredicateOperand {
116 let PrintMethod = "printMandatoryRestrictedPredicateOperand";
117 let ParserMatchClass = pred_restricted_s_asmoperand;
118 let DecoderMethod = "DecodeRestrictedSPredicateOperand";
119 let EncoderMethod = "getRestrictedCondCodeOpValue";
122 def pred_basic_fp : VCMPPredicateOperand {
123 let PrintMethod = "printMandatoryRestrictedPredicateOperand";
124 let ParserMatchClass = pred_restricted_fp_asmoperand;
125 let DecoderMethod = "DecodeRestrictedFPPredicateOperand";
126 let EncoderMethod = "getRestrictedCondCodeOpValue";
129 // Register list operands for interleaving load/stores
130 def VecList2QAsmOperand : AsmOperandClass {
131 let Name = "VecListTwoMQ";
132 let ParserMethod = "parseVectorList";
133 let RenderMethod = "addMVEVecListOperands";
134 let DiagnosticString = "operand must be a list of two consecutive "#
135 "q-registers in range [q0,q7]";
138 def VecList2Q : RegisterOperand<QQPR, "printMVEVectorListTwoQ"> {
139 let ParserMatchClass = VecList2QAsmOperand;
140 let PrintMethod = "printMVEVectorList<2>";
143 def VecList4QAsmOperand : AsmOperandClass {
144 let Name = "VecListFourMQ";
145 let ParserMethod = "parseVectorList";
146 let RenderMethod = "addMVEVecListOperands";
147 let DiagnosticString = "operand must be a list of four consecutive "#
148 "q-registers in range [q0,q7]";
151 def VecList4Q : RegisterOperand<QQQQPR, "printMVEVectorListFourQ"> {
152 let ParserMatchClass = VecList4QAsmOperand;
153 let PrintMethod = "printMVEVectorList<4>";
156 // taddrmode_imm7 := reg[r0-r7] +/- (imm7 << shift)
157 class TMemImm7ShiftOffsetAsmOperand<int shift> : AsmOperandClass {
158 let Name = "TMemImm7Shift"#shift#"Offset";
159 let PredicateMethod = "isMemImm7ShiftedOffset<"#shift#",ARM::tGPRRegClassID>";
160 let RenderMethod = "addMemImmOffsetOperands";
163 class taddrmode_imm7<int shift> : MemOperand {
164 let ParserMatchClass = TMemImm7ShiftOffsetAsmOperand<shift>;
165 // They are printed the same way as the T2 imm8 version
166 let PrintMethod = "printT2AddrModeImm8Operand<false>";
167 // This can also be the same as the T2 version.
168 let EncoderMethod = "getT2AddrModeImmOpValue<7,"#shift#">";
169 let DecoderMethod = "DecodeTAddrModeImm7<"#shift#">";
170 let MIOperandInfo = (ops tGPR:$base, i32imm:$offsimm);
173 // t2addrmode_imm7 := reg +/- (imm7)
174 class MemImm7ShiftOffsetAsmOperand<int shift> : AsmOperandClass {
175 let Name = "MemImm7Shift"#shift#"Offset";
176 let PredicateMethod = "isMemImm7ShiftedOffset<" # shift #
177 ",ARM::GPRnopcRegClassID>";
178 let RenderMethod = "addMemImmOffsetOperands";
181 def MemImm7Shift0OffsetAsmOperand : MemImm7ShiftOffsetAsmOperand<0>;
182 def MemImm7Shift1OffsetAsmOperand : MemImm7ShiftOffsetAsmOperand<1>;
183 def MemImm7Shift2OffsetAsmOperand : MemImm7ShiftOffsetAsmOperand<2>;
184 class T2AddrMode_Imm7<int shift> : MemOperand,
185 ComplexPattern<i32, 2, "SelectT2AddrModeImm7<"#shift#">", []> {
186 let EncoderMethod = "getT2AddrModeImmOpValue<7,"#shift#">";
187 let DecoderMethod = "DecodeT2AddrModeImm7<"#shift#", 0>";
188 let ParserMatchClass =
189 !cast<AsmOperandClass>("MemImm7Shift"#shift#"OffsetAsmOperand");
190 let MIOperandInfo = (ops GPRnopc:$base, i32imm:$offsimm);
193 class t2addrmode_imm7<int shift> : T2AddrMode_Imm7<shift> {
194 // They are printed the same way as the imm8 version
195 let PrintMethod = "printT2AddrModeImm8Operand<false>";
198 class MemImm7ShiftOffsetWBAsmOperand<int shift> : AsmOperandClass {
199 let Name = "MemImm7Shift"#shift#"OffsetWB";
200 let PredicateMethod = "isMemImm7ShiftedOffset<" # shift #
201 ",ARM::rGPRRegClassID>";
202 let RenderMethod = "addMemImmOffsetOperands";
205 def MemImm7Shift0OffsetWBAsmOperand : MemImm7ShiftOffsetWBAsmOperand<0>;
206 def MemImm7Shift1OffsetWBAsmOperand : MemImm7ShiftOffsetWBAsmOperand<1>;
207 def MemImm7Shift2OffsetWBAsmOperand : MemImm7ShiftOffsetWBAsmOperand<2>;
209 class t2addrmode_imm7_pre<int shift> : T2AddrMode_Imm7<shift> {
210 // They are printed the same way as the imm8 version
211 let PrintMethod = "printT2AddrModeImm8Operand<true>";
212 let ParserMatchClass =
213 !cast<AsmOperandClass>("MemImm7Shift"#shift#"OffsetWBAsmOperand");
214 let DecoderMethod = "DecodeT2AddrModeImm7<"#shift#", 1>";
215 let MIOperandInfo = (ops rGPR:$base, i32imm:$offsim);
218 class t2am_imm7shiftOffsetAsmOperand<int shift>
219 : AsmOperandClass { let Name = "Imm7Shift"#shift; }
220 def t2am_imm7shift0OffsetAsmOperand : t2am_imm7shiftOffsetAsmOperand<0>;
221 def t2am_imm7shift1OffsetAsmOperand : t2am_imm7shiftOffsetAsmOperand<1>;
222 def t2am_imm7shift2OffsetAsmOperand : t2am_imm7shiftOffsetAsmOperand<2>;
224 class t2am_imm7_offset<int shift> : MemOperand {
225 // They are printed the same way as the imm8 version
226 let PrintMethod = "printT2AddrModeImm8OffsetOperand";
227 let ParserMatchClass =
228 !cast<AsmOperandClass>("t2am_imm7shift"#shift#"OffsetAsmOperand");
229 let EncoderMethod = "getT2ScaledImmOpValue<7,"#shift#">";
230 let DecoderMethod = "DecodeT2Imm7<"#shift#">";
233 // Operands for gather/scatter loads of the form [Rbase, Qoffsets]
234 class MemRegRQOffsetAsmOperand<int shift> : AsmOperandClass {
235 let Name = "MemRegRQS"#shift#"Offset";
236 let PredicateMethod = "isMemRegRQOffset<"#shift#">";
237 let RenderMethod = "addMemRegRQOffsetOperands";
240 def MemRegRQS0OffsetAsmOperand : MemRegRQOffsetAsmOperand<0>;
241 def MemRegRQS1OffsetAsmOperand : MemRegRQOffsetAsmOperand<1>;
242 def MemRegRQS2OffsetAsmOperand : MemRegRQOffsetAsmOperand<2>;
243 def MemRegRQS3OffsetAsmOperand : MemRegRQOffsetAsmOperand<3>;
245 // mve_addr_rq_shift := reg + vreg{ << UXTW #shift}
246 class mve_addr_rq_shift<int shift> : MemOperand {
247 let EncoderMethod = "getMveAddrModeRQOpValue";
248 let PrintMethod = "printMveAddrModeRQOperand<"#shift#">";
249 let ParserMatchClass =
250 !cast<AsmOperandClass>("MemRegRQS"#shift#"OffsetAsmOperand");
251 let DecoderMethod = "DecodeMveAddrModeRQ";
252 let MIOperandInfo = (ops GPRnopc:$base, MQPR:$offsreg);
255 class MemRegQOffsetAsmOperand<int shift> : AsmOperandClass {
256 let Name = "MemRegQS"#shift#"Offset";
257 let PredicateMethod = "isMemRegQOffset<"#shift#">";
258 let RenderMethod = "addMemImmOffsetOperands";
261 def MemRegQS2OffsetAsmOperand : MemRegQOffsetAsmOperand<2>;
262 def MemRegQS3OffsetAsmOperand : MemRegQOffsetAsmOperand<3>;
264 // mve_addr_q_shift := vreg {+ #imm7s2/4}
265 class mve_addr_q_shift<int shift> : MemOperand {
266 let EncoderMethod = "getMveAddrModeQOpValue<"#shift#">";
267 // Can be printed same way as other reg + imm operands
268 let PrintMethod = "printT2AddrModeImm8Operand<false>";
269 let ParserMatchClass =
270 !cast<AsmOperandClass>("MemRegQS"#shift#"OffsetAsmOperand");
271 let DecoderMethod = "DecodeMveAddrModeQ<"#shift#">";
272 let MIOperandInfo = (ops MQPR:$base, i32imm:$imm);
275 // --------- Start of base classes for the instructions themselves
277 class MVE_MI<dag oops, dag iops, InstrItinClass itin, string asm,
278 string ops, string cstr, list<dag> pattern>
279 : Thumb2XI<oops, iops, AddrModeNone, 4, itin, !strconcat(asm, "\t", ops), cstr,
281 Requires<[HasMVEInt]> {
283 let DecoderNamespace = "MVE";
286 // MVE_p is used for most predicated instructions, to add the cluster
287 // of input operands that provides the VPT suffix (none, T or E) and
288 // the input predicate register.
289 class MVE_p<dag oops, dag iops, InstrItinClass itin, string iname,
290 string suffix, string ops, vpred_ops vpred, string cstr,
291 list<dag> pattern=[]>
292 : MVE_MI<oops, !con(iops, (ins vpred:$vp)), itin,
293 // If the instruction has a suffix, like vadd.f32, then the
294 // VPT predication suffix goes before the dot, so the full
295 // name has to be "vadd${vp}.f32".
296 !strconcat(iname, "${vp}",
297 !if(!eq(suffix, ""), "", !strconcat(".", suffix))),
298 ops, !strconcat(cstr, vpred.vpred_constraint), pattern> {
299 let Inst{31-29} = 0b111;
300 let Inst{27-26} = 0b11;
303 class MVE_f<dag oops, dag iops, InstrItinClass itin, string iname,
304 string suffix, string ops, vpred_ops vpred, string cstr,
305 list<dag> pattern=[]>
306 : MVE_p<oops, iops, itin, iname, suffix, ops, vpred, cstr, pattern> {
307 let Predicates = [HasMVEFloat];
310 class MVE_MI_with_pred<dag oops, dag iops, InstrItinClass itin, string asm,
311 string ops, string cstr, list<dag> pattern>
312 : Thumb2I<oops, iops, AddrModeNone, 4, itin, asm, !strconcat("\t", ops), cstr,
314 Requires<[HasV8_1MMainline, HasMVEInt]> {
316 let DecoderNamespace = "MVE";
319 class MVE_VMOV_lane_base<dag oops, dag iops, InstrItinClass itin, string asm,
320 string suffix, string ops, string cstr,
322 : Thumb2I<oops, iops, AddrModeNone, 4, itin, asm,
323 !if(!eq(suffix, ""), "", "." # suffix) # "\t" # ops,
325 Requires<[HasV8_1MMainline, HasMVEInt]> {
327 let DecoderNamespace = "MVE";
330 class MVE_ScalarShift<string iname, dag oops, dag iops, string asm, string cstr,
331 list<dag> pattern=[]>
332 : MVE_MI_with_pred<oops, iops, NoItinerary, iname, asm, cstr, pattern> {
333 let Inst{31-20} = 0b111010100101;
338 class MVE_ScalarShiftSingleReg<string iname, dag iops, string asm, string cstr,
339 list<dag> pattern=[]>
340 : MVE_ScalarShift<iname, (outs rGPR:$RdaDest), iops, asm, cstr, pattern> {
343 let Inst{19-16} = RdaDest{3-0};
346 class MVE_ScalarShiftSRegImm<string iname, bits<2> op5_4, list<dag> pattern=[]>
347 : MVE_ScalarShiftSingleReg<iname, (ins rGPR:$RdaSrc, long_shift:$imm),
348 "$RdaSrc, $imm", "$RdaDest = $RdaSrc", pattern> {
352 let Inst{14-12} = imm{4-2};
353 let Inst{11-8} = 0b1111;
354 let Inst{7-6} = imm{1-0};
355 let Inst{5-4} = op5_4{1-0};
356 let Inst{3-0} = 0b1111;
359 def MVE_SQSHL : MVE_ScalarShiftSRegImm<"sqshl", 0b11>;
360 def MVE_SRSHR : MVE_ScalarShiftSRegImm<"srshr", 0b10>;
361 def MVE_UQSHL : MVE_ScalarShiftSRegImm<"uqshl", 0b00>;
362 def MVE_URSHR : MVE_ScalarShiftSRegImm<"urshr", 0b01>;
364 class MVE_ScalarShiftSRegReg<string iname, bits<2> op5_4, list<dag> pattern=[]>
365 : MVE_ScalarShiftSingleReg<iname, (ins rGPR:$RdaSrc, rGPR:$Rm),
366 "$RdaSrc, $Rm", "$RdaDest = $RdaSrc", pattern> {
369 let Inst{15-12} = Rm{3-0};
370 let Inst{11-8} = 0b1111;
371 let Inst{7-6} = 0b00;
372 let Inst{5-4} = op5_4{1-0};
373 let Inst{3-0} = 0b1101;
376 def MVE_SQRSHR : MVE_ScalarShiftSRegReg<"sqrshr", 0b10>;
377 def MVE_UQRSHL : MVE_ScalarShiftSRegReg<"uqrshl", 0b00>;
379 class MVE_ScalarShiftDoubleReg<string iname, dag iops, string asm,
380 string cstr, list<dag> pattern=[]>
381 : MVE_ScalarShift<iname, (outs tGPREven:$RdaLo, tGPROdd:$RdaHi),
382 iops, asm, cstr, pattern> {
386 let Inst{19-17} = RdaLo{3-1};
387 let Inst{11-9} = RdaHi{3-1};
390 class MVE_ScalarShiftDRegImm<string iname, bits<2> op5_4, bit op16,
391 list<dag> pattern=[]>
392 : MVE_ScalarShiftDoubleReg<
393 iname, (ins tGPREven:$RdaLo_src, tGPROdd:$RdaHi_src, long_shift:$imm),
394 "$RdaLo, $RdaHi, $imm", "$RdaLo = $RdaLo_src,$RdaHi = $RdaHi_src",
400 let Inst{14-12} = imm{4-2};
401 let Inst{7-6} = imm{1-0};
402 let Inst{5-4} = op5_4{1-0};
403 let Inst{3-0} = 0b1111;
406 class MVE_ScalarShiftDRegReg<string iname, bit op5, bit op16,
407 list<dag> pattern=[]>
408 : MVE_ScalarShiftDoubleReg<
409 iname, (ins tGPREven:$RdaLo_src, tGPROdd:$RdaHi_src, rGPR:$Rm),
410 "$RdaLo, $RdaHi, $Rm", "@earlyclobber $RdaHi,@earlyclobber $RdaLo,"
411 "$RdaLo = $RdaLo_src,$RdaHi = $RdaHi_src",
416 let Inst{15-12} = Rm{3-0};
417 let Inst{7-6} = 0b00;
420 let Inst{3-0} = 0b1101;
422 // Custom decoder method because of the following overlapping encodings:
425 // SQRSHRL and SQRSHR
426 // UQRSHLL and UQRSHL
427 let DecoderMethod = "DecodeMVEOverlappingLongShift";
430 def MVE_ASRLr : MVE_ScalarShiftDRegReg<"asrl", 0b1, 0b0, [(set tGPREven:$RdaLo, tGPROdd:$RdaHi,
431 (ARMasrl tGPREven:$RdaLo_src,
432 tGPROdd:$RdaHi_src, rGPR:$Rm))]>;
433 def MVE_ASRLi : MVE_ScalarShiftDRegImm<"asrl", 0b10, ?, [(set tGPREven:$RdaLo, tGPROdd:$RdaHi,
434 (ARMasrl tGPREven:$RdaLo_src,
435 tGPROdd:$RdaHi_src, (i32 imm:$imm)))]>;
436 def MVE_LSLLr : MVE_ScalarShiftDRegReg<"lsll", 0b0, 0b0, [(set tGPREven:$RdaLo, tGPROdd:$RdaHi,
437 (ARMlsll tGPREven:$RdaLo_src,
438 tGPROdd:$RdaHi_src, rGPR:$Rm))]>;
439 def MVE_LSLLi : MVE_ScalarShiftDRegImm<"lsll", 0b00, ?, [(set tGPREven:$RdaLo, tGPROdd:$RdaHi,
440 (ARMlsll tGPREven:$RdaLo_src,
441 tGPROdd:$RdaHi_src, (i32 imm:$imm)))]>;
442 def MVE_LSRL : MVE_ScalarShiftDRegImm<"lsrl", 0b01, ?, [(set tGPREven:$RdaLo, tGPROdd:$RdaHi,
443 (ARMlsrl tGPREven:$RdaLo_src,
444 tGPROdd:$RdaHi_src, (i32 imm:$imm)))]>;
446 def MVE_SQRSHRL : MVE_ScalarShiftDRegReg<"sqrshrl", 0b1, 0b1>;
447 def MVE_SQSHLL : MVE_ScalarShiftDRegImm<"sqshll", 0b11, 0b1>;
448 def MVE_SRSHRL : MVE_ScalarShiftDRegImm<"srshrl", 0b10, 0b1>;
450 def MVE_UQRSHLL : MVE_ScalarShiftDRegReg<"uqrshll", 0b0, 0b1>;
451 def MVE_UQSHLL : MVE_ScalarShiftDRegImm<"uqshll", 0b00, 0b1>;
452 def MVE_URSHRL : MVE_ScalarShiftDRegImm<"urshrl", 0b01, 0b1>;
454 // start of mve_rDest instructions
456 class MVE_rDest<dag oops, dag iops, InstrItinClass itin,
457 string iname, string suffix,
458 string ops, string cstr, list<dag> pattern=[]>
459 // Always use vpred_n and not vpred_r: with the output register being
460 // a GPR and not a vector register, there can't be any question of
461 // what to put in its inactive lanes.
462 : MVE_p<oops, iops, itin, iname, suffix, ops, vpred_n, cstr, pattern> {
464 let Inst{25-23} = 0b101;
465 let Inst{11-9} = 0b111;
469 class MVE_VABAV<string suffix, bit U, bits<2> size, list<dag> pattern=[]>
470 : MVE_rDest<(outs rGPR:$Rda), (ins rGPR:$Rda_src, MQPR:$Qn, MQPR:$Qm),
471 NoItinerary, "vabav", suffix, "$Rda, $Qn, $Qm", "$Rda = $Rda_src",
479 let Inst{21-20} = size{1-0};
480 let Inst{19-17} = Qn{2-0};
482 let Inst{15-12} = Rda{3-0};
487 let Inst{3-1} = Qm{2-0};
491 def MVE_VABAVs8 : MVE_VABAV<"s8", 0b0, 0b00>;
492 def MVE_VABAVs16 : MVE_VABAV<"s16", 0b0, 0b01>;
493 def MVE_VABAVs32 : MVE_VABAV<"s32", 0b0, 0b10>;
494 def MVE_VABAVu8 : MVE_VABAV<"u8", 0b1, 0b00>;
495 def MVE_VABAVu16 : MVE_VABAV<"u16", 0b1, 0b01>;
496 def MVE_VABAVu32 : MVE_VABAV<"u32", 0b1, 0b10>;
498 class MVE_VADDV<string iname, string suffix, dag iops, string cstr,
499 bit A, bit U, bits<2> size, list<dag> pattern=[]>
500 : MVE_rDest<(outs tGPREven:$Rda), iops, NoItinerary,
501 iname, suffix, "$Rda, $Qm", cstr, pattern> {
506 let Inst{22-20} = 0b111;
507 let Inst{19-18} = size{1-0};
508 let Inst{17-16} = 0b01;
509 let Inst{15-13} = Rda{3-1};
511 let Inst{8-6} = 0b100;
513 let Inst{3-1} = Qm{2-0};
517 multiclass MVE_VADDV_A<string suffix, bit U, bits<2> size,
518 list<dag> pattern=[]> {
519 def acc : MVE_VADDV<"vaddva", suffix,
520 (ins tGPREven:$Rda_src, MQPR:$Qm), "$Rda = $Rda_src",
521 0b1, U, size, pattern>;
522 def no_acc : MVE_VADDV<"vaddv", suffix,
524 0b0, U, size, pattern>;
527 defm MVE_VADDVs8 : MVE_VADDV_A<"s8", 0b0, 0b00>;
528 defm MVE_VADDVs16 : MVE_VADDV_A<"s16", 0b0, 0b01>;
529 defm MVE_VADDVs32 : MVE_VADDV_A<"s32", 0b0, 0b10>;
530 defm MVE_VADDVu8 : MVE_VADDV_A<"u8", 0b1, 0b00>;
531 defm MVE_VADDVu16 : MVE_VADDV_A<"u16", 0b1, 0b01>;
532 defm MVE_VADDVu32 : MVE_VADDV_A<"u32", 0b1, 0b10>;
534 class MVE_VADDLV<string iname, string suffix, dag iops, string cstr,
535 bit A, bit U, list<dag> pattern=[]>
536 : MVE_rDest<(outs tGPREven:$RdaLo, tGPROdd:$RdaHi), iops, NoItinerary, iname,
537 suffix, "$RdaLo, $RdaHi, $Qm", cstr, pattern> {
543 let Inst{22-20} = RdaHi{3-1};
544 let Inst{19-18} = 0b10;
545 let Inst{17-16} = 0b01;
546 let Inst{15-13} = RdaLo{3-1};
548 let Inst{8-6} = 0b100;
550 let Inst{3-1} = Qm{2-0};
554 multiclass MVE_VADDLV_A<string suffix, bit U, list<dag> pattern=[]> {
555 def acc : MVE_VADDLV<"vaddlva", suffix,
556 (ins tGPREven:$RdaLo_src, tGPROdd:$RdaHi_src, MQPR:$Qm),
557 "$RdaLo = $RdaLo_src,$RdaHi = $RdaHi_src",
559 def no_acc : MVE_VADDLV<"vaddlv", suffix,
565 defm MVE_VADDLVs32 : MVE_VADDLV_A<"s32", 0b0>;
566 defm MVE_VADDLVu32 : MVE_VADDLV_A<"u32", 0b1>;
568 class MVE_VMINMAXNMV<string iname, string suffix, bit sz,
569 bit bit_17, bit bit_7, list<dag> pattern=[]>
570 : MVE_rDest<(outs rGPR:$RdaDest), (ins rGPR:$RdaSrc, MQPR:$Qm),
571 NoItinerary, iname, suffix, "$RdaSrc, $Qm",
572 "$RdaDest = $RdaSrc", pattern> {
577 let Inst{22-20} = 0b110;
578 let Inst{19-18} = 0b11;
579 let Inst{17} = bit_17;
581 let Inst{15-12} = RdaDest{3-0};
584 let Inst{6-5} = 0b00;
585 let Inst{3-1} = Qm{2-0};
588 let Predicates = [HasMVEFloat];
591 multiclass MVE_VMINMAXNMV_fty<string iname, bit bit_7, list<dag> pattern=[]> {
592 def f32 : MVE_VMINMAXNMV<iname, "f32", 0b0, 0b1, bit_7, pattern>;
593 def f16 : MVE_VMINMAXNMV<iname, "f16", 0b1, 0b1, bit_7, pattern>;
596 defm MVE_VMINNMV : MVE_VMINMAXNMV_fty<"vminnmv", 0b1>;
597 defm MVE_VMAXNMV : MVE_VMINMAXNMV_fty<"vmaxnmv", 0b0>;
599 multiclass MVE_VMINMAXNMAV_fty<string iname, bit bit_7, list<dag> pattern=[]> {
600 def f32 : MVE_VMINMAXNMV<iname, "f32", 0b0, 0b0, bit_7, pattern>;
601 def f16 : MVE_VMINMAXNMV<iname, "f16", 0b1, 0b0, bit_7, pattern>;
604 defm MVE_VMINNMAV : MVE_VMINMAXNMAV_fty<"vminnmav", 0b1>;
605 defm MVE_VMAXNMAV : MVE_VMINMAXNMAV_fty<"vmaxnmav", 0b0>;
607 class MVE_VMINMAXV<string iname, string suffix, bit U, bits<2> size,
608 bit bit_17, bit bit_7, list<dag> pattern=[]>
609 : MVE_rDest<(outs rGPR:$RdaDest), (ins rGPR:$RdaSrc, MQPR:$Qm), NoItinerary,
610 iname, suffix, "$RdaSrc, $Qm", "$RdaDest = $RdaSrc", pattern> {
615 let Inst{22-20} = 0b110;
616 let Inst{19-18} = size{1-0};
617 let Inst{17} = bit_17;
619 let Inst{15-12} = RdaDest{3-0};
622 let Inst{6-5} = 0b00;
623 let Inst{3-1} = Qm{2-0};
627 multiclass MVE_VMINMAXV_ty<string iname, bit bit_7, list<dag> pattern=[]> {
628 def s8 : MVE_VMINMAXV<iname, "s8", 0b0, 0b00, 0b1, bit_7>;
629 def s16 : MVE_VMINMAXV<iname, "s16", 0b0, 0b01, 0b1, bit_7>;
630 def s32 : MVE_VMINMAXV<iname, "s32", 0b0, 0b10, 0b1, bit_7>;
631 def u8 : MVE_VMINMAXV<iname, "u8", 0b1, 0b00, 0b1, bit_7>;
632 def u16 : MVE_VMINMAXV<iname, "u16", 0b1, 0b01, 0b1, bit_7>;
633 def u32 : MVE_VMINMAXV<iname, "u32", 0b1, 0b10, 0b1, bit_7>;
636 defm MVE_VMINV : MVE_VMINMAXV_ty<"vminv", 0b1>;
637 defm MVE_VMAXV : MVE_VMINMAXV_ty<"vmaxv", 0b0>;
639 multiclass MVE_VMINMAXAV_ty<string iname, bit bit_7, list<dag> pattern=[]> {
640 def s8 : MVE_VMINMAXV<iname, "s8", 0b0, 0b00, 0b0, bit_7>;
641 def s16 : MVE_VMINMAXV<iname, "s16", 0b0, 0b01, 0b0, bit_7>;
642 def s32 : MVE_VMINMAXV<iname, "s32", 0b0, 0b10, 0b0, bit_7>;
645 defm MVE_VMINAV : MVE_VMINMAXAV_ty<"vminav", 0b1>;
646 defm MVE_VMAXAV : MVE_VMINMAXAV_ty<"vmaxav", 0b0>;
648 class MVE_VMLAMLSDAV<string iname, string suffix, dag iops, string cstr,
649 bit sz, bit bit_28, bit A, bit X, bit bit_8, bit bit_0,
650 list<dag> pattern=[]>
651 : MVE_rDest<(outs tGPREven:$RdaDest), iops, NoItinerary, iname, suffix,
652 "$RdaDest, $Qn, $Qm", cstr, pattern> {
657 let Inst{28} = bit_28;
658 let Inst{22-20} = 0b111;
659 let Inst{19-17} = Qn{2-0};
661 let Inst{15-13} = RdaDest{3-1};
664 let Inst{7-6} = 0b00;
666 let Inst{3-1} = Qm{2-0};
670 multiclass MVE_VMLAMLSDAV_X<string iname, string suffix, dag iops, string cstr,
671 bit sz, bit bit_28, bit A, bit bit_8, bit bit_0,
672 list<dag> pattern=[]> {
673 def _noexch : MVE_VMLAMLSDAV<iname, suffix, iops, cstr, sz,
674 bit_28, A, 0b0, bit_8, bit_0, pattern>;
675 def _exch : MVE_VMLAMLSDAV<iname # "x", suffix, iops, cstr, sz,
676 bit_28, A, 0b1, bit_8, bit_0, pattern>;
679 multiclass MVE_VMLAMLSDAV_XA<string iname, string suffix, bit sz, bit bit_28,
680 bit bit_8, bit bit_0, list<dag> pattern=[]> {
681 defm _noacc : MVE_VMLAMLSDAV_X<iname, suffix, (ins MQPR:$Qn, MQPR:$Qm), "",
682 sz, bit_28, 0b0, bit_8, bit_0, pattern>;
683 defm _acc : MVE_VMLAMLSDAV_X<iname # "a", suffix,
684 (ins tGPREven:$RdaSrc, MQPR:$Qn, MQPR:$Qm),
685 "$RdaDest = $RdaSrc",
686 sz, bit_28, 0b1, bit_8, bit_0, pattern>;
689 multiclass MVE_VMLADAV_multi<string suffix, bit sz, bit U, bit bit_8,
690 list<dag> pattern=[]> {
691 defm "" : MVE_VMLAMLSDAV_XA<"vmladav", suffix, sz, U, bit_8, 0b0, pattern>;
694 defm MVE_VMLADAVs16 : MVE_VMLADAV_multi<"s16", 0b0, 0b0, 0b0>;
695 defm MVE_VMLADAVs32 : MVE_VMLADAV_multi<"s32", 0b1, 0b0, 0b0>;
696 defm MVE_VMLADAVu16 : MVE_VMLADAV_multi<"u16", 0b0, 0b1, 0b0>;
697 defm MVE_VMLADAVu32 : MVE_VMLADAV_multi<"u32", 0b1, 0b1, 0b0>;
699 defm MVE_VMLADAVs8 : MVE_VMLADAV_multi<"s8", 0b0, 0b0, 0b1>;
700 defm MVE_VMLADAVu8 : MVE_VMLADAV_multi<"u8", 0b0, 0b1, 0b1>;
702 // vmlav aliases vmladav
703 foreach acc = ["_acc", "_noacc"] in {
704 foreach suffix = ["s8", "s16", "s32", "u8", "u16", "u32"] in {
705 def : MVEInstAlias<!strconcat("vmlav", !if(!eq(acc, "_acc"), "a", ""),
706 "${vp}.", suffix, "\t$RdaDest, $Qn, $Qm"),
707 (!cast<Instruction>("MVE_VMLADAV"#suffix#acc#"_noexch")
708 tGPREven:$RdaDest, MQPR:$Qn, MQPR:$Qm, vpred_n:$vp)>;
712 multiclass MVE_VMLSDAV_multi<string suffix, bit sz, bit bit_28,
713 list<dag> pattern=[]> {
714 defm "" : MVE_VMLAMLSDAV_XA<"vmlsdav", suffix, sz, bit_28, 0b0, 0b1, pattern>;
717 defm MVE_VMLSDAVs8 : MVE_VMLSDAV_multi<"s8", 0, 0b1>;
718 defm MVE_VMLSDAVs16 : MVE_VMLSDAV_multi<"s16", 0, 0b0>;
719 defm MVE_VMLSDAVs32 : MVE_VMLSDAV_multi<"s32", 1, 0b0>;
721 // Base class for VMLALDAV and VMLSLDAV, VRMLALDAVH, VRMLSLDAVH
722 class MVE_VMLALDAVBase<string iname, string suffix, dag iops, string cstr,
723 bit sz, bit bit_28, bit A, bit X, bit bit_8, bit bit_0,
724 list<dag> pattern=[]>
725 : MVE_rDest<(outs tGPREven:$RdaLoDest, tGPROdd:$RdaHiDest), iops, NoItinerary,
726 iname, suffix, "$RdaLoDest, $RdaHiDest, $Qn, $Qm", cstr, pattern> {
732 let Inst{28} = bit_28;
733 let Inst{22-20} = RdaHiDest{3-1};
734 let Inst{19-17} = Qn{2-0};
736 let Inst{15-13} = RdaLoDest{3-1};
739 let Inst{7-6} = 0b00;
741 let Inst{3-1} = Qm{2-0};
745 multiclass MVE_VMLALDAVBase_X<string iname, string suffix, dag iops,
746 string cstr, bit sz, bit bit_28, bit A,
747 bit bit_8, bit bit_0, list<dag> pattern=[]> {
748 def _noexch : MVE_VMLALDAVBase<iname, suffix, iops, cstr, sz,
749 bit_28, A, 0b0, bit_8, bit_0, pattern>;
750 def _exch : MVE_VMLALDAVBase<iname # "x", suffix, iops, cstr, sz,
751 bit_28, A, 0b1, bit_8, bit_0, pattern>;
754 multiclass MVE_VMLALDAVBase_XA<string iname, string suffix, bit sz, bit bit_28,
755 bit bit_8, bit bit_0, list<dag> pattern=[]> {
756 defm _noacc : MVE_VMLALDAVBase_X<
757 iname, suffix, (ins MQPR:$Qn, MQPR:$Qm), "",
758 sz, bit_28, 0b0, bit_8, bit_0, pattern>;
759 defm _acc : MVE_VMLALDAVBase_X<
760 iname # "a", suffix, (ins tGPREven:$RdaLoSrc, tGPROdd:$RdaHiSrc,
762 "$RdaLoDest = $RdaLoSrc,$RdaHiDest = $RdaHiSrc",
763 sz, bit_28, 0b1, bit_8, bit_0, pattern>;
766 multiclass MVE_VRMLALDAVH_multi<string suffix, bit U, list<dag> pattern=[]> {
767 defm "" : MVE_VMLALDAVBase_XA<
768 "vrmlaldavh", suffix, 0b0, U, 0b1, 0b0, pattern>;
771 defm MVE_VRMLALDAVHs32 : MVE_VRMLALDAVH_multi<"s32", 0>;
772 defm MVE_VRMLALDAVHu32 : MVE_VRMLALDAVH_multi<"u32", 1>;
774 // vrmlalvh aliases for vrmlaldavh
775 def : MVEInstAlias<"vrmlalvh${vp}.s32\t$RdaLo, $RdaHi, $Qn, $Qm",
776 (MVE_VRMLALDAVHs32_noacc_noexch
777 tGPREven:$RdaLo, tGPROdd:$RdaHi,
778 MQPR:$Qn, MQPR:$Qm, vpred_n:$vp)>;
779 def : MVEInstAlias<"vrmlalvha${vp}.s32\t$RdaLo, $RdaHi, $Qn, $Qm",
780 (MVE_VRMLALDAVHs32_acc_noexch
781 tGPREven:$RdaLo, tGPROdd:$RdaHi,
782 MQPR:$Qn, MQPR:$Qm, vpred_n:$vp)>;
783 def : MVEInstAlias<"vrmlalvh${vp}.u32\t$RdaLo, $RdaHi, $Qn, $Qm",
784 (MVE_VRMLALDAVHu32_noacc_noexch
785 tGPREven:$RdaLo, tGPROdd:$RdaHi,
786 MQPR:$Qn, MQPR:$Qm, vpred_n:$vp)>;
787 def : MVEInstAlias<"vrmlalvha${vp}.u32\t$RdaLo, $RdaHi, $Qn, $Qm",
788 (MVE_VRMLALDAVHu32_acc_noexch
789 tGPREven:$RdaLo, tGPROdd:$RdaHi,
790 MQPR:$Qn, MQPR:$Qm, vpred_n:$vp)>;
792 multiclass MVE_VMLALDAV_multi<string suffix, bit sz, bit U,
793 list<dag> pattern=[]> {
794 defm "" : MVE_VMLALDAVBase_XA<"vmlaldav", suffix, sz, U, 0b0, 0b0, pattern>;
797 defm MVE_VMLALDAVs16 : MVE_VMLALDAV_multi<"s16", 0b0, 0b0>;
798 defm MVE_VMLALDAVs32 : MVE_VMLALDAV_multi<"s32", 0b1, 0b0>;
799 defm MVE_VMLALDAVu16 : MVE_VMLALDAV_multi<"u16", 0b0, 0b1>;
800 defm MVE_VMLALDAVu32 : MVE_VMLALDAV_multi<"u32", 0b1, 0b1>;
802 // vmlalv aliases vmlaldav
803 foreach acc = ["_acc", "_noacc"] in {
804 foreach suffix = ["s16", "s32", "u16", "u32"] in {
805 def : MVEInstAlias<!strconcat("vmlalv", !if(!eq(acc, "_acc"), "a", ""),
806 "${vp}.", suffix, "\t$RdaLoDest, $RdaHiDest, $Qn, $Qm"),
807 (!cast<Instruction>("MVE_VMLALDAV"#suffix#acc#"_noexch")
808 tGPREven:$RdaLoDest, tGPROdd:$RdaHiDest,
809 MQPR:$Qn, MQPR:$Qm, vpred_n:$vp)>;
813 multiclass MVE_VMLSLDAV_multi<string iname, string suffix, bit sz,
814 bit bit_28, list<dag> pattern=[]> {
815 defm "" : MVE_VMLALDAVBase_XA<iname, suffix, sz, bit_28, 0b0, 0b1, pattern>;
818 defm MVE_VMLSLDAVs16 : MVE_VMLSLDAV_multi<"vmlsldav", "s16", 0b0, 0b0>;
819 defm MVE_VMLSLDAVs32 : MVE_VMLSLDAV_multi<"vmlsldav", "s32", 0b1, 0b0>;
820 defm MVE_VRMLSLDAVHs32 : MVE_VMLSLDAV_multi<"vrmlsldavh", "s32", 0b0, 0b1>;
822 // end of mve_rDest instructions
824 // start of mve_comp instructions
826 class MVE_comp<InstrItinClass itin, string iname, string suffix,
827 string cstr, list<dag> pattern=[]>
828 : MVE_p<(outs MQPR:$Qd), (ins MQPR:$Qn, MQPR:$Qm), itin, iname, suffix,
829 "$Qd, $Qn, $Qm", vpred_r, cstr, pattern> {
834 let Inst{22} = Qd{3};
835 let Inst{19-17} = Qn{2-0};
837 let Inst{15-13} = Qd{2-0};
839 let Inst{10-9} = 0b11;
842 let Inst{3-1} = Qm{2-0};
846 class MVE_VMINMAXNM<string iname, string suffix, bit sz, bit bit_21,
847 list<dag> pattern=[]>
848 : MVE_comp<NoItinerary, iname, suffix, "", pattern> {
851 let Inst{25-24} = 0b11;
853 let Inst{21} = bit_21;
860 let Predicates = [HasMVEFloat];
863 def MVE_VMAXNMf32 : MVE_VMINMAXNM<"vmaxnm", "f32", 0b0, 0b0>;
864 def MVE_VMAXNMf16 : MVE_VMINMAXNM<"vmaxnm", "f16", 0b1, 0b0>;
866 let Predicates = [HasMVEFloat] in {
867 def : Pat<(v4f32 (fmaxnum (v4f32 MQPR:$val1), (v4f32 MQPR:$val2))),
868 (v4f32 (MVE_VMAXNMf32 (v4f32 MQPR:$val1), (v4f32 MQPR:$val2)))>;
869 def : Pat<(v8f16 (fmaxnum (v8f16 MQPR:$val1), (v8f16 MQPR:$val2))),
870 (v8f16 (MVE_VMAXNMf16 (v8f16 MQPR:$val1), (v8f16 MQPR:$val2)))>;
873 def MVE_VMINNMf32 : MVE_VMINMAXNM<"vminnm", "f32", 0b0, 0b1>;
874 def MVE_VMINNMf16 : MVE_VMINMAXNM<"vminnm", "f16", 0b1, 0b1>;
876 let Predicates = [HasMVEFloat] in {
877 def : Pat<(v4f32 (fminnum (v4f32 MQPR:$val1), (v4f32 MQPR:$val2))),
878 (v4f32 (MVE_VMINNMf32 (v4f32 MQPR:$val1), (v4f32 MQPR:$val2)))>;
879 def : Pat<(v8f16 (fminnum (v8f16 MQPR:$val1), (v8f16 MQPR:$val2))),
880 (v8f16 (MVE_VMINNMf16 (v8f16 MQPR:$val1), (v8f16 MQPR:$val2)))>;
884 class MVE_VMINMAX<string iname, string suffix, bit U, bits<2> size,
885 bit bit_4, list<dag> pattern=[]>
886 : MVE_comp<NoItinerary, iname, suffix, "", pattern> {
889 let Inst{25-24} = 0b11;
891 let Inst{21-20} = size{1-0};
898 multiclass MVE_VMINMAX_all_sizes<string iname, bit bit_4> {
899 def s8 : MVE_VMINMAX<iname, "s8", 0b0, 0b00, bit_4>;
900 def s16 : MVE_VMINMAX<iname, "s16", 0b0, 0b01, bit_4>;
901 def s32 : MVE_VMINMAX<iname, "s32", 0b0, 0b10, bit_4>;
902 def u8 : MVE_VMINMAX<iname, "u8", 0b1, 0b00, bit_4>;
903 def u16 : MVE_VMINMAX<iname, "u16", 0b1, 0b01, bit_4>;
904 def u32 : MVE_VMINMAX<iname, "u32", 0b1, 0b10, bit_4>;
907 defm MVE_VMAX : MVE_VMINMAX_all_sizes<"vmax", 0b0>;
908 defm MVE_VMIN : MVE_VMINMAX_all_sizes<"vmin", 0b1>;
910 let Predicates = [HasMVEInt] in {
911 def : Pat<(v16i8 (smin (v16i8 MQPR:$val1), (v16i8 MQPR:$val2))),
912 (v16i8 (MVE_VMINs8 (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
913 def : Pat<(v8i16 (smin (v8i16 MQPR:$val1), (v8i16 MQPR:$val2))),
914 (v8i16 (MVE_VMINs16 (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
915 def : Pat<(v4i32 (smin (v4i32 MQPR:$val1), (v4i32 MQPR:$val2))),
916 (v4i32 (MVE_VMINs32 (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
918 def : Pat<(v16i8 (smax (v16i8 MQPR:$val1), (v16i8 MQPR:$val2))),
919 (v16i8 (MVE_VMAXs8 (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
920 def : Pat<(v8i16 (smax (v8i16 MQPR:$val1), (v8i16 MQPR:$val2))),
921 (v8i16 (MVE_VMAXs16 (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
922 def : Pat<(v4i32 (smax (v4i32 MQPR:$val1), (v4i32 MQPR:$val2))),
923 (v4i32 (MVE_VMAXs32 (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
925 def : Pat<(v16i8 (umin (v16i8 MQPR:$val1), (v16i8 MQPR:$val2))),
926 (v16i8 (MVE_VMINu8 (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
927 def : Pat<(v8i16 (umin (v8i16 MQPR:$val1), (v8i16 MQPR:$val2))),
928 (v8i16 (MVE_VMINu16 (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
929 def : Pat<(v4i32 (umin (v4i32 MQPR:$val1), (v4i32 MQPR:$val2))),
930 (v4i32 (MVE_VMINu32 (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
932 def : Pat<(v16i8 (umax (v16i8 MQPR:$val1), (v16i8 MQPR:$val2))),
933 (v16i8 (MVE_VMAXu8 (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
934 def : Pat<(v8i16 (umax (v8i16 MQPR:$val1), (v8i16 MQPR:$val2))),
935 (v8i16 (MVE_VMAXu16 (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
936 def : Pat<(v4i32 (umax (v4i32 MQPR:$val1), (v4i32 MQPR:$val2))),
937 (v4i32 (MVE_VMAXu32 (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
940 // end of mve_comp instructions
942 // start of mve_bit instructions
944 class MVE_bit_arith<dag oops, dag iops, string iname, string suffix,
945 string ops, string cstr, list<dag> pattern=[]>
946 : MVE_p<oops, iops, NoItinerary, iname, suffix, ops, vpred_r, cstr, pattern> {
950 let Inst{22} = Qd{3};
951 let Inst{15-13} = Qd{2-0};
953 let Inst{3-1} = Qm{2-0};
956 def MVE_VBIC : MVE_bit_arith<(outs MQPR:$Qd), (ins MQPR:$Qn, MQPR:$Qm),
957 "vbic", "", "$Qd, $Qn, $Qm", ""> {
961 let Inst{25-23} = 0b110;
962 let Inst{21-20} = 0b01;
963 let Inst{19-17} = Qn{2-0};
965 let Inst{12-8} = 0b00001;
972 class MVE_VREV<string iname, string suffix, bits<2> size, bits<2> bit_8_7>
973 : MVE_bit_arith<(outs MQPR:$Qd), (ins MQPR:$Qm), iname,
974 suffix, "$Qd, $Qm", ""> {
977 let Inst{25-23} = 0b111;
978 let Inst{21-20} = 0b11;
979 let Inst{19-18} = size;
980 let Inst{17-16} = 0b00;
981 let Inst{12-9} = 0b0000;
982 let Inst{8-7} = bit_8_7;
988 def MVE_VREV64_8 : MVE_VREV<"vrev64", "8", 0b00, 0b00>;
989 def MVE_VREV64_16 : MVE_VREV<"vrev64", "16", 0b01, 0b00>;
990 def MVE_VREV64_32 : MVE_VREV<"vrev64", "32", 0b10, 0b00>;
992 def MVE_VREV32_8 : MVE_VREV<"vrev32", "8", 0b00, 0b01>;
993 def MVE_VREV32_16 : MVE_VREV<"vrev32", "16", 0b01, 0b01>;
995 def MVE_VREV16_8 : MVE_VREV<"vrev16", "8", 0b00, 0b10>;
997 let Predicates = [HasMVEInt] in {
998 def : Pat<(v4i32 (ARMvrev64 (v4i32 MQPR:$src))),
999 (v4i32 (MVE_VREV64_32 (v4i32 MQPR:$src)))>;
1000 def : Pat<(v8i16 (ARMvrev64 (v8i16 MQPR:$src))),
1001 (v8i16 (MVE_VREV64_16 (v8i16 MQPR:$src)))>;
1002 def : Pat<(v16i8 (ARMvrev64 (v16i8 MQPR:$src))),
1003 (v16i8 (MVE_VREV64_8 (v16i8 MQPR:$src)))>;
1005 def : Pat<(v8i16 (ARMvrev32 (v8i16 MQPR:$src))),
1006 (v8i16 (MVE_VREV32_16 (v8i16 MQPR:$src)))>;
1007 def : Pat<(v16i8 (ARMvrev32 (v16i8 MQPR:$src))),
1008 (v16i8 (MVE_VREV32_8 (v16i8 MQPR:$src)))>;
1010 def : Pat<(v16i8 (ARMvrev16 (v16i8 MQPR:$src))),
1011 (v16i8 (MVE_VREV16_8 (v16i8 MQPR:$src)))>;
1013 def : Pat<(v4f32 (ARMvrev64 (v4f32 MQPR:$src))),
1014 (v4f32 (MVE_VREV64_32 (v4f32 MQPR:$src)))>;
1015 def : Pat<(v8f16 (ARMvrev64 (v8f16 MQPR:$src))),
1016 (v8f16 (MVE_VREV64_16 (v8f16 MQPR:$src)))>;
1017 def : Pat<(v8f16 (ARMvrev32 (v8f16 MQPR:$src))),
1018 (v8f16 (MVE_VREV32_16 (v8f16 MQPR:$src)))>;
1021 def MVE_VMVN : MVE_bit_arith<(outs MQPR:$Qd), (ins MQPR:$Qm),
1022 "vmvn", "", "$Qd, $Qm", ""> {
1024 let Inst{25-23} = 0b111;
1025 let Inst{21-16} = 0b110000;
1026 let Inst{12-6} = 0b0010111;
1031 let Predicates = [HasMVEInt] in {
1032 def : Pat<(v16i8 (vnotq (v16i8 MQPR:$val1))),
1033 (v16i8 (MVE_VMVN (v16i8 MQPR:$val1)))>;
1034 def : Pat<(v8i16 (vnotq (v8i16 MQPR:$val1))),
1035 (v8i16 (MVE_VMVN (v8i16 MQPR:$val1)))>;
1036 def : Pat<(v4i32 (vnotq (v4i32 MQPR:$val1))),
1037 (v4i32 (MVE_VMVN (v4i32 MQPR:$val1)))>;
1040 class MVE_bit_ops<string iname, bits<2> bit_21_20, bit bit_28>
1041 : MVE_bit_arith<(outs MQPR:$Qd), (ins MQPR:$Qn, MQPR:$Qm),
1042 iname, "", "$Qd, $Qn, $Qm", ""> {
1045 let Inst{28} = bit_28;
1046 let Inst{25-23} = 0b110;
1047 let Inst{21-20} = bit_21_20;
1048 let Inst{19-17} = Qn{2-0};
1050 let Inst{12-8} = 0b00001;
1051 let Inst{7} = Qn{3};
1057 def MVE_VEOR : MVE_bit_ops<"veor", 0b00, 0b1>;
1058 def MVE_VORN : MVE_bit_ops<"vorn", 0b11, 0b0>;
1059 def MVE_VORR : MVE_bit_ops<"vorr", 0b10, 0b0>;
1060 def MVE_VAND : MVE_bit_ops<"vand", 0b00, 0b0>;
1062 // add ignored suffixes as aliases
1064 foreach s=["s8", "s16", "s32", "u8", "u16", "u32", "i8", "i16", "i32", "f16", "f32"] in {
1065 def : MVEInstAlias<"vbic${vp}." # s # "\t$QdSrc, $QnSrc, $QmSrc",
1066 (MVE_VBIC MQPR:$QdSrc, MQPR:$QnSrc, MQPR:$QmSrc, vpred_r:$vp)>;
1067 def : MVEInstAlias<"veor${vp}." # s # "\t$QdSrc, $QnSrc, $QmSrc",
1068 (MVE_VEOR MQPR:$QdSrc, MQPR:$QnSrc, MQPR:$QmSrc, vpred_r:$vp)>;
1069 def : MVEInstAlias<"vorn${vp}." # s # "\t$QdSrc, $QnSrc, $QmSrc",
1070 (MVE_VORN MQPR:$QdSrc, MQPR:$QnSrc, MQPR:$QmSrc, vpred_r:$vp)>;
1071 def : MVEInstAlias<"vorr${vp}." # s # "\t$QdSrc, $QnSrc, $QmSrc",
1072 (MVE_VORR MQPR:$QdSrc, MQPR:$QnSrc, MQPR:$QmSrc, vpred_r:$vp)>;
1073 def : MVEInstAlias<"vand${vp}." # s # "\t$QdSrc, $QnSrc, $QmSrc",
1074 (MVE_VAND MQPR:$QdSrc, MQPR:$QnSrc, MQPR:$QmSrc, vpred_r:$vp)>;
1077 let Predicates = [HasMVEInt] in {
1078 def : Pat<(v16i8 (and (v16i8 MQPR:$val1), (v16i8 MQPR:$val2))),
1079 (v16i8 (MVE_VAND (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
1080 def : Pat<(v8i16 (and (v8i16 MQPR:$val1), (v8i16 MQPR:$val2))),
1081 (v8i16 (MVE_VAND (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
1082 def : Pat<(v4i32 (and (v4i32 MQPR:$val1), (v4i32 MQPR:$val2))),
1083 (v4i32 (MVE_VAND (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
1085 def : Pat<(v16i8 (or (v16i8 MQPR:$val1), (v16i8 MQPR:$val2))),
1086 (v16i8 (MVE_VORR (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
1087 def : Pat<(v8i16 (or (v8i16 MQPR:$val1), (v8i16 MQPR:$val2))),
1088 (v8i16 (MVE_VORR (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
1089 def : Pat<(v4i32 (or (v4i32 MQPR:$val1), (v4i32 MQPR:$val2))),
1090 (v4i32 (MVE_VORR (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
1092 def : Pat<(v16i8 (xor (v16i8 MQPR:$val1), (v16i8 MQPR:$val2))),
1093 (v16i8 (MVE_VEOR (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
1094 def : Pat<(v8i16 (xor (v8i16 MQPR:$val1), (v8i16 MQPR:$val2))),
1095 (v8i16 (MVE_VEOR (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
1096 def : Pat<(v4i32 (xor (v4i32 MQPR:$val1), (v4i32 MQPR:$val2))),
1097 (v4i32 (MVE_VEOR (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
1099 def : Pat<(v16i8 (and (v16i8 MQPR:$val1), (vnotq MQPR:$val2))),
1100 (v16i8 (MVE_VBIC (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
1101 def : Pat<(v8i16 (and (v8i16 MQPR:$val1), (vnotq MQPR:$val2))),
1102 (v8i16 (MVE_VBIC (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
1103 def : Pat<(v4i32 (and (v4i32 MQPR:$val1), (vnotq MQPR:$val2))),
1104 (v4i32 (MVE_VBIC (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
1106 def : Pat<(v16i8 (or (v16i8 MQPR:$val1), (vnotq (v16i8 MQPR:$val2)))),
1107 (v16i8 (MVE_VORN (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
1108 def : Pat<(v8i16 (or (v8i16 MQPR:$val1), (vnotq MQPR:$val2))),
1109 (v8i16 (MVE_VORN (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
1110 def : Pat<(v4i32 (or (v4i32 MQPR:$val1), (vnotq MQPR:$val2))),
1111 (v4i32 (MVE_VORN (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
1114 class MVE_bit_cmode<string iname, string suffix, bits<4> cmode, dag inOps>
1115 : MVE_p<(outs MQPR:$Qd), inOps, NoItinerary,
1116 iname, suffix, "$Qd, $imm", vpred_n, "$Qd = $Qd_src"> {
1120 let Inst{28} = imm{7};
1121 let Inst{27-23} = 0b11111;
1122 let Inst{22} = Qd{3};
1123 let Inst{21-19} = 0b000;
1124 let Inst{18-16} = imm{6-4};
1125 let Inst{15-13} = Qd{2-0};
1127 let Inst{11-8} = cmode;
1128 let Inst{7-6} = 0b01;
1130 let Inst{3-0} = imm{3-0};
1133 class MVE_VORR<string suffix, bits<4> cmode, ExpandImm imm_type>
1134 : MVE_bit_cmode<"vorr", suffix, cmode, (ins MQPR:$Qd_src, imm_type:$imm)> {
1138 def MVE_VORRIZ0v4i32 : MVE_VORR<"i32", 0b0001, expzero00>;
1139 def MVE_VORRIZ0v8i16 : MVE_VORR<"i16", 0b1001, expzero00>;
1140 def MVE_VORRIZ8v4i32 : MVE_VORR<"i32", 0b0011, expzero08>;
1141 def MVE_VORRIZ8v8i16 : MVE_VORR<"i16", 0b1011, expzero08>;
1142 def MVE_VORRIZ16v4i32 : MVE_VORR<"i32", 0b0101, expzero16>;
1143 def MVE_VORRIZ24v4i32 : MVE_VORR<"i32", 0b0111, expzero24>;
1145 def MVE_VORNIZ0v4i32 : MVEAsmPseudo<"vorn${vp}.i32\t$Qd, $imm",
1146 (ins MQPR:$Qd_src, expzero00inv32:$imm, vpred_n:$vp), (outs MQPR:$Qd)>;
1147 def MVE_VORNIZ0v8i16 : MVEAsmPseudo<"vorn${vp}.i16\t$Qd, $imm",
1148 (ins MQPR:$Qd_src, expzero00inv16:$imm, vpred_n:$vp), (outs MQPR:$Qd)>;
1149 def MVE_VORNIZ8v4i32 : MVEAsmPseudo<"vorn${vp}.i32\t$Qd, $imm",
1150 (ins MQPR:$Qd_src, expzero08inv32:$imm, vpred_n:$vp), (outs MQPR:$Qd)>;
1151 def MVE_VORNIZ8v8i16 : MVEAsmPseudo<"vorn${vp}.i16\t$Qd, $imm",
1152 (ins MQPR:$Qd_src, expzero08inv16:$imm, vpred_n:$vp), (outs MQPR:$Qd)>;
1153 def MVE_VORNIZ16v4i32 : MVEAsmPseudo<"vorn${vp}.i32\t$Qd, $imm",
1154 (ins MQPR:$Qd_src, expzero16inv32:$imm, vpred_n:$vp), (outs MQPR:$Qd)>;
1155 def MVE_VORNIZ24v4i32 : MVEAsmPseudo<"vorn${vp}.i32\t$Qd, $imm",
1156 (ins MQPR:$Qd_src, expzero24inv32:$imm, vpred_n:$vp), (outs MQPR:$Qd)>;
1158 def MVE_VMOV : MVEInstAlias<"vmov${vp}\t$Qd, $Qm",
1159 (MVE_VORR MQPR:$Qd, MQPR:$Qm, MQPR:$Qm, vpred_r:$vp)>;
1161 class MVE_VBIC<string suffix, bits<4> cmode, ExpandImm imm_type>
1162 : MVE_bit_cmode<"vbic", suffix, cmode, (ins MQPR:$Qd_src, imm_type:$imm)> {
1166 def MVE_VBICIZ0v4i32 : MVE_VBIC<"i32", 0b0001, expzero00>;
1167 def MVE_VBICIZ0v8i16 : MVE_VBIC<"i16", 0b1001, expzero00>;
1168 def MVE_VBICIZ8v4i32 : MVE_VBIC<"i32", 0b0011, expzero08>;
1169 def MVE_VBICIZ8v8i16 : MVE_VBIC<"i16", 0b1011, expzero08>;
1170 def MVE_VBICIZ16v4i32 : MVE_VBIC<"i32", 0b0101, expzero16>;
1171 def MVE_VBICIZ24v4i32 : MVE_VBIC<"i32", 0b0111, expzero24>;
1173 def MVE_VANDIZ0v4i32 : MVEAsmPseudo<"vand${vp}.i32\t$Qda, $imm",
1174 (ins MQPR:$Qda_src, expzero00inv32:$imm, vpred_n:$vp), (outs MQPR:$Qda)>;
1175 def MVE_VANDIZ0v8i16 : MVEAsmPseudo<"vand${vp}.i16\t$Qda, $imm",
1176 (ins MQPR:$Qda_src, expzero00inv16:$imm, vpred_n:$vp), (outs MQPR:$Qda)>;
1177 def MVE_VANDIZ8v4i32 : MVEAsmPseudo<"vand${vp}.i32\t$Qda, $imm",
1178 (ins MQPR:$Qda_src, expzero08inv32:$imm, vpred_n:$vp), (outs MQPR:$Qda)>;
1179 def MVE_VANDIZ8v8i16 : MVEAsmPseudo<"vand${vp}.i16\t$Qda, $imm",
1180 (ins MQPR:$Qda_src, expzero08inv16:$imm, vpred_n:$vp), (outs MQPR:$Qda)>;
1181 def MVE_VANDIZ16v4i32 : MVEAsmPseudo<"vand${vp}.i32\t$Qda, $imm",
1182 (ins MQPR:$Qda_src, expzero16inv32:$imm, vpred_n:$vp), (outs MQPR:$Qda)>;
1183 def MVE_VANDIZ24v4i32 : MVEAsmPseudo<"vand${vp}.i32\t$Qda, $imm",
1184 (ins MQPR:$Qda_src, expzero24inv32:$imm, vpred_n:$vp), (outs MQPR:$Qda)>;
1186 class MVE_VMOV_lane_direction {
1193 def MVE_VMOV_from_lane : MVE_VMOV_lane_direction {
1195 let oops = (outs rGPR:$Rt);
1196 let iops = (ins MQPR:$Qd);
1197 let ops = "$Rt, $Qd$Idx";
1200 def MVE_VMOV_to_lane : MVE_VMOV_lane_direction {
1202 let oops = (outs MQPR:$Qd);
1203 let iops = (ins MQPR:$Qd_src, rGPR:$Rt);
1204 let ops = "$Qd$Idx, $Rt";
1205 let cstr = "$Qd = $Qd_src";
1208 class MVE_VMOV_lane<string suffix, bit U, dag indexop,
1209 MVE_VMOV_lane_direction dir>
1210 : MVE_VMOV_lane_base<dir.oops, !con(dir.iops, indexop), NoItinerary,
1211 "vmov", suffix, dir.ops, dir.cstr, []> {
1215 let Inst{31-24} = 0b11101110;
1217 let Inst{20} = dir.bit_20;
1218 let Inst{19-17} = Qd{2-0};
1219 let Inst{15-12} = Rt{3-0};
1220 let Inst{11-8} = 0b1011;
1221 let Inst{7} = Qd{3};
1222 let Inst{4-0} = 0b10000;
1225 class MVE_VMOV_lane_32<MVE_VMOV_lane_direction dir>
1226 : MVE_VMOV_lane<"32", 0b0, (ins MVEVectorIndex<4>:$Idx), dir> {
1229 let Inst{6-5} = 0b00;
1230 let Inst{16} = Idx{1};
1231 let Inst{21} = Idx{0};
1233 let Predicates = [HasFPRegsV8_1M];
1236 class MVE_VMOV_lane_16<string suffix, bit U, MVE_VMOV_lane_direction dir>
1237 : MVE_VMOV_lane<suffix, U, (ins MVEVectorIndex<8>:$Idx), dir> {
1241 let Inst{16} = Idx{2};
1242 let Inst{21} = Idx{1};
1243 let Inst{6} = Idx{0};
1246 class MVE_VMOV_lane_8<string suffix, bit U, MVE_VMOV_lane_direction dir>
1247 : MVE_VMOV_lane<suffix, U, (ins MVEVectorIndex<16>:$Idx), dir> {
1250 let Inst{16} = Idx{3};
1251 let Inst{21} = Idx{2};
1252 let Inst{6} = Idx{1};
1253 let Inst{5} = Idx{0};
1256 def MVE_VMOV_from_lane_32 : MVE_VMOV_lane_32< MVE_VMOV_from_lane>;
1257 def MVE_VMOV_to_lane_32 : MVE_VMOV_lane_32< MVE_VMOV_to_lane>;
1258 def MVE_VMOV_from_lane_s16 : MVE_VMOV_lane_16<"s16", 0b0, MVE_VMOV_from_lane>;
1259 def MVE_VMOV_from_lane_u16 : MVE_VMOV_lane_16<"u16", 0b1, MVE_VMOV_from_lane>;
1260 def MVE_VMOV_to_lane_16 : MVE_VMOV_lane_16< "16", 0b0, MVE_VMOV_to_lane>;
1261 def MVE_VMOV_from_lane_s8 : MVE_VMOV_lane_8 < "s8", 0b0, MVE_VMOV_from_lane>;
1262 def MVE_VMOV_from_lane_u8 : MVE_VMOV_lane_8 < "u8", 0b1, MVE_VMOV_from_lane>;
1263 def MVE_VMOV_to_lane_8 : MVE_VMOV_lane_8 < "8", 0b0, MVE_VMOV_to_lane>;
1265 let Predicates = [HasMVEInt] in {
1266 def : Pat<(extractelt (v2f64 MQPR:$src), imm:$lane),
1267 (f64 (EXTRACT_SUBREG MQPR:$src, (DSubReg_f64_reg imm:$lane)))>;
1268 def : Pat<(insertelt (v2f64 MQPR:$src1), DPR:$src2, imm:$lane),
1269 (INSERT_SUBREG (v2f64 (COPY_TO_REGCLASS MQPR:$src1, MQPR)), DPR:$src2, (DSubReg_f64_reg imm:$lane))>;
1271 def : Pat<(extractelt (v4i32 MQPR:$src), imm:$lane),
1273 (i32 (EXTRACT_SUBREG MQPR:$src, (SSubReg_f32_reg imm:$lane))), rGPR)>;
1274 def : Pat<(insertelt (v4i32 MQPR:$src1), rGPR:$src2, imm:$lane),
1275 (MVE_VMOV_to_lane_32 MQPR:$src1, rGPR:$src2, imm:$lane)>;
1277 def : Pat<(vector_insert (v16i8 MQPR:$src1), rGPR:$src2, imm:$lane),
1278 (MVE_VMOV_to_lane_8 MQPR:$src1, rGPR:$src2, imm:$lane)>;
1279 def : Pat<(vector_insert (v8i16 MQPR:$src1), rGPR:$src2, imm:$lane),
1280 (MVE_VMOV_to_lane_16 MQPR:$src1, rGPR:$src2, imm:$lane)>;
1282 def : Pat<(ARMvgetlanes (v16i8 MQPR:$src), imm:$lane),
1283 (MVE_VMOV_from_lane_s8 MQPR:$src, imm:$lane)>;
1284 def : Pat<(ARMvgetlanes (v8i16 MQPR:$src), imm:$lane),
1285 (MVE_VMOV_from_lane_s16 MQPR:$src, imm:$lane)>;
1286 def : Pat<(ARMvgetlaneu (v16i8 MQPR:$src), imm:$lane),
1287 (MVE_VMOV_from_lane_u8 MQPR:$src, imm:$lane)>;
1288 def : Pat<(ARMvgetlaneu (v8i16 MQPR:$src), imm:$lane),
1289 (MVE_VMOV_from_lane_u16 MQPR:$src, imm:$lane)>;
1291 def : Pat<(v16i8 (scalar_to_vector GPR:$src)),
1292 (MVE_VMOV_to_lane_8 (v16i8 (IMPLICIT_DEF)), rGPR:$src, (i32 0))>;
1293 def : Pat<(v8i16 (scalar_to_vector GPR:$src)),
1294 (MVE_VMOV_to_lane_16 (v8i16 (IMPLICIT_DEF)), rGPR:$src, (i32 0))>;
1295 def : Pat<(v4i32 (scalar_to_vector GPR:$src)),
1296 (MVE_VMOV_to_lane_32 (v4i32 (IMPLICIT_DEF)), rGPR:$src, (i32 0))>;
1298 // Floating point patterns, still enabled under HasMVEInt
1299 def : Pat<(extractelt (v4f32 MQPR:$src), imm:$lane),
1300 (COPY_TO_REGCLASS (f32 (EXTRACT_SUBREG MQPR:$src, (SSubReg_f32_reg imm:$lane))), SPR)>;
1301 def : Pat<(insertelt (v4f32 MQPR:$src1), (f32 SPR:$src2), imm:$lane),
1302 (INSERT_SUBREG (v4f32 (COPY_TO_REGCLASS MQPR:$src1, MQPR)), SPR:$src2, (SSubReg_f32_reg imm:$lane))>;
1304 def : Pat<(insertelt (v8f16 MQPR:$src1), HPR:$src2, imm:$lane),
1305 (MVE_VMOV_to_lane_16 MQPR:$src1, (COPY_TO_REGCLASS HPR:$src2, rGPR), imm:$lane)>;
1306 def : Pat<(extractelt (v8f16 MQPR:$src), imm:$lane),
1307 (COPY_TO_REGCLASS (MVE_VMOV_from_lane_u16 MQPR:$src, imm:$lane), HPR)>;
1309 def : Pat<(v4f32 (scalar_to_vector SPR:$src)),
1310 (INSERT_SUBREG (v4f32 (IMPLICIT_DEF)), SPR:$src, ssub_0)>;
1311 def : Pat<(v4f32 (scalar_to_vector GPR:$src)),
1312 (MVE_VMOV_to_lane_32 (v4f32 (IMPLICIT_DEF)), rGPR:$src, (i32 0))>;
1313 def : Pat<(v8f16 (scalar_to_vector HPR:$src)),
1314 (INSERT_SUBREG (v8f16 (IMPLICIT_DEF)), HPR:$src, ssub_0)>;
1315 def : Pat<(v8f16 (scalar_to_vector GPR:$src)),
1316 (MVE_VMOV_to_lane_16 (v8f16 (IMPLICIT_DEF)), rGPR:$src, (i32 0))>;
1319 // end of mve_bit instructions
1321 // start of MVE Integer instructions
1323 class MVE_int<string iname, string suffix, bits<2> size, list<dag> pattern=[]>
1324 : MVE_p<(outs MQPR:$Qd), (ins MQPR:$Qn, MQPR:$Qm), NoItinerary,
1325 iname, suffix, "$Qd, $Qn, $Qm", vpred_r, "", pattern> {
1330 let Inst{22} = Qd{3};
1331 let Inst{21-20} = size;
1332 let Inst{19-17} = Qn{2-0};
1333 let Inst{15-13} = Qd{2-0};
1334 let Inst{7} = Qn{3};
1336 let Inst{5} = Qm{3};
1337 let Inst{3-1} = Qm{2-0};
1340 class MVE_VMULt1<string suffix, bits<2> size, list<dag> pattern=[]>
1341 : MVE_int<"vmul", suffix, size, pattern> {
1344 let Inst{25-23} = 0b110;
1346 let Inst{12-8} = 0b01001;
1351 def MVE_VMULt1i8 : MVE_VMULt1<"i8", 0b00>;
1352 def MVE_VMULt1i16 : MVE_VMULt1<"i16", 0b01>;
1353 def MVE_VMULt1i32 : MVE_VMULt1<"i32", 0b10>;
1355 let Predicates = [HasMVEInt] in {
1356 def : Pat<(v16i8 (mul (v16i8 MQPR:$val1), (v16i8 MQPR:$val2))),
1357 (v16i8 (MVE_VMULt1i8 (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
1358 def : Pat<(v8i16 (mul (v8i16 MQPR:$val1), (v8i16 MQPR:$val2))),
1359 (v8i16 (MVE_VMULt1i16 (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
1360 def : Pat<(v4i32 (mul (v4i32 MQPR:$val1), (v4i32 MQPR:$val2))),
1361 (v4i32 (MVE_VMULt1i32 (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
1364 class MVE_VQxDMULH<string iname, string suffix, bits<2> size, bit rounding,
1365 list<dag> pattern=[]>
1366 : MVE_int<iname, suffix, size, pattern> {
1368 let Inst{28} = rounding;
1369 let Inst{25-23} = 0b110;
1371 let Inst{12-8} = 0b01011;
1376 class MVE_VQDMULH<string suffix, bits<2> size, list<dag> pattern=[]>
1377 : MVE_VQxDMULH<"vqdmulh", suffix, size, 0b0, pattern>;
1378 class MVE_VQRDMULH<string suffix, bits<2> size, list<dag> pattern=[]>
1379 : MVE_VQxDMULH<"vqrdmulh", suffix, size, 0b1, pattern>;
1381 def MVE_VQDMULHi8 : MVE_VQDMULH<"s8", 0b00>;
1382 def MVE_VQDMULHi16 : MVE_VQDMULH<"s16", 0b01>;
1383 def MVE_VQDMULHi32 : MVE_VQDMULH<"s32", 0b10>;
1385 def MVE_VQRDMULHi8 : MVE_VQRDMULH<"s8", 0b00>;
1386 def MVE_VQRDMULHi16 : MVE_VQRDMULH<"s16", 0b01>;
1387 def MVE_VQRDMULHi32 : MVE_VQRDMULH<"s32", 0b10>;
1389 class MVE_VADDSUB<string iname, string suffix, bits<2> size, bit subtract,
1390 list<dag> pattern=[]>
1391 : MVE_int<iname, suffix, size, pattern> {
1393 let Inst{28} = subtract;
1394 let Inst{25-23} = 0b110;
1396 let Inst{12-8} = 0b01000;
1401 class MVE_VADD<string suffix, bits<2> size, list<dag> pattern=[]>
1402 : MVE_VADDSUB<"vadd", suffix, size, 0b0, pattern>;
1403 class MVE_VSUB<string suffix, bits<2> size, list<dag> pattern=[]>
1404 : MVE_VADDSUB<"vsub", suffix, size, 0b1, pattern>;
1406 def MVE_VADDi8 : MVE_VADD<"i8", 0b00>;
1407 def MVE_VADDi16 : MVE_VADD<"i16", 0b01>;
1408 def MVE_VADDi32 : MVE_VADD<"i32", 0b10>;
1410 let Predicates = [HasMVEInt] in {
1411 def : Pat<(v16i8 (add (v16i8 MQPR:$val1), (v16i8 MQPR:$val2))),
1412 (v16i8 (MVE_VADDi8 (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
1413 def : Pat<(v8i16 (add (v8i16 MQPR:$val1), (v8i16 MQPR:$val2))),
1414 (v8i16 (MVE_VADDi16 (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
1415 def : Pat<(v4i32 (add (v4i32 MQPR:$val1), (v4i32 MQPR:$val2))),
1416 (v4i32 (MVE_VADDi32 (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
1419 def MVE_VSUBi8 : MVE_VSUB<"i8", 0b00>;
1420 def MVE_VSUBi16 : MVE_VSUB<"i16", 0b01>;
1421 def MVE_VSUBi32 : MVE_VSUB<"i32", 0b10>;
1423 let Predicates = [HasMVEInt] in {
1424 def : Pat<(v16i8 (sub (v16i8 MQPR:$val1), (v16i8 MQPR:$val2))),
1425 (v16i8 (MVE_VSUBi8 (v16i8 MQPR:$val1), (v16i8 MQPR:$val2)))>;
1426 def : Pat<(v8i16 (sub (v8i16 MQPR:$val1), (v8i16 MQPR:$val2))),
1427 (v8i16 (MVE_VSUBi16 (v8i16 MQPR:$val1), (v8i16 MQPR:$val2)))>;
1428 def : Pat<(v4i32 (sub (v4i32 MQPR:$val1), (v4i32 MQPR:$val2))),
1429 (v4i32 (MVE_VSUBi32 (v4i32 MQPR:$val1), (v4i32 MQPR:$val2)))>;
1432 class MVE_VQADDSUB<string iname, string suffix, bit U, bit subtract,
1433 bits<2> size, list<dag> pattern=[]>
1434 : MVE_int<iname, suffix, size, pattern> {
1437 let Inst{25-23} = 0b110;
1439 let Inst{12-10} = 0b000;
1440 let Inst{9} = subtract;
1446 class MVE_VQADD<string suffix, bit U, bits<2> size, list<dag> pattern=[]>
1447 : MVE_VQADDSUB<"vqadd", suffix, U, 0b0, size, pattern>;
1448 class MVE_VQSUB<string suffix, bit U, bits<2> size, list<dag> pattern=[]>
1449 : MVE_VQADDSUB<"vqsub", suffix, U, 0b1, size, pattern>;
1451 def MVE_VQADDs8 : MVE_VQADD<"s8", 0b0, 0b00>;
1452 def MVE_VQADDs16 : MVE_VQADD<"s16", 0b0, 0b01>;
1453 def MVE_VQADDs32 : MVE_VQADD<"s32", 0b0, 0b10>;
1454 def MVE_VQADDu8 : MVE_VQADD<"u8", 0b1, 0b00>;
1455 def MVE_VQADDu16 : MVE_VQADD<"u16", 0b1, 0b01>;
1456 def MVE_VQADDu32 : MVE_VQADD<"u32", 0b1, 0b10>;
1458 def MVE_VQSUBs8 : MVE_VQSUB<"s8", 0b0, 0b00>;
1459 def MVE_VQSUBs16 : MVE_VQSUB<"s16", 0b0, 0b01>;
1460 def MVE_VQSUBs32 : MVE_VQSUB<"s32", 0b0, 0b10>;
1461 def MVE_VQSUBu8 : MVE_VQSUB<"u8", 0b1, 0b00>;
1462 def MVE_VQSUBu16 : MVE_VQSUB<"u16", 0b1, 0b01>;
1463 def MVE_VQSUBu32 : MVE_VQSUB<"u32", 0b1, 0b10>;
1465 class MVE_VABD_int<string suffix, bit U, bits<2> size, list<dag> pattern=[]>
1466 : MVE_int<"vabd", suffix, size, pattern> {
1469 let Inst{25-23} = 0b110;
1471 let Inst{12-8} = 0b00111;
1476 def MVE_VABDs8 : MVE_VABD_int<"s8", 0b0, 0b00>;
1477 def MVE_VABDs16 : MVE_VABD_int<"s16", 0b0, 0b01>;
1478 def MVE_VABDs32 : MVE_VABD_int<"s32", 0b0, 0b10>;
1479 def MVE_VABDu8 : MVE_VABD_int<"u8", 0b1, 0b00>;
1480 def MVE_VABDu16 : MVE_VABD_int<"u16", 0b1, 0b01>;
1481 def MVE_VABDu32 : MVE_VABD_int<"u32", 0b1, 0b10>;
1483 class MVE_VRHADD<string suffix, bit U, bits<2> size, list<dag> pattern=[]>
1484 : MVE_int<"vrhadd", suffix, size, pattern> {
1487 let Inst{25-23} = 0b110;
1489 let Inst{12-8} = 0b00001;
1494 def MVE_VRHADDs8 : MVE_VRHADD<"s8", 0b0, 0b00>;
1495 def MVE_VRHADDs16 : MVE_VRHADD<"s16", 0b0, 0b01>;
1496 def MVE_VRHADDs32 : MVE_VRHADD<"s32", 0b0, 0b10>;
1497 def MVE_VRHADDu8 : MVE_VRHADD<"u8", 0b1, 0b00>;
1498 def MVE_VRHADDu16 : MVE_VRHADD<"u16", 0b1, 0b01>;
1499 def MVE_VRHADDu32 : MVE_VRHADD<"u32", 0b1, 0b10>;
1501 class MVE_VHADDSUB<string iname, string suffix, bit U, bit subtract,
1502 bits<2> size, list<dag> pattern=[]>
1503 : MVE_int<iname, suffix, size, pattern> {
1506 let Inst{25-23} = 0b110;
1508 let Inst{12-10} = 0b000;
1509 let Inst{9} = subtract;
1515 class MVE_VHADD<string suffix, bit U, bits<2> size,
1516 list<dag> pattern=[]>
1517 : MVE_VHADDSUB<"vhadd", suffix, U, 0b0, size, pattern>;
1518 class MVE_VHSUB<string suffix, bit U, bits<2> size,
1519 list<dag> pattern=[]>
1520 : MVE_VHADDSUB<"vhsub", suffix, U, 0b1, size, pattern>;
1522 def MVE_VHADDs8 : MVE_VHADD<"s8", 0b0, 0b00>;
1523 def MVE_VHADDs16 : MVE_VHADD<"s16", 0b0, 0b01>;
1524 def MVE_VHADDs32 : MVE_VHADD<"s32", 0b0, 0b10>;
1525 def MVE_VHADDu8 : MVE_VHADD<"u8", 0b1, 0b00>;
1526 def MVE_VHADDu16 : MVE_VHADD<"u16", 0b1, 0b01>;
1527 def MVE_VHADDu32 : MVE_VHADD<"u32", 0b1, 0b10>;
1529 def MVE_VHSUBs8 : MVE_VHSUB<"s8", 0b0, 0b00>;
1530 def MVE_VHSUBs16 : MVE_VHSUB<"s16", 0b0, 0b01>;
1531 def MVE_VHSUBs32 : MVE_VHSUB<"s32", 0b0, 0b10>;
1532 def MVE_VHSUBu8 : MVE_VHSUB<"u8", 0b1, 0b00>;
1533 def MVE_VHSUBu16 : MVE_VHSUB<"u16", 0b1, 0b01>;
1534 def MVE_VHSUBu32 : MVE_VHSUB<"u32", 0b1, 0b10>;
1536 class MVE_VDUP<string suffix, bit B, bit E, list<dag> pattern=[]>
1537 : MVE_p<(outs MQPR:$Qd), (ins rGPR:$Rt), NoItinerary,
1538 "vdup", suffix, "$Qd, $Rt", vpred_r, "", pattern> {
1543 let Inst{25-23} = 0b101;
1545 let Inst{21-20} = 0b10;
1546 let Inst{19-17} = Qd{2-0};
1548 let Inst{15-12} = Rt;
1549 let Inst{11-8} = 0b1011;
1550 let Inst{7} = Qd{3};
1553 let Inst{4-0} = 0b10000;
1556 def MVE_VDUP32 : MVE_VDUP<"32", 0b0, 0b0>;
1557 def MVE_VDUP16 : MVE_VDUP<"16", 0b0, 0b1>;
1558 def MVE_VDUP8 : MVE_VDUP<"8", 0b1, 0b0>;
1560 let Predicates = [HasMVEInt] in {
1561 def : Pat<(v16i8 (ARMvdup (i32 rGPR:$elem))),
1562 (MVE_VDUP8 rGPR:$elem)>;
1563 def : Pat<(v8i16 (ARMvdup (i32 rGPR:$elem))),
1564 (MVE_VDUP16 rGPR:$elem)>;
1565 def : Pat<(v4i32 (ARMvdup (i32 rGPR:$elem))),
1566 (MVE_VDUP32 rGPR:$elem)>;
1568 def : Pat<(v4i32 (ARMvduplane (v4i32 MQPR:$src), imm:$lane)),
1569 (MVE_VDUP32 (MVE_VMOV_from_lane_32 MQPR:$src, imm:$lane))>;
1570 // For the 16-bit and 8-bit vduplanes we don't care about the signedness
1571 // of the lane move operation as we only want the lowest 8/16 bits anyway.
1572 def : Pat<(v8i16 (ARMvduplane (v8i16 MQPR:$src), imm:$lane)),
1573 (MVE_VDUP16 (MVE_VMOV_from_lane_u16 MQPR:$src, imm:$lane))>;
1574 def : Pat<(v16i8 (ARMvduplane (v16i8 MQPR:$src), imm:$lane)),
1575 (MVE_VDUP8 (MVE_VMOV_from_lane_u8 MQPR:$src, imm:$lane))>;
1577 def : Pat<(v4f32 (ARMvdup (f32 SPR:$elem))),
1578 (v4f32 (MVE_VDUP32 (i32 (COPY_TO_REGCLASS (f32 SPR:$elem), rGPR))))>;
1579 def : Pat<(v8f16 (ARMvdup (f16 HPR:$elem))),
1580 (v8f16 (MVE_VDUP16 (i32 (COPY_TO_REGCLASS (f16 HPR:$elem), rGPR))))>;
1582 def : Pat<(v4f32 (ARMvduplane (v4f32 MQPR:$src), imm:$lane)),
1583 (MVE_VDUP32 (MVE_VMOV_from_lane_32 MQPR:$src, imm:$lane))>;
1584 def : Pat<(v8f16 (ARMvduplane (v8f16 MQPR:$src), imm:$lane)),
1585 (MVE_VDUP16 (MVE_VMOV_from_lane_u16 MQPR:$src, imm:$lane))>;
1589 class MVEIntSingleSrc<string iname, string suffix, bits<2> size,
1590 list<dag> pattern=[]>
1591 : MVE_p<(outs MQPR:$Qd), (ins MQPR:$Qm), NoItinerary,
1592 iname, suffix, "$Qd, $Qm", vpred_r, "", pattern> {
1596 let Inst{22} = Qd{3};
1597 let Inst{19-18} = size{1-0};
1598 let Inst{15-13} = Qd{2-0};
1599 let Inst{5} = Qm{3};
1600 let Inst{3-1} = Qm{2-0};
1603 class MVE_VCLSCLZ<string iname, string suffix, bits<2> size,
1604 bit count_zeroes, list<dag> pattern=[]>
1605 : MVEIntSingleSrc<iname, suffix, size, pattern> {
1608 let Inst{25-23} = 0b111;
1609 let Inst{21-20} = 0b11;
1610 let Inst{17-16} = 0b00;
1611 let Inst{12-8} = 0b00100;
1612 let Inst{7} = count_zeroes;
1618 def MVE_VCLSs8 : MVE_VCLSCLZ<"vcls", "s8", 0b00, 0b0>;
1619 def MVE_VCLSs16 : MVE_VCLSCLZ<"vcls", "s16", 0b01, 0b0>;
1620 def MVE_VCLSs32 : MVE_VCLSCLZ<"vcls", "s32", 0b10, 0b0>;
1622 def MVE_VCLZs8 : MVE_VCLSCLZ<"vclz", "i8", 0b00, 0b1>;
1623 def MVE_VCLZs16 : MVE_VCLSCLZ<"vclz", "i16", 0b01, 0b1>;
1624 def MVE_VCLZs32 : MVE_VCLSCLZ<"vclz", "i32", 0b10, 0b1>;
1626 class MVE_VABSNEG_int<string iname, string suffix, bits<2> size, bit negate,
1627 list<dag> pattern=[]>
1628 : MVEIntSingleSrc<iname, suffix, size, pattern> {
1631 let Inst{25-23} = 0b111;
1632 let Inst{21-20} = 0b11;
1633 let Inst{17-16} = 0b01;
1634 let Inst{12-8} = 0b00011;
1635 let Inst{7} = negate;
1641 def MVE_VABSs8 : MVE_VABSNEG_int<"vabs", "s8", 0b00, 0b0>;
1642 def MVE_VABSs16 : MVE_VABSNEG_int<"vabs", "s16", 0b01, 0b0>;
1643 def MVE_VABSs32 : MVE_VABSNEG_int<"vabs", "s32", 0b10, 0b0>;
1645 let Predicates = [HasMVEInt] in {
1646 def : Pat<(v16i8 (abs (v16i8 MQPR:$v))),
1647 (v16i8 (MVE_VABSs8 $v))>;
1648 def : Pat<(v8i16 (abs (v8i16 MQPR:$v))),
1649 (v8i16 (MVE_VABSs16 $v))>;
1650 def : Pat<(v4i32 (abs (v4i32 MQPR:$v))),
1651 (v4i32 (MVE_VABSs32 $v))>;
1654 def MVE_VNEGs8 : MVE_VABSNEG_int<"vneg", "s8", 0b00, 0b1>;
1655 def MVE_VNEGs16 : MVE_VABSNEG_int<"vneg", "s16", 0b01, 0b1>;
1656 def MVE_VNEGs32 : MVE_VABSNEG_int<"vneg", "s32", 0b10, 0b1>;
1658 let Predicates = [HasMVEInt] in {
1659 def : Pat<(v16i8 (vnegq (v16i8 MQPR:$v))),
1660 (v16i8 (MVE_VNEGs8 $v))>;
1661 def : Pat<(v8i16 (vnegq (v8i16 MQPR:$v))),
1662 (v8i16 (MVE_VNEGs16 $v))>;
1663 def : Pat<(v4i32 (vnegq (v4i32 MQPR:$v))),
1664 (v4i32 (MVE_VNEGs32 $v))>;
1667 class MVE_VQABSNEG<string iname, string suffix, bits<2> size,
1668 bit negate, list<dag> pattern=[]>
1669 : MVEIntSingleSrc<iname, suffix, size, pattern> {
1672 let Inst{25-23} = 0b111;
1673 let Inst{21-20} = 0b11;
1674 let Inst{17-16} = 0b00;
1675 let Inst{12-8} = 0b00111;
1676 let Inst{7} = negate;
1682 def MVE_VQABSs8 : MVE_VQABSNEG<"vqabs", "s8", 0b00, 0b0>;
1683 def MVE_VQABSs16 : MVE_VQABSNEG<"vqabs", "s16", 0b01, 0b0>;
1684 def MVE_VQABSs32 : MVE_VQABSNEG<"vqabs", "s32", 0b10, 0b0>;
1686 def MVE_VQNEGs8 : MVE_VQABSNEG<"vqneg", "s8", 0b00, 0b1>;
1687 def MVE_VQNEGs16 : MVE_VQABSNEG<"vqneg", "s16", 0b01, 0b1>;
1688 def MVE_VQNEGs32 : MVE_VQABSNEG<"vqneg", "s32", 0b10, 0b1>;
1690 class MVE_mod_imm<string iname, string suffix, bits<4> cmode, bit op,
1691 dag iops, list<dag> pattern=[]>
1692 : MVE_p<(outs MQPR:$Qd), iops, NoItinerary, iname, suffix, "$Qd, $imm",
1693 vpred_r, "", pattern> {
1697 let Inst{28} = imm{7};
1698 let Inst{25-23} = 0b111;
1699 let Inst{22} = Qd{3};
1700 let Inst{21-19} = 0b000;
1701 let Inst{18-16} = imm{6-4};
1702 let Inst{15-13} = Qd{2-0};
1704 let Inst{11-8} = cmode{3-0};
1705 let Inst{7-6} = 0b01;
1708 let Inst{3-0} = imm{3-0};
1710 let DecoderMethod = "DecodeMVEModImmInstruction";
1713 let isReMaterializable = 1 in {
1714 let isAsCheapAsAMove = 1 in {
1715 def MVE_VMOVimmi8 : MVE_mod_imm<"vmov", "i8", {1,1,1,0}, 0b0, (ins nImmSplatI8:$imm)>;
1716 def MVE_VMOVimmi16 : MVE_mod_imm<"vmov", "i16", {1,0,?,0}, 0b0, (ins nImmSplatI16:$imm)> {
1717 let Inst{9} = imm{9};
1719 def MVE_VMOVimmi32 : MVE_mod_imm<"vmov", "i32", {?,?,?,?}, 0b0, (ins nImmVMOVI32:$imm)> {
1720 let Inst{11-8} = imm{11-8};
1722 def MVE_VMOVimmi64 : MVE_mod_imm<"vmov", "i64", {1,1,1,0}, 0b1, (ins nImmSplatI64:$imm)>;
1723 def MVE_VMOVimmf32 : MVE_mod_imm<"vmov", "f32", {1,1,1,1}, 0b0, (ins nImmVMOVF32:$imm)>;
1724 } // let isAsCheapAsAMove = 1
1726 def MVE_VMVNimmi16 : MVE_mod_imm<"vmvn", "i16", {1,0,?,0}, 0b1, (ins nImmSplatI16:$imm)> {
1727 let Inst{9} = imm{9};
1729 def MVE_VMVNimmi32 : MVE_mod_imm<"vmvn", "i32", {?,?,?,?}, 0b1, (ins nImmVMOVI32:$imm)> {
1730 let Inst{11-8} = imm{11-8};
1732 } // let isReMaterializable = 1
1734 let Predicates = [HasMVEInt] in {
1735 def : Pat<(v16i8 (ARMvmovImm timm:$simm)),
1736 (v16i8 (MVE_VMOVimmi8 nImmSplatI8:$simm))>;
1737 def : Pat<(v8i16 (ARMvmovImm timm:$simm)),
1738 (v8i16 (MVE_VMOVimmi16 nImmSplatI16:$simm))>;
1739 def : Pat<(v4i32 (ARMvmovImm timm:$simm)),
1740 (v4i32 (MVE_VMOVimmi32 nImmVMOVI32:$simm))>;
1742 def : Pat<(v8i16 (ARMvmvnImm timm:$simm)),
1743 (v8i16 (MVE_VMVNimmi16 nImmSplatI16:$simm))>;
1744 def : Pat<(v4i32 (ARMvmvnImm timm:$simm)),
1745 (v4i32 (MVE_VMVNimmi32 nImmVMOVI32:$simm))>;
1747 def : Pat<(v4f32 (ARMvmovFPImm timm:$simm)),
1748 (v4f32 (MVE_VMOVimmf32 nImmVMOVF32:$simm))>;
1751 class MVE_VMINMAXA<string iname, string suffix, bits<2> size,
1752 bit bit_12, list<dag> pattern=[]>
1753 : MVE_p<(outs MQPR:$Qd), (ins MQPR:$Qd_src, MQPR:$Qm),
1754 NoItinerary, iname, suffix, "$Qd, $Qm", vpred_n, "$Qd = $Qd_src",
1760 let Inst{25-23} = 0b100;
1761 let Inst{22} = Qd{3};
1762 let Inst{21-20} = 0b11;
1763 let Inst{19-18} = size;
1764 let Inst{17-16} = 0b11;
1765 let Inst{15-13} = Qd{2-0};
1766 let Inst{12} = bit_12;
1767 let Inst{11-6} = 0b111010;
1768 let Inst{5} = Qm{3};
1770 let Inst{3-1} = Qm{2-0};
1774 def MVE_VMAXAs8 : MVE_VMINMAXA<"vmaxa", "s8", 0b00, 0b0>;
1775 def MVE_VMAXAs16 : MVE_VMINMAXA<"vmaxa", "s16", 0b01, 0b0>;
1776 def MVE_VMAXAs32 : MVE_VMINMAXA<"vmaxa", "s32", 0b10, 0b0>;
1778 def MVE_VMINAs8 : MVE_VMINMAXA<"vmina", "s8", 0b00, 0b1>;
1779 def MVE_VMINAs16 : MVE_VMINMAXA<"vmina", "s16", 0b01, 0b1>;
1780 def MVE_VMINAs32 : MVE_VMINMAXA<"vmina", "s32", 0b10, 0b1>;
1782 // end of MVE Integer instructions
1784 // start of mve_imm_shift instructions
1786 def MVE_VSHLC : MVE_p<(outs rGPR:$RdmDest, MQPR:$Qd),
1787 (ins MQPR:$QdSrc, rGPR:$RdmSrc, long_shift:$imm),
1788 NoItinerary, "vshlc", "", "$QdSrc, $RdmSrc, $imm",
1789 vpred_n, "$RdmDest = $RdmSrc,$Qd = $QdSrc"> {
1795 let Inst{25-23} = 0b101;
1796 let Inst{22} = Qd{3};
1798 let Inst{20-16} = imm{4-0};
1799 let Inst{15-13} = Qd{2-0};
1800 let Inst{12-4} = 0b011111100;
1801 let Inst{3-0} = RdmDest{3-0};
1804 class MVE_shift_imm<dag oops, dag iops, string iname, string suffix,
1805 string ops, vpred_ops vpred, string cstr,
1806 list<dag> pattern=[]>
1807 : MVE_p<oops, iops, NoItinerary, iname, suffix, ops, vpred, cstr, pattern> {
1811 let Inst{22} = Qd{3};
1812 let Inst{15-13} = Qd{2-0};
1813 let Inst{5} = Qm{3};
1814 let Inst{3-1} = Qm{2-0};
1817 class MVE_VMOVL<string iname, string suffix, bits<2> sz, bit U,
1818 list<dag> pattern=[]>
1819 : MVE_shift_imm<(outs MQPR:$Qd), (ins MQPR:$Qm),
1820 iname, suffix, "$Qd, $Qm", vpred_r, "",
1823 let Inst{25-23} = 0b101;
1825 let Inst{20-19} = sz{1-0};
1826 let Inst{18-16} = 0b000;
1827 let Inst{11-6} = 0b111101;
1832 multiclass MVE_VMOVL_shift_half<string iname, string suffix, bits<2> sz, bit U,
1833 list<dag> pattern=[]> {
1834 def bh : MVE_VMOVL<!strconcat(iname, "b"), suffix, sz, U, pattern> {
1837 def th : MVE_VMOVL<!strconcat(iname, "t"), suffix, sz, U, pattern> {
1842 defm MVE_VMOVLs8 : MVE_VMOVL_shift_half<"vmovl", "s8", 0b01, 0b0>;
1843 defm MVE_VMOVLu8 : MVE_VMOVL_shift_half<"vmovl", "u8", 0b01, 0b1>;
1844 defm MVE_VMOVLs16 : MVE_VMOVL_shift_half<"vmovl", "s16", 0b10, 0b0>;
1845 defm MVE_VMOVLu16 : MVE_VMOVL_shift_half<"vmovl", "u16", 0b10, 0b1>;
1847 let Predicates = [HasMVEInt] in {
1848 def : Pat<(sext_inreg (v4i32 MQPR:$src), v4i16),
1849 (MVE_VMOVLs16bh MQPR:$src)>;
1850 def : Pat<(sext_inreg (v8i16 MQPR:$src), v8i8),
1851 (MVE_VMOVLs8bh MQPR:$src)>;
1852 def : Pat<(sext_inreg (v4i32 MQPR:$src), v4i8),
1853 (MVE_VMOVLs16bh (MVE_VMOVLs8bh MQPR:$src))>;
1855 // zext_inreg 16 -> 32
1856 def : Pat<(and (v4i32 MQPR:$src), (v4i32 (ARMvmovImm (i32 0xCFF)))),
1857 (MVE_VMOVLu16bh MQPR:$src)>;
1858 // zext_inreg 8 -> 16
1859 def : Pat<(and (v8i16 MQPR:$src), (v8i16 (ARMvmovImm (i32 0x8FF)))),
1860 (MVE_VMOVLu8bh MQPR:$src)>;
1864 class MVE_VSHLL_imm<string iname, string suffix, bit U, bit th,
1865 dag immops, list<dag> pattern=[]>
1866 : MVE_shift_imm<(outs MQPR:$Qd), !con((ins MQPR:$Qm), immops),
1867 iname, suffix, "$Qd, $Qm, $imm", vpred_r, "", pattern> {
1869 let Inst{25-23} = 0b101;
1872 let Inst{11-6} = 0b111101;
1877 // The immediate VSHLL instructions accept shift counts from 1 up to
1878 // the lane width (8 or 16), but the full-width shifts have an
1879 // entirely separate encoding, given below with 'lw' in the name.
1881 class MVE_VSHLL_imm8<string iname, string suffix,
1882 bit U, bit th, list<dag> pattern=[]>
1883 : MVE_VSHLL_imm<iname, suffix, U, th, (ins mve_shift_imm1_7:$imm), pattern> {
1885 let Inst{20-19} = 0b01;
1886 let Inst{18-16} = imm;
1889 class MVE_VSHLL_imm16<string iname, string suffix,
1890 bit U, bit th, list<dag> pattern=[]>
1891 : MVE_VSHLL_imm<iname, suffix, U, th, (ins mve_shift_imm1_15:$imm), pattern> {
1894 let Inst{19-16} = imm;
1897 def MVE_VSHLL_imms8bh : MVE_VSHLL_imm8 <"vshllb", "s8", 0b0, 0b0>;
1898 def MVE_VSHLL_imms8th : MVE_VSHLL_imm8 <"vshllt", "s8", 0b0, 0b1>;
1899 def MVE_VSHLL_immu8bh : MVE_VSHLL_imm8 <"vshllb", "u8", 0b1, 0b0>;
1900 def MVE_VSHLL_immu8th : MVE_VSHLL_imm8 <"vshllt", "u8", 0b1, 0b1>;
1901 def MVE_VSHLL_imms16bh : MVE_VSHLL_imm16<"vshllb", "s16", 0b0, 0b0>;
1902 def MVE_VSHLL_imms16th : MVE_VSHLL_imm16<"vshllt", "s16", 0b0, 0b1>;
1903 def MVE_VSHLL_immu16bh : MVE_VSHLL_imm16<"vshllb", "u16", 0b1, 0b0>;
1904 def MVE_VSHLL_immu16th : MVE_VSHLL_imm16<"vshllt", "u16", 0b1, 0b1>;
1906 class MVE_VSHLL_by_lane_width<string iname, string suffix, bits<2> size,
1907 bit U, string ops, list<dag> pattern=[]>
1908 : MVE_shift_imm<(outs MQPR:$Qd), (ins MQPR:$Qm),
1909 iname, suffix, ops, vpred_r, "", pattern> {
1911 let Inst{25-23} = 0b100;
1912 let Inst{21-20} = 0b11;
1913 let Inst{19-18} = size{1-0};
1914 let Inst{17-16} = 0b01;
1915 let Inst{11-6} = 0b111000;
1920 multiclass MVE_VSHLL_lw<string iname, string suffix, bits<2> sz, bit U,
1921 string ops, list<dag> pattern=[]> {
1922 def bh : MVE_VSHLL_by_lane_width<iname#"b", suffix, sz, U, ops, pattern> {
1925 def th : MVE_VSHLL_by_lane_width<iname#"t", suffix, sz, U, ops, pattern> {
1930 defm MVE_VSHLL_lws8 : MVE_VSHLL_lw<"vshll", "s8", 0b00, 0b0, "$Qd, $Qm, #8">;
1931 defm MVE_VSHLL_lws16 : MVE_VSHLL_lw<"vshll", "s16", 0b01, 0b0, "$Qd, $Qm, #16">;
1932 defm MVE_VSHLL_lwu8 : MVE_VSHLL_lw<"vshll", "u8", 0b00, 0b1, "$Qd, $Qm, #8">;
1933 defm MVE_VSHLL_lwu16 : MVE_VSHLL_lw<"vshll", "u16", 0b01, 0b1, "$Qd, $Qm, #16">;
1935 class MVE_VxSHRN<string iname, string suffix, bit bit_12, bit bit_28,
1936 dag immops, list<dag> pattern=[]>
1937 : MVE_shift_imm<(outs MQPR:$Qd), !con((ins MQPR:$QdSrc, MQPR:$Qm), immops),
1938 iname, suffix, "$Qd, $Qm, $imm", vpred_n, "$Qd = $QdSrc",
1942 let Inst{28} = bit_28;
1943 let Inst{25-23} = 0b101;
1945 let Inst{20-16} = imm{4-0};
1946 let Inst{12} = bit_12;
1947 let Inst{11-6} = 0b111111;
1952 def MVE_VRSHRNi16bh : MVE_VxSHRN<
1953 "vrshrnb", "i16", 0b0, 0b1, (ins shr_imm8:$imm)> {
1954 let Inst{20-19} = 0b01;
1956 def MVE_VRSHRNi16th : MVE_VxSHRN<
1957 "vrshrnt", "i16", 0b1, 0b1,(ins shr_imm8:$imm)> {
1958 let Inst{20-19} = 0b01;
1960 def MVE_VRSHRNi32bh : MVE_VxSHRN<
1961 "vrshrnb", "i32", 0b0, 0b1, (ins shr_imm16:$imm)> {
1964 def MVE_VRSHRNi32th : MVE_VxSHRN<
1965 "vrshrnt", "i32", 0b1, 0b1, (ins shr_imm16:$imm)> {
1969 def MVE_VSHRNi16bh : MVE_VxSHRN<
1970 "vshrnb", "i16", 0b0, 0b0, (ins shr_imm8:$imm)> {
1971 let Inst{20-19} = 0b01;
1973 def MVE_VSHRNi16th : MVE_VxSHRN<
1974 "vshrnt", "i16", 0b1, 0b0, (ins shr_imm8:$imm)> {
1975 let Inst{20-19} = 0b01;
1977 def MVE_VSHRNi32bh : MVE_VxSHRN<
1978 "vshrnb", "i32", 0b0, 0b0, (ins shr_imm16:$imm)> {
1981 def MVE_VSHRNi32th : MVE_VxSHRN<
1982 "vshrnt", "i32", 0b1, 0b0, (ins shr_imm16:$imm)> {
1986 class MVE_VxQRSHRUN<string iname, string suffix, bit bit_28, bit bit_12, dag immops,
1987 list<dag> pattern=[]>
1988 : MVE_shift_imm<(outs MQPR:$Qd), !con((ins MQPR:$QdSrc, MQPR:$Qm), immops),
1989 iname, suffix, "$Qd, $Qm, $imm", vpred_n, "$Qd = $QdSrc",
1993 let Inst{28} = bit_28;
1994 let Inst{25-23} = 0b101;
1996 let Inst{20-16} = imm{4-0};
1997 let Inst{12} = bit_12;
1998 let Inst{11-6} = 0b111111;
2003 def MVE_VQRSHRUNs16bh : MVE_VxQRSHRUN<
2004 "vqrshrunb", "s16", 0b1, 0b0, (ins shr_imm8:$imm)> {
2005 let Inst{20-19} = 0b01;
2007 def MVE_VQRSHRUNs16th : MVE_VxQRSHRUN<
2008 "vqrshrunt", "s16", 0b1, 0b1, (ins shr_imm8:$imm)> {
2009 let Inst{20-19} = 0b01;
2011 def MVE_VQRSHRUNs32bh : MVE_VxQRSHRUN<
2012 "vqrshrunb", "s32", 0b1, 0b0, (ins shr_imm16:$imm)> {
2015 def MVE_VQRSHRUNs32th : MVE_VxQRSHRUN<
2016 "vqrshrunt", "s32", 0b1, 0b1, (ins shr_imm16:$imm)> {
2020 def MVE_VQSHRUNs16bh : MVE_VxQRSHRUN<
2021 "vqshrunb", "s16", 0b0, 0b0, (ins shr_imm8:$imm)> {
2022 let Inst{20-19} = 0b01;
2024 def MVE_VQSHRUNs16th : MVE_VxQRSHRUN<
2025 "vqshrunt", "s16", 0b0, 0b1, (ins shr_imm8:$imm)> {
2026 let Inst{20-19} = 0b01;
2028 def MVE_VQSHRUNs32bh : MVE_VxQRSHRUN<
2029 "vqshrunb", "s32", 0b0, 0b0, (ins shr_imm16:$imm)> {
2032 def MVE_VQSHRUNs32th : MVE_VxQRSHRUN<
2033 "vqshrunt", "s32", 0b0, 0b1, (ins shr_imm16:$imm)> {
2037 class MVE_VxQRSHRN<string iname, string suffix, bit bit_0, bit bit_12,
2038 dag immops, list<dag> pattern=[]>
2039 : MVE_shift_imm<(outs MQPR:$Qd), !con((ins MQPR:$QdSrc, MQPR:$Qm), immops),
2040 iname, suffix, "$Qd, $Qm, $imm", vpred_n, "$Qd = $QdSrc",
2044 let Inst{25-23} = 0b101;
2046 let Inst{20-16} = imm{4-0};
2047 let Inst{12} = bit_12;
2048 let Inst{11-6} = 0b111101;
2050 let Inst{0} = bit_0;
2053 multiclass MVE_VxQRSHRN_types<string iname, bit bit_0, bit bit_12> {
2054 def s16 : MVE_VxQRSHRN<iname, "s16", bit_0, bit_12, (ins shr_imm8:$imm)> {
2056 let Inst{20-19} = 0b01;
2058 def u16 : MVE_VxQRSHRN<iname, "u16", bit_0, bit_12, (ins shr_imm8:$imm)> {
2060 let Inst{20-19} = 0b01;
2062 def s32 : MVE_VxQRSHRN<iname, "s32", bit_0, bit_12, (ins shr_imm16:$imm)> {
2066 def u32 : MVE_VxQRSHRN<iname, "u32", bit_0, bit_12, (ins shr_imm16:$imm)> {
2072 defm MVE_VQRSHRNbh : MVE_VxQRSHRN_types<"vqrshrnb", 0b1, 0b0>;
2073 defm MVE_VQRSHRNth : MVE_VxQRSHRN_types<"vqrshrnt", 0b1, 0b1>;
2074 defm MVE_VQSHRNbh : MVE_VxQRSHRN_types<"vqshrnb", 0b0, 0b0>;
2075 defm MVE_VQSHRNth : MVE_VxQRSHRN_types<"vqshrnt", 0b0, 0b1>;
2077 // end of mve_imm_shift instructions
2079 // start of mve_shift instructions
2081 class MVE_shift_by_vec<string iname, string suffix, bit U,
2082 bits<2> size, bit bit_4, bit bit_8>
2083 : MVE_p<(outs MQPR:$Qd), (ins MQPR:$Qm, MQPR:$Qn), NoItinerary,
2084 iname, suffix, "$Qd, $Qm, $Qn", vpred_r, "", []> {
2085 // Shift instructions which take a vector of shift counts
2091 let Inst{25-24} = 0b11;
2093 let Inst{22} = Qd{3};
2094 let Inst{21-20} = size;
2095 let Inst{19-17} = Qn{2-0};
2097 let Inst{15-13} = Qd{2-0};
2098 let Inst{12-9} = 0b0010;
2099 let Inst{8} = bit_8;
2100 let Inst{7} = Qn{3};
2102 let Inst{5} = Qm{3};
2103 let Inst{4} = bit_4;
2104 let Inst{3-1} = Qm{2-0};
2108 multiclass mve_shift_by_vec_multi<string iname, bit bit_4, bit bit_8> {
2109 def s8 : MVE_shift_by_vec<iname, "s8", 0b0, 0b00, bit_4, bit_8>;
2110 def s16 : MVE_shift_by_vec<iname, "s16", 0b0, 0b01, bit_4, bit_8>;
2111 def s32 : MVE_shift_by_vec<iname, "s32", 0b0, 0b10, bit_4, bit_8>;
2112 def u8 : MVE_shift_by_vec<iname, "u8", 0b1, 0b00, bit_4, bit_8>;
2113 def u16 : MVE_shift_by_vec<iname, "u16", 0b1, 0b01, bit_4, bit_8>;
2114 def u32 : MVE_shift_by_vec<iname, "u32", 0b1, 0b10, bit_4, bit_8>;
2117 defm MVE_VSHL_by_vec : mve_shift_by_vec_multi<"vshl", 0b0, 0b0>;
2118 defm MVE_VQSHL_by_vec : mve_shift_by_vec_multi<"vqshl", 0b1, 0b0>;
2119 defm MVE_VQRSHL_by_vec : mve_shift_by_vec_multi<"vqrshl", 0b1, 0b1>;
2120 defm MVE_VRSHL_by_vec : mve_shift_by_vec_multi<"vrshl", 0b0, 0b1>;
2122 class MVE_shift_with_imm<string iname, string suffix, dag oops, dag iops,
2123 string ops, vpred_ops vpred, string cstr,
2124 list<dag> pattern=[]>
2125 : MVE_p<oops, iops, NoItinerary, iname, suffix, ops, vpred, cstr, pattern> {
2130 let Inst{22} = Qd{3};
2131 let Inst{15-13} = Qd{2-0};
2132 let Inst{12-11} = 0b00;
2133 let Inst{7-6} = 0b01;
2134 let Inst{5} = Qm{3};
2136 let Inst{3-1} = Qm{2-0};
2140 class MVE_VSxI_imm<string iname, string suffix, bit bit_8, dag imm>
2141 : MVE_shift_with_imm<iname, suffix, (outs MQPR:$Qd),
2142 !con((ins MQPR:$Qd_src, MQPR:$Qm), imm),
2143 "$Qd, $Qm, $imm", vpred_n, "$Qd = $Qd_src"> {
2146 let Inst{25-24} = 0b11;
2147 let Inst{21-16} = imm;
2148 let Inst{10-9} = 0b10;
2149 let Inst{8} = bit_8;
2152 def MVE_VSRIimm8 : MVE_VSxI_imm<"vsri", "8", 0b0, (ins shr_imm8:$imm)> {
2153 let Inst{21-19} = 0b001;
2156 def MVE_VSRIimm16 : MVE_VSxI_imm<"vsri", "16", 0b0, (ins shr_imm16:$imm)> {
2157 let Inst{21-20} = 0b01;
2160 def MVE_VSRIimm32 : MVE_VSxI_imm<"vsri", "32", 0b0, (ins shr_imm32:$imm)> {
2164 def MVE_VSLIimm8 : MVE_VSxI_imm<"vsli", "8", 0b1, (ins imm0_7:$imm)> {
2165 let Inst{21-19} = 0b001;
2168 def MVE_VSLIimm16 : MVE_VSxI_imm<"vsli", "16", 0b1, (ins imm0_15:$imm)> {
2169 let Inst{21-20} = 0b01;
2172 def MVE_VSLIimm32 : MVE_VSxI_imm<"vsli", "32", 0b1,(ins imm0_31:$imm)> {
2176 class MVE_VQSHL_imm<string suffix, dag imm>
2177 : MVE_shift_with_imm<"vqshl", suffix, (outs MQPR:$Qd),
2178 !con((ins MQPR:$Qm), imm), "$Qd, $Qm, $imm",
2182 let Inst{25-24} = 0b11;
2183 let Inst{21-16} = imm;
2184 let Inst{10-8} = 0b111;
2187 def MVE_VSLIimms8 : MVE_VQSHL_imm<"s8", (ins imm0_7:$imm)> {
2189 let Inst{21-19} = 0b001;
2192 def MVE_VSLIimmu8 : MVE_VQSHL_imm<"u8", (ins imm0_7:$imm)> {
2194 let Inst{21-19} = 0b001;
2197 def MVE_VSLIimms16 : MVE_VQSHL_imm<"s16", (ins imm0_15:$imm)> {
2199 let Inst{21-20} = 0b01;
2202 def MVE_VSLIimmu16 : MVE_VQSHL_imm<"u16", (ins imm0_15:$imm)> {
2204 let Inst{21-20} = 0b01;
2207 def MVE_VSLIimms32 : MVE_VQSHL_imm<"s32", (ins imm0_31:$imm)> {
2212 def MVE_VSLIimmu32 : MVE_VQSHL_imm<"u32", (ins imm0_31:$imm)> {
2217 class MVE_VQSHLU_imm<string suffix, dag imm>
2218 : MVE_shift_with_imm<"vqshlu", suffix, (outs MQPR:$Qd),
2219 !con((ins MQPR:$Qm), imm), "$Qd, $Qm, $imm",
2224 let Inst{25-24} = 0b11;
2225 let Inst{21-16} = imm;
2226 let Inst{10-8} = 0b110;
2229 def MVE_VQSHLU_imms8 : MVE_VQSHLU_imm<"s8", (ins imm0_7:$imm)> {
2230 let Inst{21-19} = 0b001;
2233 def MVE_VQSHLU_imms16 : MVE_VQSHLU_imm<"s16", (ins imm0_15:$imm)> {
2234 let Inst{21-20} = 0b01;
2237 def MVE_VQSHLU_imms32 : MVE_VQSHLU_imm<"s32", (ins imm0_31:$imm)> {
2241 class MVE_VRSHR_imm<string suffix, dag imm>
2242 : MVE_shift_with_imm<"vrshr", suffix, (outs MQPR:$Qd),
2243 !con((ins MQPR:$Qm), imm), "$Qd, $Qm, $imm",
2247 let Inst{25-24} = 0b11;
2248 let Inst{21-16} = imm;
2249 let Inst{10-8} = 0b010;
2252 def MVE_VRSHR_imms8 : MVE_VRSHR_imm<"s8", (ins shr_imm8:$imm)> {
2254 let Inst{21-19} = 0b001;
2257 def MVE_VRSHR_immu8 : MVE_VRSHR_imm<"u8", (ins shr_imm8:$imm)> {
2259 let Inst{21-19} = 0b001;
2262 def MVE_VRSHR_imms16 : MVE_VRSHR_imm<"s16", (ins shr_imm16:$imm)> {
2264 let Inst{21-20} = 0b01;
2267 def MVE_VRSHR_immu16 : MVE_VRSHR_imm<"u16", (ins shr_imm16:$imm)> {
2269 let Inst{21-20} = 0b01;
2272 def MVE_VRSHR_imms32 : MVE_VRSHR_imm<"s32", (ins shr_imm32:$imm)> {
2277 def MVE_VRSHR_immu32 : MVE_VRSHR_imm<"u32", (ins shr_imm32:$imm)> {
2282 class MVE_VSHR_imm<string suffix, dag imm>
2283 : MVE_shift_with_imm<"vshr", suffix, (outs MQPR:$Qd),
2284 !con((ins MQPR:$Qm), imm), "$Qd, $Qm, $imm",
2288 let Inst{25-24} = 0b11;
2289 let Inst{21-16} = imm;
2290 let Inst{10-8} = 0b000;
2293 def MVE_VSHR_imms8 : MVE_VSHR_imm<"s8", (ins shr_imm8:$imm)> {
2295 let Inst{21-19} = 0b001;
2298 def MVE_VSHR_immu8 : MVE_VSHR_imm<"u8", (ins shr_imm8:$imm)> {
2300 let Inst{21-19} = 0b001;
2303 def MVE_VSHR_imms16 : MVE_VSHR_imm<"s16", (ins shr_imm16:$imm)> {
2305 let Inst{21-20} = 0b01;
2308 def MVE_VSHR_immu16 : MVE_VSHR_imm<"u16", (ins shr_imm16:$imm)> {
2310 let Inst{21-20} = 0b01;
2313 def MVE_VSHR_imms32 : MVE_VSHR_imm<"s32", (ins shr_imm32:$imm)> {
2318 def MVE_VSHR_immu32 : MVE_VSHR_imm<"u32", (ins shr_imm32:$imm)> {
2323 class MVE_VSHL_imm<string suffix, dag imm>
2324 : MVE_shift_with_imm<"vshl", suffix, (outs MQPR:$Qd),
2325 !con((ins MQPR:$Qm), imm), "$Qd, $Qm, $imm",
2330 let Inst{25-24} = 0b11;
2331 let Inst{21-16} = imm;
2332 let Inst{10-8} = 0b101;
2335 def MVE_VSHL_immi8 : MVE_VSHL_imm<"i8", (ins imm0_7:$imm)> {
2336 let Inst{21-19} = 0b001;
2339 def MVE_VSHL_immi16 : MVE_VSHL_imm<"i16", (ins imm0_15:$imm)> {
2340 let Inst{21-20} = 0b01;
2343 def MVE_VSHL_immi32 : MVE_VSHL_imm<"i32", (ins imm0_31:$imm)> {
2347 // end of mve_shift instructions
2349 // start of MVE Floating Point instructions
2351 class MVE_float<string iname, string suffix, dag oops, dag iops, string ops,
2352 vpred_ops vpred, string cstr, list<dag> pattern=[]>
2353 : MVE_f<oops, iops, NoItinerary, iname, suffix, ops, vpred, cstr, pattern> {
2358 let Inst{5} = Qm{3};
2359 let Inst{3-1} = Qm{2-0};
2363 class MVE_VRINT<string rmode, bits<3> op, string suffix, bits<2> size,
2364 list<dag> pattern=[]>
2365 : MVE_float<!strconcat("vrint", rmode), suffix, (outs MQPR:$Qd),
2366 (ins MQPR:$Qm), "$Qd, $Qm", vpred_r, "", pattern> {
2370 let Inst{25-23} = 0b111;
2371 let Inst{22} = Qd{3};
2372 let Inst{21-20} = 0b11;
2373 let Inst{19-18} = size;
2374 let Inst{17-16} = 0b10;
2375 let Inst{15-13} = Qd{2-0};
2376 let Inst{11-10} = 0b01;
2377 let Inst{9-7} = op{2-0};
2382 multiclass MVE_VRINT_ops<string suffix, bits<2> size, list<dag> pattern=[]> {
2383 def N : MVE_VRINT<"n", 0b000, suffix, size, pattern>;
2384 def X : MVE_VRINT<"x", 0b001, suffix, size, pattern>;
2385 def A : MVE_VRINT<"a", 0b010, suffix, size, pattern>;
2386 def Z : MVE_VRINT<"z", 0b011, suffix, size, pattern>;
2387 def M : MVE_VRINT<"m", 0b101, suffix, size, pattern>;
2388 def P : MVE_VRINT<"p", 0b111, suffix, size, pattern>;
2391 defm MVE_VRINTf16 : MVE_VRINT_ops<"f16", 0b01>;
2392 defm MVE_VRINTf32 : MVE_VRINT_ops<"f32", 0b10>;
2394 let Predicates = [HasMVEFloat] in {
2395 def : Pat<(v4f32 (frint (v4f32 MQPR:$val1))),
2396 (v4f32 (MVE_VRINTf32X (v4f32 MQPR:$val1)))>;
2397 def : Pat<(v8f16 (frint (v8f16 MQPR:$val1))),
2398 (v8f16 (MVE_VRINTf16X (v8f16 MQPR:$val1)))>;
2399 def : Pat<(v4f32 (fround (v4f32 MQPR:$val1))),
2400 (v4f32 (MVE_VRINTf32A (v4f32 MQPR:$val1)))>;
2401 def : Pat<(v8f16 (fround (v8f16 MQPR:$val1))),
2402 (v8f16 (MVE_VRINTf16A (v8f16 MQPR:$val1)))>;
2403 def : Pat<(v4f32 (ftrunc (v4f32 MQPR:$val1))),
2404 (v4f32 (MVE_VRINTf32Z (v4f32 MQPR:$val1)))>;
2405 def : Pat<(v8f16 (ftrunc (v8f16 MQPR:$val1))),
2406 (v8f16 (MVE_VRINTf16Z (v8f16 MQPR:$val1)))>;
2407 def : Pat<(v4f32 (ffloor (v4f32 MQPR:$val1))),
2408 (v4f32 (MVE_VRINTf32M (v4f32 MQPR:$val1)))>;
2409 def : Pat<(v8f16 (ffloor (v8f16 MQPR:$val1))),
2410 (v8f16 (MVE_VRINTf16M (v8f16 MQPR:$val1)))>;
2411 def : Pat<(v4f32 (fceil (v4f32 MQPR:$val1))),
2412 (v4f32 (MVE_VRINTf32P (v4f32 MQPR:$val1)))>;
2413 def : Pat<(v8f16 (fceil (v8f16 MQPR:$val1))),
2414 (v8f16 (MVE_VRINTf16P (v8f16 MQPR:$val1)))>;
2417 class MVEFloatArithNeon<string iname, string suffix, bit size,
2418 dag oops, dag iops, string ops,
2419 vpred_ops vpred, string cstr, list<dag> pattern=[]>
2420 : MVE_float<iname, suffix, oops, iops, ops, vpred, cstr, pattern> {
2421 let Inst{20} = size;
2425 class MVE_VMUL_fp<string suffix, bit size, list<dag> pattern=[]>
2426 : MVEFloatArithNeon<"vmul", suffix, size, (outs MQPR:$Qd),
2427 (ins MQPR:$Qn, MQPR:$Qm), "$Qd, $Qn, $Qm", vpred_r, "",
2433 let Inst{25-23} = 0b110;
2434 let Inst{22} = Qd{3};
2436 let Inst{19-17} = Qn{2-0};
2437 let Inst{15-13} = Qd{2-0};
2438 let Inst{12-8} = 0b01101;
2439 let Inst{7} = Qn{3};
2443 def MVE_VMULf32 : MVE_VMUL_fp<"f32", 0b0>;
2444 def MVE_VMULf16 : MVE_VMUL_fp<"f16", 0b1>;
2446 let Predicates = [HasMVEFloat] in {
2447 def : Pat<(v4f32 (fmul (v4f32 MQPR:$val1), (v4f32 MQPR:$val2))),
2448 (v4f32 (MVE_VMULf32 (v4f32 MQPR:$val1), (v4f32 MQPR:$val2)))>;
2449 def : Pat<(v8f16 (fmul (v8f16 MQPR:$val1), (v8f16 MQPR:$val2))),
2450 (v8f16 (MVE_VMULf16 (v8f16 MQPR:$val1), (v8f16 MQPR:$val2)))>;
2453 class MVE_VCMLA<string suffix, bit size, list<dag> pattern=[]>
2454 : MVEFloatArithNeon<"vcmla", suffix, size, (outs MQPR:$Qd),
2455 (ins MQPR:$Qd_src, MQPR:$Qn, MQPR:$Qm, complexrotateop:$rot),
2456 "$Qd, $Qn, $Qm, $rot", vpred_n, "$Qd = $Qd_src", pattern> {
2463 let Inst{24-23} = rot;
2464 let Inst{22} = Qd{3};
2466 let Inst{19-17} = Qn{2-0};
2467 let Inst{15-13} = Qd{2-0};
2468 let Inst{12-8} = 0b01000;
2469 let Inst{7} = Qn{3};
2473 def MVE_VCMLAf16 : MVE_VCMLA<"f16", 0b0>;
2474 def MVE_VCMLAf32 : MVE_VCMLA<"f32", 0b1>;
2476 class MVE_VADDSUBFMA_fp<string iname, string suffix, bit size, bit bit_4,
2477 bit bit_8, bit bit_21, dag iops=(ins),
2478 vpred_ops vpred=vpred_r, string cstr="",
2479 list<dag> pattern=[]>
2480 : MVEFloatArithNeon<iname, suffix, size, (outs MQPR:$Qd),
2481 !con(iops, (ins MQPR:$Qn, MQPR:$Qm)), "$Qd, $Qn, $Qm",
2482 vpred, cstr, pattern> {
2487 let Inst{25-23} = 0b110;
2488 let Inst{22} = Qd{3};
2489 let Inst{21} = bit_21;
2490 let Inst{19-17} = Qn{2-0};
2491 let Inst{15-13} = Qd{2-0};
2492 let Inst{11-9} = 0b110;
2493 let Inst{8} = bit_8;
2494 let Inst{7} = Qn{3};
2495 let Inst{4} = bit_4;
2498 def MVE_VFMAf32 : MVE_VADDSUBFMA_fp<"vfma", "f32", 0b0, 0b1, 0b0, 0b0,
2499 (ins MQPR:$Qd_src), vpred_n, "$Qd = $Qd_src">;
2500 def MVE_VFMAf16 : MVE_VADDSUBFMA_fp<"vfma", "f16", 0b1, 0b1, 0b0, 0b0,
2501 (ins MQPR:$Qd_src), vpred_n, "$Qd = $Qd_src">;
2503 def MVE_VFMSf32 : MVE_VADDSUBFMA_fp<"vfms", "f32", 0b0, 0b1, 0b0, 0b1,
2504 (ins MQPR:$Qd_src), vpred_n, "$Qd = $Qd_src">;
2505 def MVE_VFMSf16 : MVE_VADDSUBFMA_fp<"vfms", "f16", 0b1, 0b1, 0b0, 0b1,
2506 (ins MQPR:$Qd_src), vpred_n, "$Qd = $Qd_src">;
2508 def MVE_VADDf32 : MVE_VADDSUBFMA_fp<"vadd", "f32", 0b0, 0b0, 0b1, 0b0>;
2509 def MVE_VADDf16 : MVE_VADDSUBFMA_fp<"vadd", "f16", 0b1, 0b0, 0b1, 0b0>;
2511 let Predicates = [HasMVEFloat] in {
2512 def : Pat<(v4f32 (fadd (v4f32 MQPR:$val1), (v4f32 MQPR:$val2))),
2513 (v4f32 (MVE_VADDf32 (v4f32 MQPR:$val1), (v4f32 MQPR:$val2)))>;
2514 def : Pat<(v8f16 (fadd (v8f16 MQPR:$val1), (v8f16 MQPR:$val2))),
2515 (v8f16 (MVE_VADDf16 (v8f16 MQPR:$val1), (v8f16 MQPR:$val2)))>;
2518 def MVE_VSUBf32 : MVE_VADDSUBFMA_fp<"vsub", "f32", 0b0, 0b0, 0b1, 0b1>;
2519 def MVE_VSUBf16 : MVE_VADDSUBFMA_fp<"vsub", "f16", 0b1, 0b0, 0b1, 0b1>;
2521 let Predicates = [HasMVEFloat] in {
2522 def : Pat<(v4f32 (fsub (v4f32 MQPR:$val1), (v4f32 MQPR:$val2))),
2523 (v4f32 (MVE_VSUBf32 (v4f32 MQPR:$val1), (v4f32 MQPR:$val2)))>;
2524 def : Pat<(v8f16 (fsub (v8f16 MQPR:$val1), (v8f16 MQPR:$val2))),
2525 (v8f16 (MVE_VSUBf16 (v8f16 MQPR:$val1), (v8f16 MQPR:$val2)))>;
2528 class MVE_VCADD<string suffix, bit size, list<dag> pattern=[]>
2529 : MVEFloatArithNeon<"vcadd", suffix, size, (outs MQPR:$Qd),
2530 (ins MQPR:$Qn, MQPR:$Qm, complexrotateopodd:$rot),
2531 "$Qd, $Qn, $Qm, $rot", vpred_r, "", pattern> {
2540 let Inst{22} = Qd{3};
2542 let Inst{19-17} = Qn{2-0};
2543 let Inst{15-13} = Qd{2-0};
2544 let Inst{12-8} = 0b01000;
2545 let Inst{7} = Qn{3};
2549 def MVE_VCADDf16 : MVE_VCADD<"f16", 0b0>;
2550 def MVE_VCADDf32 : MVE_VCADD<"f32", 0b1>;
2552 class MVE_VABD_fp<string suffix, bit size>
2553 : MVE_float<"vabd", suffix, (outs MQPR:$Qd), (ins MQPR:$Qn, MQPR:$Qm),
2554 "$Qd, $Qn, $Qm", vpred_r, ""> {
2559 let Inst{25-23} = 0b110;
2560 let Inst{22} = Qd{3};
2562 let Inst{20} = size;
2563 let Inst{19-17} = Qn{2-0};
2565 let Inst{15-13} = Qd{2-0};
2566 let Inst{11-8} = 0b1101;
2567 let Inst{7} = Qn{3};
2571 def MVE_VABDf32 : MVE_VABD_fp<"f32", 0b0>;
2572 def MVE_VABDf16 : MVE_VABD_fp<"f16", 0b1>;
2574 class MVE_VCVT_fix<string suffix, bit fsi, bit U, bit op,
2575 Operand imm_operand_type, list<dag> pattern=[]>
2576 : MVE_float<"vcvt", suffix,
2577 (outs MQPR:$Qd), (ins MQPR:$Qm, imm_operand_type:$imm6),
2578 "$Qd, $Qm, $imm6", vpred_r, "", pattern> {
2583 let Inst{25-23} = 0b111;
2584 let Inst{22} = Qd{3};
2586 let Inst{19-16} = imm6{3-0};
2587 let Inst{15-13} = Qd{2-0};
2588 let Inst{11-10} = 0b11;
2594 let DecoderMethod = "DecodeMVEVCVTt1fp";
2597 class MVE_VCVT_imm_asmop<int Bits> : AsmOperandClass {
2598 let PredicateMethod = "isImmediate<1," # Bits # ">";
2599 let DiagnosticString =
2600 "MVE fixed-point immediate operand must be between 1 and " # Bits;
2601 let Name = "MVEVcvtImm" # Bits;
2602 let RenderMethod = "addImmOperands";
2604 class MVE_VCVT_imm<int Bits>: Operand<i32> {
2605 let ParserMatchClass = MVE_VCVT_imm_asmop<Bits>;
2606 let EncoderMethod = "getNEONVcvtImm32OpValue";
2607 let DecoderMethod = "DecodeVCVTImmOperand";
2610 class MVE_VCVT_fix_f32<string suffix, bit U, bit op>
2611 : MVE_VCVT_fix<suffix, 0b1, U, op, MVE_VCVT_imm<32>> {
2612 let Inst{20} = imm6{4};
2614 class MVE_VCVT_fix_f16<string suffix, bit U, bit op>
2615 : MVE_VCVT_fix<suffix, 0b0, U, op, MVE_VCVT_imm<16>> {
2619 def MVE_VCVTf16s16_fix : MVE_VCVT_fix_f16<"f16.s16", 0b0, 0b0>;
2620 def MVE_VCVTs16f16_fix : MVE_VCVT_fix_f16<"s16.f16", 0b0, 0b1>;
2621 def MVE_VCVTf16u16_fix : MVE_VCVT_fix_f16<"f16.u16", 0b1, 0b0>;
2622 def MVE_VCVTu16f16_fix : MVE_VCVT_fix_f16<"u16.f16", 0b1, 0b1>;
2623 def MVE_VCVTf32s32_fix : MVE_VCVT_fix_f32<"f32.s32", 0b0, 0b0>;
2624 def MVE_VCVTs32f32_fix : MVE_VCVT_fix_f32<"s32.f32", 0b0, 0b1>;
2625 def MVE_VCVTf32u32_fix : MVE_VCVT_fix_f32<"f32.u32", 0b1, 0b0>;
2626 def MVE_VCVTu32f32_fix : MVE_VCVT_fix_f32<"u32.f32", 0b1, 0b1>;
2628 class MVE_VCVT_fp_int_anpm<string suffix, bits<2> size, bit op, string anpm,
2629 bits<2> rm, list<dag> pattern=[]>
2630 : MVE_float<!strconcat("vcvt", anpm), suffix, (outs MQPR:$Qd),
2631 (ins MQPR:$Qm), "$Qd, $Qm", vpred_r, "", pattern> {
2635 let Inst{25-23} = 0b111;
2636 let Inst{22} = Qd{3};
2637 let Inst{21-20} = 0b11;
2638 let Inst{19-18} = size;
2639 let Inst{17-16} = 0b11;
2640 let Inst{15-13} = Qd{2-0};
2641 let Inst{12-10} = 0b000;
2647 multiclass MVE_VCVT_fp_int_anpm_multi<string suffix, bits<2> size, bit op,
2648 list<dag> pattern=[]> {
2649 def a : MVE_VCVT_fp_int_anpm<suffix, size, op, "a", 0b00>;
2650 def n : MVE_VCVT_fp_int_anpm<suffix, size, op, "n", 0b01>;
2651 def p : MVE_VCVT_fp_int_anpm<suffix, size, op, "p", 0b10>;
2652 def m : MVE_VCVT_fp_int_anpm<suffix, size, op, "m", 0b11>;
2655 // This defines instructions such as MVE_VCVTu16f16a, with an explicit
2656 // rounding-mode suffix on the mnemonic. The class below will define
2657 // the bare MVE_VCVTu16f16 (with implied rounding toward zero).
2658 defm MVE_VCVTs16f16 : MVE_VCVT_fp_int_anpm_multi<"s16.f16", 0b01, 0b0>;
2659 defm MVE_VCVTu16f16 : MVE_VCVT_fp_int_anpm_multi<"u16.f16", 0b01, 0b1>;
2660 defm MVE_VCVTs32f32 : MVE_VCVT_fp_int_anpm_multi<"s32.f32", 0b10, 0b0>;
2661 defm MVE_VCVTu32f32 : MVE_VCVT_fp_int_anpm_multi<"u32.f32", 0b10, 0b1>;
2663 class MVE_VCVT_fp_int<string suffix, bits<2> size, bits<2> op,
2664 list<dag> pattern=[]>
2665 : MVE_float<"vcvt", suffix, (outs MQPR:$Qd),
2666 (ins MQPR:$Qm), "$Qd, $Qm", vpred_r, "", pattern> {
2670 let Inst{25-23} = 0b111;
2671 let Inst{22} = Qd{3};
2672 let Inst{21-20} = 0b11;
2673 let Inst{19-18} = size;
2674 let Inst{17-16} = 0b11;
2675 let Inst{15-13} = Qd{2-0};
2676 let Inst{12-9} = 0b0011;
2681 // The unsuffixed VCVT for float->int implicitly rounds toward zero,
2682 // which I reflect here in the llvm instruction names
2683 def MVE_VCVTs16f16z : MVE_VCVT_fp_int<"s16.f16", 0b01, 0b10>;
2684 def MVE_VCVTu16f16z : MVE_VCVT_fp_int<"u16.f16", 0b01, 0b11>;
2685 def MVE_VCVTs32f32z : MVE_VCVT_fp_int<"s32.f32", 0b10, 0b10>;
2686 def MVE_VCVTu32f32z : MVE_VCVT_fp_int<"u32.f32", 0b10, 0b11>;
2687 // Whereas VCVT for int->float rounds to nearest
2688 def MVE_VCVTf16s16n : MVE_VCVT_fp_int<"f16.s16", 0b01, 0b00>;
2689 def MVE_VCVTf16u16n : MVE_VCVT_fp_int<"f16.u16", 0b01, 0b01>;
2690 def MVE_VCVTf32s32n : MVE_VCVT_fp_int<"f32.s32", 0b10, 0b00>;
2691 def MVE_VCVTf32u32n : MVE_VCVT_fp_int<"f32.u32", 0b10, 0b01>;
2693 let Predicates = [HasMVEFloat] in {
2694 def : Pat<(v4i32 (fp_to_sint (v4f32 MQPR:$src))),
2695 (v4i32 (MVE_VCVTs32f32z (v4f32 MQPR:$src)))>;
2696 def : Pat<(v4i32 (fp_to_uint (v4f32 MQPR:$src))),
2697 (v4i32 (MVE_VCVTu32f32z (v4f32 MQPR:$src)))>;
2698 def : Pat<(v8i16 (fp_to_sint (v8f16 MQPR:$src))),
2699 (v8i16 (MVE_VCVTs16f16z (v8f16 MQPR:$src)))>;
2700 def : Pat<(v8i16 (fp_to_uint (v8f16 MQPR:$src))),
2701 (v8i16 (MVE_VCVTu16f16z (v8f16 MQPR:$src)))>;
2702 def : Pat<(v4f32 (sint_to_fp (v4i32 MQPR:$src))),
2703 (v4f32 (MVE_VCVTf32s32n (v4i32 MQPR:$src)))>;
2704 def : Pat<(v4f32 (uint_to_fp (v4i32 MQPR:$src))),
2705 (v4f32 (MVE_VCVTf32u32n (v4i32 MQPR:$src)))>;
2706 def : Pat<(v8f16 (sint_to_fp (v8i16 MQPR:$src))),
2707 (v8f16 (MVE_VCVTf16s16n (v8i16 MQPR:$src)))>;
2708 def : Pat<(v8f16 (uint_to_fp (v8i16 MQPR:$src))),
2709 (v8f16 (MVE_VCVTf16u16n (v8i16 MQPR:$src)))>;
2712 class MVE_VABSNEG_fp<string iname, string suffix, bits<2> size, bit negate,
2713 list<dag> pattern=[]>
2714 : MVE_float<iname, suffix, (outs MQPR:$Qd),
2715 (ins MQPR:$Qm), "$Qd, $Qm", vpred_r, "", pattern> {
2719 let Inst{25-23} = 0b111;
2720 let Inst{22} = Qd{3};
2721 let Inst{21-20} = 0b11;
2722 let Inst{19-18} = size;
2723 let Inst{17-16} = 0b01;
2724 let Inst{15-13} = Qd{2-0};
2725 let Inst{11-8} = 0b0111;
2726 let Inst{7} = negate;
2730 def MVE_VABSf16 : MVE_VABSNEG_fp<"vabs", "f16", 0b01, 0b0>;
2731 def MVE_VABSf32 : MVE_VABSNEG_fp<"vabs", "f32", 0b10, 0b0>;
2733 let Predicates = [HasMVEFloat] in {
2734 def : Pat<(v8f16 (fabs MQPR:$src)),
2735 (MVE_VABSf16 MQPR:$src)>;
2736 def : Pat<(v4f32 (fabs MQPR:$src)),
2737 (MVE_VABSf32 MQPR:$src)>;
2740 def MVE_VNEGf16 : MVE_VABSNEG_fp<"vneg", "f16", 0b01, 0b1>;
2741 def MVE_VNEGf32 : MVE_VABSNEG_fp<"vneg", "f32", 0b10, 0b1>;
2743 let Predicates = [HasMVEFloat] in {
2744 def : Pat<(v8f16 (fneg MQPR:$src)),
2745 (MVE_VNEGf16 MQPR:$src)>;
2746 def : Pat<(v4f32 (fneg MQPR:$src)),
2747 (MVE_VNEGf32 MQPR:$src)>;
2750 class MVE_VMAXMINNMA<string iname, string suffix, bit size, bit bit_12,
2751 list<dag> pattern=[]>
2752 : MVE_f<(outs MQPR:$Qd), (ins MQPR:$Qd_src, MQPR:$Qm),
2753 NoItinerary, iname, suffix, "$Qd, $Qm", vpred_n, "$Qd = $Qd_src",
2758 let Inst{28} = size;
2759 let Inst{25-23} = 0b100;
2760 let Inst{22} = Qd{3};
2761 let Inst{21-16} = 0b111111;
2762 let Inst{15-13} = Qd{2-0};
2763 let Inst{12} = bit_12;
2764 let Inst{11-6} = 0b111010;
2765 let Inst{5} = Qm{3};
2767 let Inst{3-1} = Qm{2-0};
2771 def MVE_VMAXNMAf32 : MVE_VMAXMINNMA<"vmaxnma", "f32", 0b0, 0b0>;
2772 def MVE_VMAXNMAf16 : MVE_VMAXMINNMA<"vmaxnma", "f16", 0b1, 0b0>;
2774 def MVE_VMINNMAf32 : MVE_VMAXMINNMA<"vminnma", "f32", 0b0, 0b1>;
2775 def MVE_VMINNMAf16 : MVE_VMAXMINNMA<"vminnma", "f16", 0b1, 0b1>;
2777 // end of MVE Floating Point instructions
2779 // start of MVE compares
2781 class MVE_VCMPqq<string suffix, bit bit_28, bits<2> bits_21_20,
2782 VCMPPredicateOperand predtype, list<dag> pattern=[]>
2783 : MVE_p<(outs VCCR:$P0), (ins MQPR:$Qn, MQPR:$Qm, predtype:$fc),
2784 NoItinerary, "vcmp", suffix, "$fc, $Qn, $Qm", vpred_n, "", pattern> {
2785 // Base class for comparing two vector registers
2790 let Inst{28} = bit_28;
2791 let Inst{25-22} = 0b1000;
2792 let Inst{21-20} = bits_21_20;
2793 let Inst{19-17} = Qn{2-0};
2794 let Inst{16-13} = 0b1000;
2795 let Inst{12} = fc{2};
2796 let Inst{11-8} = 0b1111;
2797 let Inst{7} = fc{0};
2799 let Inst{5} = Qm{3};
2801 let Inst{3-1} = Qm{2-0};
2802 let Inst{0} = fc{1};
2804 let Constraints = "";
2806 // We need a custom decoder method for these instructions because of
2807 // the output VCCR operand, which isn't encoded in the instruction
2808 // bits anywhere (there is only one choice for it) but has to be
2809 // included in the MC operands so that codegen will be able to track
2810 // its data flow between instructions, spill/reload it when
2811 // necessary, etc. There seems to be no way to get the Tablegen
2812 // decoder to emit an operand that isn't affected by any instruction
2814 let DecoderMethod = "DecodeMVEVCMP<false," # predtype.DecoderMethod # ">";
2817 class MVE_VCMPqqf<string suffix, bit size>
2818 : MVE_VCMPqq<suffix, size, 0b11, pred_basic_fp> {
2819 let Predicates = [HasMVEFloat];
2822 class MVE_VCMPqqi<string suffix, bits<2> size>
2823 : MVE_VCMPqq<suffix, 0b1, size, pred_basic_i> {
2828 class MVE_VCMPqqu<string suffix, bits<2> size>
2829 : MVE_VCMPqq<suffix, 0b1, size, pred_basic_u> {
2834 class MVE_VCMPqqs<string suffix, bits<2> size>
2835 : MVE_VCMPqq<suffix, 0b1, size, pred_basic_s> {
2839 def MVE_VCMPf32 : MVE_VCMPqqf<"f32", 0b0>;
2840 def MVE_VCMPf16 : MVE_VCMPqqf<"f16", 0b1>;
2842 def MVE_VCMPi8 : MVE_VCMPqqi<"i8", 0b00>;
2843 def MVE_VCMPi16 : MVE_VCMPqqi<"i16", 0b01>;
2844 def MVE_VCMPi32 : MVE_VCMPqqi<"i32", 0b10>;
2846 def MVE_VCMPu8 : MVE_VCMPqqu<"u8", 0b00>;
2847 def MVE_VCMPu16 : MVE_VCMPqqu<"u16", 0b01>;
2848 def MVE_VCMPu32 : MVE_VCMPqqu<"u32", 0b10>;
2850 def MVE_VCMPs8 : MVE_VCMPqqs<"s8", 0b00>;
2851 def MVE_VCMPs16 : MVE_VCMPqqs<"s16", 0b01>;
2852 def MVE_VCMPs32 : MVE_VCMPqqs<"s32", 0b10>;
2854 class MVE_VCMPqr<string suffix, bit bit_28, bits<2> bits_21_20,
2855 VCMPPredicateOperand predtype, list<dag> pattern=[]>
2856 : MVE_p<(outs VCCR:$P0), (ins MQPR:$Qn, GPRwithZR:$Rm, predtype:$fc),
2857 NoItinerary, "vcmp", suffix, "$fc, $Qn, $Rm", vpred_n, "", pattern> {
2858 // Base class for comparing a vector register with a scalar
2863 let Inst{28} = bit_28;
2864 let Inst{25-22} = 0b1000;
2865 let Inst{21-20} = bits_21_20;
2866 let Inst{19-17} = Qn{2-0};
2867 let Inst{16-13} = 0b1000;
2868 let Inst{12} = fc{2};
2869 let Inst{11-8} = 0b1111;
2870 let Inst{7} = fc{0};
2872 let Inst{5} = fc{1};
2874 let Inst{3-0} = Rm{3-0};
2876 let Constraints = "";
2877 // Custom decoder method, for the same reason as MVE_VCMPqq
2878 let DecoderMethod = "DecodeMVEVCMP<true," # predtype.DecoderMethod # ">";
2881 class MVE_VCMPqrf<string suffix, bit size>
2882 : MVE_VCMPqr<suffix, size, 0b11, pred_basic_fp> {
2883 let Predicates = [HasMVEFloat];
2886 class MVE_VCMPqri<string suffix, bits<2> size>
2887 : MVE_VCMPqr<suffix, 0b1, size, pred_basic_i> {
2892 class MVE_VCMPqru<string suffix, bits<2> size>
2893 : MVE_VCMPqr<suffix, 0b1, size, pred_basic_u> {
2898 class MVE_VCMPqrs<string suffix, bits<2> size>
2899 : MVE_VCMPqr<suffix, 0b1, size, pred_basic_s> {
2903 def MVE_VCMPf32r : MVE_VCMPqrf<"f32", 0b0>;
2904 def MVE_VCMPf16r : MVE_VCMPqrf<"f16", 0b1>;
2906 def MVE_VCMPi8r : MVE_VCMPqri<"i8", 0b00>;
2907 def MVE_VCMPi16r : MVE_VCMPqri<"i16", 0b01>;
2908 def MVE_VCMPi32r : MVE_VCMPqri<"i32", 0b10>;
2910 def MVE_VCMPu8r : MVE_VCMPqru<"u8", 0b00>;
2911 def MVE_VCMPu16r : MVE_VCMPqru<"u16", 0b01>;
2912 def MVE_VCMPu32r : MVE_VCMPqru<"u32", 0b10>;
2914 def MVE_VCMPs8r : MVE_VCMPqrs<"s8", 0b00>;
2915 def MVE_VCMPs16r : MVE_VCMPqrs<"s16", 0b01>;
2916 def MVE_VCMPs32r : MVE_VCMPqrs<"s32", 0b10>;
2918 // end of MVE compares
2920 // start of MVE_qDest_qSrc
2922 class MVE_qDest_qSrc<string iname, string suffix, dag oops, dag iops,
2923 string ops, vpred_ops vpred, string cstr,
2924 list<dag> pattern=[]>
2925 : MVE_p<oops, iops, NoItinerary, iname, suffix,
2926 ops, vpred, cstr, pattern> {
2930 let Inst{25-23} = 0b100;
2931 let Inst{22} = Qd{3};
2932 let Inst{15-13} = Qd{2-0};
2933 let Inst{11-9} = 0b111;
2935 let Inst{5} = Qm{3};
2937 let Inst{3-1} = Qm{2-0};
2940 class MVE_VQxDMLxDH<string iname, bit exch, bit round, bit subtract,
2941 string suffix, bits<2> size, list<dag> pattern=[]>
2942 : MVE_qDest_qSrc<iname, suffix, (outs MQPR:$Qd),
2943 (ins MQPR:$Qd_src, MQPR:$Qn, MQPR:$Qm), "$Qd, $Qn, $Qm",
2944 vpred_n, "$Qd = $Qd_src", pattern> {
2947 let Inst{28} = subtract;
2948 let Inst{21-20} = size;
2949 let Inst{19-17} = Qn{2-0};
2951 let Inst{12} = exch;
2953 let Inst{7} = Qn{3};
2954 let Inst{0} = round;
2957 multiclass MVE_VQxDMLxDH_multi<string iname, bit exch,
2958 bit round, bit subtract> {
2959 def s8 : MVE_VQxDMLxDH<iname, exch, round, subtract, "s8", 0b00>;
2960 def s16 : MVE_VQxDMLxDH<iname, exch, round, subtract, "s16", 0b01>;
2961 def s32 : MVE_VQxDMLxDH<iname, exch, round, subtract, "s32", 0b10>;
2964 defm MVE_VQDMLADH : MVE_VQxDMLxDH_multi<"vqdmladh", 0b0, 0b0, 0b0>;
2965 defm MVE_VQDMLADHX : MVE_VQxDMLxDH_multi<"vqdmladhx", 0b1, 0b0, 0b0>;
2966 defm MVE_VQRDMLADH : MVE_VQxDMLxDH_multi<"vqrdmladh", 0b0, 0b1, 0b0>;
2967 defm MVE_VQRDMLADHX : MVE_VQxDMLxDH_multi<"vqrdmladhx", 0b1, 0b1, 0b0>;
2968 defm MVE_VQDMLSDH : MVE_VQxDMLxDH_multi<"vqdmlsdh", 0b0, 0b0, 0b1>;
2969 defm MVE_VQDMLSDHX : MVE_VQxDMLxDH_multi<"vqdmlsdhx", 0b1, 0b0, 0b1>;
2970 defm MVE_VQRDMLSDH : MVE_VQxDMLxDH_multi<"vqrdmlsdh", 0b0, 0b1, 0b1>;
2971 defm MVE_VQRDMLSDHX : MVE_VQxDMLxDH_multi<"vqrdmlsdhx", 0b1, 0b1, 0b1>;
2973 class MVE_VCMUL<string iname, string suffix, bit size, list<dag> pattern=[]>
2974 : MVE_qDest_qSrc<iname, suffix, (outs MQPR:$Qd),
2975 (ins MQPR:$Qn, MQPR:$Qm, complexrotateop:$rot),
2976 "$Qd, $Qn, $Qm, $rot", vpred_r, "", pattern> {
2980 let Inst{28} = size;
2981 let Inst{21-20} = 0b11;
2982 let Inst{19-17} = Qn{2-0};
2984 let Inst{12} = rot{1};
2986 let Inst{7} = Qn{3};
2987 let Inst{0} = rot{0};
2989 let Predicates = [HasMVEFloat];
2992 def MVE_VCMULf16 : MVE_VCMUL<"vcmul", "f16", 0b0>;
2993 def MVE_VCMULf32 : MVE_VCMUL<"vcmul", "f32", 0b1>;
2995 class MVE_VMULL<string iname, string suffix, bit bit_28, bits<2> bits_21_20,
2996 bit T, list<dag> pattern=[]>
2997 : MVE_qDest_qSrc<iname, suffix, (outs MQPR:$Qd),
2998 (ins MQPR:$Qn, MQPR:$Qm), "$Qd, $Qn, $Qm",
2999 vpred_r, "", pattern> {
3004 let Inst{28} = bit_28;
3005 let Inst{21-20} = bits_21_20;
3006 let Inst{19-17} = Qn{2-0};
3010 let Inst{7} = Qn{3};
3014 multiclass MVE_VMULL_multi<string iname, string suffix,
3015 bit bit_28, bits<2> bits_21_20> {
3016 def bh : MVE_VMULL<iname # "b", suffix, bit_28, bits_21_20, 0b0>;
3017 def th : MVE_VMULL<iname # "t", suffix, bit_28, bits_21_20, 0b1>;
3020 // For integer multiplies, bits 21:20 encode size, and bit 28 signedness.
3021 // For polynomial multiplies, bits 21:20 take the unused value 0b11, and
3022 // bit 28 switches to encoding the size.
3024 defm MVE_VMULLs8 : MVE_VMULL_multi<"vmull", "s8", 0b0, 0b00>;
3025 defm MVE_VMULLs16 : MVE_VMULL_multi<"vmull", "s16", 0b0, 0b01>;
3026 defm MVE_VMULLs32 : MVE_VMULL_multi<"vmull", "s32", 0b0, 0b10>;
3027 defm MVE_VMULLu8 : MVE_VMULL_multi<"vmull", "u8", 0b1, 0b00>;
3028 defm MVE_VMULLu16 : MVE_VMULL_multi<"vmull", "u16", 0b1, 0b01>;
3029 defm MVE_VMULLu32 : MVE_VMULL_multi<"vmull", "u32", 0b1, 0b10>;
3030 defm MVE_VMULLp8 : MVE_VMULL_multi<"vmull", "p8", 0b0, 0b11>;
3031 defm MVE_VMULLp16 : MVE_VMULL_multi<"vmull", "p16", 0b1, 0b11>;
3033 class MVE_VxMULH<string iname, string suffix, bit U, bits<2> size,
3034 bit round, list<dag> pattern=[]>
3035 : MVE_qDest_qSrc<iname, suffix, (outs MQPR:$Qd),
3036 (ins MQPR:$Qn, MQPR:$Qm), "$Qd, $Qn, $Qm",
3037 vpred_r, "", pattern> {
3041 let Inst{21-20} = size;
3042 let Inst{19-17} = Qn{2-0};
3044 let Inst{12} = round;
3046 let Inst{7} = Qn{3};
3050 def MVE_VMULHs8 : MVE_VxMULH<"vmulh", "s8", 0b0, 0b00, 0b0>;
3051 def MVE_VMULHs16 : MVE_VxMULH<"vmulh", "s16", 0b0, 0b01, 0b0>;
3052 def MVE_VMULHs32 : MVE_VxMULH<"vmulh", "s32", 0b0, 0b10, 0b0>;
3053 def MVE_VMULHu8 : MVE_VxMULH<"vmulh", "u8", 0b1, 0b00, 0b0>;
3054 def MVE_VMULHu16 : MVE_VxMULH<"vmulh", "u16", 0b1, 0b01, 0b0>;
3055 def MVE_VMULHu32 : MVE_VxMULH<"vmulh", "u32", 0b1, 0b10, 0b0>;
3057 def MVE_VRMULHs8 : MVE_VxMULH<"vrmulh", "s8", 0b0, 0b00, 0b1>;
3058 def MVE_VRMULHs16 : MVE_VxMULH<"vrmulh", "s16", 0b0, 0b01, 0b1>;
3059 def MVE_VRMULHs32 : MVE_VxMULH<"vrmulh", "s32", 0b0, 0b10, 0b1>;
3060 def MVE_VRMULHu8 : MVE_VxMULH<"vrmulh", "u8", 0b1, 0b00, 0b1>;
3061 def MVE_VRMULHu16 : MVE_VxMULH<"vrmulh", "u16", 0b1, 0b01, 0b1>;
3062 def MVE_VRMULHu32 : MVE_VxMULH<"vrmulh", "u32", 0b1, 0b10, 0b1>;
3064 class MVE_VxMOVxN<string iname, string suffix, bit bit_28, bit bit_17,
3065 bits<2> size, bit T, list<dag> pattern=[]>
3066 : MVE_qDest_qSrc<iname, suffix, (outs MQPR:$Qd),
3067 (ins MQPR:$Qd_src, MQPR:$Qm), "$Qd, $Qm",
3068 vpred_n, "$Qd = $Qd_src", pattern> {
3070 let Inst{28} = bit_28;
3071 let Inst{21-20} = 0b11;
3072 let Inst{19-18} = size;
3073 let Inst{17} = bit_17;
3077 let Inst{7} = !if(!eq(bit_17, 0), 1, 0);
3081 multiclass MVE_VxMOVxN_halves<string iname, string suffix,
3082 bit bit_28, bit bit_17, bits<2> size> {
3083 def bh : MVE_VxMOVxN<iname # "b", suffix, bit_28, bit_17, size, 0b0>;
3084 def th : MVE_VxMOVxN<iname # "t", suffix, bit_28, bit_17, size, 0b1>;
3087 defm MVE_VMOVNi16 : MVE_VxMOVxN_halves<"vmovn", "i16", 0b1, 0b0, 0b00>;
3088 defm MVE_VMOVNi32 : MVE_VxMOVxN_halves<"vmovn", "i32", 0b1, 0b0, 0b01>;
3089 defm MVE_VQMOVNs16 : MVE_VxMOVxN_halves<"vqmovn", "s16", 0b0, 0b1, 0b00>;
3090 defm MVE_VQMOVNs32 : MVE_VxMOVxN_halves<"vqmovn", "s32", 0b0, 0b1, 0b01>;
3091 defm MVE_VQMOVNu16 : MVE_VxMOVxN_halves<"vqmovn", "u16", 0b1, 0b1, 0b00>;
3092 defm MVE_VQMOVNu32 : MVE_VxMOVxN_halves<"vqmovn", "u32", 0b1, 0b1, 0b01>;
3093 defm MVE_VQMOVUNs16 : MVE_VxMOVxN_halves<"vqmovun", "s16", 0b0, 0b0, 0b00>;
3094 defm MVE_VQMOVUNs32 : MVE_VxMOVxN_halves<"vqmovun", "s32", 0b0, 0b0, 0b01>;
3096 class MVE_VCVT_ff<string iname, string suffix, bit op, bit T,
3097 list<dag> pattern=[]>
3098 : MVE_qDest_qSrc<iname, suffix, (outs MQPR:$Qd), (ins MQPR:$Qd_src, MQPR:$Qm),
3099 "$Qd, $Qm", vpred_n, "$Qd = $Qd_src", pattern> {
3101 let Inst{21-16} = 0b111111;
3103 let Inst{8-7} = 0b00;
3106 let Predicates = [HasMVEFloat];
3109 multiclass MVE_VCVT_ff_halves<string suffix, bit op> {
3110 def bh : MVE_VCVT_ff<"vcvtb", suffix, op, 0b0>;
3111 def th : MVE_VCVT_ff<"vcvtt", suffix, op, 0b1>;
3114 defm MVE_VCVTf16f32 : MVE_VCVT_ff_halves<"f16.f32", 0b0>;
3115 defm MVE_VCVTf32f16 : MVE_VCVT_ff_halves<"f32.f16", 0b1>;
3117 class MVE_VxCADD<string iname, string suffix, bits<2> size, bit halve,
3118 list<dag> pattern=[]>
3119 : MVE_qDest_qSrc<iname, suffix, (outs MQPR:$Qd),
3120 (ins MQPR:$Qn, MQPR:$Qm, complexrotateopodd:$rot),
3121 "$Qd, $Qn, $Qm, $rot", vpred_r, "",
3126 let Inst{28} = halve;
3127 let Inst{21-20} = size;
3128 let Inst{19-17} = Qn{2-0};
3132 let Inst{7} = Qn{3};
3136 def MVE_VCADDi8 : MVE_VxCADD<"vcadd", "i8", 0b00, 0b1>;
3137 def MVE_VCADDi16 : MVE_VxCADD<"vcadd", "i16", 0b01, 0b1>;
3138 def MVE_VCADDi32 : MVE_VxCADD<"vcadd", "i32", 0b10, 0b1>;
3140 def MVE_VHCADDs8 : MVE_VxCADD<"vhcadd", "s8", 0b00, 0b0>;
3141 def MVE_VHCADDs16 : MVE_VxCADD<"vhcadd", "s16", 0b01, 0b0>;
3142 def MVE_VHCADDs32 : MVE_VxCADD<"vhcadd", "s32", 0b10, 0b0>;
3144 class MVE_VADCSBC<string iname, bit I, bit subtract,
3145 dag carryin, list<dag> pattern=[]>
3146 : MVE_qDest_qSrc<iname, "i32", (outs MQPR:$Qd, cl_FPSCR_NZCV:$carryout),
3147 !con((ins MQPR:$Qn, MQPR:$Qm), carryin),
3148 "$Qd, $Qn, $Qm", vpred_r, "", pattern> {
3151 let Inst{28} = subtract;
3152 let Inst{21-20} = 0b11;
3153 let Inst{19-17} = Qn{2-0};
3157 let Inst{7} = Qn{3};
3160 // Custom decoder method in order to add the FPSCR operand(s), which
3161 // Tablegen won't do right
3162 let DecoderMethod = "DecodeMVEVADCInstruction";
3165 def MVE_VADC : MVE_VADCSBC<"vadc", 0b0, 0b0, (ins cl_FPSCR_NZCV:$carryin)>;
3166 def MVE_VADCI : MVE_VADCSBC<"vadci", 0b1, 0b0, (ins)>;
3168 def MVE_VSBC : MVE_VADCSBC<"vsbc", 0b0, 0b1, (ins cl_FPSCR_NZCV:$carryin)>;
3169 def MVE_VSBCI : MVE_VADCSBC<"vsbci", 0b1, 0b1, (ins)>;
3171 class MVE_VQDMULL<string iname, string suffix, bit size, bit T,
3172 list<dag> pattern=[]>
3173 : MVE_qDest_qSrc<iname, suffix, (outs MQPR:$Qd),
3174 (ins MQPR:$Qn, MQPR:$Qm), "$Qd, $Qn, $Qm",
3175 vpred_r, "", pattern> {
3178 let Inst{28} = size;
3179 let Inst{21-20} = 0b11;
3180 let Inst{19-17} = Qn{2-0};
3184 let Inst{7} = Qn{3};
3188 multiclass MVE_VQDMULL_halves<string suffix, bit size> {
3189 def bh : MVE_VQDMULL<"vqdmullb", suffix, size, 0b0>;
3190 def th : MVE_VQDMULL<"vqdmullt", suffix, size, 0b1>;
3193 defm MVE_VQDMULLs16 : MVE_VQDMULL_halves<"s16", 0b0>;
3194 defm MVE_VQDMULLs32 : MVE_VQDMULL_halves<"s32", 0b1>;
3196 // end of mve_qDest_qSrc
3198 // start of mve_qDest_rSrc
3200 class MVE_qr_base<dag oops, dag iops, InstrItinClass itin, string iname,
3201 string suffix, string ops, vpred_ops vpred, string cstr,
3202 list<dag> pattern=[]>
3203 : MVE_p<oops, iops, NoItinerary, iname, suffix, ops, vpred, cstr, pattern> {
3208 let Inst{25-23} = 0b100;
3209 let Inst{22} = Qd{3};
3210 let Inst{19-17} = Qn{2-0};
3211 let Inst{15-13} = Qd{2-0};
3212 let Inst{11-9} = 0b111;
3213 let Inst{7} = Qn{3};
3216 let Inst{3-0} = Rm{3-0};
3219 class MVE_qDest_rSrc<string iname, string suffix, list<dag> pattern=[]>
3220 : MVE_qr_base<(outs MQPR:$Qd), (ins MQPR:$Qn, rGPR:$Rm),
3221 NoItinerary, iname, suffix, "$Qd, $Qn, $Rm", vpred_r, "",
3224 class MVE_qDestSrc_rSrc<string iname, string suffix, list<dag> pattern=[]>
3225 : MVE_qr_base<(outs MQPR:$Qd), (ins MQPR:$Qd_src, MQPR:$Qn, rGPR:$Rm),
3226 NoItinerary, iname, suffix, "$Qd, $Qn, $Rm", vpred_n, "$Qd = $Qd_src",
3229 class MVE_qDest_single_rSrc<string iname, string suffix, list<dag> pattern=[]>
3230 : MVE_p<(outs MQPR:$Qd), (ins MQPR:$Qd_src, rGPR:$Rm), NoItinerary, iname,
3231 suffix, "$Qd, $Rm", vpred_n, "$Qd = $Qd_src", pattern> {
3235 let Inst{22} = Qd{3};
3236 let Inst{15-13} = Qd{2-0};
3237 let Inst{3-0} = Rm{3-0};
3240 class MVE_VADDSUB_qr<string iname, string suffix, bits<2> size,
3241 bit bit_5, bit bit_12, bit bit_16,
3242 bit bit_28, list<dag> pattern=[]>
3243 : MVE_qDest_rSrc<iname, suffix, pattern> {
3245 let Inst{28} = bit_28;
3246 let Inst{21-20} = size;
3247 let Inst{16} = bit_16;
3248 let Inst{12} = bit_12;
3250 let Inst{5} = bit_5;
3253 multiclass MVE_VADDSUB_qr_sizes<string iname, string suffix,
3254 bit bit_5, bit bit_12, bit bit_16,
3255 bit bit_28, list<dag> pattern=[]> {
3256 def "8" : MVE_VADDSUB_qr<iname, suffix#"8", 0b00,
3257 bit_5, bit_12, bit_16, bit_28>;
3258 def "16" : MVE_VADDSUB_qr<iname, suffix#"16", 0b01,
3259 bit_5, bit_12, bit_16, bit_28>;
3260 def "32" : MVE_VADDSUB_qr<iname, suffix#"32", 0b10,
3261 bit_5, bit_12, bit_16, bit_28>;
3264 defm MVE_VADD_qr_i : MVE_VADDSUB_qr_sizes<"vadd", "i", 0b0, 0b0, 0b1, 0b0>;
3265 defm MVE_VQADD_qr_s : MVE_VADDSUB_qr_sizes<"vqadd", "s", 0b1, 0b0, 0b0, 0b0>;
3266 defm MVE_VQADD_qr_u : MVE_VADDSUB_qr_sizes<"vqadd", "u", 0b1, 0b0, 0b0, 0b1>;
3268 defm MVE_VSUB_qr_i : MVE_VADDSUB_qr_sizes<"vsub", "i", 0b0, 0b1, 0b1, 0b0>;
3269 defm MVE_VQSUB_qr_s : MVE_VADDSUB_qr_sizes<"vqsub", "s", 0b1, 0b1, 0b0, 0b0>;
3270 defm MVE_VQSUB_qr_u : MVE_VADDSUB_qr_sizes<"vqsub", "u", 0b1, 0b1, 0b0, 0b1>;
3272 class MVE_VQDMULL_qr<string iname, string suffix, bit size,
3273 bit T, list<dag> pattern=[]>
3274 : MVE_qDest_rSrc<iname, suffix, pattern> {
3276 let Inst{28} = size;
3277 let Inst{21-20} = 0b11;
3284 multiclass MVE_VQDMULL_qr_halves<string suffix, bit size> {
3285 def bh : MVE_VQDMULL_qr<"vqdmullb", suffix, size, 0b0>;
3286 def th : MVE_VQDMULL_qr<"vqdmullt", suffix, size, 0b1>;
3289 defm MVE_VQDMULL_qr_s16 : MVE_VQDMULL_qr_halves<"s16", 0b0>;
3290 defm MVE_VQDMULL_qr_s32 : MVE_VQDMULL_qr_halves<"s32", 0b1>;
3292 class MVE_VxADDSUB_qr<string iname, string suffix,
3293 bit bit_28, bits<2> bits_21_20, bit subtract,
3294 list<dag> pattern=[]>
3295 : MVE_qDest_rSrc<iname, suffix, pattern> {
3297 let Inst{28} = bit_28;
3298 let Inst{21-20} = bits_21_20;
3300 let Inst{12} = subtract;
3305 def MVE_VHADD_qr_s8 : MVE_VxADDSUB_qr<"vhadd", "s8", 0b0, 0b00, 0b0>;
3306 def MVE_VHADD_qr_s16 : MVE_VxADDSUB_qr<"vhadd", "s16", 0b0, 0b01, 0b0>;
3307 def MVE_VHADD_qr_s32 : MVE_VxADDSUB_qr<"vhadd", "s32", 0b0, 0b10, 0b0>;
3308 def MVE_VHADD_qr_u8 : MVE_VxADDSUB_qr<"vhadd", "u8", 0b1, 0b00, 0b0>;
3309 def MVE_VHADD_qr_u16 : MVE_VxADDSUB_qr<"vhadd", "u16", 0b1, 0b01, 0b0>;
3310 def MVE_VHADD_qr_u32 : MVE_VxADDSUB_qr<"vhadd", "u32", 0b1, 0b10, 0b0>;
3312 def MVE_VHSUB_qr_s8 : MVE_VxADDSUB_qr<"vhsub", "s8", 0b0, 0b00, 0b1>;
3313 def MVE_VHSUB_qr_s16 : MVE_VxADDSUB_qr<"vhsub", "s16", 0b0, 0b01, 0b1>;
3314 def MVE_VHSUB_qr_s32 : MVE_VxADDSUB_qr<"vhsub", "s32", 0b0, 0b10, 0b1>;
3315 def MVE_VHSUB_qr_u8 : MVE_VxADDSUB_qr<"vhsub", "u8", 0b1, 0b00, 0b1>;
3316 def MVE_VHSUB_qr_u16 : MVE_VxADDSUB_qr<"vhsub", "u16", 0b1, 0b01, 0b1>;
3317 def MVE_VHSUB_qr_u32 : MVE_VxADDSUB_qr<"vhsub", "u32", 0b1, 0b10, 0b1>;
3319 let Predicates = [HasMVEFloat] in {
3320 def MVE_VADD_qr_f32 : MVE_VxADDSUB_qr<"vadd", "f32", 0b0, 0b11, 0b0>;
3321 def MVE_VADD_qr_f16 : MVE_VxADDSUB_qr<"vadd", "f16", 0b1, 0b11, 0b0>;
3323 def MVE_VSUB_qr_f32 : MVE_VxADDSUB_qr<"vsub", "f32", 0b0, 0b11, 0b1>;
3324 def MVE_VSUB_qr_f16 : MVE_VxADDSUB_qr<"vsub", "f16", 0b1, 0b11, 0b1>;
3327 class MVE_VxSHL_qr<string iname, string suffix, bit U, bits<2> size,
3328 bit bit_7, bit bit_17, list<dag> pattern=[]>
3329 : MVE_qDest_single_rSrc<iname, suffix, pattern> {
3332 let Inst{25-23} = 0b100;
3333 let Inst{21-20} = 0b11;
3334 let Inst{19-18} = size;
3335 let Inst{17} = bit_17;
3337 let Inst{12-8} = 0b11110;
3338 let Inst{7} = bit_7;
3339 let Inst{6-4} = 0b110;
3342 multiclass MVE_VxSHL_qr_types<string iname, bit bit_7, bit bit_17> {
3343 def s8 : MVE_VxSHL_qr<iname, "s8", 0b0, 0b00, bit_7, bit_17>;
3344 def s16 : MVE_VxSHL_qr<iname, "s16", 0b0, 0b01, bit_7, bit_17>;
3345 def s32 : MVE_VxSHL_qr<iname, "s32", 0b0, 0b10, bit_7, bit_17>;
3346 def u8 : MVE_VxSHL_qr<iname, "u8", 0b1, 0b00, bit_7, bit_17>;
3347 def u16 : MVE_VxSHL_qr<iname, "u16", 0b1, 0b01, bit_7, bit_17>;
3348 def u32 : MVE_VxSHL_qr<iname, "u32", 0b1, 0b10, bit_7, bit_17>;
3351 defm MVE_VSHL_qr : MVE_VxSHL_qr_types<"vshl", 0b0, 0b0>;
3352 defm MVE_VRSHL_qr : MVE_VxSHL_qr_types<"vrshl", 0b0, 0b1>;
3353 defm MVE_VQSHL_qr : MVE_VxSHL_qr_types<"vqshl", 0b1, 0b0>;
3354 defm MVE_VQRSHL_qr : MVE_VxSHL_qr_types<"vqrshl", 0b1, 0b1>;
3356 class MVE_VBRSR<string iname, string suffix, bits<2> size, list<dag> pattern=[]>
3357 : MVE_qDest_rSrc<iname, suffix, pattern> {
3360 let Inst{21-20} = size;
3367 def MVE_VBRSR8 : MVE_VBRSR<"vbrsr", "8", 0b00>;
3368 def MVE_VBRSR16 : MVE_VBRSR<"vbrsr", "16", 0b01>;
3369 def MVE_VBRSR32 : MVE_VBRSR<"vbrsr", "32", 0b10>;
3371 class MVE_VMUL_qr_int<string iname, string suffix,
3372 bits<2> size, list<dag> pattern=[]>
3373 : MVE_qDest_rSrc<iname, suffix, pattern> {
3376 let Inst{21-20} = size;
3383 def MVE_VMUL_qr_i8 : MVE_VMUL_qr_int<"vmul", "i8", 0b00>;
3384 def MVE_VMUL_qr_i16 : MVE_VMUL_qr_int<"vmul", "i16", 0b01>;
3385 def MVE_VMUL_qr_i32 : MVE_VMUL_qr_int<"vmul", "i32", 0b10>;
3387 class MVE_VxxMUL_qr<string iname, string suffix,
3388 bit bit_28, bits<2> bits_21_20, list<dag> pattern=[]>
3389 : MVE_qDest_rSrc<iname, suffix, pattern> {
3391 let Inst{28} = bit_28;
3392 let Inst{21-20} = bits_21_20;
3399 def MVE_VQDMULH_qr_s8 : MVE_VxxMUL_qr<"vqdmulh", "s8", 0b0, 0b00>;
3400 def MVE_VQDMULH_qr_s16 : MVE_VxxMUL_qr<"vqdmulh", "s16", 0b0, 0b01>;
3401 def MVE_VQDMULH_qr_s32 : MVE_VxxMUL_qr<"vqdmulh", "s32", 0b0, 0b10>;
3403 def MVE_VQRDMULH_qr_s8 : MVE_VxxMUL_qr<"vqrdmulh", "s8", 0b1, 0b00>;
3404 def MVE_VQRDMULH_qr_s16 : MVE_VxxMUL_qr<"vqrdmulh", "s16", 0b1, 0b01>;
3405 def MVE_VQRDMULH_qr_s32 : MVE_VxxMUL_qr<"vqrdmulh", "s32", 0b1, 0b10>;
3407 let Predicates = [HasMVEFloat] in {
3408 def MVE_VMUL_qr_f16 : MVE_VxxMUL_qr<"vmul", "f16", 0b1, 0b11>;
3409 def MVE_VMUL_qr_f32 : MVE_VxxMUL_qr<"vmul", "f32", 0b0, 0b11>;
3412 class MVE_VFMAMLA_qr<string iname, string suffix,
3413 bit bit_28, bits<2> bits_21_20, bit S,
3414 list<dag> pattern=[]>
3415 : MVE_qDestSrc_rSrc<iname, suffix, pattern> {
3417 let Inst{28} = bit_28;
3418 let Inst{21-20} = bits_21_20;
3425 def MVE_VMLA_qr_s8 : MVE_VFMAMLA_qr<"vmla", "s8", 0b0, 0b00, 0b0>;
3426 def MVE_VMLA_qr_s16 : MVE_VFMAMLA_qr<"vmla", "s16", 0b0, 0b01, 0b0>;
3427 def MVE_VMLA_qr_s32 : MVE_VFMAMLA_qr<"vmla", "s32", 0b0, 0b10, 0b0>;
3428 def MVE_VMLA_qr_u8 : MVE_VFMAMLA_qr<"vmla", "u8", 0b1, 0b00, 0b0>;
3429 def MVE_VMLA_qr_u16 : MVE_VFMAMLA_qr<"vmla", "u16", 0b1, 0b01, 0b0>;
3430 def MVE_VMLA_qr_u32 : MVE_VFMAMLA_qr<"vmla", "u32", 0b1, 0b10, 0b0>;
3432 def MVE_VMLAS_qr_s8 : MVE_VFMAMLA_qr<"vmlas", "s8", 0b0, 0b00, 0b1>;
3433 def MVE_VMLAS_qr_s16 : MVE_VFMAMLA_qr<"vmlas", "s16", 0b0, 0b01, 0b1>;
3434 def MVE_VMLAS_qr_s32 : MVE_VFMAMLA_qr<"vmlas", "s32", 0b0, 0b10, 0b1>;
3435 def MVE_VMLAS_qr_u8 : MVE_VFMAMLA_qr<"vmlas", "u8", 0b1, 0b00, 0b1>;
3436 def MVE_VMLAS_qr_u16 : MVE_VFMAMLA_qr<"vmlas", "u16", 0b1, 0b01, 0b1>;
3437 def MVE_VMLAS_qr_u32 : MVE_VFMAMLA_qr<"vmlas", "u32", 0b1, 0b10, 0b1>;
3439 let Predicates = [HasMVEFloat] in {
3440 def MVE_VFMA_qr_f16 : MVE_VFMAMLA_qr<"vfma", "f16", 0b1, 0b11, 0b0>;
3441 def MVE_VFMA_qr_f32 : MVE_VFMAMLA_qr<"vfma", "f32", 0b0, 0b11, 0b0>;
3442 def MVE_VFMA_qr_Sf16 : MVE_VFMAMLA_qr<"vfmas", "f16", 0b1, 0b11, 0b1>;
3443 def MVE_VFMA_qr_Sf32 : MVE_VFMAMLA_qr<"vfmas", "f32", 0b0, 0b11, 0b1>;
3446 class MVE_VQDMLAH_qr<string iname, string suffix, bit U, bits<2> size,
3447 bit bit_5, bit bit_12, list<dag> pattern=[]>
3448 : MVE_qDestSrc_rSrc<iname, suffix, pattern> {
3451 let Inst{21-20} = size;
3453 let Inst{12} = bit_12;
3455 let Inst{5} = bit_5;
3458 multiclass MVE_VQDMLAH_qr_types<string iname, bit bit_5, bit bit_12> {
3459 def s8 : MVE_VQDMLAH_qr<iname, "s8", 0b0, 0b00, bit_5, bit_12>;
3460 def s16 : MVE_VQDMLAH_qr<iname, "s16", 0b0, 0b01, bit_5, bit_12>;
3461 def s32 : MVE_VQDMLAH_qr<iname, "s32", 0b0, 0b10, bit_5, bit_12>;
3464 defm MVE_VQDMLAH_qr : MVE_VQDMLAH_qr_types<"vqdmlah", 0b1, 0b0>;
3465 defm MVE_VQRDMLAH_qr : MVE_VQDMLAH_qr_types<"vqrdmlah", 0b0, 0b0>;
3466 defm MVE_VQDMLASH_qr : MVE_VQDMLAH_qr_types<"vqdmlash", 0b1, 0b1>;
3467 defm MVE_VQRDMLASH_qr : MVE_VQDMLAH_qr_types<"vqrdmlash", 0b0, 0b1>;
3469 class MVE_VxDUP<string iname, string suffix, bits<2> size, bit bit_12,
3470 list<dag> pattern=[]>
3471 : MVE_p<(outs MQPR:$Qd, tGPREven:$Rn),
3472 (ins tGPREven:$Rn_src, MVE_VIDUP_imm:$imm), NoItinerary,
3473 iname, suffix, "$Qd, $Rn, $imm", vpred_r, "$Rn = $Rn_src",
3480 let Inst{25-23} = 0b100;
3481 let Inst{22} = Qd{3};
3482 let Inst{21-20} = size;
3483 let Inst{19-17} = Rn{3-1};
3485 let Inst{15-13} = Qd{2-0};
3486 let Inst{12} = bit_12;
3487 let Inst{11-8} = 0b1111;
3488 let Inst{7} = imm{1};
3489 let Inst{6-1} = 0b110111;
3490 let Inst{0} = imm{0};
3493 def MVE_VIDUPu8 : MVE_VxDUP<"vidup", "u8", 0b00, 0b0>;
3494 def MVE_VIDUPu16 : MVE_VxDUP<"vidup", "u16", 0b01, 0b0>;
3495 def MVE_VIDUPu32 : MVE_VxDUP<"vidup", "u32", 0b10, 0b0>;
3497 def MVE_VDDUPu8 : MVE_VxDUP<"vddup", "u8", 0b00, 0b1>;
3498 def MVE_VDDUPu16 : MVE_VxDUP<"vddup", "u16", 0b01, 0b1>;
3499 def MVE_VDDUPu32 : MVE_VxDUP<"vddup", "u32", 0b10, 0b1>;
3501 class MVE_VxWDUP<string iname, string suffix, bits<2> size, bit bit_12,
3502 list<dag> pattern=[]>
3503 : MVE_p<(outs MQPR:$Qd, tGPREven:$Rn),
3504 (ins tGPREven:$Rn_src, tGPROdd:$Rm, MVE_VIDUP_imm:$imm), NoItinerary,
3505 iname, suffix, "$Qd, $Rn, $Rm, $imm", vpred_r, "$Rn = $Rn_src",
3513 let Inst{25-23} = 0b100;
3514 let Inst{22} = Qd{3};
3515 let Inst{21-20} = size;
3516 let Inst{19-17} = Rn{3-1};
3518 let Inst{15-13} = Qd{2-0};
3519 let Inst{12} = bit_12;
3520 let Inst{11-8} = 0b1111;
3521 let Inst{7} = imm{1};
3522 let Inst{6-4} = 0b110;
3523 let Inst{3-1} = Rm{3-1};
3524 let Inst{0} = imm{0};
3527 def MVE_VIWDUPu8 : MVE_VxWDUP<"viwdup", "u8", 0b00, 0b0>;
3528 def MVE_VIWDUPu16 : MVE_VxWDUP<"viwdup", "u16", 0b01, 0b0>;
3529 def MVE_VIWDUPu32 : MVE_VxWDUP<"viwdup", "u32", 0b10, 0b0>;
3531 def MVE_VDWDUPu8 : MVE_VxWDUP<"vdwdup", "u8", 0b00, 0b1>;
3532 def MVE_VDWDUPu16 : MVE_VxWDUP<"vdwdup", "u16", 0b01, 0b1>;
3533 def MVE_VDWDUPu32 : MVE_VxWDUP<"vdwdup", "u32", 0b10, 0b1>;
3535 class MVE_VCTP<string suffix, bits<2> size, list<dag> pattern=[]>
3536 : MVE_p<(outs VCCR:$P0), (ins rGPR:$Rn), NoItinerary, "vctp", suffix,
3537 "$Rn", vpred_n, "", pattern> {
3540 let Inst{28-27} = 0b10;
3541 let Inst{26-22} = 0b00000;
3542 let Inst{21-20} = size;
3543 let Inst{19-16} = Rn{3-0};
3544 let Inst{15-11} = 0b11101;
3545 let Inst{10-0} = 0b00000000001;
3546 let Unpredictable{10-0} = 0b11111111111;
3548 let Constraints = "";
3549 let DecoderMethod = "DecodeMveVCTP";
3552 def MVE_VCTP8 : MVE_VCTP<"8", 0b00>;
3553 def MVE_VCTP16 : MVE_VCTP<"16", 0b01>;
3554 def MVE_VCTP32 : MVE_VCTP<"32", 0b10>;
3555 def MVE_VCTP64 : MVE_VCTP<"64", 0b11>;
3557 // end of mve_qDest_rSrc
3559 // start of coproc mov
3561 class MVE_VMOV_64bit<dag oops, dag iops, bit to_qreg, string ops, string cstr>
3562 : MVE_VMOV_lane_base<oops, !con(iops, (ins MVEPairVectorIndex2:$idx,
3563 MVEPairVectorIndex0:$idx2)),
3564 NoItinerary, "vmov", "", ops, cstr, []> {
3571 let Inst{31-23} = 0b111011000;
3572 let Inst{22} = Qd{3};
3574 let Inst{20} = to_qreg;
3575 let Inst{19-16} = Rt2{3-0};
3576 let Inst{15-13} = Qd{2-0};
3577 let Inst{12-5} = 0b01111000;
3579 let Inst{3-0} = Rt{3-0};
3582 // The assembly syntax for these instructions mentions the vector
3583 // register name twice, e.g.
3585 // vmov q2[2], q2[0], r0, r1
3586 // vmov r0, r1, q2[2], q2[0]
3588 // which needs a bit of juggling with MC operand handling.
3590 // For the move _into_ a vector register, the MC operand list also has
3591 // to mention the register name twice: once as the output, and once as
3592 // an extra input to represent where the unchanged half of the output
3593 // register comes from (when this instruction is used in code
3594 // generation). So we arrange that the first mention of the vector reg
3595 // in the instruction is considered by the AsmMatcher to be the output
3596 // ($Qd), and the second one is the input ($QdSrc). Binding them
3597 // together with the existing 'tie' constraint is enough to enforce at
3598 // register allocation time that they have to be the same register.
3600 // For the move _from_ a vector register, there's no way to get round
3601 // the fact that both instances of that register name have to be
3602 // inputs. They have to be the same register again, but this time, we
3603 // can't use a tie constraint, because that has to be between an
3604 // output and an input operand. So this time, we have to arrange that
3605 // the q-reg appears just once in the MC operand list, in spite of
3606 // being mentioned twice in the asm syntax - which needs a custom
3607 // AsmMatchConverter.
3609 def MVE_VMOV_q_rr : MVE_VMOV_64bit<(outs MQPR:$Qd),
3610 (ins MQPR:$QdSrc, rGPR:$Rt, rGPR:$Rt2),
3611 0b1, "$Qd$idx, $QdSrc$idx2, $Rt, $Rt2",
3613 let DecoderMethod = "DecodeMVEVMOVDRegtoQ";
3616 def MVE_VMOV_rr_q : MVE_VMOV_64bit<(outs rGPR:$Rt, rGPR:$Rt2), (ins MQPR:$Qd),
3617 0b0, "$Rt, $Rt2, $Qd$idx, $Qd$idx2", ""> {
3618 let DecoderMethod = "DecodeMVEVMOVQtoDReg";
3619 let AsmMatchConverter = "cvtMVEVMOVQtoDReg";
3622 // end of coproc mov
3624 // start of MVE interleaving load/store
3626 // Base class for the family of interleaving/deinterleaving
3627 // load/stores with names like VLD20.8 and VST43.32.
3628 class MVE_vldst24_base<bit writeback, bit fourregs, bits<2> stage, bits<2> size,
3629 bit load, dag Oops, dag loadIops, dag wbIops,
3630 string iname, string ops,
3631 string cstr, list<dag> pattern=[]>
3632 : MVE_MI<Oops, !con(loadIops, wbIops), NoItinerary, iname, ops, cstr, pattern> {
3636 let Inst{31-22} = 0b1111110010;
3637 let Inst{21} = writeback;
3638 let Inst{20} = load;
3639 let Inst{19-16} = Rn;
3640 let Inst{15-13} = VQd{2-0};
3641 let Inst{12-9} = 0b1111;
3642 let Inst{8-7} = size;
3643 let Inst{6-5} = stage;
3644 let Inst{4-1} = 0b0000;
3645 let Inst{0} = fourregs;
3648 let mayStore = !eq(load,0);
3651 // A parameter class used to encapsulate all the ways the writeback
3652 // variants of VLD20 and friends differ from the non-writeback ones.
3653 class MVE_vldst24_writeback<bit b, dag Oo, dag Io,
3654 string sy="", string c="", string n=""> {
3660 string id_suffix = n;
3663 // Another parameter class that encapsulates the differences between VLD2x
3665 class MVE_vldst24_nvecs<int n, list<int> s, bit b, RegisterOperand vl> {
3667 list<int> stages = s;
3669 RegisterOperand VecList = vl;
3672 // A third parameter class that distinguishes VLDnn.8 from .16 from .32.
3673 class MVE_vldst24_lanesize<int i, bits<2> b> {
3675 bits<2> sizebits = b;
3678 // A base class for each direction of transfer: one for load, one for
3679 // store. I can't make these a fourth independent parametric tuple
3680 // class, because they have to take the nvecs tuple class as a
3681 // parameter, in order to find the right VecList operand type.
3683 class MVE_vld24_base<MVE_vldst24_nvecs n, bits<2> pat, bits<2> size,
3684 MVE_vldst24_writeback wb, string iname,
3685 list<dag> pattern=[]>
3686 : MVE_vldst24_base<wb.writeback, n.bit0, pat, size, 1,
3687 !con((outs n.VecList:$VQd), wb.Oops),
3688 (ins n.VecList:$VQdSrc), wb.Iops,
3689 iname, "$VQd, $Rn" # wb.syntax,
3690 wb.cstr # ",$VQdSrc = $VQd", pattern>;
3692 class MVE_vst24_base<MVE_vldst24_nvecs n, bits<2> pat, bits<2> size,
3693 MVE_vldst24_writeback wb, string iname,
3694 list<dag> pattern=[]>
3695 : MVE_vldst24_base<wb.writeback, n.bit0, pat, size, 0,
3696 wb.Oops, (ins n.VecList:$VQd), wb.Iops,
3697 iname, "$VQd, $Rn" # wb.syntax,
3700 // Actually define all the interleaving loads and stores, by a series
3701 // of nested foreaches over number of vectors (VLD2/VLD4); stage
3702 // within one of those series (VLDx0/VLDx1/VLDx2/VLDx3); size of
3703 // vector lane; writeback or no writeback.
3704 foreach n = [MVE_vldst24_nvecs<2, [0,1], 0, VecList2Q>,
3705 MVE_vldst24_nvecs<4, [0,1,2,3], 1, VecList4Q>] in
3706 foreach stage = n.stages in
3707 foreach s = [MVE_vldst24_lanesize< 8, 0b00>,
3708 MVE_vldst24_lanesize<16, 0b01>,
3709 MVE_vldst24_lanesize<32, 0b10>] in
3710 foreach wb = [MVE_vldst24_writeback<
3711 1, (outs rGPR:$wb), (ins t2_nosp_addr_offset_none:$Rn),
3712 "!", "$Rn.base = $wb", "_wb">,
3713 MVE_vldst24_writeback<0, (outs), (ins t2_addr_offset_none:$Rn)>] in {
3715 // For each case within all of those foreaches, define the actual
3716 // instructions. The def names are made by gluing together pieces
3717 // from all the parameter classes, and will end up being things like
3718 // MVE_VLD20_8 and MVE_VST43_16_wb.
3720 def "MVE_VLD" # n.nvecs # stage # "_" # s.lanesize # wb.id_suffix
3721 : MVE_vld24_base<n, stage, s.sizebits, wb,
3722 "vld" # n.nvecs # stage # "." # s.lanesize>;
3724 def "MVE_VST" # n.nvecs # stage # "_" # s.lanesize # wb.id_suffix
3725 : MVE_vst24_base<n, stage, s.sizebits, wb,
3726 "vst" # n.nvecs # stage # "." # s.lanesize>;
3729 // end of MVE interleaving load/store
3731 // start of MVE predicable load/store
3733 // A parameter class for the direction of transfer.
3734 class MVE_ldst_direction<bit b, dag Oo, dag Io, string c=""> {
3740 def MVE_ld: MVE_ldst_direction<1, (outs MQPR:$Qd), (ins), ",@earlyclobber $Qd">;
3741 def MVE_st: MVE_ldst_direction<0, (outs), (ins MQPR:$Qd)>;
3743 // A parameter class for the size of memory access in a load.
3744 class MVE_memsz<bits<2> e, int s, AddrMode m, string mn, list<string> types> {
3745 bits<2> encoding = e; // opcode bit(s) for encoding
3746 int shift = s; // shift applied to immediate load offset
3749 // For instruction aliases: define the complete list of type
3750 // suffixes at this size, and the canonical ones for loads and
3752 string MnemonicLetter = mn;
3753 int TypeBits = !shl(8, s);
3754 string CanonLoadSuffix = ".u" # TypeBits;
3755 string CanonStoreSuffix = "." # TypeBits;
3756 list<string> suffixes = !foreach(letter, types, "." # letter # TypeBits);
3759 // Instances of MVE_memsz.
3761 // (memD doesn't need an AddrMode, because those are only for
3762 // contiguous loads, and memD is only used by gather/scatters.)
3763 def MVE_memB: MVE_memsz<0b00, 0, AddrModeT2_i7, "b", ["", "u", "s"]>;
3764 def MVE_memH: MVE_memsz<0b01, 1, AddrModeT2_i7s2, "h", ["", "u", "s", "f"]>;
3765 def MVE_memW: MVE_memsz<0b10, 2, AddrModeT2_i7s4, "w", ["", "u", "s", "f"]>;
3766 def MVE_memD: MVE_memsz<0b11, 3, ?, "d", ["", "u", "s", "f"]>;
3768 // This is the base class for all the MVE loads and stores other than
3769 // the interleaving ones. All the non-interleaving loads/stores share
3770 // the characteristic that they operate on just one vector register,
3771 // so they are VPT-predicable.
3773 // The predication operand is vpred_n, for both loads and stores. For
3774 // store instructions, the reason is obvious: if there is no output
3775 // register, there can't be a need for an input parameter giving the
3776 // output register's previous value. Load instructions also don't need
3777 // that input parameter, because unlike MVE data processing
3778 // instructions, predicated loads are defined to set the inactive
3779 // lanes of the output register to zero, instead of preserving their
3781 class MVE_VLDRSTR_base<MVE_ldst_direction dir, bit U, bit P, bit W, bit opc,
3782 dag oops, dag iops, string asm, string suffix,
3783 string ops, string cstr, list<dag> pattern=[]>
3784 : MVE_p<oops, iops, NoItinerary, asm, suffix, ops, vpred_n, cstr, pattern> {
3792 let Inst{20} = dir.load;
3793 let Inst{15-13} = Qd{2-0};
3795 let Inst{11-9} = 0b111;
3797 let mayLoad = dir.load;
3798 let mayStore = !eq(dir.load,0);
3801 // Contiguous load and store instructions. These come in two main
3802 // categories: same-size loads/stores in which 128 bits of vector
3803 // register is transferred to or from 128 bits of memory in the most
3804 // obvious way, and widening loads / narrowing stores, in which the
3805 // size of memory accessed is less than the size of a vector register,
3806 // so the load instructions sign- or zero-extend each memory value
3807 // into a wider vector lane, and the store instructions truncate
3810 // The instruction mnemonics for these two classes look reasonably
3811 // similar, but the actual encodings are different enough to need two
3812 // separate base classes.
3814 // Contiguous, same size
3815 class MVE_VLDRSTR_cs<MVE_ldst_direction dir, MVE_memsz memsz, bit P, bit W,
3816 dag oops, dag iops, string asm, string suffix,
3817 IndexMode im, string ops, string cstr>
3818 : MVE_VLDRSTR_base<dir, 0, P, W, 1, oops, iops, asm, suffix, ops, cstr> {
3820 let Inst{23} = addr{7};
3821 let Inst{19-16} = addr{11-8};
3822 let Inst{8-7} = memsz.encoding;
3823 let Inst{6-0} = addr{6-0};
3826 // Contiguous, widening/narrowing
3827 class MVE_VLDRSTR_cw<MVE_ldst_direction dir, MVE_memsz memsz, bit U,
3828 bit P, bit W, bits<2> size, dag oops, dag iops,
3829 string asm, string suffix, IndexMode im,
3830 string ops, string cstr>
3831 : MVE_VLDRSTR_base<dir, U, P, W, 0, oops, iops, asm, suffix, ops, cstr> {
3833 let Inst{23} = addr{7};
3834 let Inst{19} = memsz.encoding{0}; // enough to tell 16- from 32-bit
3835 let Inst{18-16} = addr{10-8};
3836 let Inst{8-7} = size;
3837 let Inst{6-0} = addr{6-0};
3842 // Multiclass wrapper on each of the _cw and _cs base classes, to
3843 // generate three writeback modes (none, preindex, postindex).
3845 multiclass MVE_VLDRSTR_cw_m<MVE_ldst_direction dir, MVE_memsz memsz,
3846 string asm, string suffix, bit U, bits<2> size> {
3847 let AM = memsz.AM in {
3848 def "" : MVE_VLDRSTR_cw<
3849 dir, memsz, U, 1, 0, size,
3850 dir.Oops, !con(dir.Iops, (ins taddrmode_imm7<memsz.shift>:$addr)),
3851 asm, suffix, IndexModeNone, "$Qd, $addr", "">;
3853 def _pre : MVE_VLDRSTR_cw<
3854 dir, memsz, U, 1, 1, size,
3855 !con((outs tGPR:$wb), dir.Oops),
3856 !con(dir.Iops, (ins taddrmode_imm7<memsz.shift>:$addr)),
3857 asm, suffix, IndexModePre, "$Qd, $addr!", "$addr.base = $wb"> {
3858 let DecoderMethod = "DecodeMVE_MEM_1_pre<"#memsz.shift#">";
3861 def _post : MVE_VLDRSTR_cw<
3862 dir, memsz, U, 0, 1, size,
3863 !con((outs tGPR:$wb), dir.Oops),
3864 !con(dir.Iops, (ins t_addr_offset_none:$Rn,
3865 t2am_imm7_offset<memsz.shift>:$addr)),
3866 asm, suffix, IndexModePost, "$Qd, $Rn$addr", "$Rn.base = $wb"> {
3868 let Inst{18-16} = Rn{2-0};
3873 multiclass MVE_VLDRSTR_cs_m<MVE_ldst_direction dir, MVE_memsz memsz,
3874 string asm, string suffix> {
3875 let AM = memsz.AM in {
3876 def "" : MVE_VLDRSTR_cs<
3878 dir.Oops, !con(dir.Iops, (ins t2addrmode_imm7<memsz.shift>:$addr)),
3879 asm, suffix, IndexModeNone, "$Qd, $addr", "">;
3881 def _pre : MVE_VLDRSTR_cs<
3883 !con((outs rGPR:$wb), dir.Oops),
3884 !con(dir.Iops, (ins t2addrmode_imm7_pre<memsz.shift>:$addr)),
3885 asm, suffix, IndexModePre, "$Qd, $addr!", "$addr.base = $wb"> {
3886 let DecoderMethod = "DecodeMVE_MEM_2_pre<"#memsz.shift#">";
3889 def _post : MVE_VLDRSTR_cs<
3891 !con((outs rGPR:$wb), dir.Oops),
3892 // We need an !if here to select the base register class,
3893 // because it's legal to write back to SP in a load of this
3894 // type, but not in a store.
3895 !con(dir.Iops, (ins !if(dir.load, t2_addr_offset_none,
3896 t2_nosp_addr_offset_none):$Rn,
3897 t2am_imm7_offset<memsz.shift>:$addr)),
3898 asm, suffix, IndexModePost, "$Qd, $Rn$addr", "$Rn.base = $wb"> {
3900 let Inst{19-16} = Rn{3-0};
3905 // Now actually declare all the contiguous load/stores, via those
3906 // multiclasses. The instruction ids coming out of this are the bare
3907 // names shown in the defm, with _pre or _post appended for writeback,
3908 // e.g. MVE_VLDRBS16, MVE_VSTRB16_pre, MVE_VSTRHU16_post.
3910 defm MVE_VLDRBS16: MVE_VLDRSTR_cw_m<MVE_ld, MVE_memB, "vldrb", "s16", 0, 0b01>;
3911 defm MVE_VLDRBS32: MVE_VLDRSTR_cw_m<MVE_ld, MVE_memB, "vldrb", "s32", 0, 0b10>;
3912 defm MVE_VLDRBU16: MVE_VLDRSTR_cw_m<MVE_ld, MVE_memB, "vldrb", "u16", 1, 0b01>;
3913 defm MVE_VLDRBU32: MVE_VLDRSTR_cw_m<MVE_ld, MVE_memB, "vldrb", "u32", 1, 0b10>;
3914 defm MVE_VLDRHS32: MVE_VLDRSTR_cw_m<MVE_ld, MVE_memH, "vldrh", "s32", 0, 0b10>;
3915 defm MVE_VLDRHU32: MVE_VLDRSTR_cw_m<MVE_ld, MVE_memH, "vldrh", "u32", 1, 0b10>;
3917 defm MVE_VLDRBU8: MVE_VLDRSTR_cs_m<MVE_ld, MVE_memB, "vldrb", "u8">;
3918 defm MVE_VLDRHU16: MVE_VLDRSTR_cs_m<MVE_ld, MVE_memH, "vldrh", "u16">;
3919 defm MVE_VLDRWU32: MVE_VLDRSTR_cs_m<MVE_ld, MVE_memW, "vldrw", "u32">;
3921 defm MVE_VSTRB16: MVE_VLDRSTR_cw_m<MVE_st, MVE_memB, "vstrb", "16", 0, 0b01>;
3922 defm MVE_VSTRB32: MVE_VLDRSTR_cw_m<MVE_st, MVE_memB, "vstrb", "32", 0, 0b10>;
3923 defm MVE_VSTRH32: MVE_VLDRSTR_cw_m<MVE_st, MVE_memH, "vstrh", "32", 0, 0b10>;
3925 defm MVE_VSTRBU8 : MVE_VLDRSTR_cs_m<MVE_st, MVE_memB, "vstrb", "8">;
3926 defm MVE_VSTRHU16: MVE_VLDRSTR_cs_m<MVE_st, MVE_memH, "vstrh", "16">;
3927 defm MVE_VSTRWU32: MVE_VLDRSTR_cs_m<MVE_st, MVE_memW, "vstrw", "32">;
3929 // Gather loads / scatter stores whose address operand is of the form
3930 // [Rn,Qm], i.e. a single GPR as the common base address, plus a
3931 // vector of offset from it. ('Load/store this sequence of elements of
3932 // the same array.')
3934 // Like the contiguous family, these loads and stores can widen the
3935 // loaded values / truncate the stored ones, or they can just
3936 // load/store the same size of memory and vector lane. But unlike the
3937 // contiguous family, there's no particular difference in encoding
3938 // between those two cases.
3940 // This family also comes with the option to scale the offset values
3941 // in Qm by the size of the loaded memory (i.e. to treat them as array
3942 // indices), or not to scale them (to treat them as plain byte offsets
3943 // in memory, so that perhaps the loaded values are unaligned). The
3944 // scaled instructions' address operand in assembly looks like
3945 // [Rn,Qm,UXTW #2] or similar.
3948 class MVE_VLDRSTR_rq<MVE_ldst_direction dir, MVE_memsz memsz, bit U,
3949 bits<2> size, bit os, string asm, string suffix, int shift>
3950 : MVE_VLDRSTR_base<dir, U, 0b0, 0b0, 0, dir.Oops,
3951 !con(dir.Iops, (ins mve_addr_rq_shift<shift>:$addr)),
3952 asm, suffix, "$Qd, $addr", dir.cstr> {
3955 let Inst{19-16} = addr{6-3};
3956 let Inst{8-7} = size;
3957 let Inst{6} = memsz.encoding{1};
3959 let Inst{4} = memsz.encoding{0};
3960 let Inst{3-1} = addr{2-0};
3964 // Multiclass that defines the scaled and unscaled versions of an
3965 // instruction, when the memory size is wider than a byte. The scaled
3966 // version gets the default name like MVE_VLDRBU16_rq; the unscaled /
3967 // potentially unaligned version gets a "_u" suffix, e.g.
3968 // MVE_VLDRBU16_rq_u.
3969 multiclass MVE_VLDRSTR_rq_w<MVE_ldst_direction dir, MVE_memsz memsz,
3970 string asm, string suffix, bit U, bits<2> size> {
3971 def _u : MVE_VLDRSTR_rq<dir, memsz, U, size, 0, asm, suffix, 0>;
3972 def "" : MVE_VLDRSTR_rq<dir, memsz, U, size, 1, asm, suffix, memsz.shift>;
3975 // Subclass of MVE_VLDRSTR_rq with the same API as that multiclass,
3976 // for use when the memory size is one byte, so there's no 'scaled'
3977 // version of the instruction at all. (This is encoded as if it were
3978 // unscaled, but named in the default way with no _u suffix.)
3979 class MVE_VLDRSTR_rq_b<MVE_ldst_direction dir, MVE_memsz memsz,
3980 string asm, string suffix, bit U, bits<2> size>
3981 : MVE_VLDRSTR_rq<dir, memsz, U, size, 0, asm, suffix, 0>;
3983 // Actually define all the loads and stores in this family.
3985 def MVE_VLDRBU8_rq : MVE_VLDRSTR_rq_b<MVE_ld, MVE_memB, "vldrb","u8", 1,0b00>;
3986 def MVE_VLDRBU16_rq: MVE_VLDRSTR_rq_b<MVE_ld, MVE_memB, "vldrb","u16", 1,0b01>;
3987 def MVE_VLDRBS16_rq: MVE_VLDRSTR_rq_b<MVE_ld, MVE_memB, "vldrb","s16", 0,0b01>;
3988 def MVE_VLDRBU32_rq: MVE_VLDRSTR_rq_b<MVE_ld, MVE_memB, "vldrb","u32", 1,0b10>;
3989 def MVE_VLDRBS32_rq: MVE_VLDRSTR_rq_b<MVE_ld, MVE_memB, "vldrb","s32", 0,0b10>;
3991 defm MVE_VLDRHU16_rq: MVE_VLDRSTR_rq_w<MVE_ld, MVE_memH, "vldrh","u16", 1,0b01>;
3992 defm MVE_VLDRHU32_rq: MVE_VLDRSTR_rq_w<MVE_ld, MVE_memH, "vldrh","u32", 1,0b10>;
3993 defm MVE_VLDRHS32_rq: MVE_VLDRSTR_rq_w<MVE_ld, MVE_memH, "vldrh","s32", 0,0b10>;
3994 defm MVE_VLDRWU32_rq: MVE_VLDRSTR_rq_w<MVE_ld, MVE_memW, "vldrw","u32", 1,0b10>;
3995 defm MVE_VLDRDU64_rq: MVE_VLDRSTR_rq_w<MVE_ld, MVE_memD, "vldrd","u64", 1,0b11>;
3997 def MVE_VSTRB8_rq : MVE_VLDRSTR_rq_b<MVE_st, MVE_memB, "vstrb","8", 0,0b00>;
3998 def MVE_VSTRB16_rq : MVE_VLDRSTR_rq_b<MVE_st, MVE_memB, "vstrb","16", 0,0b01>;
3999 def MVE_VSTRB32_rq : MVE_VLDRSTR_rq_b<MVE_st, MVE_memB, "vstrb","32", 0,0b10>;
4001 defm MVE_VSTRH16_rq : MVE_VLDRSTR_rq_w<MVE_st, MVE_memH, "vstrh","16", 0,0b01>;
4002 defm MVE_VSTRH32_rq : MVE_VLDRSTR_rq_w<MVE_st, MVE_memH, "vstrh","32", 0,0b10>;
4003 defm MVE_VSTRW32_rq : MVE_VLDRSTR_rq_w<MVE_st, MVE_memW, "vstrw","32", 0,0b10>;
4004 defm MVE_VSTRD64_rq : MVE_VLDRSTR_rq_w<MVE_st, MVE_memD, "vstrd","64", 0,0b11>;
4006 // Gather loads / scatter stores whose address operand is of the form
4007 // [Qm,#imm], i.e. a vector containing a full base address for each
4008 // loaded item, plus an immediate offset applied consistently to all
4009 // of them. ('Load/store the same field from this vector of pointers
4010 // to a structure type.')
4012 // This family requires the vector lane size to be at least 32 bits
4013 // (so there's room for an address in each lane at all). It has no
4014 // widening/narrowing variants. But it does support preindex
4015 // writeback, in which the address vector is updated to hold the
4016 // addresses actually loaded from.
4019 class MVE_VLDRSTR_qi<MVE_ldst_direction dir, MVE_memsz memsz, bit W, dag wbops,
4020 string asm, string wbAsm, string suffix, string cstr = "">
4021 : MVE_VLDRSTR_base<dir, 1, 1, W, 1, !con(wbops, dir.Oops),
4022 !con(dir.Iops, (ins mve_addr_q_shift<memsz.shift>:$addr)),
4023 asm, suffix, "$Qd, $addr" # wbAsm, cstr # dir.cstr> {
4025 let Inst{23} = addr{7};
4026 let Inst{19-17} = addr{10-8};
4028 let Inst{8} = memsz.encoding{0}; // enough to distinguish 32- from 64-bit
4030 let Inst{6-0} = addr{6-0};
4033 // Multiclass that generates the non-writeback and writeback variants.
4034 multiclass MVE_VLDRSTR_qi_m<MVE_ldst_direction dir, MVE_memsz memsz,
4035 string asm, string suffix> {
4036 def "" : MVE_VLDRSTR_qi<dir, memsz, 0, (outs), asm, "", suffix>;
4037 def _pre : MVE_VLDRSTR_qi<dir, memsz, 1, (outs MQPR:$wb), asm, "!", suffix,
4038 "$addr.base = $wb"> {
4039 let DecoderMethod="DecodeMVE_MEM_3_pre<"#memsz.shift#">";
4043 // Actual instruction definitions.
4044 defm MVE_VLDRWU32_qi: MVE_VLDRSTR_qi_m<MVE_ld, MVE_memW, "vldrw", "u32">;
4045 defm MVE_VLDRDU64_qi: MVE_VLDRSTR_qi_m<MVE_ld, MVE_memD, "vldrd", "u64">;
4046 defm MVE_VSTRW32_qi: MVE_VLDRSTR_qi_m<MVE_st, MVE_memW, "vstrw", "32">;
4047 defm MVE_VSTRD64_qi: MVE_VLDRSTR_qi_m<MVE_st, MVE_memD, "vstrd", "64">;
4049 // Define aliases for all the instructions where memory size and
4050 // vector lane size are the same. These are mnemonic aliases, so they
4051 // apply consistently across all of the above families - contiguous
4052 // loads, and both the rq and qi types of gather/scatter.
4054 // Rationale: As long as you're loading (for example) 16-bit memory
4055 // values into 16-bit vector lanes, you can think of them as signed or
4056 // unsigned integers, fp16 or just raw 16-bit blobs and it makes no
4057 // difference. So we permit all of vldrh.16, vldrh.u16, vldrh.s16,
4058 // vldrh.f16 and treat them all as equivalent to the canonical
4059 // spelling (which happens to be .u16 for loads, and just .16 for
4062 foreach vpt_cond = ["", "t", "e"] in
4063 foreach memsz = [MVE_memB, MVE_memH, MVE_memW, MVE_memD] in
4064 foreach suffix = memsz.suffixes in {
4066 // These foreaches are conceptually ifs, implemented by iterating a
4067 // dummy variable over a list with 0 or 1 elements depending on the
4068 // condition. The idea is to iterate over _nearly_ all the suffixes
4069 // in memsz.suffixes, but omit the one we want all the others to alias.
4071 foreach _ = !if(!ne(suffix, memsz.CanonLoadSuffix), [1], []<int>) in
4072 def : MnemonicAlias<
4073 "vldr" # memsz.MnemonicLetter # vpt_cond # suffix,
4074 "vldr" # memsz.MnemonicLetter # vpt_cond # memsz.CanonLoadSuffix>;
4076 foreach _ = !if(!ne(suffix, memsz.CanonStoreSuffix), [1], []<int>) in
4077 def : MnemonicAlias<
4078 "vstr" # memsz.MnemonicLetter # vpt_cond # suffix,
4079 "vstr" # memsz.MnemonicLetter # vpt_cond # memsz.CanonStoreSuffix>;
4082 // end of MVE predicable load/store
4084 class MVE_VPT<string suffix, bits<2> size, dag iops, string asm, list<dag> pattern=[]>
4085 : MVE_MI<(outs ), iops, NoItinerary, !strconcat("vpt", "${Mk}", ".", suffix), asm, "", pattern> {
4090 let Inst{31-23} = 0b111111100;
4091 let Inst{22} = Mk{3};
4092 let Inst{21-20} = size;
4093 let Inst{19-17} = Qn{2-0};
4095 let Inst{15-13} = Mk{2-0};
4096 let Inst{12} = fc{2};
4097 let Inst{11-8} = 0b1111;
4098 let Inst{7} = fc{0};
4101 let Defs = [VPR, P0];
4104 class MVE_VPTt1<string suffix, bits<2> size, dag iops>
4105 : MVE_VPT<suffix, size, iops, "$fc, $Qn, $Qm"> {
4110 let Inst{5} = Qm{3};
4111 let Inst{3-1} = Qm{2-0};
4112 let Inst{0} = fc{1};
4115 class MVE_VPTt1i<string suffix, bits<2> size>
4116 : MVE_VPTt1<suffix, size,
4117 (ins vpt_mask:$Mk, pred_basic_i:$fc, MQPR:$Qn, MQPR:$Qm)> {
4122 def MVE_VPTv4i32 : MVE_VPTt1i<"i32", 0b10>;
4123 def MVE_VPTv8i16 : MVE_VPTt1i<"i16", 0b01>;
4124 def MVE_VPTv16i8 : MVE_VPTt1i<"i8", 0b00>;
4126 class MVE_VPTt1u<string suffix, bits<2> size>
4127 : MVE_VPTt1<suffix, size,
4128 (ins vpt_mask:$Mk, pred_basic_u:$fc, MQPR:$Qn, MQPR:$Qm)> {
4133 def MVE_VPTv4u32 : MVE_VPTt1u<"u32", 0b10>;
4134 def MVE_VPTv8u16 : MVE_VPTt1u<"u16", 0b01>;
4135 def MVE_VPTv16u8 : MVE_VPTt1u<"u8", 0b00>;
4137 class MVE_VPTt1s<string suffix, bits<2> size>
4138 : MVE_VPTt1<suffix, size,
4139 (ins vpt_mask:$Mk, pred_basic_s:$fc, MQPR:$Qn, MQPR:$Qm)> {
4143 def MVE_VPTv4s32 : MVE_VPTt1s<"s32", 0b10>;
4144 def MVE_VPTv8s16 : MVE_VPTt1s<"s16", 0b01>;
4145 def MVE_VPTv16s8 : MVE_VPTt1s<"s8", 0b00>;
4147 class MVE_VPTt2<string suffix, bits<2> size, dag iops>
4148 : MVE_VPT<suffix, size, iops,
4155 let Inst{5} = fc{1};
4156 let Inst{3-0} = Rm{3-0};
4159 class MVE_VPTt2i<string suffix, bits<2> size>
4160 : MVE_VPTt2<suffix, size,
4161 (ins vpt_mask:$Mk, pred_basic_i:$fc, MQPR:$Qn, GPRwithZR:$Rm)> {
4166 def MVE_VPTv4i32r : MVE_VPTt2i<"i32", 0b10>;
4167 def MVE_VPTv8i16r : MVE_VPTt2i<"i16", 0b01>;
4168 def MVE_VPTv16i8r : MVE_VPTt2i<"i8", 0b00>;
4170 class MVE_VPTt2u<string suffix, bits<2> size>
4171 : MVE_VPTt2<suffix, size,
4172 (ins vpt_mask:$Mk, pred_basic_u:$fc, MQPR:$Qn, GPRwithZR:$Rm)> {
4177 def MVE_VPTv4u32r : MVE_VPTt2u<"u32", 0b10>;
4178 def MVE_VPTv8u16r : MVE_VPTt2u<"u16", 0b01>;
4179 def MVE_VPTv16u8r : MVE_VPTt2u<"u8", 0b00>;
4181 class MVE_VPTt2s<string suffix, bits<2> size>
4182 : MVE_VPTt2<suffix, size,
4183 (ins vpt_mask:$Mk, pred_basic_s:$fc, MQPR:$Qn, GPRwithZR:$Rm)> {
4187 def MVE_VPTv4s32r : MVE_VPTt2s<"s32", 0b10>;
4188 def MVE_VPTv8s16r : MVE_VPTt2s<"s16", 0b01>;
4189 def MVE_VPTv16s8r : MVE_VPTt2s<"s8", 0b00>;
4192 class MVE_VPTf<string suffix, bit size, dag iops, string asm, list<dag> pattern=[]>
4193 : MVE_MI<(outs ), iops, NoItinerary, !strconcat("vpt", "${Mk}", ".", suffix), asm,
4199 let Inst{31-29} = 0b111;
4200 let Inst{28} = size;
4201 let Inst{27-23} = 0b11100;
4202 let Inst{22} = Mk{3};
4203 let Inst{21-20} = 0b11;
4204 let Inst{19-17} = Qn{2-0};
4206 let Inst{15-13} = Mk{2-0};
4207 let Inst{12} = fc{2};
4208 let Inst{11-8} = 0b1111;
4209 let Inst{7} = fc{0};
4213 let Predicates = [HasMVEFloat];
4216 class MVE_VPTft1<string suffix, bit size>
4217 : MVE_VPTf<suffix, size, (ins vpt_mask:$Mk, pred_basic_fp:$fc, MQPR:$Qn, MQPR:$Qm),
4223 let Inst{5} = Qm{3};
4224 let Inst{3-1} = Qm{2-0};
4225 let Inst{0} = fc{1};
4228 def MVE_VPTv4f32 : MVE_VPTft1<"f32", 0b0>;
4229 def MVE_VPTv8f16 : MVE_VPTft1<"f16", 0b1>;
4231 class MVE_VPTft2<string suffix, bit size>
4232 : MVE_VPTf<suffix, size, (ins vpt_mask:$Mk, pred_basic_fp:$fc, MQPR:$Qn, GPRwithZR:$Rm),
4238 let Inst{5} = fc{1};
4239 let Inst{3-0} = Rm{3-0};
4242 def MVE_VPTv4f32r : MVE_VPTft2<"f32", 0b0>;
4243 def MVE_VPTv8f16r : MVE_VPTft2<"f16", 0b1>;
4245 def MVE_VPST : MVE_MI<(outs ), (ins vpt_mask:$Mk), NoItinerary,
4246 !strconcat("vpst", "${Mk}"), "", "", []> {
4249 let Inst{31-23} = 0b111111100;
4250 let Inst{22} = Mk{3};
4251 let Inst{21-16} = 0b110001;
4252 let Inst{15-13} = Mk{2-0};
4253 let Inst{12-0} = 0b0111101001101;
4254 let Unpredictable{12} = 0b1;
4255 let Unpredictable{7} = 0b1;
4256 let Unpredictable{5} = 0b1;
4261 def MVE_VPSEL : MVE_p<(outs MQPR:$Qd), (ins MQPR:$Qn, MQPR:$Qm), NoItinerary,
4262 "vpsel", "", "$Qd, $Qn, $Qm", vpred_n, "", []> {
4268 let Inst{25-23} = 0b100;
4269 let Inst{22} = Qd{3};
4270 let Inst{21-20} = 0b11;
4271 let Inst{19-17} = Qn{2-0};
4273 let Inst{15-13} = Qd{2-0};
4274 let Inst{12-9} = 0b0111;
4276 let Inst{7} = Qn{3};
4278 let Inst{5} = Qm{3};
4280 let Inst{3-1} = Qm{2-0};
4284 foreach suffix = ["s8", "s16", "s32", "u8", "u16", "u32",
4285 "i8", "i16", "i32", "f16", "f32"] in
4286 def : MVEInstAlias<"vpsel${vp}." # suffix # "\t$Qd, $Qn, $Qm",
4287 (MVE_VPSEL MQPR:$Qd, MQPR:$Qn, MQPR:$Qm, vpred_n:$vp)>;
4289 def MVE_VPNOT : MVE_p<(outs), (ins), NoItinerary,
4290 "vpnot", "", "", vpred_n, "", []> {
4291 let Inst{31-0} = 0b11111110001100010000111101001101;
4292 let Unpredictable{19-17} = 0b111;
4293 let Unpredictable{12} = 0b1;
4294 let Unpredictable{7} = 0b1;
4295 let Unpredictable{5} = 0b1;
4299 let Constraints = "";
4302 class MVE_loltp_start<dag iops, string asm, string ops, bits<2> size>
4303 : t2LOL<(outs GPRlr:$LR), iops, asm, ops> {
4305 let Predicates = [HasMVEInt];
4307 let Inst{21-20} = size;
4308 let Inst{19-16} = Rn{3-0};
4312 class MVE_DLSTP<string asm, bits<2> size>
4313 : MVE_loltp_start<(ins rGPR:$Rn), asm, "$LR, $Rn", size> {
4315 let Inst{11-1} = 0b00000000000;
4316 let Unpredictable{10-1} = 0b1111111111;
4319 class MVE_WLSTP<string asm, bits<2> size>
4320 : MVE_loltp_start<(ins rGPR:$Rn, wlslabel_u11:$label),
4321 asm, "$LR, $Rn, $label", size> {
4324 let Inst{11} = label{0};
4325 let Inst{10-1} = label{10-1};
4328 def MVE_DLSTP_8 : MVE_DLSTP<"dlstp.8", 0b00>;
4329 def MVE_DLSTP_16 : MVE_DLSTP<"dlstp.16", 0b01>;
4330 def MVE_DLSTP_32 : MVE_DLSTP<"dlstp.32", 0b10>;
4331 def MVE_DLSTP_64 : MVE_DLSTP<"dlstp.64", 0b11>;
4333 def MVE_WLSTP_8 : MVE_WLSTP<"wlstp.8", 0b00>;
4334 def MVE_WLSTP_16 : MVE_WLSTP<"wlstp.16", 0b01>;
4335 def MVE_WLSTP_32 : MVE_WLSTP<"wlstp.32", 0b10>;
4336 def MVE_WLSTP_64 : MVE_WLSTP<"wlstp.64", 0b11>;
4338 class MVE_loltp_end<dag oops, dag iops, string asm, string ops>
4339 : t2LOL<oops, iops, asm, ops> {
4340 let Predicates = [HasMVEInt];
4341 let Inst{22-21} = 0b00;
4342 let Inst{19-16} = 0b1111;
4346 def MVE_LETP : MVE_loltp_end<(outs GPRlr:$LRout),
4347 (ins GPRlr:$LRin, lelabel_u11:$label),
4348 "letp", "$LRin, $label"> {
4352 let Inst{11} = label{0};
4353 let Inst{10-1} = label{10-1};
4356 def MVE_LCTP : MVE_loltp_end<(outs), (ins pred:$p), "lctp${p}", ""> {
4359 let Inst{11-1} = 0b00000000000;
4360 let Unpredictable{21-20} = 0b11;
4361 let Unpredictable{11-1} = 0b11111111111;
4365 //===----------------------------------------------------------------------===//
4367 //===----------------------------------------------------------------------===//
4369 class MVE_unpred_vector_store_typed<ValueType Ty, Instruction RegImmInst,
4370 PatFrag StoreKind, int shift>
4371 : Pat<(StoreKind (Ty MQPR:$val), t2addrmode_imm7<shift>:$addr),
4372 (RegImmInst (Ty MQPR:$val), t2addrmode_imm7<shift>:$addr)>;
4374 multiclass MVE_unpred_vector_store<Instruction RegImmInst, PatFrag StoreKind,
4376 def : MVE_unpred_vector_store_typed<v16i8, RegImmInst, StoreKind, shift>;
4377 def : MVE_unpred_vector_store_typed<v8i16, RegImmInst, StoreKind, shift>;
4378 def : MVE_unpred_vector_store_typed<v8f16, RegImmInst, StoreKind, shift>;
4379 def : MVE_unpred_vector_store_typed<v4i32, RegImmInst, StoreKind, shift>;
4380 def : MVE_unpred_vector_store_typed<v4f32, RegImmInst, StoreKind, shift>;
4381 def : MVE_unpred_vector_store_typed<v2i64, RegImmInst, StoreKind, shift>;
4382 def : MVE_unpred_vector_store_typed<v2f64, RegImmInst, StoreKind, shift>;
4385 class MVE_unpred_vector_load_typed<ValueType Ty, Instruction RegImmInst,
4386 PatFrag LoadKind, int shift>
4387 : Pat<(Ty (LoadKind t2addrmode_imm7<shift>:$addr)),
4388 (Ty (RegImmInst t2addrmode_imm7<shift>:$addr))>;
4390 multiclass MVE_unpred_vector_load<Instruction RegImmInst, PatFrag LoadKind,
4392 def : MVE_unpred_vector_load_typed<v16i8, RegImmInst, LoadKind, shift>;
4393 def : MVE_unpred_vector_load_typed<v8i16, RegImmInst, LoadKind, shift>;
4394 def : MVE_unpred_vector_load_typed<v8f16, RegImmInst, LoadKind, shift>;
4395 def : MVE_unpred_vector_load_typed<v4i32, RegImmInst, LoadKind, shift>;
4396 def : MVE_unpred_vector_load_typed<v4f32, RegImmInst, LoadKind, shift>;
4397 def : MVE_unpred_vector_load_typed<v2i64, RegImmInst, LoadKind, shift>;
4398 def : MVE_unpred_vector_load_typed<v2f64, RegImmInst, LoadKind, shift>;
4401 let Predicates = [HasMVEInt, IsLE] in {
4402 defm : MVE_unpred_vector_store<MVE_VSTRBU8, byte_alignedstore, 0>;
4403 defm : MVE_unpred_vector_store<MVE_VSTRHU16, hword_alignedstore, 1>;
4404 defm : MVE_unpred_vector_store<MVE_VSTRWU32, alignedstore32, 2>;
4406 defm : MVE_unpred_vector_load<MVE_VLDRBU8, byte_alignedload, 0>;
4407 defm : MVE_unpred_vector_load<MVE_VLDRHU16, hword_alignedload, 1>;
4408 defm : MVE_unpred_vector_load<MVE_VLDRWU32, alignedload32, 2>;
4410 def : Pat<(v16i1 (load t2addrmode_imm7<2>:$addr)),
4411 (v16i1 (VLDR_P0_off t2addrmode_imm7<2>:$addr))>;
4412 def : Pat<(v8i1 (load t2addrmode_imm7<2>:$addr)),
4413 (v8i1 (VLDR_P0_off t2addrmode_imm7<2>:$addr))>;
4414 def : Pat<(v4i1 (load t2addrmode_imm7<2>:$addr)),
4415 (v4i1 (VLDR_P0_off t2addrmode_imm7<2>:$addr))>;
4418 let Predicates = [HasMVEInt, IsBE] in {
4419 def : MVE_unpred_vector_store_typed<v16i8, MVE_VSTRBU8, store, 0>;
4420 def : MVE_unpred_vector_store_typed<v8i16, MVE_VSTRHU16, alignedstore16, 1>;
4421 def : MVE_unpred_vector_store_typed<v8f16, MVE_VSTRHU16, alignedstore16, 1>;
4422 def : MVE_unpred_vector_store_typed<v4i32, MVE_VSTRWU32, alignedstore32, 2>;
4423 def : MVE_unpred_vector_store_typed<v4f32, MVE_VSTRWU32, alignedstore32, 2>;
4425 def : MVE_unpred_vector_load_typed<v16i8, MVE_VLDRBU8, load, 0>;
4426 def : MVE_unpred_vector_load_typed<v8i16, MVE_VLDRHU16, alignedload16, 1>;
4427 def : MVE_unpred_vector_load_typed<v8f16, MVE_VLDRHU16, alignedload16, 1>;
4428 def : MVE_unpred_vector_load_typed<v4i32, MVE_VLDRWU32, alignedload32, 2>;
4429 def : MVE_unpred_vector_load_typed<v4f32, MVE_VLDRWU32, alignedload32, 2>;
4433 // Widening/Narrowing Loads/Stores
4435 let Predicates = [HasMVEInt] in {
4436 def : Pat<(truncstorevi8 (v8i16 MQPR:$val), t2addrmode_imm7<1>:$addr),
4437 (MVE_VSTRB16 MQPR:$val, t2addrmode_imm7<1>:$addr)>;
4438 def : Pat<(truncstorevi8 (v4i32 MQPR:$val), t2addrmode_imm7<1>:$addr),
4439 (MVE_VSTRB32 MQPR:$val, t2addrmode_imm7<1>:$addr)>;
4440 def : Pat<(truncstorevi16 (v4i32 MQPR:$val), t2addrmode_imm7<2>:$addr),
4441 (MVE_VSTRH32 MQPR:$val, t2addrmode_imm7<2>:$addr)>;
4444 multiclass MVEExtLoad<string DestLanes, string DestElemBits,
4445 string SrcElemBits, string SrcElemType,
4447 def _Any : Pat<(!cast<ValueType>("v" # DestLanes # "i" # DestElemBits)
4448 (!cast<PatFrag>("extloadvi" # SrcElemBits) am:$addr)),
4449 (!cast<Instruction>("MVE_VLDR" # SrcElemType # "U" # DestElemBits)
4451 def _Z : Pat<(!cast<ValueType>("v" # DestLanes # "i" # DestElemBits)
4452 (!cast<PatFrag>("zextloadvi" # SrcElemBits) am:$addr)),
4453 (!cast<Instruction>("MVE_VLDR" # SrcElemType # "U" # DestElemBits)
4455 def _S : Pat<(!cast<ValueType>("v" # DestLanes # "i" # DestElemBits)
4456 (!cast<PatFrag>("sextloadvi" # SrcElemBits) am:$addr)),
4457 (!cast<Instruction>("MVE_VLDR" # SrcElemType # "S" # DestElemBits)
4461 let Predicates = [HasMVEInt] in {
4462 defm : MVEExtLoad<"4", "32", "8", "B", t2addrmode_imm7<1>>;
4463 defm : MVEExtLoad<"8", "16", "8", "B", t2addrmode_imm7<1>>;
4464 defm : MVEExtLoad<"4", "32", "16", "H", t2addrmode_imm7<2>>;
4468 // Bit convert patterns
4470 let Predicates = [HasMVEInt] in {
4471 def : Pat<(v2f64 (bitconvert (v2i64 QPR:$src))), (v2f64 QPR:$src)>;
4472 def : Pat<(v2i64 (bitconvert (v2f64 QPR:$src))), (v2i64 QPR:$src)>;
4474 def : Pat<(v4i32 (bitconvert (v4f32 QPR:$src))), (v4i32 QPR:$src)>;
4475 def : Pat<(v4f32 (bitconvert (v4i32 QPR:$src))), (v4f32 QPR:$src)>;
4477 def : Pat<(v8i16 (bitconvert (v8f16 QPR:$src))), (v8i16 QPR:$src)>;
4478 def : Pat<(v8f16 (bitconvert (v8i16 QPR:$src))), (v8f16 QPR:$src)>;
4481 let Predicates = [IsLE,HasMVEInt] in {
4482 def : Pat<(v2f64 (bitconvert (v4f32 QPR:$src))), (v2f64 QPR:$src)>;
4483 def : Pat<(v2f64 (bitconvert (v4i32 QPR:$src))), (v2f64 QPR:$src)>;
4484 def : Pat<(v2f64 (bitconvert (v8f16 QPR:$src))), (v2f64 QPR:$src)>;
4485 def : Pat<(v2f64 (bitconvert (v8i16 QPR:$src))), (v2f64 QPR:$src)>;
4486 def : Pat<(v2f64 (bitconvert (v16i8 QPR:$src))), (v2f64 QPR:$src)>;
4488 def : Pat<(v2i64 (bitconvert (v4f32 QPR:$src))), (v2i64 QPR:$src)>;
4489 def : Pat<(v2i64 (bitconvert (v4i32 QPR:$src))), (v2i64 QPR:$src)>;
4490 def : Pat<(v2i64 (bitconvert (v8f16 QPR:$src))), (v2i64 QPR:$src)>;
4491 def : Pat<(v2i64 (bitconvert (v8i16 QPR:$src))), (v2i64 QPR:$src)>;
4492 def : Pat<(v2i64 (bitconvert (v16i8 QPR:$src))), (v2i64 QPR:$src)>;
4494 def : Pat<(v4f32 (bitconvert (v2f64 QPR:$src))), (v4f32 QPR:$src)>;
4495 def : Pat<(v4f32 (bitconvert (v2i64 QPR:$src))), (v4f32 QPR:$src)>;
4496 def : Pat<(v4f32 (bitconvert (v8f16 QPR:$src))), (v4f32 QPR:$src)>;
4497 def : Pat<(v4f32 (bitconvert (v8i16 QPR:$src))), (v4f32 QPR:$src)>;
4498 def : Pat<(v4f32 (bitconvert (v16i8 QPR:$src))), (v4f32 QPR:$src)>;
4500 def : Pat<(v4i32 (bitconvert (v2f64 QPR:$src))), (v4i32 QPR:$src)>;
4501 def : Pat<(v4i32 (bitconvert (v2i64 QPR:$src))), (v4i32 QPR:$src)>;
4502 def : Pat<(v4i32 (bitconvert (v8f16 QPR:$src))), (v4i32 QPR:$src)>;
4503 def : Pat<(v4i32 (bitconvert (v8i16 QPR:$src))), (v4i32 QPR:$src)>;
4504 def : Pat<(v4i32 (bitconvert (v16i8 QPR:$src))), (v4i32 QPR:$src)>;
4506 def : Pat<(v8f16 (bitconvert (v2f64 QPR:$src))), (v8f16 QPR:$src)>;
4507 def : Pat<(v8f16 (bitconvert (v2i64 QPR:$src))), (v8f16 QPR:$src)>;
4508 def : Pat<(v8f16 (bitconvert (v4f32 QPR:$src))), (v8f16 QPR:$src)>;
4509 def : Pat<(v8f16 (bitconvert (v4i32 QPR:$src))), (v8f16 QPR:$src)>;
4510 def : Pat<(v8f16 (bitconvert (v16i8 QPR:$src))), (v8f16 QPR:$src)>;
4512 def : Pat<(v8i16 (bitconvert (v2f64 QPR:$src))), (v8i16 QPR:$src)>;
4513 def : Pat<(v8i16 (bitconvert (v2i64 QPR:$src))), (v8i16 QPR:$src)>;
4514 def : Pat<(v8i16 (bitconvert (v4f32 QPR:$src))), (v8i16 QPR:$src)>;
4515 def : Pat<(v8i16 (bitconvert (v4i32 QPR:$src))), (v8i16 QPR:$src)>;
4516 def : Pat<(v8i16 (bitconvert (v16i8 QPR:$src))), (v8i16 QPR:$src)>;
4518 def : Pat<(v16i8 (bitconvert (v2f64 QPR:$src))), (v16i8 QPR:$src)>;
4519 def : Pat<(v16i8 (bitconvert (v2i64 QPR:$src))), (v16i8 QPR:$src)>;
4520 def : Pat<(v16i8 (bitconvert (v4f32 QPR:$src))), (v16i8 QPR:$src)>;
4521 def : Pat<(v16i8 (bitconvert (v4i32 QPR:$src))), (v16i8 QPR:$src)>;
4522 def : Pat<(v16i8 (bitconvert (v8f16 QPR:$src))), (v16i8 QPR:$src)>;
4523 def : Pat<(v16i8 (bitconvert (v8i16 QPR:$src))), (v16i8 QPR:$src)>;