1 //===- ARMInstrNEON.td - NEON support for ARM -----------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file describes the ARM NEON instruction set.
12 //===----------------------------------------------------------------------===//
14 //===----------------------------------------------------------------------===//
15 // NEON-specific DAG Nodes.
16 //===----------------------------------------------------------------------===//
18 def SDTARMVCMP : SDTypeProfile<1, 2, [SDTCisInt<0>, SDTCisSameAs<1, 2>]>;
20 def NEONvceq : SDNode<"ARMISD::VCEQ", SDTARMVCMP>;
21 def NEONvcge : SDNode<"ARMISD::VCGE", SDTARMVCMP>;
22 def NEONvcgeu : SDNode<"ARMISD::VCGEU", SDTARMVCMP>;
23 def NEONvcgt : SDNode<"ARMISD::VCGT", SDTARMVCMP>;
24 def NEONvcgtu : SDNode<"ARMISD::VCGTU", SDTARMVCMP>;
25 def NEONvtst : SDNode<"ARMISD::VTST", SDTARMVCMP>;
27 // Types for vector shift by immediates. The "SHX" version is for long and
28 // narrow operations where the source and destination vectors have different
29 // types. The "SHINS" version is for shift and insert operations.
30 def SDTARMVSH : SDTypeProfile<1, 2, [SDTCisInt<0>, SDTCisSameAs<0, 1>,
32 def SDTARMVSHX : SDTypeProfile<1, 2, [SDTCisInt<0>, SDTCisInt<1>,
34 def SDTARMVSHINS : SDTypeProfile<1, 3, [SDTCisInt<0>, SDTCisSameAs<0, 1>,
35 SDTCisSameAs<0, 2>, SDTCisVT<3, i32>]>;
37 def NEONvshl : SDNode<"ARMISD::VSHL", SDTARMVSH>;
38 def NEONvshrs : SDNode<"ARMISD::VSHRs", SDTARMVSH>;
39 def NEONvshru : SDNode<"ARMISD::VSHRu", SDTARMVSH>;
40 def NEONvshlls : SDNode<"ARMISD::VSHLLs", SDTARMVSHX>;
41 def NEONvshllu : SDNode<"ARMISD::VSHLLu", SDTARMVSHX>;
42 def NEONvshlli : SDNode<"ARMISD::VSHLLi", SDTARMVSHX>;
43 def NEONvshrn : SDNode<"ARMISD::VSHRN", SDTARMVSHX>;
45 def NEONvrshrs : SDNode<"ARMISD::VRSHRs", SDTARMVSH>;
46 def NEONvrshru : SDNode<"ARMISD::VRSHRu", SDTARMVSH>;
47 def NEONvrshrn : SDNode<"ARMISD::VRSHRN", SDTARMVSHX>;
49 def NEONvqshls : SDNode<"ARMISD::VQSHLs", SDTARMVSH>;
50 def NEONvqshlu : SDNode<"ARMISD::VQSHLu", SDTARMVSH>;
51 def NEONvqshlsu : SDNode<"ARMISD::VQSHLsu", SDTARMVSH>;
52 def NEONvqshrns : SDNode<"ARMISD::VQSHRNs", SDTARMVSHX>;
53 def NEONvqshrnu : SDNode<"ARMISD::VQSHRNu", SDTARMVSHX>;
54 def NEONvqshrnsu : SDNode<"ARMISD::VQSHRNsu", SDTARMVSHX>;
56 def NEONvqrshrns : SDNode<"ARMISD::VQRSHRNs", SDTARMVSHX>;
57 def NEONvqrshrnu : SDNode<"ARMISD::VQRSHRNu", SDTARMVSHX>;
58 def NEONvqrshrnsu : SDNode<"ARMISD::VQRSHRNsu", SDTARMVSHX>;
60 def NEONvsli : SDNode<"ARMISD::VSLI", SDTARMVSHINS>;
61 def NEONvsri : SDNode<"ARMISD::VSRI", SDTARMVSHINS>;
63 def SDTARMVGETLN : SDTypeProfile<1, 2, [SDTCisVT<0, i32>, SDTCisInt<1>,
65 def NEONvgetlaneu : SDNode<"ARMISD::VGETLANEu", SDTARMVGETLN>;
66 def NEONvgetlanes : SDNode<"ARMISD::VGETLANEs", SDTARMVGETLN>;
68 def NEONvdup : SDNode<"ARMISD::VDUP", SDTypeProfile<1, 1, [SDTCisVec<0>]>>;
70 // VDUPLANE can produce a quad-register result from a double-register source,
71 // so the result is not constrained to match the source.
72 def NEONvduplane : SDNode<"ARMISD::VDUPLANE",
73 SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisVec<1>,
76 def SDTARMVEXT : SDTypeProfile<1, 3, [SDTCisVec<0>, SDTCisSameAs<0, 1>,
77 SDTCisSameAs<0, 2>, SDTCisVT<3, i32>]>;
78 def NEONvext : SDNode<"ARMISD::VEXT", SDTARMVEXT>;
80 def SDTARMVSHUF : SDTypeProfile<1, 1, [SDTCisVec<0>, SDTCisSameAs<0, 1>]>;
81 def NEONvrev64 : SDNode<"ARMISD::VREV64", SDTARMVSHUF>;
82 def NEONvrev32 : SDNode<"ARMISD::VREV32", SDTARMVSHUF>;
83 def NEONvrev16 : SDNode<"ARMISD::VREV16", SDTARMVSHUF>;
85 def SDTARMVSHUF2 : SDTypeProfile<2, 2, [SDTCisVec<0>, SDTCisSameAs<0, 1>,
86 SDTCisSameAs<0, 2>, SDTCisSameAs<0, 3>]>;
87 def NEONzip : SDNode<"ARMISD::VZIP", SDTARMVSHUF2>;
88 def NEONuzp : SDNode<"ARMISD::VUZP", SDTARMVSHUF2>;
89 def NEONtrn : SDNode<"ARMISD::VTRN", SDTARMVSHUF2>;
91 //===----------------------------------------------------------------------===//
92 // NEON operand definitions
93 //===----------------------------------------------------------------------===//
95 // addrmode_neonldstm := reg
97 /* TODO: Take advantage of vldm.
98 def addrmode_neonldstm : Operand<i32>,
99 ComplexPattern<i32, 2, "SelectAddrModeNeonLdStM", []> {
100 let PrintMethod = "printAddrNeonLdStMOperand";
101 let MIOperandInfo = (ops GPR, i32imm);
105 //===----------------------------------------------------------------------===//
106 // NEON load / store instructions
107 //===----------------------------------------------------------------------===//
109 /* TODO: Take advantage of vldm.
110 let mayLoad = 1, hasExtraDefRegAllocReq = 1 in {
111 def VLDMD : NI<(outs),
112 (ins addrmode_neonldstm:$addr, reglist:$dst1, variable_ops),
114 "vldm${addr:submode} ${addr:base}, $dst1",
116 let Inst{27-25} = 0b110;
118 let Inst{11-9} = 0b101;
121 def VLDMS : NI<(outs),
122 (ins addrmode_neonldstm:$addr, reglist:$dst1, variable_ops),
124 "vldm${addr:submode} ${addr:base}, $dst1",
126 let Inst{27-25} = 0b110;
128 let Inst{11-9} = 0b101;
133 // Use vldmia to load a Q register as a D register pair.
134 def VLDRQ : NI4<(outs QPR:$dst), (ins addrmode4:$addr),
136 "vldmia $addr, ${dst:dregpair}",
137 [(set QPR:$dst, (v2f64 (load addrmode4:$addr)))]> {
138 let Inst{27-25} = 0b110;
139 let Inst{24} = 0; // P bit
140 let Inst{23} = 1; // U bit
142 let Inst{11-9} = 0b101;
145 // Use vstmia to store a Q register as a D register pair.
146 def VSTRQ : NI4<(outs), (ins QPR:$src, addrmode4:$addr),
148 "vstmia $addr, ${src:dregpair}",
149 [(store (v2f64 QPR:$src), addrmode4:$addr)]> {
150 let Inst{27-25} = 0b110;
151 let Inst{24} = 0; // P bit
152 let Inst{23} = 1; // U bit
154 let Inst{11-9} = 0b101;
157 // VLD1 : Vector Load (multiple single elements)
158 class VLD1D<string OpcodeStr, ValueType Ty, Intrinsic IntOp>
159 : NLdSt<(outs DPR:$dst), (ins addrmode6:$addr), IIC_VLD1,
160 !strconcat(OpcodeStr, "\t\\{$dst\\}, $addr"), "",
161 [(set DPR:$dst, (Ty (IntOp addrmode6:$addr)))]>;
162 class VLD1Q<string OpcodeStr, ValueType Ty, Intrinsic IntOp>
163 : NLdSt<(outs QPR:$dst), (ins addrmode6:$addr), IIC_VLD1,
164 !strconcat(OpcodeStr, "\t${dst:dregpair}, $addr"), "",
165 [(set QPR:$dst, (Ty (IntOp addrmode6:$addr)))]>;
167 def VLD1d8 : VLD1D<"vld1.8", v8i8, int_arm_neon_vld1>;
168 def VLD1d16 : VLD1D<"vld1.16", v4i16, int_arm_neon_vld1>;
169 def VLD1d32 : VLD1D<"vld1.32", v2i32, int_arm_neon_vld1>;
170 def VLD1df : VLD1D<"vld1.32", v2f32, int_arm_neon_vld1>;
171 def VLD1d64 : VLD1D<"vld1.64", v1i64, int_arm_neon_vld1>;
173 def VLD1q8 : VLD1Q<"vld1.8", v16i8, int_arm_neon_vld1>;
174 def VLD1q16 : VLD1Q<"vld1.16", v8i16, int_arm_neon_vld1>;
175 def VLD1q32 : VLD1Q<"vld1.32", v4i32, int_arm_neon_vld1>;
176 def VLD1qf : VLD1Q<"vld1.32", v4f32, int_arm_neon_vld1>;
177 def VLD1q64 : VLD1Q<"vld1.64", v2i64, int_arm_neon_vld1>;
179 let mayLoad = 1, hasExtraDefRegAllocReq = 1 in {
181 // VLD2 : Vector Load (multiple 2-element structures)
182 class VLD2D<string OpcodeStr>
183 : NLdSt<(outs DPR:$dst1, DPR:$dst2), (ins addrmode6:$addr), IIC_VLD2,
184 !strconcat(OpcodeStr, "\t\\{$dst1,$dst2\\}, $addr"), "", []>;
185 class VLD2Q<string OpcodeStr>
186 : NLdSt<(outs DPR:$dst1, DPR:$dst2, DPR:$dst3, DPR:$dst4),
187 (ins addrmode6:$addr), IIC_VLD2,
188 !strconcat(OpcodeStr, "\t\\{$dst1,$dst2,$dst3,$dst4\\}, $addr"),
191 def VLD2d8 : VLD2D<"vld2.8">;
192 def VLD2d16 : VLD2D<"vld2.16">;
193 def VLD2d32 : VLD2D<"vld2.32">;
195 def VLD2q8 : VLD2Q<"vld2.8">;
196 def VLD2q16 : VLD2Q<"vld2.16">;
197 def VLD2q32 : VLD2Q<"vld2.32">;
199 // VLD3 : Vector Load (multiple 3-element structures)
200 class VLD3D<string OpcodeStr>
201 : NLdSt<(outs DPR:$dst1, DPR:$dst2, DPR:$dst3), (ins addrmode6:$addr),
203 !strconcat(OpcodeStr, "\t\\{$dst1,$dst2,$dst3\\}, $addr"), "", []>;
204 class VLD3WB<string OpcodeStr>
205 : NLdSt<(outs DPR:$dst1, DPR:$dst2, DPR:$dst3, GPR:$wb),
206 (ins addrmode6:$addr), IIC_VLD3,
207 !strconcat(OpcodeStr, "\t\\{$dst1,$dst2,$dst3\\}, $addr"),
208 "$addr.addr = $wb", []>;
210 def VLD3d8 : VLD3D<"vld3.8">;
211 def VLD3d16 : VLD3D<"vld3.16">;
212 def VLD3d32 : VLD3D<"vld3.32">;
214 // vld3 to double-spaced even registers.
215 def VLD3q8a : VLD3WB<"vld3.8">;
216 def VLD3q16a : VLD3WB<"vld3.16">;
217 def VLD3q32a : VLD3WB<"vld3.32">;
219 // vld3 to double-spaced odd registers.
220 def VLD3q8b : VLD3WB<"vld3.8">;
221 def VLD3q16b : VLD3WB<"vld3.16">;
222 def VLD3q32b : VLD3WB<"vld3.32">;
224 // VLD4 : Vector Load (multiple 4-element structures)
225 class VLD4D<string OpcodeStr>
226 : NLdSt<(outs DPR:$dst1, DPR:$dst2, DPR:$dst3, DPR:$dst4),
227 (ins addrmode6:$addr), IIC_VLD4,
228 !strconcat(OpcodeStr, "\t\\{$dst1,$dst2,$dst3,$dst4\\}, $addr"),
231 def VLD4d8 : VLD4D<"vld4.8">;
232 def VLD4d16 : VLD4D<"vld4.16">;
233 def VLD4d32 : VLD4D<"vld4.32">;
235 // VLD2LN : Vector Load (single 2-element structure to one lane)
236 class VLD2LND<string OpcodeStr>
237 : NLdSt<(outs DPR:$dst1, DPR:$dst2),
238 (ins addrmode6:$addr, DPR:$src1, DPR:$src2, nohash_imm:$lane),
240 !strconcat(OpcodeStr, "\t\\{$dst1[$lane],$dst2[$lane]\\}, $addr"),
241 "$src1 = $dst1, $src2 = $dst2", []>;
243 def VLD2LNd8 : VLD2LND<"vld2.8">;
244 def VLD2LNd16 : VLD2LND<"vld2.16">;
245 def VLD2LNd32 : VLD2LND<"vld2.32">;
247 // VLD3LN : Vector Load (single 3-element structure to one lane)
248 class VLD3LND<string OpcodeStr>
249 : NLdSt<(outs DPR:$dst1, DPR:$dst2, DPR:$dst3),
250 (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3,
251 nohash_imm:$lane), IIC_VLD3,
252 !strconcat(OpcodeStr,
253 "\t\\{$dst1[$lane],$dst2[$lane],$dst3[$lane]\\}, $addr"),
254 "$src1 = $dst1, $src2 = $dst2, $src3 = $dst3", []>;
256 def VLD3LNd8 : VLD3LND<"vld3.8">;
257 def VLD3LNd16 : VLD3LND<"vld3.16">;
258 def VLD3LNd32 : VLD3LND<"vld3.32">;
260 // VLD4LN : Vector Load (single 4-element structure to one lane)
261 class VLD4LND<string OpcodeStr>
262 : NLdSt<(outs DPR:$dst1, DPR:$dst2, DPR:$dst3, DPR:$dst4),
263 (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3, DPR:$src4,
264 nohash_imm:$lane), IIC_VLD4,
265 !strconcat(OpcodeStr,
266 "\t\\{$dst1[$lane],$dst2[$lane],$dst3[$lane],$dst4[$lane]\\}, $addr"),
267 "$src1 = $dst1, $src2 = $dst2, $src3 = $dst3, $src4 = $dst4", []>;
269 def VLD4LNd8 : VLD4LND<"vld4.8">;
270 def VLD4LNd16 : VLD4LND<"vld4.16">;
271 def VLD4LNd32 : VLD4LND<"vld4.32">;
272 } // mayLoad = 1, hasExtraDefRegAllocReq = 1
274 // VST1 : Vector Store (multiple single elements)
275 class VST1D<string OpcodeStr, ValueType Ty, Intrinsic IntOp>
276 : NLdSt<(outs), (ins addrmode6:$addr, DPR:$src), IIC_VST,
277 !strconcat(OpcodeStr, "\t\\{$src\\}, $addr"), "",
278 [(IntOp addrmode6:$addr, (Ty DPR:$src))]>;
279 class VST1Q<string OpcodeStr, ValueType Ty, Intrinsic IntOp>
280 : NLdSt<(outs), (ins addrmode6:$addr, QPR:$src), IIC_VST,
281 !strconcat(OpcodeStr, "\t${src:dregpair}, $addr"), "",
282 [(IntOp addrmode6:$addr, (Ty QPR:$src))]>;
284 let hasExtraSrcRegAllocReq = 1 in {
285 def VST1d8 : VST1D<"vst1.8", v8i8, int_arm_neon_vst1>;
286 def VST1d16 : VST1D<"vst1.16", v4i16, int_arm_neon_vst1>;
287 def VST1d32 : VST1D<"vst1.32", v2i32, int_arm_neon_vst1>;
288 def VST1df : VST1D<"vst1.32", v2f32, int_arm_neon_vst1>;
289 def VST1d64 : VST1D<"vst1.64", v1i64, int_arm_neon_vst1>;
291 def VST1q8 : VST1Q<"vst1.8", v16i8, int_arm_neon_vst1>;
292 def VST1q16 : VST1Q<"vst1.16", v8i16, int_arm_neon_vst1>;
293 def VST1q32 : VST1Q<"vst1.32", v4i32, int_arm_neon_vst1>;
294 def VST1qf : VST1Q<"vst1.32", v4f32, int_arm_neon_vst1>;
295 def VST1q64 : VST1Q<"vst1.64", v2i64, int_arm_neon_vst1>;
296 } // hasExtraSrcRegAllocReq
298 let mayStore = 1, hasExtraSrcRegAllocReq = 1 in {
300 // VST2 : Vector Store (multiple 2-element structures)
301 class VST2D<string OpcodeStr>
302 : NLdSt<(outs), (ins addrmode6:$addr, DPR:$src1, DPR:$src2), IIC_VST,
303 !strconcat(OpcodeStr, "\t\\{$src1,$src2\\}, $addr"), "", []>;
305 def VST2d8 : VST2D<"vst2.8">;
306 def VST2d16 : VST2D<"vst2.16">;
307 def VST2d32 : VST2D<"vst2.32">;
309 // VST3 : Vector Store (multiple 3-element structures)
310 class VST3D<string OpcodeStr>
311 : NLdSt<(outs), (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3),
313 !strconcat(OpcodeStr, "\t\\{$src1,$src2,$src3\\}, $addr"), "", []>;
315 def VST3d8 : VST3D<"vst3.8">;
316 def VST3d16 : VST3D<"vst3.16">;
317 def VST3d32 : VST3D<"vst3.32">;
319 // VST4 : Vector Store (multiple 4-element structures)
320 class VST4D<string OpcodeStr>
321 : NLdSt<(outs), (ins addrmode6:$addr,
322 DPR:$src1, DPR:$src2, DPR:$src3, DPR:$src4), IIC_VST,
323 !strconcat(OpcodeStr, "\t\\{$src1,$src2,$src3,$src4\\}, $addr"),
326 def VST4d8 : VST4D<"vst4.8">;
327 def VST4d16 : VST4D<"vst4.16">;
328 def VST4d32 : VST4D<"vst4.32">;
330 // VST2LN : Vector Store (single 2-element structure from one lane)
331 class VST2LND<string OpcodeStr>
332 : NLdSt<(outs), (ins addrmode6:$addr, DPR:$src1, DPR:$src2, nohash_imm:$lane),
334 !strconcat(OpcodeStr, "\t\\{$src1[$lane],$src2[$lane]\\}, $addr"),
337 def VST2LNd8 : VST2LND<"vst2.8">;
338 def VST2LNd16 : VST2LND<"vst2.16">;
339 def VST2LNd32 : VST2LND<"vst2.32">;
341 // VST3LN : Vector Store (single 3-element structure from one lane)
342 class VST3LND<string OpcodeStr>
343 : NLdSt<(outs), (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3,
344 nohash_imm:$lane), IIC_VST,
345 !strconcat(OpcodeStr,
346 "\t\\{$src1[$lane],$src2[$lane],$src3[$lane]\\}, $addr"), "", []>;
348 def VST3LNd8 : VST3LND<"vst3.8">;
349 def VST3LNd16 : VST3LND<"vst3.16">;
350 def VST3LNd32 : VST3LND<"vst3.32">;
352 // VST4LN : Vector Store (single 4-element structure from one lane)
353 class VST4LND<string OpcodeStr>
354 : NLdSt<(outs), (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3,
355 DPR:$src4, nohash_imm:$lane), IIC_VST,
356 !strconcat(OpcodeStr,
357 "\t\\{$src1[$lane],$src2[$lane],$src3[$lane],$src4[$lane]\\}, $addr"),
360 def VST4LNd8 : VST4LND<"vst4.8">;
361 def VST4LNd16 : VST4LND<"vst4.16">;
362 def VST4LNd32 : VST4LND<"vst4.32">;
363 } // mayStore = 1, hasExtraSrcRegAllocReq = 1
366 //===----------------------------------------------------------------------===//
367 // NEON pattern fragments
368 //===----------------------------------------------------------------------===//
370 // Extract D sub-registers of Q registers.
371 // (arm_dsubreg_0 is 5; arm_dsubreg_1 is 6)
372 def DSubReg_i8_reg : SDNodeXForm<imm, [{
373 return CurDAG->getTargetConstant(5 + N->getZExtValue() / 8, MVT::i32);
375 def DSubReg_i16_reg : SDNodeXForm<imm, [{
376 return CurDAG->getTargetConstant(5 + N->getZExtValue() / 4, MVT::i32);
378 def DSubReg_i32_reg : SDNodeXForm<imm, [{
379 return CurDAG->getTargetConstant(5 + N->getZExtValue() / 2, MVT::i32);
381 def DSubReg_f64_reg : SDNodeXForm<imm, [{
382 return CurDAG->getTargetConstant(5 + N->getZExtValue(), MVT::i32);
384 def DSubReg_f64_other_reg : SDNodeXForm<imm, [{
385 return CurDAG->getTargetConstant(5 + (1 - N->getZExtValue()), MVT::i32);
388 // Extract S sub-registers of Q/D registers.
389 // (arm_ssubreg_0 is 1; arm_ssubreg_1 is 2; etc.)
390 def SSubReg_f32_reg : SDNodeXForm<imm, [{
391 return CurDAG->getTargetConstant(1 + N->getZExtValue(), MVT::i32);
394 // Translate lane numbers from Q registers to D subregs.
395 def SubReg_i8_lane : SDNodeXForm<imm, [{
396 return CurDAG->getTargetConstant(N->getZExtValue() & 7, MVT::i32);
398 def SubReg_i16_lane : SDNodeXForm<imm, [{
399 return CurDAG->getTargetConstant(N->getZExtValue() & 3, MVT::i32);
401 def SubReg_i32_lane : SDNodeXForm<imm, [{
402 return CurDAG->getTargetConstant(N->getZExtValue() & 1, MVT::i32);
405 //===----------------------------------------------------------------------===//
406 // Instruction Classes
407 //===----------------------------------------------------------------------===//
409 // Basic 2-register operations, both double- and quad-register.
410 class N2VD<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
411 bits<2> op17_16, bits<5> op11_7, bit op4, string OpcodeStr,
412 ValueType ResTy, ValueType OpTy, SDNode OpNode>
413 : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 0, op4, (outs DPR:$dst),
414 (ins DPR:$src), IIC_VUNAD, !strconcat(OpcodeStr, "\t$dst, $src"), "",
415 [(set DPR:$dst, (ResTy (OpNode (OpTy DPR:$src))))]>;
416 class N2VQ<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
417 bits<2> op17_16, bits<5> op11_7, bit op4, string OpcodeStr,
418 ValueType ResTy, ValueType OpTy, SDNode OpNode>
419 : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 1, op4, (outs QPR:$dst),
420 (ins QPR:$src), IIC_VUNAQ, !strconcat(OpcodeStr, "\t$dst, $src"), "",
421 [(set QPR:$dst, (ResTy (OpNode (OpTy QPR:$src))))]>;
423 // Basic 2-register operations, scalar single-precision.
424 class N2VDs<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
425 bits<2> op17_16, bits<5> op11_7, bit op4, string OpcodeStr,
426 ValueType ResTy, ValueType OpTy, SDNode OpNode>
427 : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 0, op4,
428 (outs DPR_VFP2:$dst), (ins DPR_VFP2:$src),
429 IIC_VUNAD, !strconcat(OpcodeStr, "\t$dst, $src"), "", []>;
431 class N2VDsPat<SDNode OpNode, ValueType ResTy, ValueType OpTy, NeonI Inst>
432 : NEONFPPat<(ResTy (OpNode SPR:$a)),
434 (Inst (INSERT_SUBREG (OpTy (IMPLICIT_DEF)), SPR:$a, arm_ssubreg_0)),
437 // Basic 2-register intrinsics, both double- and quad-register.
438 class N2VDInt<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
439 bits<2> op17_16, bits<5> op11_7, bit op4,
440 InstrItinClass itin, string OpcodeStr,
441 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
442 : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 0, op4, (outs DPR:$dst),
443 (ins DPR:$src), itin, !strconcat(OpcodeStr, "\t$dst, $src"), "",
444 [(set DPR:$dst, (ResTy (IntOp (OpTy DPR:$src))))]>;
445 class N2VQInt<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
446 bits<2> op17_16, bits<5> op11_7, bit op4,
447 InstrItinClass itin, string OpcodeStr,
448 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
449 : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 1, op4, (outs QPR:$dst),
450 (ins QPR:$src), itin, !strconcat(OpcodeStr, "\t$dst, $src"), "",
451 [(set QPR:$dst, (ResTy (IntOp (OpTy QPR:$src))))]>;
453 // Basic 2-register intrinsics, scalar single-precision
454 class N2VDInts<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
455 bits<2> op17_16, bits<5> op11_7, bit op4,
456 InstrItinClass itin, string OpcodeStr,
457 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
458 : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 0, op4,
459 (outs DPR_VFP2:$dst), (ins DPR_VFP2:$src), itin,
460 !strconcat(OpcodeStr, "\t$dst, $src"), "", []>;
462 class N2VDIntsPat<SDNode OpNode, NeonI Inst>
463 : NEONFPPat<(f32 (OpNode SPR:$a)),
465 (Inst (INSERT_SUBREG (v2f32 (IMPLICIT_DEF)), SPR:$a, arm_ssubreg_0)),
468 // Narrow 2-register intrinsics.
469 class N2VNInt<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
470 bits<2> op17_16, bits<5> op11_7, bit op6, bit op4,
471 InstrItinClass itin, string OpcodeStr,
472 ValueType TyD, ValueType TyQ, Intrinsic IntOp>
473 : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, op6, op4, (outs DPR:$dst),
474 (ins QPR:$src), itin, !strconcat(OpcodeStr, "\t$dst, $src"), "",
475 [(set DPR:$dst, (TyD (IntOp (TyQ QPR:$src))))]>;
477 // Long 2-register intrinsics. (This is currently only used for VMOVL and is
478 // derived from N2VImm instead of N2V because of the way the size is encoded.)
479 class N2VLInt<bit op24, bit op23, bits<6> op21_16, bits<4> op11_8, bit op7,
480 bit op6, bit op4, InstrItinClass itin, string OpcodeStr,
481 ValueType TyQ, ValueType TyD, Intrinsic IntOp>
482 : N2VImm<op24, op23, op21_16, op11_8, op7, op6, op4, (outs QPR:$dst),
483 (ins DPR:$src), itin, !strconcat(OpcodeStr, "\t$dst, $src"), "",
484 [(set QPR:$dst, (TyQ (IntOp (TyD DPR:$src))))]>;
486 // 2-register shuffles (VTRN/VZIP/VUZP), both double- and quad-register.
487 class N2VDShuffle<bits<2> op19_18, bits<5> op11_7, string OpcodeStr>
488 : N2V<0b11, 0b11, op19_18, 0b10, op11_7, 0, 0, (outs DPR:$dst1, DPR:$dst2),
489 (ins DPR:$src1, DPR:$src2), IIC_VPERMD,
490 !strconcat(OpcodeStr, "\t$dst1, $dst2"),
491 "$src1 = $dst1, $src2 = $dst2", []>;
492 class N2VQShuffle<bits<2> op19_18, bits<5> op11_7,
493 InstrItinClass itin, string OpcodeStr>
494 : N2V<0b11, 0b11, op19_18, 0b10, op11_7, 1, 0, (outs QPR:$dst1, QPR:$dst2),
495 (ins QPR:$src1, QPR:$src2), itin,
496 !strconcat(OpcodeStr, "\t$dst1, $dst2"),
497 "$src1 = $dst1, $src2 = $dst2", []>;
499 // Basic 3-register operations, both double- and quad-register.
500 class N3VD<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
501 InstrItinClass itin, string OpcodeStr, ValueType ResTy, ValueType OpTy,
502 SDNode OpNode, bit Commutable>
503 : N3V<op24, op23, op21_20, op11_8, 0, op4,
504 (outs DPR:$dst), (ins DPR:$src1, DPR:$src2), itin,
505 !strconcat(OpcodeStr, "\t$dst, $src1, $src2"), "",
506 [(set DPR:$dst, (ResTy (OpNode (OpTy DPR:$src1), (OpTy DPR:$src2))))]> {
507 let isCommutable = Commutable;
509 class N3VDSL<bits<2> op21_20, bits<4> op11_8,
510 InstrItinClass itin, string OpcodeStr, ValueType Ty, SDNode ShOp>
511 : N3V<0, 1, op21_20, op11_8, 1, 0,
512 (outs DPR:$dst), (ins DPR:$src1, DPR_VFP2:$src2, nohash_imm:$lane),
513 itin, !strconcat(OpcodeStr, "\t$dst, $src1, $src2[$lane]"), "",
515 (Ty (ShOp (Ty DPR:$src1),
516 (Ty (NEONvduplane (Ty DPR_VFP2:$src2),
518 let isCommutable = 0;
520 class N3VDSL16<bits<2> op21_20, bits<4> op11_8,
521 string OpcodeStr, ValueType Ty, SDNode ShOp>
522 : N3V<0, 1, op21_20, op11_8, 1, 0,
523 (outs DPR:$dst), (ins DPR:$src1, DPR_8:$src2, nohash_imm:$lane),
525 !strconcat(OpcodeStr, "\t$dst, $src1, $src2[$lane]"), "",
527 (Ty (ShOp (Ty DPR:$src1),
528 (Ty (NEONvduplane (Ty DPR_8:$src2),
530 let isCommutable = 0;
533 class N3VQ<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
534 InstrItinClass itin, string OpcodeStr, ValueType ResTy, ValueType OpTy,
535 SDNode OpNode, bit Commutable>
536 : N3V<op24, op23, op21_20, op11_8, 1, op4,
537 (outs QPR:$dst), (ins QPR:$src1, QPR:$src2), itin,
538 !strconcat(OpcodeStr, "\t$dst, $src1, $src2"), "",
539 [(set QPR:$dst, (ResTy (OpNode (OpTy QPR:$src1), (OpTy QPR:$src2))))]> {
540 let isCommutable = Commutable;
542 class N3VQSL<bits<2> op21_20, bits<4> op11_8,
543 InstrItinClass itin, string OpcodeStr,
544 ValueType ResTy, ValueType OpTy, SDNode ShOp>
545 : N3V<1, 1, op21_20, op11_8, 1, 0,
546 (outs QPR:$dst), (ins QPR:$src1, DPR_VFP2:$src2, nohash_imm:$lane),
547 itin, !strconcat(OpcodeStr, "\t$dst, $src1, $src2[$lane]"), "",
548 [(set (ResTy QPR:$dst),
549 (ResTy (ShOp (ResTy QPR:$src1),
550 (ResTy (NEONvduplane (OpTy DPR_VFP2:$src2),
552 let isCommutable = 0;
554 class N3VQSL16<bits<2> op21_20, bits<4> op11_8,
555 string OpcodeStr, ValueType ResTy, ValueType OpTy, SDNode ShOp>
556 : N3V<1, 1, op21_20, op11_8, 1, 0,
557 (outs QPR:$dst), (ins QPR:$src1, DPR_8:$src2, nohash_imm:$lane),
559 !strconcat(OpcodeStr, "\t$dst, $src1, $src2[$lane]"), "",
560 [(set (ResTy QPR:$dst),
561 (ResTy (ShOp (ResTy QPR:$src1),
562 (ResTy (NEONvduplane (OpTy DPR_8:$src2),
564 let isCommutable = 0;
567 // Basic 3-register operations, scalar single-precision
568 class N3VDs<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
569 string OpcodeStr, ValueType ResTy, ValueType OpTy,
570 SDNode OpNode, bit Commutable>
571 : N3V<op24, op23, op21_20, op11_8, 0, op4,
572 (outs DPR_VFP2:$dst), (ins DPR_VFP2:$src1, DPR_VFP2:$src2), IIC_VBIND,
573 !strconcat(OpcodeStr, "\t$dst, $src1, $src2"), "", []> {
574 let isCommutable = Commutable;
576 class N3VDsPat<SDNode OpNode, NeonI Inst>
577 : NEONFPPat<(f32 (OpNode SPR:$a, SPR:$b)),
579 (Inst (INSERT_SUBREG (v2f32 (IMPLICIT_DEF)), SPR:$a, arm_ssubreg_0),
580 (INSERT_SUBREG (v2f32 (IMPLICIT_DEF)), SPR:$b, arm_ssubreg_0)),
583 // Basic 3-register intrinsics, both double- and quad-register.
584 class N3VDInt<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
585 InstrItinClass itin, string OpcodeStr, ValueType ResTy, ValueType OpTy,
586 Intrinsic IntOp, bit Commutable>
587 : N3V<op24, op23, op21_20, op11_8, 0, op4,
588 (outs DPR:$dst), (ins DPR:$src1, DPR:$src2), itin,
589 !strconcat(OpcodeStr, "\t$dst, $src1, $src2"), "",
590 [(set DPR:$dst, (ResTy (IntOp (OpTy DPR:$src1), (OpTy DPR:$src2))))]> {
591 let isCommutable = Commutable;
593 class N3VDIntSL<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
594 string OpcodeStr, ValueType Ty, Intrinsic IntOp>
595 : N3V<0, 1, op21_20, op11_8, 1, 0,
596 (outs DPR:$dst), (ins DPR:$src1, DPR_VFP2:$src2, nohash_imm:$lane),
597 itin, !strconcat(OpcodeStr, "\t$dst, $src1, $src2[$lane]"), "",
599 (Ty (IntOp (Ty DPR:$src1),
600 (Ty (NEONvduplane (Ty DPR_VFP2:$src2),
602 let isCommutable = 0;
604 class N3VDIntSL16<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
605 string OpcodeStr, ValueType Ty, Intrinsic IntOp>
606 : N3V<0, 1, op21_20, op11_8, 1, 0,
607 (outs DPR:$dst), (ins DPR:$src1, DPR_8:$src2, nohash_imm:$lane),
608 itin, !strconcat(OpcodeStr, "\t$dst, $src1, $src2[$lane]"), "",
610 (Ty (IntOp (Ty DPR:$src1),
611 (Ty (NEONvduplane (Ty DPR_8:$src2),
613 let isCommutable = 0;
616 class N3VQInt<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
617 InstrItinClass itin, string OpcodeStr, ValueType ResTy, ValueType OpTy,
618 Intrinsic IntOp, bit Commutable>
619 : N3V<op24, op23, op21_20, op11_8, 1, op4,
620 (outs QPR:$dst), (ins QPR:$src1, QPR:$src2), itin,
621 !strconcat(OpcodeStr, "\t$dst, $src1, $src2"), "",
622 [(set QPR:$dst, (ResTy (IntOp (OpTy QPR:$src1), (OpTy QPR:$src2))))]> {
623 let isCommutable = Commutable;
625 class N3VQIntSL<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
626 string OpcodeStr, ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
627 : N3V<1, 1, op21_20, op11_8, 1, 0,
628 (outs QPR:$dst), (ins QPR:$src1, DPR_VFP2:$src2, nohash_imm:$lane),
629 itin, !strconcat(OpcodeStr, "\t$dst, $src1, $src2[$lane]"), "",
630 [(set (ResTy QPR:$dst),
631 (ResTy (IntOp (ResTy QPR:$src1),
632 (ResTy (NEONvduplane (OpTy DPR_VFP2:$src2),
634 let isCommutable = 0;
636 class N3VQIntSL16<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
637 string OpcodeStr, ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
638 : N3V<1, 1, op21_20, op11_8, 1, 0,
639 (outs QPR:$dst), (ins QPR:$src1, DPR_8:$src2, nohash_imm:$lane),
640 itin, !strconcat(OpcodeStr, "\t$dst, $src1, $src2[$lane]"), "",
641 [(set (ResTy QPR:$dst),
642 (ResTy (IntOp (ResTy QPR:$src1),
643 (ResTy (NEONvduplane (OpTy DPR_8:$src2),
645 let isCommutable = 0;
648 // Multiply-Add/Sub operations, both double- and quad-register.
649 class N3VDMulOp<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
650 InstrItinClass itin, string OpcodeStr,
651 ValueType Ty, SDNode MulOp, SDNode OpNode>
652 : N3V<op24, op23, op21_20, op11_8, 0, op4,
653 (outs DPR:$dst), (ins DPR:$src1, DPR:$src2, DPR:$src3), itin,
654 !strconcat(OpcodeStr, "\t$dst, $src2, $src3"), "$src1 = $dst",
655 [(set DPR:$dst, (Ty (OpNode DPR:$src1,
656 (Ty (MulOp DPR:$src2, DPR:$src3)))))]>;
657 class N3VDMulOpSL<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
658 string OpcodeStr, ValueType Ty, SDNode MulOp, SDNode ShOp>
659 : N3V<0, 1, op21_20, op11_8, 1, 0,
661 (ins DPR:$src1, DPR:$src2, DPR_VFP2:$src3, nohash_imm:$lane), itin,
662 !strconcat(OpcodeStr, "\t$dst, $src2, $src3[$lane]"), "$src1 = $dst",
664 (Ty (ShOp (Ty DPR:$src1),
665 (Ty (MulOp DPR:$src2,
666 (Ty (NEONvduplane (Ty DPR_VFP2:$src3),
668 class N3VDMulOpSL16<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
669 string OpcodeStr, ValueType Ty, SDNode MulOp, SDNode ShOp>
670 : N3V<0, 1, op21_20, op11_8, 1, 0,
672 (ins DPR:$src1, DPR:$src2, DPR_8:$src3, nohash_imm:$lane), itin,
673 !strconcat(OpcodeStr, "\t$dst, $src2, $src3[$lane]"), "$src1 = $dst",
675 (Ty (ShOp (Ty DPR:$src1),
676 (Ty (MulOp DPR:$src2,
677 (Ty (NEONvduplane (Ty DPR_8:$src3),
680 class N3VQMulOp<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
681 InstrItinClass itin, string OpcodeStr, ValueType Ty,
682 SDNode MulOp, SDNode OpNode>
683 : N3V<op24, op23, op21_20, op11_8, 1, op4,
684 (outs QPR:$dst), (ins QPR:$src1, QPR:$src2, QPR:$src3), itin,
685 !strconcat(OpcodeStr, "\t$dst, $src2, $src3"), "$src1 = $dst",
686 [(set QPR:$dst, (Ty (OpNode QPR:$src1,
687 (Ty (MulOp QPR:$src2, QPR:$src3)))))]>;
688 class N3VQMulOpSL<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
689 string OpcodeStr, ValueType ResTy, ValueType OpTy,
690 SDNode MulOp, SDNode ShOp>
691 : N3V<1, 1, op21_20, op11_8, 1, 0,
693 (ins QPR:$src1, QPR:$src2, DPR_VFP2:$src3, nohash_imm:$lane), itin,
694 !strconcat(OpcodeStr, "\t$dst, $src2, $src3[$lane]"), "$src1 = $dst",
695 [(set (ResTy QPR:$dst),
696 (ResTy (ShOp (ResTy QPR:$src1),
697 (ResTy (MulOp QPR:$src2,
698 (ResTy (NEONvduplane (OpTy DPR_VFP2:$src3),
700 class N3VQMulOpSL16<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
701 string OpcodeStr, ValueType ResTy, ValueType OpTy,
702 SDNode MulOp, SDNode ShOp>
703 : N3V<1, 1, op21_20, op11_8, 1, 0,
705 (ins QPR:$src1, QPR:$src2, DPR_8:$src3, nohash_imm:$lane), itin,
706 !strconcat(OpcodeStr, "\t$dst, $src2, $src3[$lane]"), "$src1 = $dst",
707 [(set (ResTy QPR:$dst),
708 (ResTy (ShOp (ResTy QPR:$src1),
709 (ResTy (MulOp QPR:$src2,
710 (ResTy (NEONvduplane (OpTy DPR_8:$src3),
713 // Multiply-Add/Sub operations, scalar single-precision
714 class N3VDMulOps<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
715 InstrItinClass itin, string OpcodeStr,
716 ValueType Ty, SDNode MulOp, SDNode OpNode>
717 : N3V<op24, op23, op21_20, op11_8, 0, op4,
718 (outs DPR_VFP2:$dst),
719 (ins DPR_VFP2:$src1, DPR_VFP2:$src2, DPR_VFP2:$src3), itin,
720 !strconcat(OpcodeStr, "\t$dst, $src2, $src3"), "$src1 = $dst", []>;
722 class N3VDMulOpsPat<SDNode MulNode, SDNode OpNode, NeonI Inst>
723 : NEONFPPat<(f32 (OpNode SPR:$acc, (f32 (MulNode SPR:$a, SPR:$b)))),
725 (Inst (INSERT_SUBREG (v2f32 (IMPLICIT_DEF)), SPR:$acc, arm_ssubreg_0),
726 (INSERT_SUBREG (v2f32 (IMPLICIT_DEF)), SPR:$a, arm_ssubreg_0),
727 (INSERT_SUBREG (v2f32 (IMPLICIT_DEF)), SPR:$b, arm_ssubreg_0)),
730 // Neon 3-argument intrinsics, both double- and quad-register.
731 // The destination register is also used as the first source operand register.
732 class N3VDInt3<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
733 InstrItinClass itin, string OpcodeStr,
734 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
735 : N3V<op24, op23, op21_20, op11_8, 0, op4,
736 (outs DPR:$dst), (ins DPR:$src1, DPR:$src2, DPR:$src3), itin,
737 !strconcat(OpcodeStr, "\t$dst, $src2, $src3"), "$src1 = $dst",
738 [(set DPR:$dst, (ResTy (IntOp (OpTy DPR:$src1),
739 (OpTy DPR:$src2), (OpTy DPR:$src3))))]>;
740 class N3VQInt3<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
741 InstrItinClass itin, string OpcodeStr,
742 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
743 : N3V<op24, op23, op21_20, op11_8, 1, op4,
744 (outs QPR:$dst), (ins QPR:$src1, QPR:$src2, QPR:$src3), itin,
745 !strconcat(OpcodeStr, "\t$dst, $src2, $src3"), "$src1 = $dst",
746 [(set QPR:$dst, (ResTy (IntOp (OpTy QPR:$src1),
747 (OpTy QPR:$src2), (OpTy QPR:$src3))))]>;
749 // Neon Long 3-argument intrinsic. The destination register is
750 // a quad-register and is also used as the first source operand register.
751 class N3VLInt3<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
752 InstrItinClass itin, string OpcodeStr,
753 ValueType TyQ, ValueType TyD, Intrinsic IntOp>
754 : N3V<op24, op23, op21_20, op11_8, 0, op4,
755 (outs QPR:$dst), (ins QPR:$src1, DPR:$src2, DPR:$src3), itin,
756 !strconcat(OpcodeStr, "\t$dst, $src2, $src3"), "$src1 = $dst",
758 (TyQ (IntOp (TyQ QPR:$src1), (TyD DPR:$src2), (TyD DPR:$src3))))]>;
759 class N3VLInt3SL<bit op24, bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
760 string OpcodeStr, ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
761 : N3V<op24, 1, op21_20, op11_8, 1, 0,
763 (ins QPR:$src1, DPR:$src2, DPR_VFP2:$src3, nohash_imm:$lane), itin,
764 !strconcat(OpcodeStr, "\t$dst, $src2, $src3[$lane]"), "$src1 = $dst",
765 [(set (ResTy QPR:$dst),
766 (ResTy (IntOp (ResTy QPR:$src1),
768 (OpTy (NEONvduplane (OpTy DPR_VFP2:$src3),
770 class N3VLInt3SL16<bit op24, bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
771 string OpcodeStr, ValueType ResTy, ValueType OpTy,
773 : N3V<op24, 1, op21_20, op11_8, 1, 0,
775 (ins QPR:$src1, DPR:$src2, DPR_8:$src3, nohash_imm:$lane), itin,
776 !strconcat(OpcodeStr, "\t$dst, $src2, $src3[$lane]"), "$src1 = $dst",
777 [(set (ResTy QPR:$dst),
778 (ResTy (IntOp (ResTy QPR:$src1),
780 (OpTy (NEONvduplane (OpTy DPR_8:$src3),
784 // Narrowing 3-register intrinsics.
785 class N3VNInt<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
786 string OpcodeStr, ValueType TyD, ValueType TyQ,
787 Intrinsic IntOp, bit Commutable>
788 : N3V<op24, op23, op21_20, op11_8, 0, op4,
789 (outs DPR:$dst), (ins QPR:$src1, QPR:$src2), IIC_VBINi4D,
790 !strconcat(OpcodeStr, "\t$dst, $src1, $src2"), "",
791 [(set DPR:$dst, (TyD (IntOp (TyQ QPR:$src1), (TyQ QPR:$src2))))]> {
792 let isCommutable = Commutable;
795 // Long 3-register intrinsics.
796 class N3VLInt<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
797 InstrItinClass itin, string OpcodeStr, ValueType TyQ, ValueType TyD,
798 Intrinsic IntOp, bit Commutable>
799 : N3V<op24, op23, op21_20, op11_8, 0, op4,
800 (outs QPR:$dst), (ins DPR:$src1, DPR:$src2), itin,
801 !strconcat(OpcodeStr, "\t$dst, $src1, $src2"), "",
802 [(set QPR:$dst, (TyQ (IntOp (TyD DPR:$src1), (TyD DPR:$src2))))]> {
803 let isCommutable = Commutable;
805 class N3VLIntSL<bit op24, bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
806 string OpcodeStr, ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
807 : N3V<op24, 1, op21_20, op11_8, 1, 0,
808 (outs QPR:$dst), (ins DPR:$src1, DPR_VFP2:$src2, nohash_imm:$lane),
809 itin, !strconcat(OpcodeStr, "\t$dst, $src1, $src2[$lane]"), "",
810 [(set (ResTy QPR:$dst),
811 (ResTy (IntOp (OpTy DPR:$src1),
812 (OpTy (NEONvduplane (OpTy DPR_VFP2:$src2),
814 class N3VLIntSL16<bit op24, bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
815 string OpcodeStr, ValueType ResTy, ValueType OpTy,
817 : N3V<op24, 1, op21_20, op11_8, 1, 0,
818 (outs QPR:$dst), (ins DPR:$src1, DPR_8:$src2, nohash_imm:$lane),
819 itin, !strconcat(OpcodeStr, "\t$dst, $src1, $src2[$lane]"), "",
820 [(set (ResTy QPR:$dst),
821 (ResTy (IntOp (OpTy DPR:$src1),
822 (OpTy (NEONvduplane (OpTy DPR_8:$src2),
825 // Wide 3-register intrinsics.
826 class N3VWInt<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
827 string OpcodeStr, ValueType TyQ, ValueType TyD,
828 Intrinsic IntOp, bit Commutable>
829 : N3V<op24, op23, op21_20, op11_8, 0, op4,
830 (outs QPR:$dst), (ins QPR:$src1, DPR:$src2), IIC_VSUBiD,
831 !strconcat(OpcodeStr, "\t$dst, $src1, $src2"), "",
832 [(set QPR:$dst, (TyQ (IntOp (TyQ QPR:$src1), (TyD DPR:$src2))))]> {
833 let isCommutable = Commutable;
836 // Pairwise long 2-register intrinsics, both double- and quad-register.
837 class N2VDPLInt<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
838 bits<2> op17_16, bits<5> op11_7, bit op4, string OpcodeStr,
839 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
840 : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 0, op4, (outs DPR:$dst),
841 (ins DPR:$src), IIC_VSHLiD, !strconcat(OpcodeStr, "\t$dst, $src"), "",
842 [(set DPR:$dst, (ResTy (IntOp (OpTy DPR:$src))))]>;
843 class N2VQPLInt<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
844 bits<2> op17_16, bits<5> op11_7, bit op4, string OpcodeStr,
845 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
846 : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 1, op4, (outs QPR:$dst),
847 (ins QPR:$src), IIC_VSHLiD, !strconcat(OpcodeStr, "\t$dst, $src"), "",
848 [(set QPR:$dst, (ResTy (IntOp (OpTy QPR:$src))))]>;
850 // Pairwise long 2-register accumulate intrinsics,
851 // both double- and quad-register.
852 // The destination register is also used as the first source operand register.
853 class N2VDPLInt2<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
854 bits<2> op17_16, bits<5> op11_7, bit op4, string OpcodeStr,
855 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
856 : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 0, op4,
857 (outs DPR:$dst), (ins DPR:$src1, DPR:$src2), IIC_VPALiD,
858 !strconcat(OpcodeStr, "\t$dst, $src2"), "$src1 = $dst",
859 [(set DPR:$dst, (ResTy (IntOp (ResTy DPR:$src1), (OpTy DPR:$src2))))]>;
860 class N2VQPLInt2<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
861 bits<2> op17_16, bits<5> op11_7, bit op4, string OpcodeStr,
862 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
863 : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 1, op4,
864 (outs QPR:$dst), (ins QPR:$src1, QPR:$src2), IIC_VPALiQ,
865 !strconcat(OpcodeStr, "\t$dst, $src2"), "$src1 = $dst",
866 [(set QPR:$dst, (ResTy (IntOp (ResTy QPR:$src1), (OpTy QPR:$src2))))]>;
868 // Shift by immediate,
869 // both double- and quad-register.
870 class N2VDSh<bit op24, bit op23, bits<6> op21_16, bits<4> op11_8, bit op7,
871 bit op4, InstrItinClass itin, string OpcodeStr,
872 ValueType Ty, SDNode OpNode>
873 : N2VImm<op24, op23, op21_16, op11_8, op7, 0, op4,
874 (outs DPR:$dst), (ins DPR:$src, i32imm:$SIMM), itin,
875 !strconcat(OpcodeStr, "\t$dst, $src, $SIMM"), "",
876 [(set DPR:$dst, (Ty (OpNode (Ty DPR:$src), (i32 imm:$SIMM))))]>;
877 class N2VQSh<bit op24, bit op23, bits<6> op21_16, bits<4> op11_8, bit op7,
878 bit op4, InstrItinClass itin, string OpcodeStr,
879 ValueType Ty, SDNode OpNode>
880 : N2VImm<op24, op23, op21_16, op11_8, op7, 1, op4,
881 (outs QPR:$dst), (ins QPR:$src, i32imm:$SIMM), itin,
882 !strconcat(OpcodeStr, "\t$dst, $src, $SIMM"), "",
883 [(set QPR:$dst, (Ty (OpNode (Ty QPR:$src), (i32 imm:$SIMM))))]>;
885 // Long shift by immediate.
886 class N2VLSh<bit op24, bit op23, bits<6> op21_16, bits<4> op11_8, bit op7,
887 bit op6, bit op4, string OpcodeStr, ValueType ResTy,
888 ValueType OpTy, SDNode OpNode>
889 : N2VImm<op24, op23, op21_16, op11_8, op7, op6, op4,
890 (outs QPR:$dst), (ins DPR:$src, i32imm:$SIMM), IIC_VSHLiD,
891 !strconcat(OpcodeStr, "\t$dst, $src, $SIMM"), "",
892 [(set QPR:$dst, (ResTy (OpNode (OpTy DPR:$src),
893 (i32 imm:$SIMM))))]>;
895 // Narrow shift by immediate.
896 class N2VNSh<bit op24, bit op23, bits<6> op21_16, bits<4> op11_8, bit op7,
897 bit op6, bit op4, InstrItinClass itin, string OpcodeStr,
898 ValueType ResTy, ValueType OpTy, SDNode OpNode>
899 : N2VImm<op24, op23, op21_16, op11_8, op7, op6, op4,
900 (outs DPR:$dst), (ins QPR:$src, i32imm:$SIMM), itin,
901 !strconcat(OpcodeStr, "\t$dst, $src, $SIMM"), "",
902 [(set DPR:$dst, (ResTy (OpNode (OpTy QPR:$src),
903 (i32 imm:$SIMM))))]>;
905 // Shift right by immediate and accumulate,
906 // both double- and quad-register.
907 class N2VDShAdd<bit op24, bit op23, bits<6> op21_16, bits<4> op11_8, bit op7,
908 bit op4, string OpcodeStr, ValueType Ty, SDNode ShOp>
909 : N2VImm<op24, op23, op21_16, op11_8, op7, 0, op4,
910 (outs DPR:$dst), (ins DPR:$src1, DPR:$src2, i32imm:$SIMM),
912 !strconcat(OpcodeStr, "\t$dst, $src2, $SIMM"), "$src1 = $dst",
913 [(set DPR:$dst, (Ty (add DPR:$src1,
914 (Ty (ShOp DPR:$src2, (i32 imm:$SIMM))))))]>;
915 class N2VQShAdd<bit op24, bit op23, bits<6> op21_16, bits<4> op11_8, bit op7,
916 bit op4, string OpcodeStr, ValueType Ty, SDNode ShOp>
917 : N2VImm<op24, op23, op21_16, op11_8, op7, 1, op4,
918 (outs QPR:$dst), (ins QPR:$src1, QPR:$src2, i32imm:$SIMM),
920 !strconcat(OpcodeStr, "\t$dst, $src2, $SIMM"), "$src1 = $dst",
921 [(set QPR:$dst, (Ty (add QPR:$src1,
922 (Ty (ShOp QPR:$src2, (i32 imm:$SIMM))))))]>;
924 // Shift by immediate and insert,
925 // both double- and quad-register.
926 class N2VDShIns<bit op24, bit op23, bits<6> op21_16, bits<4> op11_8, bit op7,
927 bit op4, string OpcodeStr, ValueType Ty, SDNode ShOp>
928 : N2VImm<op24, op23, op21_16, op11_8, op7, 0, op4,
929 (outs DPR:$dst), (ins DPR:$src1, DPR:$src2, i32imm:$SIMM),
931 !strconcat(OpcodeStr, "\t$dst, $src2, $SIMM"), "$src1 = $dst",
932 [(set DPR:$dst, (Ty (ShOp DPR:$src1, DPR:$src2, (i32 imm:$SIMM))))]>;
933 class N2VQShIns<bit op24, bit op23, bits<6> op21_16, bits<4> op11_8, bit op7,
934 bit op4, string OpcodeStr, ValueType Ty, SDNode ShOp>
935 : N2VImm<op24, op23, op21_16, op11_8, op7, 1, op4,
936 (outs QPR:$dst), (ins QPR:$src1, QPR:$src2, i32imm:$SIMM),
938 !strconcat(OpcodeStr, "\t$dst, $src2, $SIMM"), "$src1 = $dst",
939 [(set QPR:$dst, (Ty (ShOp QPR:$src1, QPR:$src2, (i32 imm:$SIMM))))]>;
941 // Convert, with fractional bits immediate,
942 // both double- and quad-register.
943 class N2VCvtD<bit op24, bit op23, bits<6> op21_16, bits<4> op11_8, bit op7,
944 bit op4, string OpcodeStr, ValueType ResTy, ValueType OpTy,
946 : N2VImm<op24, op23, op21_16, op11_8, op7, 0, op4,
947 (outs DPR:$dst), (ins DPR:$src, i32imm:$SIMM), IIC_VUNAD,
948 !strconcat(OpcodeStr, "\t$dst, $src, $SIMM"), "",
949 [(set DPR:$dst, (ResTy (IntOp (OpTy DPR:$src), (i32 imm:$SIMM))))]>;
950 class N2VCvtQ<bit op24, bit op23, bits<6> op21_16, bits<4> op11_8, bit op7,
951 bit op4, string OpcodeStr, ValueType ResTy, ValueType OpTy,
953 : N2VImm<op24, op23, op21_16, op11_8, op7, 1, op4,
954 (outs QPR:$dst), (ins QPR:$src, i32imm:$SIMM), IIC_VUNAQ,
955 !strconcat(OpcodeStr, "\t$dst, $src, $SIMM"), "",
956 [(set QPR:$dst, (ResTy (IntOp (OpTy QPR:$src), (i32 imm:$SIMM))))]>;
958 //===----------------------------------------------------------------------===//
960 //===----------------------------------------------------------------------===//
962 // Abbreviations used in multiclass suffixes:
963 // Q = quarter int (8 bit) elements
964 // H = half int (16 bit) elements
965 // S = single int (32 bit) elements
966 // D = double int (64 bit) elements
968 // Neon 3-register vector operations.
970 // First with only element sizes of 8, 16 and 32 bits:
971 multiclass N3V_QHS<bit op24, bit op23, bits<4> op11_8, bit op4,
972 InstrItinClass itinD16, InstrItinClass itinD32,
973 InstrItinClass itinQ16, InstrItinClass itinQ32,
974 string OpcodeStr, SDNode OpNode, bit Commutable = 0> {
975 // 64-bit vector types.
976 def v8i8 : N3VD<op24, op23, 0b00, op11_8, op4, itinD16,
977 !strconcat(OpcodeStr, "8"), v8i8, v8i8, OpNode, Commutable>;
978 def v4i16 : N3VD<op24, op23, 0b01, op11_8, op4, itinD16,
979 !strconcat(OpcodeStr, "16"), v4i16, v4i16, OpNode, Commutable>;
980 def v2i32 : N3VD<op24, op23, 0b10, op11_8, op4, itinD32,
981 !strconcat(OpcodeStr, "32"), v2i32, v2i32, OpNode, Commutable>;
983 // 128-bit vector types.
984 def v16i8 : N3VQ<op24, op23, 0b00, op11_8, op4, itinQ16,
985 !strconcat(OpcodeStr, "8"), v16i8, v16i8, OpNode, Commutable>;
986 def v8i16 : N3VQ<op24, op23, 0b01, op11_8, op4, itinQ16,
987 !strconcat(OpcodeStr, "16"), v8i16, v8i16, OpNode, Commutable>;
988 def v4i32 : N3VQ<op24, op23, 0b10, op11_8, op4, itinQ32,
989 !strconcat(OpcodeStr, "32"), v4i32, v4i32, OpNode, Commutable>;
992 multiclass N3VSL_HS<bits<4> op11_8, string OpcodeStr, SDNode ShOp> {
993 def v4i16 : N3VDSL16<0b01, op11_8, !strconcat(OpcodeStr, "16"), v4i16, ShOp>;
994 def v2i32 : N3VDSL<0b10, op11_8, IIC_VMULi32D, !strconcat(OpcodeStr, "32"), v2i32, ShOp>;
995 def v8i16 : N3VQSL16<0b01, op11_8, !strconcat(OpcodeStr, "16"), v8i16, v4i16, ShOp>;
996 def v4i32 : N3VQSL<0b10, op11_8, IIC_VMULi32Q, !strconcat(OpcodeStr, "32"), v4i32, v2i32, ShOp>;
999 // ....then also with element size 64 bits:
1000 multiclass N3V_QHSD<bit op24, bit op23, bits<4> op11_8, bit op4,
1001 InstrItinClass itinD, InstrItinClass itinQ,
1002 string OpcodeStr, SDNode OpNode, bit Commutable = 0>
1003 : N3V_QHS<op24, op23, op11_8, op4, itinD, itinD, itinQ, itinQ,
1004 OpcodeStr, OpNode, Commutable> {
1005 def v1i64 : N3VD<op24, op23, 0b11, op11_8, op4, itinD,
1006 !strconcat(OpcodeStr, "64"), v1i64, v1i64, OpNode, Commutable>;
1007 def v2i64 : N3VQ<op24, op23, 0b11, op11_8, op4, itinQ,
1008 !strconcat(OpcodeStr, "64"), v2i64, v2i64, OpNode, Commutable>;
1012 // Neon Narrowing 2-register vector intrinsics,
1013 // source operand element sizes of 16, 32 and 64 bits:
1014 multiclass N2VNInt_HSD<bits<2> op24_23, bits<2> op21_20, bits<2> op17_16,
1015 bits<5> op11_7, bit op6, bit op4,
1016 InstrItinClass itin, string OpcodeStr,
1018 def v8i8 : N2VNInt<op24_23, op21_20, 0b00, op17_16, op11_7, op6, op4,
1019 itin, !strconcat(OpcodeStr, "16"), v8i8, v8i16, IntOp>;
1020 def v4i16 : N2VNInt<op24_23, op21_20, 0b01, op17_16, op11_7, op6, op4,
1021 itin, !strconcat(OpcodeStr, "32"), v4i16, v4i32, IntOp>;
1022 def v2i32 : N2VNInt<op24_23, op21_20, 0b10, op17_16, op11_7, op6, op4,
1023 itin, !strconcat(OpcodeStr, "64"), v2i32, v2i64, IntOp>;
1027 // Neon Lengthening 2-register vector intrinsic (currently specific to VMOVL).
1028 // source operand element sizes of 16, 32 and 64 bits:
1029 multiclass N2VLInt_QHS<bit op24, bit op23, bits<4> op11_8, bit op7, bit op6,
1030 bit op4, string OpcodeStr, Intrinsic IntOp> {
1031 def v8i16 : N2VLInt<op24, op23, 0b001000, op11_8, op7, op6, op4,
1032 IIC_VQUNAiD, !strconcat(OpcodeStr, "8"), v8i16, v8i8, IntOp>;
1033 def v4i32 : N2VLInt<op24, op23, 0b010000, op11_8, op7, op6, op4,
1034 IIC_VQUNAiD, !strconcat(OpcodeStr, "16"), v4i32, v4i16, IntOp>;
1035 def v2i64 : N2VLInt<op24, op23, 0b100000, op11_8, op7, op6, op4,
1036 IIC_VQUNAiD, !strconcat(OpcodeStr, "32"), v2i64, v2i32, IntOp>;
1040 // Neon 3-register vector intrinsics.
1042 // First with only element sizes of 16 and 32 bits:
1043 multiclass N3VInt_HS<bit op24, bit op23, bits<4> op11_8, bit op4,
1044 InstrItinClass itinD16, InstrItinClass itinD32,
1045 InstrItinClass itinQ16, InstrItinClass itinQ32,
1046 string OpcodeStr, Intrinsic IntOp, bit Commutable = 0> {
1047 // 64-bit vector types.
1048 def v4i16 : N3VDInt<op24, op23, 0b01, op11_8, op4, itinD16, !strconcat(OpcodeStr,"16"),
1049 v4i16, v4i16, IntOp, Commutable>;
1050 def v2i32 : N3VDInt<op24, op23, 0b10, op11_8, op4, itinD32, !strconcat(OpcodeStr,"32"),
1051 v2i32, v2i32, IntOp, Commutable>;
1053 // 128-bit vector types.
1054 def v8i16 : N3VQInt<op24, op23, 0b01, op11_8, op4, itinQ16, !strconcat(OpcodeStr,"16"),
1055 v8i16, v8i16, IntOp, Commutable>;
1056 def v4i32 : N3VQInt<op24, op23, 0b10, op11_8, op4, itinQ32, !strconcat(OpcodeStr,"32"),
1057 v4i32, v4i32, IntOp, Commutable>;
1060 multiclass N3VIntSL_HS<bits<4> op11_8,
1061 InstrItinClass itinD16, InstrItinClass itinD32,
1062 InstrItinClass itinQ16, InstrItinClass itinQ32,
1063 string OpcodeStr, Intrinsic IntOp> {
1064 def v4i16 : N3VDIntSL16<0b01, op11_8, itinD16, !strconcat(OpcodeStr, "16"), v4i16, IntOp>;
1065 def v2i32 : N3VDIntSL<0b10, op11_8, itinD32, !strconcat(OpcodeStr, "32"), v2i32, IntOp>;
1066 def v8i16 : N3VQIntSL16<0b01, op11_8, itinQ16, !strconcat(OpcodeStr, "16"), v8i16, v4i16, IntOp>;
1067 def v4i32 : N3VQIntSL<0b10, op11_8, itinQ32, !strconcat(OpcodeStr, "32"), v4i32, v2i32, IntOp>;
1070 // ....then also with element size of 8 bits:
1071 multiclass N3VInt_QHS<bit op24, bit op23, bits<4> op11_8, bit op4,
1072 InstrItinClass itinD16, InstrItinClass itinD32,
1073 InstrItinClass itinQ16, InstrItinClass itinQ32,
1074 string OpcodeStr, Intrinsic IntOp, bit Commutable = 0>
1075 : N3VInt_HS<op24, op23, op11_8, op4, itinD16, itinD32, itinQ16, itinQ32,
1076 OpcodeStr, IntOp, Commutable> {
1077 def v8i8 : N3VDInt<op24, op23, 0b00, op11_8, op4, itinD16,
1078 !strconcat(OpcodeStr, "8"), v8i8, v8i8, IntOp, Commutable>;
1079 def v16i8 : N3VQInt<op24, op23, 0b00, op11_8, op4, itinQ16,
1080 !strconcat(OpcodeStr, "8"), v16i8, v16i8, IntOp, Commutable>;
1083 // ....then also with element size of 64 bits:
1084 multiclass N3VInt_QHSD<bit op24, bit op23, bits<4> op11_8, bit op4,
1085 InstrItinClass itinD16, InstrItinClass itinD32,
1086 InstrItinClass itinQ16, InstrItinClass itinQ32,
1087 string OpcodeStr, Intrinsic IntOp, bit Commutable = 0>
1088 : N3VInt_QHS<op24, op23, op11_8, op4, itinD16, itinD32, itinQ16, itinQ32,
1089 OpcodeStr, IntOp, Commutable> {
1090 def v1i64 : N3VDInt<op24, op23, 0b11, op11_8, op4, itinD32,
1091 !strconcat(OpcodeStr,"64"), v1i64, v1i64, IntOp, Commutable>;
1092 def v2i64 : N3VQInt<op24, op23, 0b11, op11_8, op4, itinQ32,
1093 !strconcat(OpcodeStr,"64"), v2i64, v2i64, IntOp, Commutable>;
1097 // Neon Narrowing 3-register vector intrinsics,
1098 // source operand element sizes of 16, 32 and 64 bits:
1099 multiclass N3VNInt_HSD<bit op24, bit op23, bits<4> op11_8, bit op4,
1100 string OpcodeStr, Intrinsic IntOp, bit Commutable = 0> {
1101 def v8i8 : N3VNInt<op24, op23, 0b00, op11_8, op4, !strconcat(OpcodeStr,"16"),
1102 v8i8, v8i16, IntOp, Commutable>;
1103 def v4i16 : N3VNInt<op24, op23, 0b01, op11_8, op4, !strconcat(OpcodeStr,"32"),
1104 v4i16, v4i32, IntOp, Commutable>;
1105 def v2i32 : N3VNInt<op24, op23, 0b10, op11_8, op4, !strconcat(OpcodeStr,"64"),
1106 v2i32, v2i64, IntOp, Commutable>;
1110 // Neon Long 3-register vector intrinsics.
1112 // First with only element sizes of 16 and 32 bits:
1113 multiclass N3VLInt_HS<bit op24, bit op23, bits<4> op11_8, bit op4,
1114 InstrItinClass itin, string OpcodeStr,
1115 Intrinsic IntOp, bit Commutable = 0> {
1116 def v4i32 : N3VLInt<op24, op23, 0b01, op11_8, op4, itin,
1117 !strconcat(OpcodeStr,"16"), v4i32, v4i16, IntOp, Commutable>;
1118 def v2i64 : N3VLInt<op24, op23, 0b10, op11_8, op4, itin,
1119 !strconcat(OpcodeStr,"32"), v2i64, v2i32, IntOp, Commutable>;
1122 multiclass N3VLIntSL_HS<bit op24, bits<4> op11_8,
1123 InstrItinClass itin, string OpcodeStr, Intrinsic IntOp> {
1124 def v4i16 : N3VLIntSL16<op24, 0b01, op11_8, itin,
1125 !strconcat(OpcodeStr, "16"), v4i32, v4i16, IntOp>;
1126 def v2i32 : N3VLIntSL<op24, 0b10, op11_8, itin,
1127 !strconcat(OpcodeStr, "32"), v2i64, v2i32, IntOp>;
1130 // ....then also with element size of 8 bits:
1131 multiclass N3VLInt_QHS<bit op24, bit op23, bits<4> op11_8, bit op4,
1132 InstrItinClass itin, string OpcodeStr,
1133 Intrinsic IntOp, bit Commutable = 0>
1134 : N3VLInt_HS<op24, op23, op11_8, op4, itin, OpcodeStr, IntOp, Commutable> {
1135 def v8i16 : N3VLInt<op24, op23, 0b00, op11_8, op4, itin,
1136 !strconcat(OpcodeStr, "8"), v8i16, v8i8, IntOp, Commutable>;
1140 // Neon Wide 3-register vector intrinsics,
1141 // source operand element sizes of 8, 16 and 32 bits:
1142 multiclass N3VWInt_QHS<bit op24, bit op23, bits<4> op11_8, bit op4,
1143 string OpcodeStr, Intrinsic IntOp, bit Commutable = 0> {
1144 def v8i16 : N3VWInt<op24, op23, 0b00, op11_8, op4, !strconcat(OpcodeStr, "8"),
1145 v8i16, v8i8, IntOp, Commutable>;
1146 def v4i32 : N3VWInt<op24, op23, 0b01, op11_8, op4, !strconcat(OpcodeStr,"16"),
1147 v4i32, v4i16, IntOp, Commutable>;
1148 def v2i64 : N3VWInt<op24, op23, 0b10, op11_8, op4, !strconcat(OpcodeStr,"32"),
1149 v2i64, v2i32, IntOp, Commutable>;
1153 // Neon Multiply-Op vector operations,
1154 // element sizes of 8, 16 and 32 bits:
1155 multiclass N3VMulOp_QHS<bit op24, bit op23, bits<4> op11_8, bit op4,
1156 InstrItinClass itinD16, InstrItinClass itinD32,
1157 InstrItinClass itinQ16, InstrItinClass itinQ32,
1158 string OpcodeStr, SDNode OpNode> {
1159 // 64-bit vector types.
1160 def v8i8 : N3VDMulOp<op24, op23, 0b00, op11_8, op4, itinD16,
1161 !strconcat(OpcodeStr, "8"), v8i8, mul, OpNode>;
1162 def v4i16 : N3VDMulOp<op24, op23, 0b01, op11_8, op4, itinD16,
1163 !strconcat(OpcodeStr, "16"), v4i16, mul, OpNode>;
1164 def v2i32 : N3VDMulOp<op24, op23, 0b10, op11_8, op4, itinD32,
1165 !strconcat(OpcodeStr, "32"), v2i32, mul, OpNode>;
1167 // 128-bit vector types.
1168 def v16i8 : N3VQMulOp<op24, op23, 0b00, op11_8, op4, itinQ16,
1169 !strconcat(OpcodeStr, "8"), v16i8, mul, OpNode>;
1170 def v8i16 : N3VQMulOp<op24, op23, 0b01, op11_8, op4, itinQ16,
1171 !strconcat(OpcodeStr, "16"), v8i16, mul, OpNode>;
1172 def v4i32 : N3VQMulOp<op24, op23, 0b10, op11_8, op4, itinQ32,
1173 !strconcat(OpcodeStr, "32"), v4i32, mul, OpNode>;
1176 multiclass N3VMulOpSL_HS<bits<4> op11_8,
1177 InstrItinClass itinD16, InstrItinClass itinD32,
1178 InstrItinClass itinQ16, InstrItinClass itinQ32,
1179 string OpcodeStr, SDNode ShOp> {
1180 def v4i16 : N3VDMulOpSL16<0b01, op11_8, itinD16,
1181 !strconcat(OpcodeStr, "16"), v4i16, mul, ShOp>;
1182 def v2i32 : N3VDMulOpSL<0b10, op11_8, itinD32,
1183 !strconcat(OpcodeStr, "32"), v2i32, mul, ShOp>;
1184 def v8i16 : N3VQMulOpSL16<0b01, op11_8, itinQ16,
1185 !strconcat(OpcodeStr, "16"), v8i16, v4i16, mul, ShOp>;
1186 def v4i32 : N3VQMulOpSL<0b10, op11_8, itinQ32,
1187 !strconcat(OpcodeStr, "32"), v4i32, v2i32, mul, ShOp>;
1190 // Neon 3-argument intrinsics,
1191 // element sizes of 8, 16 and 32 bits:
1192 multiclass N3VInt3_QHS<bit op24, bit op23, bits<4> op11_8, bit op4,
1193 string OpcodeStr, Intrinsic IntOp> {
1194 // 64-bit vector types.
1195 def v8i8 : N3VDInt3<op24, op23, 0b00, op11_8, op4, IIC_VMACi16D,
1196 !strconcat(OpcodeStr, "8"), v8i8, v8i8, IntOp>;
1197 def v4i16 : N3VDInt3<op24, op23, 0b01, op11_8, op4, IIC_VMACi16D,
1198 !strconcat(OpcodeStr, "16"), v4i16, v4i16, IntOp>;
1199 def v2i32 : N3VDInt3<op24, op23, 0b10, op11_8, op4, IIC_VMACi32D,
1200 !strconcat(OpcodeStr, "32"), v2i32, v2i32, IntOp>;
1202 // 128-bit vector types.
1203 def v16i8 : N3VQInt3<op24, op23, 0b00, op11_8, op4, IIC_VMACi16Q,
1204 !strconcat(OpcodeStr, "8"), v16i8, v16i8, IntOp>;
1205 def v8i16 : N3VQInt3<op24, op23, 0b01, op11_8, op4, IIC_VMACi16Q,
1206 !strconcat(OpcodeStr, "16"), v8i16, v8i16, IntOp>;
1207 def v4i32 : N3VQInt3<op24, op23, 0b10, op11_8, op4, IIC_VMACi32Q,
1208 !strconcat(OpcodeStr, "32"), v4i32, v4i32, IntOp>;
1212 // Neon Long 3-argument intrinsics.
1214 // First with only element sizes of 16 and 32 bits:
1215 multiclass N3VLInt3_HS<bit op24, bit op23, bits<4> op11_8, bit op4,
1216 string OpcodeStr, Intrinsic IntOp> {
1217 def v4i32 : N3VLInt3<op24, op23, 0b01, op11_8, op4, IIC_VMACi16D,
1218 !strconcat(OpcodeStr, "16"), v4i32, v4i16, IntOp>;
1219 def v2i64 : N3VLInt3<op24, op23, 0b10, op11_8, op4, IIC_VMACi16D,
1220 !strconcat(OpcodeStr, "32"), v2i64, v2i32, IntOp>;
1223 multiclass N3VLInt3SL_HS<bit op24, bits<4> op11_8,
1224 string OpcodeStr, Intrinsic IntOp> {
1225 def v4i16 : N3VLInt3SL16<op24, 0b01, op11_8, IIC_VMACi16D,
1226 !strconcat(OpcodeStr, "16"), v4i32, v4i16, IntOp>;
1227 def v2i32 : N3VLInt3SL<op24, 0b10, op11_8, IIC_VMACi32D,
1228 !strconcat(OpcodeStr, "32"), v2i64, v2i32, IntOp>;
1231 // ....then also with element size of 8 bits:
1232 multiclass N3VLInt3_QHS<bit op24, bit op23, bits<4> op11_8, bit op4,
1233 string OpcodeStr, Intrinsic IntOp>
1234 : N3VLInt3_HS<op24, op23, op11_8, op4, OpcodeStr, IntOp> {
1235 def v8i16 : N3VLInt3<op24, op23, 0b01, op11_8, op4, IIC_VMACi16D,
1236 !strconcat(OpcodeStr, "8"), v8i16, v8i8, IntOp>;
1240 // Neon 2-register vector intrinsics,
1241 // element sizes of 8, 16 and 32 bits:
1242 multiclass N2VInt_QHS<bits<2> op24_23, bits<2> op21_20, bits<2> op17_16,
1243 bits<5> op11_7, bit op4,
1244 InstrItinClass itinD, InstrItinClass itinQ,
1245 string OpcodeStr, Intrinsic IntOp> {
1246 // 64-bit vector types.
1247 def v8i8 : N2VDInt<op24_23, op21_20, 0b00, op17_16, op11_7, op4,
1248 itinD, !strconcat(OpcodeStr, "8"), v8i8, v8i8, IntOp>;
1249 def v4i16 : N2VDInt<op24_23, op21_20, 0b01, op17_16, op11_7, op4,
1250 itinD, !strconcat(OpcodeStr, "16"), v4i16, v4i16, IntOp>;
1251 def v2i32 : N2VDInt<op24_23, op21_20, 0b10, op17_16, op11_7, op4,
1252 itinD, !strconcat(OpcodeStr, "32"), v2i32, v2i32, IntOp>;
1254 // 128-bit vector types.
1255 def v16i8 : N2VQInt<op24_23, op21_20, 0b00, op17_16, op11_7, op4,
1256 itinQ, !strconcat(OpcodeStr, "8"), v16i8, v16i8, IntOp>;
1257 def v8i16 : N2VQInt<op24_23, op21_20, 0b01, op17_16, op11_7, op4,
1258 itinQ, !strconcat(OpcodeStr, "16"), v8i16, v8i16, IntOp>;
1259 def v4i32 : N2VQInt<op24_23, op21_20, 0b10, op17_16, op11_7, op4,
1260 itinQ, !strconcat(OpcodeStr, "32"), v4i32, v4i32, IntOp>;
1264 // Neon Pairwise long 2-register intrinsics,
1265 // element sizes of 8, 16 and 32 bits:
1266 multiclass N2VPLInt_QHS<bits<2> op24_23, bits<2> op21_20, bits<2> op17_16,
1267 bits<5> op11_7, bit op4,
1268 string OpcodeStr, Intrinsic IntOp> {
1269 // 64-bit vector types.
1270 def v8i8 : N2VDPLInt<op24_23, op21_20, 0b00, op17_16, op11_7, op4,
1271 !strconcat(OpcodeStr, "8"), v4i16, v8i8, IntOp>;
1272 def v4i16 : N2VDPLInt<op24_23, op21_20, 0b01, op17_16, op11_7, op4,
1273 !strconcat(OpcodeStr, "16"), v2i32, v4i16, IntOp>;
1274 def v2i32 : N2VDPLInt<op24_23, op21_20, 0b10, op17_16, op11_7, op4,
1275 !strconcat(OpcodeStr, "32"), v1i64, v2i32, IntOp>;
1277 // 128-bit vector types.
1278 def v16i8 : N2VQPLInt<op24_23, op21_20, 0b00, op17_16, op11_7, op4,
1279 !strconcat(OpcodeStr, "8"), v8i16, v16i8, IntOp>;
1280 def v8i16 : N2VQPLInt<op24_23, op21_20, 0b01, op17_16, op11_7, op4,
1281 !strconcat(OpcodeStr, "16"), v4i32, v8i16, IntOp>;
1282 def v4i32 : N2VQPLInt<op24_23, op21_20, 0b10, op17_16, op11_7, op4,
1283 !strconcat(OpcodeStr, "32"), v2i64, v4i32, IntOp>;
1287 // Neon Pairwise long 2-register accumulate intrinsics,
1288 // element sizes of 8, 16 and 32 bits:
1289 multiclass N2VPLInt2_QHS<bits<2> op24_23, bits<2> op21_20, bits<2> op17_16,
1290 bits<5> op11_7, bit op4,
1291 string OpcodeStr, Intrinsic IntOp> {
1292 // 64-bit vector types.
1293 def v8i8 : N2VDPLInt2<op24_23, op21_20, 0b00, op17_16, op11_7, op4,
1294 !strconcat(OpcodeStr, "8"), v4i16, v8i8, IntOp>;
1295 def v4i16 : N2VDPLInt2<op24_23, op21_20, 0b01, op17_16, op11_7, op4,
1296 !strconcat(OpcodeStr, "16"), v2i32, v4i16, IntOp>;
1297 def v2i32 : N2VDPLInt2<op24_23, op21_20, 0b10, op17_16, op11_7, op4,
1298 !strconcat(OpcodeStr, "32"), v1i64, v2i32, IntOp>;
1300 // 128-bit vector types.
1301 def v16i8 : N2VQPLInt2<op24_23, op21_20, 0b00, op17_16, op11_7, op4,
1302 !strconcat(OpcodeStr, "8"), v8i16, v16i8, IntOp>;
1303 def v8i16 : N2VQPLInt2<op24_23, op21_20, 0b01, op17_16, op11_7, op4,
1304 !strconcat(OpcodeStr, "16"), v4i32, v8i16, IntOp>;
1305 def v4i32 : N2VQPLInt2<op24_23, op21_20, 0b10, op17_16, op11_7, op4,
1306 !strconcat(OpcodeStr, "32"), v2i64, v4i32, IntOp>;
1310 // Neon 2-register vector shift by immediate,
1311 // element sizes of 8, 16, 32 and 64 bits:
1312 multiclass N2VSh_QHSD<bit op24, bit op23, bits<4> op11_8, bit op4,
1313 InstrItinClass itin, string OpcodeStr, SDNode OpNode> {
1314 // 64-bit vector types.
1315 def v8i8 : N2VDSh<op24, op23, 0b001000, op11_8, 0, op4, itin,
1316 !strconcat(OpcodeStr, "8"), v8i8, OpNode>;
1317 def v4i16 : N2VDSh<op24, op23, 0b010000, op11_8, 0, op4, itin,
1318 !strconcat(OpcodeStr, "16"), v4i16, OpNode>;
1319 def v2i32 : N2VDSh<op24, op23, 0b100000, op11_8, 0, op4, itin,
1320 !strconcat(OpcodeStr, "32"), v2i32, OpNode>;
1321 def v1i64 : N2VDSh<op24, op23, 0b000000, op11_8, 1, op4, itin,
1322 !strconcat(OpcodeStr, "64"), v1i64, OpNode>;
1324 // 128-bit vector types.
1325 def v16i8 : N2VQSh<op24, op23, 0b001000, op11_8, 0, op4, itin,
1326 !strconcat(OpcodeStr, "8"), v16i8, OpNode>;
1327 def v8i16 : N2VQSh<op24, op23, 0b010000, op11_8, 0, op4, itin,
1328 !strconcat(OpcodeStr, "16"), v8i16, OpNode>;
1329 def v4i32 : N2VQSh<op24, op23, 0b100000, op11_8, 0, op4, itin,
1330 !strconcat(OpcodeStr, "32"), v4i32, OpNode>;
1331 def v2i64 : N2VQSh<op24, op23, 0b000000, op11_8, 1, op4, itin,
1332 !strconcat(OpcodeStr, "64"), v2i64, OpNode>;
1336 // Neon Shift-Accumulate vector operations,
1337 // element sizes of 8, 16, 32 and 64 bits:
1338 multiclass N2VShAdd_QHSD<bit op24, bit op23, bits<4> op11_8, bit op4,
1339 string OpcodeStr, SDNode ShOp> {
1340 // 64-bit vector types.
1341 def v8i8 : N2VDShAdd<op24, op23, 0b001000, op11_8, 0, op4,
1342 !strconcat(OpcodeStr, "8"), v8i8, ShOp>;
1343 def v4i16 : N2VDShAdd<op24, op23, 0b010000, op11_8, 0, op4,
1344 !strconcat(OpcodeStr, "16"), v4i16, ShOp>;
1345 def v2i32 : N2VDShAdd<op24, op23, 0b100000, op11_8, 0, op4,
1346 !strconcat(OpcodeStr, "32"), v2i32, ShOp>;
1347 def v1i64 : N2VDShAdd<op24, op23, 0b000000, op11_8, 1, op4,
1348 !strconcat(OpcodeStr, "64"), v1i64, ShOp>;
1350 // 128-bit vector types.
1351 def v16i8 : N2VQShAdd<op24, op23, 0b001000, op11_8, 0, op4,
1352 !strconcat(OpcodeStr, "8"), v16i8, ShOp>;
1353 def v8i16 : N2VQShAdd<op24, op23, 0b010000, op11_8, 0, op4,
1354 !strconcat(OpcodeStr, "16"), v8i16, ShOp>;
1355 def v4i32 : N2VQShAdd<op24, op23, 0b100000, op11_8, 0, op4,
1356 !strconcat(OpcodeStr, "32"), v4i32, ShOp>;
1357 def v2i64 : N2VQShAdd<op24, op23, 0b000000, op11_8, 1, op4,
1358 !strconcat(OpcodeStr, "64"), v2i64, ShOp>;
1362 // Neon Shift-Insert vector operations,
1363 // element sizes of 8, 16, 32 and 64 bits:
1364 multiclass N2VShIns_QHSD<bit op24, bit op23, bits<4> op11_8, bit op4,
1365 string OpcodeStr, SDNode ShOp> {
1366 // 64-bit vector types.
1367 def v8i8 : N2VDShIns<op24, op23, 0b001000, op11_8, 0, op4,
1368 !strconcat(OpcodeStr, "8"), v8i8, ShOp>;
1369 def v4i16 : N2VDShIns<op24, op23, 0b010000, op11_8, 0, op4,
1370 !strconcat(OpcodeStr, "16"), v4i16, ShOp>;
1371 def v2i32 : N2VDShIns<op24, op23, 0b100000, op11_8, 0, op4,
1372 !strconcat(OpcodeStr, "32"), v2i32, ShOp>;
1373 def v1i64 : N2VDShIns<op24, op23, 0b000000, op11_8, 1, op4,
1374 !strconcat(OpcodeStr, "64"), v1i64, ShOp>;
1376 // 128-bit vector types.
1377 def v16i8 : N2VQShIns<op24, op23, 0b001000, op11_8, 0, op4,
1378 !strconcat(OpcodeStr, "8"), v16i8, ShOp>;
1379 def v8i16 : N2VQShIns<op24, op23, 0b010000, op11_8, 0, op4,
1380 !strconcat(OpcodeStr, "16"), v8i16, ShOp>;
1381 def v4i32 : N2VQShIns<op24, op23, 0b100000, op11_8, 0, op4,
1382 !strconcat(OpcodeStr, "32"), v4i32, ShOp>;
1383 def v2i64 : N2VQShIns<op24, op23, 0b000000, op11_8, 1, op4,
1384 !strconcat(OpcodeStr, "64"), v2i64, ShOp>;
1387 //===----------------------------------------------------------------------===//
1388 // Instruction Definitions.
1389 //===----------------------------------------------------------------------===//
1391 // Vector Add Operations.
1393 // VADD : Vector Add (integer and floating-point)
1394 defm VADD : N3V_QHSD<0, 0, 0b1000, 0, IIC_VBINiD, IIC_VBINiQ, "vadd.i", add, 1>;
1395 def VADDfd : N3VD<0, 0, 0b00, 0b1101, 0, IIC_VBIND, "vadd.f32", v2f32, v2f32, fadd, 1>;
1396 def VADDfq : N3VQ<0, 0, 0b00, 0b1101, 0, IIC_VBINQ, "vadd.f32", v4f32, v4f32, fadd, 1>;
1397 // VADDL : Vector Add Long (Q = D + D)
1398 defm VADDLs : N3VLInt_QHS<0,1,0b0000,0, IIC_VSHLiD, "vaddl.s", int_arm_neon_vaddls, 1>;
1399 defm VADDLu : N3VLInt_QHS<1,1,0b0000,0, IIC_VSHLiD, "vaddl.u", int_arm_neon_vaddlu, 1>;
1400 // VADDW : Vector Add Wide (Q = Q + D)
1401 defm VADDWs : N3VWInt_QHS<0,1,0b0001,0, "vaddw.s", int_arm_neon_vaddws, 0>;
1402 defm VADDWu : N3VWInt_QHS<1,1,0b0001,0, "vaddw.u", int_arm_neon_vaddwu, 0>;
1403 // VHADD : Vector Halving Add
1404 defm VHADDs : N3VInt_QHS<0,0,0b0000,0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1405 IIC_VBINi4Q, "vhadd.s", int_arm_neon_vhadds, 1>;
1406 defm VHADDu : N3VInt_QHS<1,0,0b0000,0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1407 IIC_VBINi4Q, "vhadd.u", int_arm_neon_vhaddu, 1>;
1408 // VRHADD : Vector Rounding Halving Add
1409 defm VRHADDs : N3VInt_QHS<0,0,0b0001,0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1410 IIC_VBINi4Q, "vrhadd.s", int_arm_neon_vrhadds, 1>;
1411 defm VRHADDu : N3VInt_QHS<1,0,0b0001,0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1412 IIC_VBINi4Q, "vrhadd.u", int_arm_neon_vrhaddu, 1>;
1413 // VQADD : Vector Saturating Add
1414 defm VQADDs : N3VInt_QHSD<0,0,0b0000,1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1415 IIC_VBINi4Q, "vqadd.s", int_arm_neon_vqadds, 1>;
1416 defm VQADDu : N3VInt_QHSD<1,0,0b0000,1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1417 IIC_VBINi4Q, "vqadd.u", int_arm_neon_vqaddu, 1>;
1418 // VADDHN : Vector Add and Narrow Returning High Half (D = Q + Q)
1419 defm VADDHN : N3VNInt_HSD<0,1,0b0100,0, "vaddhn.i", int_arm_neon_vaddhn, 1>;
1420 // VRADDHN : Vector Rounding Add and Narrow Returning High Half (D = Q + Q)
1421 defm VRADDHN : N3VNInt_HSD<1,1,0b0100,0, "vraddhn.i", int_arm_neon_vraddhn, 1>;
1423 // Vector Multiply Operations.
1425 // VMUL : Vector Multiply (integer, polynomial and floating-point)
1426 defm VMUL : N3V_QHS<0, 0, 0b1001, 1, IIC_VMULi16D, IIC_VMULi32D, IIC_VMULi16Q,
1427 IIC_VMULi32Q, "vmul.i", mul, 1>;
1428 def VMULpd : N3VDInt<1, 0, 0b00, 0b1001, 1, IIC_VMULi16D, "vmul.p8", v8i8, v8i8,
1429 int_arm_neon_vmulp, 1>;
1430 def VMULpq : N3VQInt<1, 0, 0b00, 0b1001, 1, IIC_VMULi16Q, "vmul.p8", v16i8, v16i8,
1431 int_arm_neon_vmulp, 1>;
1432 def VMULfd : N3VD<1, 0, 0b00, 0b1101, 1, IIC_VBIND, "vmul.f32", v2f32, v2f32, fmul, 1>;
1433 def VMULfq : N3VQ<1, 0, 0b00, 0b1101, 1, IIC_VBINQ, "vmul.f32", v4f32, v4f32, fmul, 1>;
1434 defm VMULsl : N3VSL_HS<0b1000, "vmul.i", mul>;
1435 def VMULslfd : N3VDSL<0b10, 0b1001, IIC_VBIND, "vmul.f32", v2f32, fmul>;
1436 def VMULslfq : N3VQSL<0b10, 0b1001, IIC_VBINQ, "vmul.f32", v4f32, v2f32, fmul>;
1437 def : Pat<(v8i16 (mul (v8i16 QPR:$src1),
1438 (v8i16 (NEONvduplane (v8i16 QPR:$src2), imm:$lane)))),
1439 (v8i16 (VMULslv8i16 (v8i16 QPR:$src1),
1440 (v4i16 (EXTRACT_SUBREG QPR:$src2,
1441 (DSubReg_i16_reg imm:$lane))),
1442 (SubReg_i16_lane imm:$lane)))>;
1443 def : Pat<(v4i32 (mul (v4i32 QPR:$src1),
1444 (v4i32 (NEONvduplane (v4i32 QPR:$src2), imm:$lane)))),
1445 (v4i32 (VMULslv4i32 (v4i32 QPR:$src1),
1446 (v2i32 (EXTRACT_SUBREG QPR:$src2,
1447 (DSubReg_i32_reg imm:$lane))),
1448 (SubReg_i32_lane imm:$lane)))>;
1449 def : Pat<(v4f32 (fmul (v4f32 QPR:$src1),
1450 (v4f32 (NEONvduplane (v4f32 QPR:$src2), imm:$lane)))),
1451 (v4f32 (VMULslfq (v4f32 QPR:$src1),
1452 (v2f32 (EXTRACT_SUBREG QPR:$src2,
1453 (DSubReg_i32_reg imm:$lane))),
1454 (SubReg_i32_lane imm:$lane)))>;
1456 // VQDMULH : Vector Saturating Doubling Multiply Returning High Half
1457 defm VQDMULH : N3VInt_HS<0, 0, 0b1011, 0, IIC_VMULi16D, IIC_VMULi32D,
1458 IIC_VMULi16Q, IIC_VMULi32Q,
1459 "vqdmulh.s", int_arm_neon_vqdmulh, 1>;
1460 defm VQDMULHsl: N3VIntSL_HS<0b1100, IIC_VMULi16D, IIC_VMULi32D,
1461 IIC_VMULi16Q, IIC_VMULi32Q,
1462 "vqdmulh.s", int_arm_neon_vqdmulh>;
1463 def : Pat<(v8i16 (int_arm_neon_vqdmulh (v8i16 QPR:$src1),
1464 (v8i16 (NEONvduplane (v8i16 QPR:$src2), imm:$lane)))),
1465 (v8i16 (VQDMULHslv8i16 (v8i16 QPR:$src1),
1466 (v4i16 (EXTRACT_SUBREG QPR:$src2,
1467 (DSubReg_i16_reg imm:$lane))),
1468 (SubReg_i16_lane imm:$lane)))>;
1469 def : Pat<(v4i32 (int_arm_neon_vqdmulh (v4i32 QPR:$src1),
1470 (v4i32 (NEONvduplane (v4i32 QPR:$src2), imm:$lane)))),
1471 (v4i32 (VQDMULHslv4i32 (v4i32 QPR:$src1),
1472 (v2i32 (EXTRACT_SUBREG QPR:$src2,
1473 (DSubReg_i32_reg imm:$lane))),
1474 (SubReg_i32_lane imm:$lane)))>;
1476 // VQRDMULH : Vector Rounding Saturating Doubling Multiply Returning High Half
1477 defm VQRDMULH : N3VInt_HS<1, 0, 0b1011, 0, IIC_VMULi16D, IIC_VMULi32D,
1478 IIC_VMULi16Q, IIC_VMULi32Q,
1479 "vqrdmulh.s", int_arm_neon_vqrdmulh, 1>;
1480 defm VQRDMULHsl : N3VIntSL_HS<0b1101, IIC_VMULi16D, IIC_VMULi32D,
1481 IIC_VMULi16Q, IIC_VMULi32Q,
1482 "vqrdmulh.s", int_arm_neon_vqrdmulh>;
1483 def : Pat<(v8i16 (int_arm_neon_vqrdmulh (v8i16 QPR:$src1),
1484 (v8i16 (NEONvduplane (v8i16 QPR:$src2), imm:$lane)))),
1485 (v8i16 (VQRDMULHslv8i16 (v8i16 QPR:$src1),
1486 (v4i16 (EXTRACT_SUBREG QPR:$src2,
1487 (DSubReg_i16_reg imm:$lane))),
1488 (SubReg_i16_lane imm:$lane)))>;
1489 def : Pat<(v4i32 (int_arm_neon_vqrdmulh (v4i32 QPR:$src1),
1490 (v4i32 (NEONvduplane (v4i32 QPR:$src2), imm:$lane)))),
1491 (v4i32 (VQRDMULHslv4i32 (v4i32 QPR:$src1),
1492 (v2i32 (EXTRACT_SUBREG QPR:$src2,
1493 (DSubReg_i32_reg imm:$lane))),
1494 (SubReg_i32_lane imm:$lane)))>;
1496 // VMULL : Vector Multiply Long (integer and polynomial) (Q = D * D)
1497 defm VMULLs : N3VLInt_QHS<0,1,0b1100,0, IIC_VMULi16D, "vmull.s", int_arm_neon_vmulls, 1>;
1498 defm VMULLu : N3VLInt_QHS<1,1,0b1100,0, IIC_VMULi16D, "vmull.u", int_arm_neon_vmullu, 1>;
1499 def VMULLp : N3VLInt<0, 1, 0b00, 0b1110, 0, IIC_VMULi16D, "vmull.p8", v8i16, v8i8,
1500 int_arm_neon_vmullp, 1>;
1501 defm VMULLsls : N3VLIntSL_HS<0, 0b1010, IIC_VMULi16D, "vmull.s", int_arm_neon_vmulls>;
1502 defm VMULLslu : N3VLIntSL_HS<1, 0b1010, IIC_VMULi16D, "vmull.u", int_arm_neon_vmullu>;
1504 // VQDMULL : Vector Saturating Doubling Multiply Long (Q = D * D)
1505 defm VQDMULL : N3VLInt_HS<0,1,0b1101,0, IIC_VMULi16D, "vqdmull.s", int_arm_neon_vqdmull, 1>;
1506 defm VQDMULLsl: N3VLIntSL_HS<0, 0b1011, IIC_VMULi16D, "vqdmull.s", int_arm_neon_vqdmull>;
1508 // Vector Multiply-Accumulate and Multiply-Subtract Operations.
1510 // VMLA : Vector Multiply Accumulate (integer and floating-point)
1511 defm VMLA : N3VMulOp_QHS<0, 0, 0b1001, 0, IIC_VMACi16D, IIC_VMACi32D,
1512 IIC_VMACi16Q, IIC_VMACi32Q, "vmla.i", add>;
1513 def VMLAfd : N3VDMulOp<0, 0, 0b00, 0b1101, 1, IIC_VMACD, "vmla.f32", v2f32, fmul, fadd>;
1514 def VMLAfq : N3VQMulOp<0, 0, 0b00, 0b1101, 1, IIC_VMACQ, "vmla.f32", v4f32, fmul, fadd>;
1515 defm VMLAsl : N3VMulOpSL_HS<0b0000, IIC_VMACi16D, IIC_VMACi32D,
1516 IIC_VMACi16Q, IIC_VMACi32Q, "vmla.i", add>;
1517 def VMLAslfd : N3VDMulOpSL<0b10, 0b0001, IIC_VMACD, "vmla.f32", v2f32, fmul, fadd>;
1518 def VMLAslfq : N3VQMulOpSL<0b10, 0b0001, IIC_VMACQ, "vmla.f32", v4f32, v2f32, fmul, fadd>;
1520 def : Pat<(v8i16 (add (v8i16 QPR:$src1),
1521 (mul (v8i16 QPR:$src2),
1522 (v8i16 (NEONvduplane (v8i16 QPR:$src3), imm:$lane))))),
1523 (v8i16 (VMLAslv8i16 (v8i16 QPR:$src1),
1525 (v4i16 (EXTRACT_SUBREG QPR:$src3,
1526 (DSubReg_i16_reg imm:$lane))),
1527 (SubReg_i16_lane imm:$lane)))>;
1529 def : Pat<(v4i32 (add (v4i32 QPR:$src1),
1530 (mul (v4i32 QPR:$src2),
1531 (v4i32 (NEONvduplane (v4i32 QPR:$src3), imm:$lane))))),
1532 (v4i32 (VMLAslv4i32 (v4i32 QPR:$src1),
1534 (v2i32 (EXTRACT_SUBREG QPR:$src3,
1535 (DSubReg_i32_reg imm:$lane))),
1536 (SubReg_i32_lane imm:$lane)))>;
1538 def : Pat<(v4f32 (fadd (v4f32 QPR:$src1),
1539 (fmul (v4f32 QPR:$src2),
1540 (v4f32 (NEONvduplane (v4f32 QPR:$src3), imm:$lane))))),
1541 (v4f32 (VMLAslfq (v4f32 QPR:$src1),
1543 (v2f32 (EXTRACT_SUBREG QPR:$src3,
1544 (DSubReg_i32_reg imm:$lane))),
1545 (SubReg_i32_lane imm:$lane)))>;
1547 // VMLAL : Vector Multiply Accumulate Long (Q += D * D)
1548 defm VMLALs : N3VLInt3_QHS<0,1,0b1000,0, "vmlal.s", int_arm_neon_vmlals>;
1549 defm VMLALu : N3VLInt3_QHS<1,1,0b1000,0, "vmlal.u", int_arm_neon_vmlalu>;
1551 defm VMLALsls : N3VLInt3SL_HS<0, 0b0010, "vmlal.s", int_arm_neon_vmlals>;
1552 defm VMLALslu : N3VLInt3SL_HS<1, 0b0010, "vmlal.u", int_arm_neon_vmlalu>;
1554 // VQDMLAL : Vector Saturating Doubling Multiply Accumulate Long (Q += D * D)
1555 defm VQDMLAL : N3VLInt3_HS<0, 1, 0b1001, 0, "vqdmlal.s", int_arm_neon_vqdmlal>;
1556 defm VQDMLALsl: N3VLInt3SL_HS<0, 0b0011, "vqdmlal.s", int_arm_neon_vqdmlal>;
1558 // VMLS : Vector Multiply Subtract (integer and floating-point)
1559 defm VMLS : N3VMulOp_QHS<1, 0, 0b1001, 0, IIC_VMACi16D, IIC_VMACi32D,
1560 IIC_VMACi16Q, IIC_VMACi32Q, "vmls.i", sub>;
1561 def VMLSfd : N3VDMulOp<0, 0, 0b10, 0b1101, 1, IIC_VMACD, "vmls.f32", v2f32, fmul, fsub>;
1562 def VMLSfq : N3VQMulOp<0, 0, 0b10, 0b1101, 1, IIC_VMACQ, "vmls.f32", v4f32, fmul, fsub>;
1563 defm VMLSsl : N3VMulOpSL_HS<0b0100, IIC_VMACi16D, IIC_VMACi32D,
1564 IIC_VMACi16Q, IIC_VMACi32Q, "vmls.i", sub>;
1565 def VMLSslfd : N3VDMulOpSL<0b10, 0b0101, IIC_VMACD, "vmls.f32", v2f32, fmul, fsub>;
1566 def VMLSslfq : N3VQMulOpSL<0b10, 0b0101, IIC_VMACQ, "vmls.f32", v4f32, v2f32, fmul, fsub>;
1568 def : Pat<(v8i16 (sub (v8i16 QPR:$src1),
1569 (mul (v8i16 QPR:$src2),
1570 (v8i16 (NEONvduplane (v8i16 QPR:$src3), imm:$lane))))),
1571 (v8i16 (VMLSslv8i16 (v8i16 QPR:$src1),
1573 (v4i16 (EXTRACT_SUBREG QPR:$src3,
1574 (DSubReg_i16_reg imm:$lane))),
1575 (SubReg_i16_lane imm:$lane)))>;
1577 def : Pat<(v4i32 (sub (v4i32 QPR:$src1),
1578 (mul (v4i32 QPR:$src2),
1579 (v4i32 (NEONvduplane (v4i32 QPR:$src3), imm:$lane))))),
1580 (v4i32 (VMLSslv4i32 (v4i32 QPR:$src1),
1582 (v2i32 (EXTRACT_SUBREG QPR:$src3,
1583 (DSubReg_i32_reg imm:$lane))),
1584 (SubReg_i32_lane imm:$lane)))>;
1586 def : Pat<(v4f32 (fsub (v4f32 QPR:$src1),
1587 (fmul (v4f32 QPR:$src2),
1588 (v4f32 (NEONvduplane (v4f32 QPR:$src3), imm:$lane))))),
1589 (v4f32 (VMLSslfq (v4f32 QPR:$src1),
1591 (v2f32 (EXTRACT_SUBREG QPR:$src3,
1592 (DSubReg_i32_reg imm:$lane))),
1593 (SubReg_i32_lane imm:$lane)))>;
1595 // VMLSL : Vector Multiply Subtract Long (Q -= D * D)
1596 defm VMLSLs : N3VLInt3_QHS<0,1,0b1010,0, "vmlsl.s", int_arm_neon_vmlsls>;
1597 defm VMLSLu : N3VLInt3_QHS<1,1,0b1010,0, "vmlsl.u", int_arm_neon_vmlslu>;
1599 defm VMLSLsls : N3VLInt3SL_HS<0, 0b0110, "vmlsl.s", int_arm_neon_vmlsls>;
1600 defm VMLSLslu : N3VLInt3SL_HS<1, 0b0110, "vmlsl.u", int_arm_neon_vmlslu>;
1602 // VQDMLSL : Vector Saturating Doubling Multiply Subtract Long (Q -= D * D)
1603 defm VQDMLSL : N3VLInt3_HS<0, 1, 0b1011, 0, "vqdmlsl.s", int_arm_neon_vqdmlsl>;
1604 defm VQDMLSLsl: N3VLInt3SL_HS<0, 0b111, "vqdmlsl.s", int_arm_neon_vqdmlsl>;
1606 // Vector Subtract Operations.
1608 // VSUB : Vector Subtract (integer and floating-point)
1609 defm VSUB : N3V_QHSD<1, 0, 0b1000, 0, IIC_VSUBiD, IIC_VSUBiQ, "vsub.i", sub, 0>;
1610 def VSUBfd : N3VD<0, 0, 0b10, 0b1101, 0, IIC_VBIND, "vsub.f32", v2f32, v2f32, fsub, 0>;
1611 def VSUBfq : N3VQ<0, 0, 0b10, 0b1101, 0, IIC_VBINQ, "vsub.f32", v4f32, v4f32, fsub, 0>;
1612 // VSUBL : Vector Subtract Long (Q = D - D)
1613 defm VSUBLs : N3VLInt_QHS<0,1,0b0010,0, IIC_VSHLiD, "vsubl.s", int_arm_neon_vsubls, 1>;
1614 defm VSUBLu : N3VLInt_QHS<1,1,0b0010,0, IIC_VSHLiD, "vsubl.u", int_arm_neon_vsublu, 1>;
1615 // VSUBW : Vector Subtract Wide (Q = Q - D)
1616 defm VSUBWs : N3VWInt_QHS<0,1,0b0011,0, "vsubw.s", int_arm_neon_vsubws, 0>;
1617 defm VSUBWu : N3VWInt_QHS<1,1,0b0011,0, "vsubw.u", int_arm_neon_vsubwu, 0>;
1618 // VHSUB : Vector Halving Subtract
1619 defm VHSUBs : N3VInt_QHS<0, 0, 0b0010, 0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1620 IIC_VBINi4Q, "vhsub.s", int_arm_neon_vhsubs, 0>;
1621 defm VHSUBu : N3VInt_QHS<1, 0, 0b0010, 0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1622 IIC_VBINi4Q, "vhsub.u", int_arm_neon_vhsubu, 0>;
1623 // VQSUB : Vector Saturing Subtract
1624 defm VQSUBs : N3VInt_QHSD<0, 0, 0b0010, 1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1625 IIC_VBINi4Q, "vqsub.s", int_arm_neon_vqsubs, 0>;
1626 defm VQSUBu : N3VInt_QHSD<1, 0, 0b0010, 1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1627 IIC_VBINi4Q, "vqsub.u", int_arm_neon_vqsubu, 0>;
1628 // VSUBHN : Vector Subtract and Narrow Returning High Half (D = Q - Q)
1629 defm VSUBHN : N3VNInt_HSD<0,1,0b0110,0, "vsubhn.i", int_arm_neon_vsubhn, 0>;
1630 // VRSUBHN : Vector Rounding Subtract and Narrow Returning High Half (D=Q-Q)
1631 defm VRSUBHN : N3VNInt_HSD<1,1,0b0110,0, "vrsubhn.i", int_arm_neon_vrsubhn, 0>;
1633 // Vector Comparisons.
1635 // VCEQ : Vector Compare Equal
1636 defm VCEQ : N3V_QHS<1, 0, 0b1000, 1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1637 IIC_VBINi4Q, "vceq.i", NEONvceq, 1>;
1638 def VCEQfd : N3VD<0,0,0b00,0b1110,0, IIC_VBIND, "vceq.f32", v2i32, v2f32, NEONvceq, 1>;
1639 def VCEQfq : N3VQ<0,0,0b00,0b1110,0, IIC_VBINQ, "vceq.f32", v4i32, v4f32, NEONvceq, 1>;
1640 // VCGE : Vector Compare Greater Than or Equal
1641 defm VCGEs : N3V_QHS<0, 0, 0b0011, 1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1642 IIC_VBINi4Q, "vcge.s", NEONvcge, 0>;
1643 defm VCGEu : N3V_QHS<1, 0, 0b0011, 1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1644 IIC_VBINi4Q, "vcge.u", NEONvcgeu, 0>;
1645 def VCGEfd : N3VD<1,0,0b00,0b1110,0, IIC_VBIND, "vcge.f32", v2i32, v2f32, NEONvcge, 0>;
1646 def VCGEfq : N3VQ<1,0,0b00,0b1110,0, IIC_VBINQ, "vcge.f32", v4i32, v4f32, NEONvcge, 0>;
1647 // VCGT : Vector Compare Greater Than
1648 defm VCGTs : N3V_QHS<0, 0, 0b0011, 0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1649 IIC_VBINi4Q, "vcgt.s", NEONvcgt, 0>;
1650 defm VCGTu : N3V_QHS<1, 0, 0b0011, 0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1651 IIC_VBINi4Q, "vcgt.u", NEONvcgtu, 0>;
1652 def VCGTfd : N3VD<1,0,0b10,0b1110,0, IIC_VBIND, "vcgt.f32", v2i32, v2f32, NEONvcgt, 0>;
1653 def VCGTfq : N3VQ<1,0,0b10,0b1110,0, IIC_VBINQ, "vcgt.f32", v4i32, v4f32, NEONvcgt, 0>;
1654 // VACGE : Vector Absolute Compare Greater Than or Equal (aka VCAGE)
1655 def VACGEd : N3VDInt<1, 0, 0b00, 0b1110, 1, IIC_VBIND, "vacge.f32", v2i32, v2f32,
1656 int_arm_neon_vacged, 0>;
1657 def VACGEq : N3VQInt<1, 0, 0b00, 0b1110, 1, IIC_VBINQ, "vacge.f32", v4i32, v4f32,
1658 int_arm_neon_vacgeq, 0>;
1659 // VACGT : Vector Absolute Compare Greater Than (aka VCAGT)
1660 def VACGTd : N3VDInt<1, 0, 0b10, 0b1110, 1, IIC_VBIND, "vacgt.f32", v2i32, v2f32,
1661 int_arm_neon_vacgtd, 0>;
1662 def VACGTq : N3VQInt<1, 0, 0b10, 0b1110, 1, IIC_VBINQ, "vacgt.f32", v4i32, v4f32,
1663 int_arm_neon_vacgtq, 0>;
1664 // VTST : Vector Test Bits
1665 defm VTST : N3V_QHS<0, 0, 0b1000, 1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1666 IIC_VBINi4Q, "vtst.i", NEONvtst, 1>;
1668 // Vector Bitwise Operations.
1670 // VAND : Vector Bitwise AND
1671 def VANDd : N3VD<0, 0, 0b00, 0b0001, 1, IIC_VBINiD, "vand", v2i32, v2i32, and, 1>;
1672 def VANDq : N3VQ<0, 0, 0b00, 0b0001, 1, IIC_VBINiQ, "vand", v4i32, v4i32, and, 1>;
1674 // VEOR : Vector Bitwise Exclusive OR
1675 def VEORd : N3VD<1, 0, 0b00, 0b0001, 1, IIC_VBINiD, "veor", v2i32, v2i32, xor, 1>;
1676 def VEORq : N3VQ<1, 0, 0b00, 0b0001, 1, IIC_VBINiQ, "veor", v4i32, v4i32, xor, 1>;
1678 // VORR : Vector Bitwise OR
1679 def VORRd : N3VD<0, 0, 0b10, 0b0001, 1, IIC_VBINiD, "vorr", v2i32, v2i32, or, 1>;
1680 def VORRq : N3VQ<0, 0, 0b10, 0b0001, 1, IIC_VBINiQ, "vorr", v4i32, v4i32, or, 1>;
1682 // VBIC : Vector Bitwise Bit Clear (AND NOT)
1683 def VBICd : N3V<0, 0, 0b01, 0b0001, 0, 1, (outs DPR:$dst),
1684 (ins DPR:$src1, DPR:$src2), IIC_VBINiD,
1685 "vbic\t$dst, $src1, $src2", "",
1686 [(set DPR:$dst, (v2i32 (and DPR:$src1,
1687 (vnot_conv DPR:$src2))))]>;
1688 def VBICq : N3V<0, 0, 0b01, 0b0001, 1, 1, (outs QPR:$dst),
1689 (ins QPR:$src1, QPR:$src2), IIC_VBINiQ,
1690 "vbic\t$dst, $src1, $src2", "",
1691 [(set QPR:$dst, (v4i32 (and QPR:$src1,
1692 (vnot_conv QPR:$src2))))]>;
1694 // VORN : Vector Bitwise OR NOT
1695 def VORNd : N3V<0, 0, 0b11, 0b0001, 0, 1, (outs DPR:$dst),
1696 (ins DPR:$src1, DPR:$src2), IIC_VBINiD,
1697 "vorn\t$dst, $src1, $src2", "",
1698 [(set DPR:$dst, (v2i32 (or DPR:$src1,
1699 (vnot_conv DPR:$src2))))]>;
1700 def VORNq : N3V<0, 0, 0b11, 0b0001, 1, 1, (outs QPR:$dst),
1701 (ins QPR:$src1, QPR:$src2), IIC_VBINiQ,
1702 "vorn\t$dst, $src1, $src2", "",
1703 [(set QPR:$dst, (v4i32 (or QPR:$src1,
1704 (vnot_conv QPR:$src2))))]>;
1706 // VMVN : Vector Bitwise NOT
1707 def VMVNd : N2V<0b11, 0b11, 0b00, 0b00, 0b01011, 0, 0,
1708 (outs DPR:$dst), (ins DPR:$src), IIC_VSHLiD,
1709 "vmvn\t$dst, $src", "",
1710 [(set DPR:$dst, (v2i32 (vnot DPR:$src)))]>;
1711 def VMVNq : N2V<0b11, 0b11, 0b00, 0b00, 0b01011, 1, 0,
1712 (outs QPR:$dst), (ins QPR:$src), IIC_VSHLiD,
1713 "vmvn\t$dst, $src", "",
1714 [(set QPR:$dst, (v4i32 (vnot QPR:$src)))]>;
1715 def : Pat<(v2i32 (vnot_conv DPR:$src)), (VMVNd DPR:$src)>;
1716 def : Pat<(v4i32 (vnot_conv QPR:$src)), (VMVNq QPR:$src)>;
1718 // VBSL : Vector Bitwise Select
1719 def VBSLd : N3V<1, 0, 0b01, 0b0001, 0, 1, (outs DPR:$dst),
1720 (ins DPR:$src1, DPR:$src2, DPR:$src3), IIC_VCNTiD,
1721 "vbsl\t$dst, $src2, $src3", "$src1 = $dst",
1723 (v2i32 (or (and DPR:$src2, DPR:$src1),
1724 (and DPR:$src3, (vnot_conv DPR:$src1)))))]>;
1725 def VBSLq : N3V<1, 0, 0b01, 0b0001, 1, 1, (outs QPR:$dst),
1726 (ins QPR:$src1, QPR:$src2, QPR:$src3), IIC_VCNTiQ,
1727 "vbsl\t$dst, $src2, $src3", "$src1 = $dst",
1729 (v4i32 (or (and QPR:$src2, QPR:$src1),
1730 (and QPR:$src3, (vnot_conv QPR:$src1)))))]>;
1732 // VBIF : Vector Bitwise Insert if False
1733 // like VBSL but with: "vbif\t$dst, $src3, $src1", "$src2 = $dst",
1734 // VBIT : Vector Bitwise Insert if True
1735 // like VBSL but with: "vbit\t$dst, $src2, $src1", "$src3 = $dst",
1736 // These are not yet implemented. The TwoAddress pass will not go looking
1737 // for equivalent operations with different register constraints; it just
1740 // Vector Absolute Differences.
1742 // VABD : Vector Absolute Difference
1743 defm VABDs : N3VInt_QHS<0, 0, 0b0111, 0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1744 IIC_VBINi4Q, "vabd.s", int_arm_neon_vabds, 0>;
1745 defm VABDu : N3VInt_QHS<1, 0, 0b0111, 0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1746 IIC_VBINi4Q, "vabd.u", int_arm_neon_vabdu, 0>;
1747 def VABDfd : N3VDInt<1, 0, 0b10, 0b1101, 0, IIC_VBIND, "vabd.f32", v2f32, v2f32,
1748 int_arm_neon_vabds, 0>;
1749 def VABDfq : N3VQInt<1, 0, 0b10, 0b1101, 0, IIC_VBINQ, "vabd.f32", v4f32, v4f32,
1750 int_arm_neon_vabds, 0>;
1752 // VABDL : Vector Absolute Difference Long (Q = | D - D |)
1753 defm VABDLs : N3VLInt_QHS<0,1,0b0111,0, IIC_VBINi4Q, "vabdl.s", int_arm_neon_vabdls, 0>;
1754 defm VABDLu : N3VLInt_QHS<1,1,0b0111,0, IIC_VBINi4Q, "vabdl.u", int_arm_neon_vabdlu, 0>;
1756 // VABA : Vector Absolute Difference and Accumulate
1757 defm VABAs : N3VInt3_QHS<0,1,0b0101,0, "vaba.s", int_arm_neon_vabas>;
1758 defm VABAu : N3VInt3_QHS<1,1,0b0101,0, "vaba.u", int_arm_neon_vabau>;
1760 // VABAL : Vector Absolute Difference and Accumulate Long (Q += | D - D |)
1761 defm VABALs : N3VLInt3_QHS<0,1,0b0101,0, "vabal.s", int_arm_neon_vabals>;
1762 defm VABALu : N3VLInt3_QHS<1,1,0b0101,0, "vabal.u", int_arm_neon_vabalu>;
1764 // Vector Maximum and Minimum.
1766 // VMAX : Vector Maximum
1767 defm VMAXs : N3VInt_QHS<0, 0, 0b0110, 0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1768 IIC_VBINi4Q, "vmax.s", int_arm_neon_vmaxs, 1>;
1769 defm VMAXu : N3VInt_QHS<1, 0, 0b0110, 0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1770 IIC_VBINi4Q, "vmax.u", int_arm_neon_vmaxu, 1>;
1771 def VMAXfd : N3VDInt<0, 0, 0b00, 0b1111, 0, IIC_VBIND, "vmax.f32", v2f32, v2f32,
1772 int_arm_neon_vmaxs, 1>;
1773 def VMAXfq : N3VQInt<0, 0, 0b00, 0b1111, 0, IIC_VBINQ, "vmax.f32", v4f32, v4f32,
1774 int_arm_neon_vmaxs, 1>;
1776 // VMIN : Vector Minimum
1777 defm VMINs : N3VInt_QHS<0, 0, 0b0110, 1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1778 IIC_VBINi4Q, "vmin.s", int_arm_neon_vmins, 1>;
1779 defm VMINu : N3VInt_QHS<1, 0, 0b0110, 1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
1780 IIC_VBINi4Q, "vmin.u", int_arm_neon_vminu, 1>;
1781 def VMINfd : N3VDInt<0, 0, 0b10, 0b1111, 0, IIC_VBIND, "vmin.f32", v2f32, v2f32,
1782 int_arm_neon_vmins, 1>;
1783 def VMINfq : N3VQInt<0, 0, 0b10, 0b1111, 0, IIC_VBINQ, "vmin.f32", v4f32, v4f32,
1784 int_arm_neon_vmins, 1>;
1786 // Vector Pairwise Operations.
1788 // VPADD : Vector Pairwise Add
1789 def VPADDi8 : N3VDInt<0, 0, 0b00, 0b1011, 1, IIC_VBINiD, "vpadd.i8", v8i8, v8i8,
1790 int_arm_neon_vpadd, 0>;
1791 def VPADDi16 : N3VDInt<0, 0, 0b01, 0b1011, 1, IIC_VBINiD, "vpadd.i16", v4i16, v4i16,
1792 int_arm_neon_vpadd, 0>;
1793 def VPADDi32 : N3VDInt<0, 0, 0b10, 0b1011, 1, IIC_VBINiD, "vpadd.i32", v2i32, v2i32,
1794 int_arm_neon_vpadd, 0>;
1795 def VPADDf : N3VDInt<1, 0, 0b00, 0b1101, 0, IIC_VBIND, "vpadd.f32", v2f32, v2f32,
1796 int_arm_neon_vpadd, 0>;
1798 // VPADDL : Vector Pairwise Add Long
1799 defm VPADDLs : N2VPLInt_QHS<0b11, 0b11, 0b00, 0b00100, 0, "vpaddl.s",
1800 int_arm_neon_vpaddls>;
1801 defm VPADDLu : N2VPLInt_QHS<0b11, 0b11, 0b00, 0b00101, 0, "vpaddl.u",
1802 int_arm_neon_vpaddlu>;
1804 // VPADAL : Vector Pairwise Add and Accumulate Long
1805 defm VPADALs : N2VPLInt2_QHS<0b11, 0b11, 0b00, 0b00100, 0, "vpadal.s",
1806 int_arm_neon_vpadals>;
1807 defm VPADALu : N2VPLInt2_QHS<0b11, 0b11, 0b00, 0b00101, 0, "vpadal.u",
1808 int_arm_neon_vpadalu>;
1810 // VPMAX : Vector Pairwise Maximum
1811 def VPMAXs8 : N3VDInt<0, 0, 0b00, 0b1010, 0, IIC_VBINi4D, "vpmax.s8", v8i8, v8i8,
1812 int_arm_neon_vpmaxs, 0>;
1813 def VPMAXs16 : N3VDInt<0, 0, 0b01, 0b1010, 0, IIC_VBINi4D, "vpmax.s16", v4i16, v4i16,
1814 int_arm_neon_vpmaxs, 0>;
1815 def VPMAXs32 : N3VDInt<0, 0, 0b10, 0b1010, 0, IIC_VBINi4D, "vpmax.s32", v2i32, v2i32,
1816 int_arm_neon_vpmaxs, 0>;
1817 def VPMAXu8 : N3VDInt<1, 0, 0b00, 0b1010, 0, IIC_VBINi4D, "vpmax.u8", v8i8, v8i8,
1818 int_arm_neon_vpmaxu, 0>;
1819 def VPMAXu16 : N3VDInt<1, 0, 0b01, 0b1010, 0, IIC_VBINi4D, "vpmax.u16", v4i16, v4i16,
1820 int_arm_neon_vpmaxu, 0>;
1821 def VPMAXu32 : N3VDInt<1, 0, 0b10, 0b1010, 0, IIC_VBINi4D, "vpmax.u32", v2i32, v2i32,
1822 int_arm_neon_vpmaxu, 0>;
1823 def VPMAXf : N3VDInt<1, 0, 0b00, 0b1111, 0, IIC_VBINi4D, "vpmax.f32", v2f32, v2f32,
1824 int_arm_neon_vpmaxs, 0>;
1826 // VPMIN : Vector Pairwise Minimum
1827 def VPMINs8 : N3VDInt<0, 0, 0b00, 0b1010, 1, IIC_VBINi4D, "vpmin.s8", v8i8, v8i8,
1828 int_arm_neon_vpmins, 0>;
1829 def VPMINs16 : N3VDInt<0, 0, 0b01, 0b1010, 1, IIC_VBINi4D, "vpmin.s16", v4i16, v4i16,
1830 int_arm_neon_vpmins, 0>;
1831 def VPMINs32 : N3VDInt<0, 0, 0b10, 0b1010, 1, IIC_VBINi4D, "vpmin.s32", v2i32, v2i32,
1832 int_arm_neon_vpmins, 0>;
1833 def VPMINu8 : N3VDInt<1, 0, 0b00, 0b1010, 1, IIC_VBINi4D, "vpmin.u8", v8i8, v8i8,
1834 int_arm_neon_vpminu, 0>;
1835 def VPMINu16 : N3VDInt<1, 0, 0b01, 0b1010, 1, IIC_VBINi4D, "vpmin.u16", v4i16, v4i16,
1836 int_arm_neon_vpminu, 0>;
1837 def VPMINu32 : N3VDInt<1, 0, 0b10, 0b1010, 1, IIC_VBINi4D, "vpmin.u32", v2i32, v2i32,
1838 int_arm_neon_vpminu, 0>;
1839 def VPMINf : N3VDInt<1, 0, 0b10, 0b1111, 0, IIC_VBINi4D, "vpmin.f32", v2f32, v2f32,
1840 int_arm_neon_vpmins, 0>;
1842 // Vector Reciprocal and Reciprocal Square Root Estimate and Step.
1844 // VRECPE : Vector Reciprocal Estimate
1845 def VRECPEd : N2VDInt<0b11, 0b11, 0b10, 0b11, 0b01000, 0,
1846 IIC_VUNAD, "vrecpe.u32",
1847 v2i32, v2i32, int_arm_neon_vrecpe>;
1848 def VRECPEq : N2VQInt<0b11, 0b11, 0b10, 0b11, 0b01000, 0,
1849 IIC_VUNAQ, "vrecpe.u32",
1850 v4i32, v4i32, int_arm_neon_vrecpe>;
1851 def VRECPEfd : N2VDInt<0b11, 0b11, 0b10, 0b11, 0b01010, 0,
1852 IIC_VUNAD, "vrecpe.f32",
1853 v2f32, v2f32, int_arm_neon_vrecpe>;
1854 def VRECPEfq : N2VQInt<0b11, 0b11, 0b10, 0b11, 0b01010, 0,
1855 IIC_VUNAQ, "vrecpe.f32",
1856 v4f32, v4f32, int_arm_neon_vrecpe>;
1858 // VRECPS : Vector Reciprocal Step
1859 def VRECPSfd : N3VDInt<0, 0, 0b00, 0b1111, 1, IIC_VRECSD, "vrecps.f32", v2f32, v2f32,
1860 int_arm_neon_vrecps, 1>;
1861 def VRECPSfq : N3VQInt<0, 0, 0b00, 0b1111, 1, IIC_VRECSQ, "vrecps.f32", v4f32, v4f32,
1862 int_arm_neon_vrecps, 1>;
1864 // VRSQRTE : Vector Reciprocal Square Root Estimate
1865 def VRSQRTEd : N2VDInt<0b11, 0b11, 0b10, 0b11, 0b01001, 0,
1866 IIC_VUNAD, "vrsqrte.u32",
1867 v2i32, v2i32, int_arm_neon_vrsqrte>;
1868 def VRSQRTEq : N2VQInt<0b11, 0b11, 0b10, 0b11, 0b01001, 0,
1869 IIC_VUNAQ, "vrsqrte.u32",
1870 v4i32, v4i32, int_arm_neon_vrsqrte>;
1871 def VRSQRTEfd : N2VDInt<0b11, 0b11, 0b10, 0b11, 0b01011, 0,
1872 IIC_VUNAD, "vrsqrte.f32",
1873 v2f32, v2f32, int_arm_neon_vrsqrte>;
1874 def VRSQRTEfq : N2VQInt<0b11, 0b11, 0b10, 0b11, 0b01011, 0,
1875 IIC_VUNAQ, "vrsqrte.f32",
1876 v4f32, v4f32, int_arm_neon_vrsqrte>;
1878 // VRSQRTS : Vector Reciprocal Square Root Step
1879 def VRSQRTSfd : N3VDInt<0, 0, 0b10, 0b1111, 1, IIC_VRECSD, "vrsqrts.f32", v2f32, v2f32,
1880 int_arm_neon_vrsqrts, 1>;
1881 def VRSQRTSfq : N3VQInt<0, 0, 0b10, 0b1111, 1, IIC_VRECSQ, "vrsqrts.f32", v4f32, v4f32,
1882 int_arm_neon_vrsqrts, 1>;
1886 // VSHL : Vector Shift
1887 defm VSHLs : N3VInt_QHSD<0, 0, 0b0100, 0, IIC_VSHLiD, IIC_VSHLiD, IIC_VSHLiQ,
1888 IIC_VSHLiQ, "vshl.s", int_arm_neon_vshifts, 0>;
1889 defm VSHLu : N3VInt_QHSD<1, 0, 0b0100, 0, IIC_VSHLiD, IIC_VSHLiD, IIC_VSHLiQ,
1890 IIC_VSHLiQ, "vshl.u", int_arm_neon_vshiftu, 0>;
1891 // VSHL : Vector Shift Left (Immediate)
1892 defm VSHLi : N2VSh_QHSD<0, 1, 0b0111, 1, IIC_VSHLiD, "vshl.i", NEONvshl>;
1893 // VSHR : Vector Shift Right (Immediate)
1894 defm VSHRs : N2VSh_QHSD<0, 1, 0b0000, 1, IIC_VSHLiD, "vshr.s", NEONvshrs>;
1895 defm VSHRu : N2VSh_QHSD<1, 1, 0b0000, 1, IIC_VSHLiD, "vshr.u", NEONvshru>;
1897 // VSHLL : Vector Shift Left Long
1898 def VSHLLs8 : N2VLSh<0, 1, 0b001000, 0b1010, 0, 0, 1, "vshll.s8",
1899 v8i16, v8i8, NEONvshlls>;
1900 def VSHLLs16 : N2VLSh<0, 1, 0b010000, 0b1010, 0, 0, 1, "vshll.s16",
1901 v4i32, v4i16, NEONvshlls>;
1902 def VSHLLs32 : N2VLSh<0, 1, 0b100000, 0b1010, 0, 0, 1, "vshll.s32",
1903 v2i64, v2i32, NEONvshlls>;
1904 def VSHLLu8 : N2VLSh<1, 1, 0b001000, 0b1010, 0, 0, 1, "vshll.u8",
1905 v8i16, v8i8, NEONvshllu>;
1906 def VSHLLu16 : N2VLSh<1, 1, 0b010000, 0b1010, 0, 0, 1, "vshll.u16",
1907 v4i32, v4i16, NEONvshllu>;
1908 def VSHLLu32 : N2VLSh<1, 1, 0b100000, 0b1010, 0, 0, 1, "vshll.u32",
1909 v2i64, v2i32, NEONvshllu>;
1911 // VSHLL : Vector Shift Left Long (with maximum shift count)
1912 def VSHLLi8 : N2VLSh<1, 1, 0b110010, 0b0011, 0, 0, 0, "vshll.i8",
1913 v8i16, v8i8, NEONvshlli>;
1914 def VSHLLi16 : N2VLSh<1, 1, 0b110110, 0b0011, 0, 0, 0, "vshll.i16",
1915 v4i32, v4i16, NEONvshlli>;
1916 def VSHLLi32 : N2VLSh<1, 1, 0b111010, 0b0011, 0, 0, 0, "vshll.i32",
1917 v2i64, v2i32, NEONvshlli>;
1919 // VSHRN : Vector Shift Right and Narrow
1920 def VSHRN16 : N2VNSh<0, 1, 0b001000, 0b1000, 0, 0, 1,
1921 IIC_VSHLiD, "vshrn.i16", v8i8, v8i16, NEONvshrn>;
1922 def VSHRN32 : N2VNSh<0, 1, 0b010000, 0b1000, 0, 0, 1,
1923 IIC_VSHLiD, "vshrn.i32", v4i16, v4i32, NEONvshrn>;
1924 def VSHRN64 : N2VNSh<0, 1, 0b100000, 0b1000, 0, 0, 1,
1925 IIC_VSHLiD, "vshrn.i64", v2i32, v2i64, NEONvshrn>;
1927 // VRSHL : Vector Rounding Shift
1928 defm VRSHLs : N3VInt_QHSD<0,0,0b0101,0, IIC_VSHLi4D, IIC_VSHLi4D, IIC_VSHLi4Q,
1929 IIC_VSHLi4Q, "vrshl.s", int_arm_neon_vrshifts, 0>;
1930 defm VRSHLu : N3VInt_QHSD<1,0,0b0101,0, IIC_VSHLi4D, IIC_VSHLi4D, IIC_VSHLi4Q,
1931 IIC_VSHLi4Q, "vrshl.u", int_arm_neon_vrshiftu, 0>;
1932 // VRSHR : Vector Rounding Shift Right
1933 defm VRSHRs : N2VSh_QHSD<0, 1, 0b0010, 1, IIC_VSHLi4D, "vrshr.s", NEONvrshrs>;
1934 defm VRSHRu : N2VSh_QHSD<1, 1, 0b0010, 1, IIC_VSHLi4D, "vrshr.u", NEONvrshru>;
1936 // VRSHRN : Vector Rounding Shift Right and Narrow
1937 def VRSHRN16 : N2VNSh<0, 1, 0b001000, 0b1000, 0, 1, 1,
1938 IIC_VSHLi4D, "vrshrn.i16", v8i8, v8i16, NEONvrshrn>;
1939 def VRSHRN32 : N2VNSh<0, 1, 0b010000, 0b1000, 0, 1, 1,
1940 IIC_VSHLi4D, "vrshrn.i32", v4i16, v4i32, NEONvrshrn>;
1941 def VRSHRN64 : N2VNSh<0, 1, 0b100000, 0b1000, 0, 1, 1,
1942 IIC_VSHLi4D, "vrshrn.i64", v2i32, v2i64, NEONvrshrn>;
1944 // VQSHL : Vector Saturating Shift
1945 defm VQSHLs : N3VInt_QHSD<0,0,0b0100,1, IIC_VSHLi4D, IIC_VSHLi4D, IIC_VSHLi4Q,
1946 IIC_VSHLi4Q, "vqshl.s", int_arm_neon_vqshifts, 0>;
1947 defm VQSHLu : N3VInt_QHSD<1,0,0b0100,1, IIC_VSHLi4D, IIC_VSHLi4D, IIC_VSHLi4Q,
1948 IIC_VSHLi4Q, "vqshl.u", int_arm_neon_vqshiftu, 0>;
1949 // VQSHL : Vector Saturating Shift Left (Immediate)
1950 defm VQSHLsi : N2VSh_QHSD<0, 1, 0b0111, 1, IIC_VSHLi4D, "vqshl.s", NEONvqshls>;
1951 defm VQSHLui : N2VSh_QHSD<1, 1, 0b0111, 1, IIC_VSHLi4D, "vqshl.u", NEONvqshlu>;
1952 // VQSHLU : Vector Saturating Shift Left (Immediate, Unsigned)
1953 defm VQSHLsu : N2VSh_QHSD<1, 1, 0b0110, 1, IIC_VSHLi4D, "vqshlu.s", NEONvqshlsu>;
1955 // VQSHRN : Vector Saturating Shift Right and Narrow
1956 def VQSHRNs16 : N2VNSh<0, 1, 0b001000, 0b1001, 0, 0, 1,
1957 IIC_VSHLi4D, "vqshrn.s16", v8i8, v8i16, NEONvqshrns>;
1958 def VQSHRNs32 : N2VNSh<0, 1, 0b010000, 0b1001, 0, 0, 1,
1959 IIC_VSHLi4D, "vqshrn.s32", v4i16, v4i32, NEONvqshrns>;
1960 def VQSHRNs64 : N2VNSh<0, 1, 0b100000, 0b1001, 0, 0, 1,
1961 IIC_VSHLi4D, "vqshrn.s64", v2i32, v2i64, NEONvqshrns>;
1962 def VQSHRNu16 : N2VNSh<1, 1, 0b001000, 0b1001, 0, 0, 1,
1963 IIC_VSHLi4D, "vqshrn.u16", v8i8, v8i16, NEONvqshrnu>;
1964 def VQSHRNu32 : N2VNSh<1, 1, 0b010000, 0b1001, 0, 0, 1,
1965 IIC_VSHLi4D, "vqshrn.u32", v4i16, v4i32, NEONvqshrnu>;
1966 def VQSHRNu64 : N2VNSh<1, 1, 0b100000, 0b1001, 0, 0, 1,
1967 IIC_VSHLi4D, "vqshrn.u64", v2i32, v2i64, NEONvqshrnu>;
1969 // VQSHRUN : Vector Saturating Shift Right and Narrow (Unsigned)
1970 def VQSHRUN16 : N2VNSh<1, 1, 0b001000, 0b1000, 0, 0, 1,
1971 IIC_VSHLi4D, "vqshrun.s16", v8i8, v8i16, NEONvqshrnsu>;
1972 def VQSHRUN32 : N2VNSh<1, 1, 0b010000, 0b1000, 0, 0, 1,
1973 IIC_VSHLi4D, "vqshrun.s32", v4i16, v4i32, NEONvqshrnsu>;
1974 def VQSHRUN64 : N2VNSh<1, 1, 0b100000, 0b1000, 0, 0, 1,
1975 IIC_VSHLi4D, "vqshrun.s64", v2i32, v2i64, NEONvqshrnsu>;
1977 // VQRSHL : Vector Saturating Rounding Shift
1978 defm VQRSHLs : N3VInt_QHSD<0, 0, 0b0101, 1, IIC_VSHLi4D, IIC_VSHLi4D, IIC_VSHLi4Q,
1979 IIC_VSHLi4Q, "vqrshl.s", int_arm_neon_vqrshifts, 0>;
1980 defm VQRSHLu : N3VInt_QHSD<1, 0, 0b0101, 1, IIC_VSHLi4D, IIC_VSHLi4D, IIC_VSHLi4Q,
1981 IIC_VSHLi4Q, "vqrshl.u", int_arm_neon_vqrshiftu, 0>;
1983 // VQRSHRN : Vector Saturating Rounding Shift Right and Narrow
1984 def VQRSHRNs16: N2VNSh<0, 1, 0b001000, 0b1001, 0, 1, 1,
1985 IIC_VSHLi4D, "vqrshrn.s16", v8i8, v8i16, NEONvqrshrns>;
1986 def VQRSHRNs32: N2VNSh<0, 1, 0b010000, 0b1001, 0, 1, 1,
1987 IIC_VSHLi4D, "vqrshrn.s32", v4i16, v4i32, NEONvqrshrns>;
1988 def VQRSHRNs64: N2VNSh<0, 1, 0b100000, 0b1001, 0, 1, 1,
1989 IIC_VSHLi4D, "vqrshrn.s64", v2i32, v2i64, NEONvqrshrns>;
1990 def VQRSHRNu16: N2VNSh<1, 1, 0b001000, 0b1001, 0, 1, 1,
1991 IIC_VSHLi4D, "vqrshrn.u16", v8i8, v8i16, NEONvqrshrnu>;
1992 def VQRSHRNu32: N2VNSh<1, 1, 0b010000, 0b1001, 0, 1, 1,
1993 IIC_VSHLi4D, "vqrshrn.u32", v4i16, v4i32, NEONvqrshrnu>;
1994 def VQRSHRNu64: N2VNSh<1, 1, 0b100000, 0b1001, 0, 1, 1,
1995 IIC_VSHLi4D, "vqrshrn.u64", v2i32, v2i64, NEONvqrshrnu>;
1997 // VQRSHRUN : Vector Saturating Rounding Shift Right and Narrow (Unsigned)
1998 def VQRSHRUN16: N2VNSh<1, 1, 0b001000, 0b1000, 0, 1, 1,
1999 IIC_VSHLi4D, "vqrshrun.s16", v8i8, v8i16, NEONvqrshrnsu>;
2000 def VQRSHRUN32: N2VNSh<1, 1, 0b010000, 0b1000, 0, 1, 1,
2001 IIC_VSHLi4D, "vqrshrun.s32", v4i16, v4i32, NEONvqrshrnsu>;
2002 def VQRSHRUN64: N2VNSh<1, 1, 0b100000, 0b1000, 0, 1, 1,
2003 IIC_VSHLi4D, "vqrshrun.s64", v2i32, v2i64, NEONvqrshrnsu>;
2005 // VSRA : Vector Shift Right and Accumulate
2006 defm VSRAs : N2VShAdd_QHSD<0, 1, 0b0001, 1, "vsra.s", NEONvshrs>;
2007 defm VSRAu : N2VShAdd_QHSD<1, 1, 0b0001, 1, "vsra.u", NEONvshru>;
2008 // VRSRA : Vector Rounding Shift Right and Accumulate
2009 defm VRSRAs : N2VShAdd_QHSD<0, 1, 0b0011, 1, "vrsra.s", NEONvrshrs>;
2010 defm VRSRAu : N2VShAdd_QHSD<1, 1, 0b0011, 1, "vrsra.u", NEONvrshru>;
2012 // VSLI : Vector Shift Left and Insert
2013 defm VSLI : N2VShIns_QHSD<1, 1, 0b0101, 1, "vsli.", NEONvsli>;
2014 // VSRI : Vector Shift Right and Insert
2015 defm VSRI : N2VShIns_QHSD<1, 1, 0b0100, 1, "vsri.", NEONvsri>;
2017 // Vector Absolute and Saturating Absolute.
2019 // VABS : Vector Absolute Value
2020 defm VABS : N2VInt_QHS<0b11, 0b11, 0b01, 0b00110, 0,
2021 IIC_VUNAiD, IIC_VUNAiQ, "vabs.s",
2023 def VABSfd : N2VDInt<0b11, 0b11, 0b10, 0b01, 0b01110, 0,
2024 IIC_VUNAD, "vabs.f32",
2025 v2f32, v2f32, int_arm_neon_vabs>;
2026 def VABSfq : N2VQInt<0b11, 0b11, 0b10, 0b01, 0b01110, 0,
2027 IIC_VUNAQ, "vabs.f32",
2028 v4f32, v4f32, int_arm_neon_vabs>;
2030 // VQABS : Vector Saturating Absolute Value
2031 defm VQABS : N2VInt_QHS<0b11, 0b11, 0b00, 0b01110, 0,
2032 IIC_VQUNAiD, IIC_VQUNAiQ, "vqabs.s",
2033 int_arm_neon_vqabs>;
2037 def vneg : PatFrag<(ops node:$in), (sub immAllZerosV, node:$in)>;
2038 def vneg_conv : PatFrag<(ops node:$in), (sub immAllZerosV_bc, node:$in)>;
2040 class VNEGD<bits<2> size, string OpcodeStr, ValueType Ty>
2041 : N2V<0b11, 0b11, size, 0b01, 0b00111, 0, 0, (outs DPR:$dst), (ins DPR:$src),
2042 IIC_VSHLiD, !strconcat(OpcodeStr, "\t$dst, $src"), "",
2043 [(set DPR:$dst, (Ty (vneg DPR:$src)))]>;
2044 class VNEGQ<bits<2> size, string OpcodeStr, ValueType Ty>
2045 : N2V<0b11, 0b11, size, 0b01, 0b00111, 1, 0, (outs QPR:$dst), (ins QPR:$src),
2046 IIC_VSHLiD, !strconcat(OpcodeStr, "\t$dst, $src"), "",
2047 [(set QPR:$dst, (Ty (vneg QPR:$src)))]>;
2049 // VNEG : Vector Negate
2050 def VNEGs8d : VNEGD<0b00, "vneg.s8", v8i8>;
2051 def VNEGs16d : VNEGD<0b01, "vneg.s16", v4i16>;
2052 def VNEGs32d : VNEGD<0b10, "vneg.s32", v2i32>;
2053 def VNEGs8q : VNEGQ<0b00, "vneg.s8", v16i8>;
2054 def VNEGs16q : VNEGQ<0b01, "vneg.s16", v8i16>;
2055 def VNEGs32q : VNEGQ<0b10, "vneg.s32", v4i32>;
2057 // VNEG : Vector Negate (floating-point)
2058 def VNEGf32d : N2V<0b11, 0b11, 0b10, 0b01, 0b01111, 0, 0,
2059 (outs DPR:$dst), (ins DPR:$src), IIC_VUNAD,
2060 "vneg.f32\t$dst, $src", "",
2061 [(set DPR:$dst, (v2f32 (fneg DPR:$src)))]>;
2062 def VNEGf32q : N2V<0b11, 0b11, 0b10, 0b01, 0b01111, 1, 0,
2063 (outs QPR:$dst), (ins QPR:$src), IIC_VUNAQ,
2064 "vneg.f32\t$dst, $src", "",
2065 [(set QPR:$dst, (v4f32 (fneg QPR:$src)))]>;
2067 def : Pat<(v8i8 (vneg_conv DPR:$src)), (VNEGs8d DPR:$src)>;
2068 def : Pat<(v4i16 (vneg_conv DPR:$src)), (VNEGs16d DPR:$src)>;
2069 def : Pat<(v2i32 (vneg_conv DPR:$src)), (VNEGs32d DPR:$src)>;
2070 def : Pat<(v16i8 (vneg_conv QPR:$src)), (VNEGs8q QPR:$src)>;
2071 def : Pat<(v8i16 (vneg_conv QPR:$src)), (VNEGs16q QPR:$src)>;
2072 def : Pat<(v4i32 (vneg_conv QPR:$src)), (VNEGs32q QPR:$src)>;
2074 // VQNEG : Vector Saturating Negate
2075 defm VQNEG : N2VInt_QHS<0b11, 0b11, 0b00, 0b01111, 0,
2076 IIC_VQUNAiD, IIC_VQUNAiQ, "vqneg.s",
2077 int_arm_neon_vqneg>;
2079 // Vector Bit Counting Operations.
2081 // VCLS : Vector Count Leading Sign Bits
2082 defm VCLS : N2VInt_QHS<0b11, 0b11, 0b00, 0b01000, 0,
2083 IIC_VCNTiD, IIC_VCNTiQ, "vcls.s",
2085 // VCLZ : Vector Count Leading Zeros
2086 defm VCLZ : N2VInt_QHS<0b11, 0b11, 0b00, 0b01001, 0,
2087 IIC_VCNTiD, IIC_VCNTiQ, "vclz.i",
2089 // VCNT : Vector Count One Bits
2090 def VCNTd : N2VDInt<0b11, 0b11, 0b00, 0b00, 0b01010, 0,
2091 IIC_VCNTiD, "vcnt.8",
2092 v8i8, v8i8, int_arm_neon_vcnt>;
2093 def VCNTq : N2VQInt<0b11, 0b11, 0b00, 0b00, 0b01010, 0,
2094 IIC_VCNTiQ, "vcnt.8",
2095 v16i8, v16i8, int_arm_neon_vcnt>;
2097 // Vector Move Operations.
2099 // VMOV : Vector Move (Register)
2101 def VMOVD : N3V<0, 0, 0b10, 0b0001, 0, 1, (outs DPR:$dst), (ins DPR:$src),
2102 IIC_VMOVD, "vmov\t$dst, $src", "", []>;
2103 def VMOVQ : N3V<0, 0, 0b10, 0b0001, 1, 1, (outs QPR:$dst), (ins QPR:$src),
2104 IIC_VMOVD, "vmov\t$dst, $src", "", []>;
2106 // VMOV : Vector Move (Immediate)
2108 // VMOV_get_imm8 xform function: convert build_vector to VMOV.i8 imm.
2109 def VMOV_get_imm8 : SDNodeXForm<build_vector, [{
2110 return ARM::getVMOVImm(N, 1, *CurDAG);
2112 def vmovImm8 : PatLeaf<(build_vector), [{
2113 return ARM::getVMOVImm(N, 1, *CurDAG).getNode() != 0;
2116 // VMOV_get_imm16 xform function: convert build_vector to VMOV.i16 imm.
2117 def VMOV_get_imm16 : SDNodeXForm<build_vector, [{
2118 return ARM::getVMOVImm(N, 2, *CurDAG);
2120 def vmovImm16 : PatLeaf<(build_vector), [{
2121 return ARM::getVMOVImm(N, 2, *CurDAG).getNode() != 0;
2122 }], VMOV_get_imm16>;
2124 // VMOV_get_imm32 xform function: convert build_vector to VMOV.i32 imm.
2125 def VMOV_get_imm32 : SDNodeXForm<build_vector, [{
2126 return ARM::getVMOVImm(N, 4, *CurDAG);
2128 def vmovImm32 : PatLeaf<(build_vector), [{
2129 return ARM::getVMOVImm(N, 4, *CurDAG).getNode() != 0;
2130 }], VMOV_get_imm32>;
2132 // VMOV_get_imm64 xform function: convert build_vector to VMOV.i64 imm.
2133 def VMOV_get_imm64 : SDNodeXForm<build_vector, [{
2134 return ARM::getVMOVImm(N, 8, *CurDAG);
2136 def vmovImm64 : PatLeaf<(build_vector), [{
2137 return ARM::getVMOVImm(N, 8, *CurDAG).getNode() != 0;
2138 }], VMOV_get_imm64>;
2140 // Note: Some of the cmode bits in the following VMOV instructions need to
2141 // be encoded based on the immed values.
2143 def VMOVv8i8 : N1ModImm<1, 0b000, 0b1110, 0, 0, 0, 1, (outs DPR:$dst),
2144 (ins i8imm:$SIMM), IIC_VMOVImm,
2145 "vmov.i8\t$dst, $SIMM", "",
2146 [(set DPR:$dst, (v8i8 vmovImm8:$SIMM))]>;
2147 def VMOVv16i8 : N1ModImm<1, 0b000, 0b1110, 0, 1, 0, 1, (outs QPR:$dst),
2148 (ins i8imm:$SIMM), IIC_VMOVImm,
2149 "vmov.i8\t$dst, $SIMM", "",
2150 [(set QPR:$dst, (v16i8 vmovImm8:$SIMM))]>;
2152 def VMOVv4i16 : N1ModImm<1, 0b000, 0b1000, 0, 0, 0, 1, (outs DPR:$dst),
2153 (ins i16imm:$SIMM), IIC_VMOVImm,
2154 "vmov.i16\t$dst, $SIMM", "",
2155 [(set DPR:$dst, (v4i16 vmovImm16:$SIMM))]>;
2156 def VMOVv8i16 : N1ModImm<1, 0b000, 0b1000, 0, 1, 0, 1, (outs QPR:$dst),
2157 (ins i16imm:$SIMM), IIC_VMOVImm,
2158 "vmov.i16\t$dst, $SIMM", "",
2159 [(set QPR:$dst, (v8i16 vmovImm16:$SIMM))]>;
2161 def VMOVv2i32 : N1ModImm<1, 0b000, 0b0000, 0, 0, 0, 1, (outs DPR:$dst),
2162 (ins i32imm:$SIMM), IIC_VMOVImm,
2163 "vmov.i32\t$dst, $SIMM", "",
2164 [(set DPR:$dst, (v2i32 vmovImm32:$SIMM))]>;
2165 def VMOVv4i32 : N1ModImm<1, 0b000, 0b0000, 0, 1, 0, 1, (outs QPR:$dst),
2166 (ins i32imm:$SIMM), IIC_VMOVImm,
2167 "vmov.i32\t$dst, $SIMM", "",
2168 [(set QPR:$dst, (v4i32 vmovImm32:$SIMM))]>;
2170 def VMOVv1i64 : N1ModImm<1, 0b000, 0b1110, 0, 0, 1, 1, (outs DPR:$dst),
2171 (ins i64imm:$SIMM), IIC_VMOVImm,
2172 "vmov.i64\t$dst, $SIMM", "",
2173 [(set DPR:$dst, (v1i64 vmovImm64:$SIMM))]>;
2174 def VMOVv2i64 : N1ModImm<1, 0b000, 0b1110, 0, 1, 1, 1, (outs QPR:$dst),
2175 (ins i64imm:$SIMM), IIC_VMOVImm,
2176 "vmov.i64\t$dst, $SIMM", "",
2177 [(set QPR:$dst, (v2i64 vmovImm64:$SIMM))]>;
2179 // VMOV : Vector Get Lane (move scalar to ARM core register)
2181 def VGETLNs8 : NVGetLane<0b11100101, 0b1011, 0b00,
2182 (outs GPR:$dst), (ins DPR:$src, nohash_imm:$lane),
2183 IIC_VMOVSI, "vmov", ".s8\t$dst, $src[$lane]",
2184 [(set GPR:$dst, (NEONvgetlanes (v8i8 DPR:$src),
2186 def VGETLNs16 : NVGetLane<0b11100001, 0b1011, 0b01,
2187 (outs GPR:$dst), (ins DPR:$src, nohash_imm:$lane),
2188 IIC_VMOVSI, "vmov", ".s16\t$dst, $src[$lane]",
2189 [(set GPR:$dst, (NEONvgetlanes (v4i16 DPR:$src),
2191 def VGETLNu8 : NVGetLane<0b11101101, 0b1011, 0b00,
2192 (outs GPR:$dst), (ins DPR:$src, nohash_imm:$lane),
2193 IIC_VMOVSI, "vmov", ".u8\t$dst, $src[$lane]",
2194 [(set GPR:$dst, (NEONvgetlaneu (v8i8 DPR:$src),
2196 def VGETLNu16 : NVGetLane<0b11101001, 0b1011, 0b01,
2197 (outs GPR:$dst), (ins DPR:$src, nohash_imm:$lane),
2198 IIC_VMOVSI, "vmov", ".u16\t$dst, $src[$lane]",
2199 [(set GPR:$dst, (NEONvgetlaneu (v4i16 DPR:$src),
2201 def VGETLNi32 : NVGetLane<0b11100001, 0b1011, 0b00,
2202 (outs GPR:$dst), (ins DPR:$src, nohash_imm:$lane),
2203 IIC_VMOVSI, "vmov", ".32\t$dst, $src[$lane]",
2204 [(set GPR:$dst, (extractelt (v2i32 DPR:$src),
2206 // def VGETLNf32: see FMRDH and FMRDL in ARMInstrVFP.td
2207 def : Pat<(NEONvgetlanes (v16i8 QPR:$src), imm:$lane),
2208 (VGETLNs8 (v8i8 (EXTRACT_SUBREG QPR:$src,
2209 (DSubReg_i8_reg imm:$lane))),
2210 (SubReg_i8_lane imm:$lane))>;
2211 def : Pat<(NEONvgetlanes (v8i16 QPR:$src), imm:$lane),
2212 (VGETLNs16 (v4i16 (EXTRACT_SUBREG QPR:$src,
2213 (DSubReg_i16_reg imm:$lane))),
2214 (SubReg_i16_lane imm:$lane))>;
2215 def : Pat<(NEONvgetlaneu (v16i8 QPR:$src), imm:$lane),
2216 (VGETLNu8 (v8i8 (EXTRACT_SUBREG QPR:$src,
2217 (DSubReg_i8_reg imm:$lane))),
2218 (SubReg_i8_lane imm:$lane))>;
2219 def : Pat<(NEONvgetlaneu (v8i16 QPR:$src), imm:$lane),
2220 (VGETLNu16 (v4i16 (EXTRACT_SUBREG QPR:$src,
2221 (DSubReg_i16_reg imm:$lane))),
2222 (SubReg_i16_lane imm:$lane))>;
2223 def : Pat<(extractelt (v4i32 QPR:$src), imm:$lane),
2224 (VGETLNi32 (v2i32 (EXTRACT_SUBREG QPR:$src,
2225 (DSubReg_i32_reg imm:$lane))),
2226 (SubReg_i32_lane imm:$lane))>;
2227 def : Pat<(extractelt (v2f32 DPR:$src1), imm:$src2),
2228 (EXTRACT_SUBREG (COPY_TO_REGCLASS DPR:$src1, DPR_VFP2),
2229 (SSubReg_f32_reg imm:$src2))>;
2230 def : Pat<(extractelt (v4f32 QPR:$src1), imm:$src2),
2231 (EXTRACT_SUBREG (COPY_TO_REGCLASS QPR:$src1, QPR_VFP2),
2232 (SSubReg_f32_reg imm:$src2))>;
2233 //def : Pat<(extractelt (v2i64 QPR:$src1), imm:$src2),
2234 // (EXTRACT_SUBREG QPR:$src1, (DSubReg_f64_reg imm:$src2))>;
2235 def : Pat<(extractelt (v2f64 QPR:$src1), imm:$src2),
2236 (EXTRACT_SUBREG QPR:$src1, (DSubReg_f64_reg imm:$src2))>;
2239 // VMOV : Vector Set Lane (move ARM core register to scalar)
2241 let Constraints = "$src1 = $dst" in {
2242 def VSETLNi8 : NVSetLane<0b11100100, 0b1011, 0b00, (outs DPR:$dst),
2243 (ins DPR:$src1, GPR:$src2, nohash_imm:$lane),
2244 IIC_VMOVISL, "vmov", ".8\t$dst[$lane], $src2",
2245 [(set DPR:$dst, (vector_insert (v8i8 DPR:$src1),
2246 GPR:$src2, imm:$lane))]>;
2247 def VSETLNi16 : NVSetLane<0b11100000, 0b1011, 0b01, (outs DPR:$dst),
2248 (ins DPR:$src1, GPR:$src2, nohash_imm:$lane),
2249 IIC_VMOVISL, "vmov", ".16\t$dst[$lane], $src2",
2250 [(set DPR:$dst, (vector_insert (v4i16 DPR:$src1),
2251 GPR:$src2, imm:$lane))]>;
2252 def VSETLNi32 : NVSetLane<0b11100000, 0b1011, 0b00, (outs DPR:$dst),
2253 (ins DPR:$src1, GPR:$src2, nohash_imm:$lane),
2254 IIC_VMOVISL, "vmov", ".32\t$dst[$lane], $src2",
2255 [(set DPR:$dst, (insertelt (v2i32 DPR:$src1),
2256 GPR:$src2, imm:$lane))]>;
2258 def : Pat<(vector_insert (v16i8 QPR:$src1), GPR:$src2, imm:$lane),
2259 (v16i8 (INSERT_SUBREG QPR:$src1,
2260 (VSETLNi8 (v8i8 (EXTRACT_SUBREG QPR:$src1,
2261 (DSubReg_i8_reg imm:$lane))),
2262 GPR:$src2, (SubReg_i8_lane imm:$lane)),
2263 (DSubReg_i8_reg imm:$lane)))>;
2264 def : Pat<(vector_insert (v8i16 QPR:$src1), GPR:$src2, imm:$lane),
2265 (v8i16 (INSERT_SUBREG QPR:$src1,
2266 (VSETLNi16 (v4i16 (EXTRACT_SUBREG QPR:$src1,
2267 (DSubReg_i16_reg imm:$lane))),
2268 GPR:$src2, (SubReg_i16_lane imm:$lane)),
2269 (DSubReg_i16_reg imm:$lane)))>;
2270 def : Pat<(insertelt (v4i32 QPR:$src1), GPR:$src2, imm:$lane),
2271 (v4i32 (INSERT_SUBREG QPR:$src1,
2272 (VSETLNi32 (v2i32 (EXTRACT_SUBREG QPR:$src1,
2273 (DSubReg_i32_reg imm:$lane))),
2274 GPR:$src2, (SubReg_i32_lane imm:$lane)),
2275 (DSubReg_i32_reg imm:$lane)))>;
2277 def : Pat<(v2f32 (insertelt DPR:$src1, SPR:$src2, imm:$src3)),
2278 (INSERT_SUBREG (COPY_TO_REGCLASS DPR:$src1, DPR_VFP2),
2279 SPR:$src2, (SSubReg_f32_reg imm:$src3))>;
2280 def : Pat<(v4f32 (insertelt QPR:$src1, SPR:$src2, imm:$src3)),
2281 (INSERT_SUBREG (COPY_TO_REGCLASS QPR:$src1, QPR_VFP2),
2282 SPR:$src2, (SSubReg_f32_reg imm:$src3))>;
2284 //def : Pat<(v2i64 (insertelt QPR:$src1, DPR:$src2, imm:$src3)),
2285 // (INSERT_SUBREG QPR:$src1, DPR:$src2, (DSubReg_f64_reg imm:$src3))>;
2286 def : Pat<(v2f64 (insertelt QPR:$src1, DPR:$src2, imm:$src3)),
2287 (INSERT_SUBREG QPR:$src1, DPR:$src2, (DSubReg_f64_reg imm:$src3))>;
2289 def : Pat<(v2f32 (scalar_to_vector SPR:$src)),
2290 (INSERT_SUBREG (v2f32 (IMPLICIT_DEF)), SPR:$src, arm_ssubreg_0)>;
2291 def : Pat<(v2f64 (scalar_to_vector DPR:$src)),
2292 (INSERT_SUBREG (v2f64 (IMPLICIT_DEF)), DPR:$src, arm_dsubreg_0)>;
2293 def : Pat<(v4f32 (scalar_to_vector SPR:$src)),
2294 (INSERT_SUBREG (v4f32 (IMPLICIT_DEF)), SPR:$src, arm_ssubreg_0)>;
2296 def : Pat<(v8i8 (scalar_to_vector GPR:$src)),
2297 (VSETLNi8 (v8i8 (IMPLICIT_DEF)), GPR:$src, (i32 0))>;
2298 def : Pat<(v4i16 (scalar_to_vector GPR:$src)),
2299 (VSETLNi16 (v4i16 (IMPLICIT_DEF)), GPR:$src, (i32 0))>;
2300 def : Pat<(v2i32 (scalar_to_vector GPR:$src)),
2301 (VSETLNi32 (v2i32 (IMPLICIT_DEF)), GPR:$src, (i32 0))>;
2303 def : Pat<(v16i8 (scalar_to_vector GPR:$src)),
2304 (INSERT_SUBREG (v16i8 (IMPLICIT_DEF)),
2305 (VSETLNi8 (v8i8 (IMPLICIT_DEF)), GPR:$src, (i32 0)),
2307 def : Pat<(v8i16 (scalar_to_vector GPR:$src)),
2308 (INSERT_SUBREG (v8i16 (IMPLICIT_DEF)),
2309 (VSETLNi16 (v4i16 (IMPLICIT_DEF)), GPR:$src, (i32 0)),
2311 def : Pat<(v4i32 (scalar_to_vector GPR:$src)),
2312 (INSERT_SUBREG (v4i32 (IMPLICIT_DEF)),
2313 (VSETLNi32 (v2i32 (IMPLICIT_DEF)), GPR:$src, (i32 0)),
2316 // VDUP : Vector Duplicate (from ARM core register to all elements)
2318 class VDUPD<bits<8> opcod1, bits<2> opcod3, string asmSize, ValueType Ty>
2319 : NVDup<opcod1, 0b1011, opcod3, (outs DPR:$dst), (ins GPR:$src),
2320 IIC_VMOVIS, "vdup", !strconcat(asmSize, "\t$dst, $src"),
2321 [(set DPR:$dst, (Ty (NEONvdup (i32 GPR:$src))))]>;
2322 class VDUPQ<bits<8> opcod1, bits<2> opcod3, string asmSize, ValueType Ty>
2323 : NVDup<opcod1, 0b1011, opcod3, (outs QPR:$dst), (ins GPR:$src),
2324 IIC_VMOVIS, "vdup", !strconcat(asmSize, "\t$dst, $src"),
2325 [(set QPR:$dst, (Ty (NEONvdup (i32 GPR:$src))))]>;
2327 def VDUP8d : VDUPD<0b11101100, 0b00, ".8", v8i8>;
2328 def VDUP16d : VDUPD<0b11101000, 0b01, ".16", v4i16>;
2329 def VDUP32d : VDUPD<0b11101000, 0b00, ".32", v2i32>;
2330 def VDUP8q : VDUPQ<0b11101110, 0b00, ".8", v16i8>;
2331 def VDUP16q : VDUPQ<0b11101010, 0b01, ".16", v8i16>;
2332 def VDUP32q : VDUPQ<0b11101010, 0b00, ".32", v4i32>;
2334 def VDUPfd : NVDup<0b11101000, 0b1011, 0b00, (outs DPR:$dst), (ins GPR:$src),
2335 IIC_VMOVIS, "vdup", ".32\t$dst, $src",
2336 [(set DPR:$dst, (v2f32 (NEONvdup
2337 (f32 (bitconvert GPR:$src)))))]>;
2338 def VDUPfq : NVDup<0b11101010, 0b1011, 0b00, (outs QPR:$dst), (ins GPR:$src),
2339 IIC_VMOVIS, "vdup", ".32\t$dst, $src",
2340 [(set QPR:$dst, (v4f32 (NEONvdup
2341 (f32 (bitconvert GPR:$src)))))]>;
2343 // VDUP : Vector Duplicate Lane (from scalar to all elements)
2345 class VDUPLND<bits<2> op19_18, bits<2> op17_16, string OpcodeStr, ValueType Ty>
2346 : N2V<0b11, 0b11, op19_18, op17_16, 0b11000, 0, 0,
2347 (outs DPR:$dst), (ins DPR:$src, nohash_imm:$lane), IIC_VMOVD,
2348 !strconcat(OpcodeStr, "\t$dst, $src[$lane]"), "",
2349 [(set DPR:$dst, (Ty (NEONvduplane (Ty DPR:$src), imm:$lane)))]>;
2351 class VDUPLNQ<bits<2> op19_18, bits<2> op17_16, string OpcodeStr,
2352 ValueType ResTy, ValueType OpTy>
2353 : N2V<0b11, 0b11, op19_18, op17_16, 0b11000, 1, 0,
2354 (outs QPR:$dst), (ins DPR:$src, nohash_imm:$lane), IIC_VMOVD,
2355 !strconcat(OpcodeStr, "\t$dst, $src[$lane]"), "",
2356 [(set QPR:$dst, (ResTy (NEONvduplane (OpTy DPR:$src), imm:$lane)))]>;
2358 def VDUPLN8d : VDUPLND<0b00, 0b01, "vdup.8", v8i8>;
2359 def VDUPLN16d : VDUPLND<0b00, 0b10, "vdup.16", v4i16>;
2360 def VDUPLN32d : VDUPLND<0b01, 0b00, "vdup.32", v2i32>;
2361 def VDUPLNfd : VDUPLND<0b01, 0b00, "vdup.32", v2f32>;
2362 def VDUPLN8q : VDUPLNQ<0b00, 0b01, "vdup.8", v16i8, v8i8>;
2363 def VDUPLN16q : VDUPLNQ<0b00, 0b10, "vdup.16", v8i16, v4i16>;
2364 def VDUPLN32q : VDUPLNQ<0b01, 0b00, "vdup.32", v4i32, v2i32>;
2365 def VDUPLNfq : VDUPLNQ<0b01, 0b00, "vdup.32", v4f32, v2f32>;
2367 def : Pat<(v16i8 (NEONvduplane (v16i8 QPR:$src), imm:$lane)),
2368 (v16i8 (VDUPLN8q (v8i8 (EXTRACT_SUBREG QPR:$src,
2369 (DSubReg_i8_reg imm:$lane))),
2370 (SubReg_i8_lane imm:$lane)))>;
2371 def : Pat<(v8i16 (NEONvduplane (v8i16 QPR:$src), imm:$lane)),
2372 (v8i16 (VDUPLN16q (v4i16 (EXTRACT_SUBREG QPR:$src,
2373 (DSubReg_i16_reg imm:$lane))),
2374 (SubReg_i16_lane imm:$lane)))>;
2375 def : Pat<(v4i32 (NEONvduplane (v4i32 QPR:$src), imm:$lane)),
2376 (v4i32 (VDUPLN32q (v2i32 (EXTRACT_SUBREG QPR:$src,
2377 (DSubReg_i32_reg imm:$lane))),
2378 (SubReg_i32_lane imm:$lane)))>;
2379 def : Pat<(v4f32 (NEONvduplane (v4f32 QPR:$src), imm:$lane)),
2380 (v4f32 (VDUPLNfq (v2f32 (EXTRACT_SUBREG QPR:$src,
2381 (DSubReg_i32_reg imm:$lane))),
2382 (SubReg_i32_lane imm:$lane)))>;
2384 def VDUPfdf : N2V<0b11, 0b11, 0b01, 0b00, 0b11000, 0, 0,
2385 (outs DPR:$dst), (ins SPR:$src),
2386 IIC_VMOVD, "vdup.32\t$dst, ${src:lane}", "",
2387 [(set DPR:$dst, (v2f32 (NEONvdup (f32 SPR:$src))))]>;
2389 def VDUPfqf : N2V<0b11, 0b11, 0b01, 0b00, 0b11000, 1, 0,
2390 (outs QPR:$dst), (ins SPR:$src),
2391 IIC_VMOVD, "vdup.32\t$dst, ${src:lane}", "",
2392 [(set QPR:$dst, (v4f32 (NEONvdup (f32 SPR:$src))))]>;
2394 def : Pat<(v2i64 (NEONvduplane (v2i64 QPR:$src), imm:$lane)),
2395 (INSERT_SUBREG QPR:$src,
2396 (i64 (EXTRACT_SUBREG QPR:$src, (DSubReg_f64_reg imm:$lane))),
2397 (DSubReg_f64_other_reg imm:$lane))>;
2398 def : Pat<(v2f64 (NEONvduplane (v2f64 QPR:$src), imm:$lane)),
2399 (INSERT_SUBREG QPR:$src,
2400 (f64 (EXTRACT_SUBREG QPR:$src, (DSubReg_f64_reg imm:$lane))),
2401 (DSubReg_f64_other_reg imm:$lane))>;
2403 // VMOVN : Vector Narrowing Move
2404 defm VMOVN : N2VNInt_HSD<0b11,0b11,0b10,0b00100,0,0, IIC_VMOVD, "vmovn.i",
2405 int_arm_neon_vmovn>;
2406 // VQMOVN : Vector Saturating Narrowing Move
2407 defm VQMOVNs : N2VNInt_HSD<0b11,0b11,0b10,0b00101,0,0, IIC_VQUNAiD, "vqmovn.s",
2408 int_arm_neon_vqmovns>;
2409 defm VQMOVNu : N2VNInt_HSD<0b11,0b11,0b10,0b00101,1,0, IIC_VQUNAiD, "vqmovn.u",
2410 int_arm_neon_vqmovnu>;
2411 defm VQMOVNsu : N2VNInt_HSD<0b11,0b11,0b10,0b00100,1,0, IIC_VQUNAiD, "vqmovun.s",
2412 int_arm_neon_vqmovnsu>;
2413 // VMOVL : Vector Lengthening Move
2414 defm VMOVLs : N2VLInt_QHS<0,1,0b1010,0,0,1, "vmovl.s", int_arm_neon_vmovls>;
2415 defm VMOVLu : N2VLInt_QHS<1,1,0b1010,0,0,1, "vmovl.u", int_arm_neon_vmovlu>;
2417 // Vector Conversions.
2419 // VCVT : Vector Convert Between Floating-Point and Integers
2420 def VCVTf2sd : N2VD<0b11, 0b11, 0b10, 0b11, 0b01110, 0, "vcvt.s32.f32",
2421 v2i32, v2f32, fp_to_sint>;
2422 def VCVTf2ud : N2VD<0b11, 0b11, 0b10, 0b11, 0b01111, 0, "vcvt.u32.f32",
2423 v2i32, v2f32, fp_to_uint>;
2424 def VCVTs2fd : N2VD<0b11, 0b11, 0b10, 0b11, 0b01100, 0, "vcvt.f32.s32",
2425 v2f32, v2i32, sint_to_fp>;
2426 def VCVTu2fd : N2VD<0b11, 0b11, 0b10, 0b11, 0b01101, 0, "vcvt.f32.u32",
2427 v2f32, v2i32, uint_to_fp>;
2429 def VCVTf2sq : N2VQ<0b11, 0b11, 0b10, 0b11, 0b01110, 0, "vcvt.s32.f32",
2430 v4i32, v4f32, fp_to_sint>;
2431 def VCVTf2uq : N2VQ<0b11, 0b11, 0b10, 0b11, 0b01111, 0, "vcvt.u32.f32",
2432 v4i32, v4f32, fp_to_uint>;
2433 def VCVTs2fq : N2VQ<0b11, 0b11, 0b10, 0b11, 0b01100, 0, "vcvt.f32.s32",
2434 v4f32, v4i32, sint_to_fp>;
2435 def VCVTu2fq : N2VQ<0b11, 0b11, 0b10, 0b11, 0b01101, 0, "vcvt.f32.u32",
2436 v4f32, v4i32, uint_to_fp>;
2438 // VCVT : Vector Convert Between Floating-Point and Fixed-Point.
2439 // Note: Some of the opcode bits in the following VCVT instructions need to
2440 // be encoded based on the immed values.
2441 def VCVTf2xsd : N2VCvtD<0, 1, 0b000000, 0b1111, 0, 1, "vcvt.s32.f32",
2442 v2i32, v2f32, int_arm_neon_vcvtfp2fxs>;
2443 def VCVTf2xud : N2VCvtD<1, 1, 0b000000, 0b1111, 0, 1, "vcvt.u32.f32",
2444 v2i32, v2f32, int_arm_neon_vcvtfp2fxu>;
2445 def VCVTxs2fd : N2VCvtD<0, 1, 0b000000, 0b1110, 0, 1, "vcvt.f32.s32",
2446 v2f32, v2i32, int_arm_neon_vcvtfxs2fp>;
2447 def VCVTxu2fd : N2VCvtD<1, 1, 0b000000, 0b1110, 0, 1, "vcvt.f32.u32",
2448 v2f32, v2i32, int_arm_neon_vcvtfxu2fp>;
2450 def VCVTf2xsq : N2VCvtQ<0, 1, 0b000000, 0b1111, 0, 1, "vcvt.s32.f32",
2451 v4i32, v4f32, int_arm_neon_vcvtfp2fxs>;
2452 def VCVTf2xuq : N2VCvtQ<1, 1, 0b000000, 0b1111, 0, 1, "vcvt.u32.f32",
2453 v4i32, v4f32, int_arm_neon_vcvtfp2fxu>;
2454 def VCVTxs2fq : N2VCvtQ<0, 1, 0b000000, 0b1110, 0, 1, "vcvt.f32.s32",
2455 v4f32, v4i32, int_arm_neon_vcvtfxs2fp>;
2456 def VCVTxu2fq : N2VCvtQ<1, 1, 0b000000, 0b1110, 0, 1, "vcvt.f32.u32",
2457 v4f32, v4i32, int_arm_neon_vcvtfxu2fp>;
2461 // VREV64 : Vector Reverse elements within 64-bit doublewords
2463 class VREV64D<bits<2> op19_18, string OpcodeStr, ValueType Ty>
2464 : N2V<0b11, 0b11, op19_18, 0b00, 0b00000, 0, 0, (outs DPR:$dst),
2465 (ins DPR:$src), IIC_VMOVD,
2466 !strconcat(OpcodeStr, "\t$dst, $src"), "",
2467 [(set DPR:$dst, (Ty (NEONvrev64 (Ty DPR:$src))))]>;
2468 class VREV64Q<bits<2> op19_18, string OpcodeStr, ValueType Ty>
2469 : N2V<0b11, 0b11, op19_18, 0b00, 0b00000, 1, 0, (outs QPR:$dst),
2470 (ins QPR:$src), IIC_VMOVD,
2471 !strconcat(OpcodeStr, "\t$dst, $src"), "",
2472 [(set QPR:$dst, (Ty (NEONvrev64 (Ty QPR:$src))))]>;
2474 def VREV64d8 : VREV64D<0b00, "vrev64.8", v8i8>;
2475 def VREV64d16 : VREV64D<0b01, "vrev64.16", v4i16>;
2476 def VREV64d32 : VREV64D<0b10, "vrev64.32", v2i32>;
2477 def VREV64df : VREV64D<0b10, "vrev64.32", v2f32>;
2479 def VREV64q8 : VREV64Q<0b00, "vrev64.8", v16i8>;
2480 def VREV64q16 : VREV64Q<0b01, "vrev64.16", v8i16>;
2481 def VREV64q32 : VREV64Q<0b10, "vrev64.32", v4i32>;
2482 def VREV64qf : VREV64Q<0b10, "vrev64.32", v4f32>;
2484 // VREV32 : Vector Reverse elements within 32-bit words
2486 class VREV32D<bits<2> op19_18, string OpcodeStr, ValueType Ty>
2487 : N2V<0b11, 0b11, op19_18, 0b00, 0b00001, 0, 0, (outs DPR:$dst),
2488 (ins DPR:$src), IIC_VMOVD,
2489 !strconcat(OpcodeStr, "\t$dst, $src"), "",
2490 [(set DPR:$dst, (Ty (NEONvrev32 (Ty DPR:$src))))]>;
2491 class VREV32Q<bits<2> op19_18, string OpcodeStr, ValueType Ty>
2492 : N2V<0b11, 0b11, op19_18, 0b00, 0b00001, 1, 0, (outs QPR:$dst),
2493 (ins QPR:$src), IIC_VMOVD,
2494 !strconcat(OpcodeStr, "\t$dst, $src"), "",
2495 [(set QPR:$dst, (Ty (NEONvrev32 (Ty QPR:$src))))]>;
2497 def VREV32d8 : VREV32D<0b00, "vrev32.8", v8i8>;
2498 def VREV32d16 : VREV32D<0b01, "vrev32.16", v4i16>;
2500 def VREV32q8 : VREV32Q<0b00, "vrev32.8", v16i8>;
2501 def VREV32q16 : VREV32Q<0b01, "vrev32.16", v8i16>;
2503 // VREV16 : Vector Reverse elements within 16-bit halfwords
2505 class VREV16D<bits<2> op19_18, string OpcodeStr, ValueType Ty>
2506 : N2V<0b11, 0b11, op19_18, 0b00, 0b00010, 0, 0, (outs DPR:$dst),
2507 (ins DPR:$src), IIC_VMOVD,
2508 !strconcat(OpcodeStr, "\t$dst, $src"), "",
2509 [(set DPR:$dst, (Ty (NEONvrev16 (Ty DPR:$src))))]>;
2510 class VREV16Q<bits<2> op19_18, string OpcodeStr, ValueType Ty>
2511 : N2V<0b11, 0b11, op19_18, 0b00, 0b00010, 1, 0, (outs QPR:$dst),
2512 (ins QPR:$src), IIC_VMOVD,
2513 !strconcat(OpcodeStr, "\t$dst, $src"), "",
2514 [(set QPR:$dst, (Ty (NEONvrev16 (Ty QPR:$src))))]>;
2516 def VREV16d8 : VREV16D<0b00, "vrev16.8", v8i8>;
2517 def VREV16q8 : VREV16Q<0b00, "vrev16.8", v16i8>;
2519 // Other Vector Shuffles.
2521 // VEXT : Vector Extract
2523 class VEXTd<string OpcodeStr, ValueType Ty>
2524 : N3V<0,1,0b11,0b0000,0,0, (outs DPR:$dst),
2525 (ins DPR:$lhs, DPR:$rhs, i32imm:$index), IIC_VEXTD,
2526 !strconcat(OpcodeStr, "\t$dst, $lhs, $rhs, $index"), "",
2527 [(set DPR:$dst, (Ty (NEONvext (Ty DPR:$lhs),
2528 (Ty DPR:$rhs), imm:$index)))]>;
2530 class VEXTq<string OpcodeStr, ValueType Ty>
2531 : N3V<0,1,0b11,0b0000,1,0, (outs QPR:$dst),
2532 (ins QPR:$lhs, QPR:$rhs, i32imm:$index), IIC_VEXTQ,
2533 !strconcat(OpcodeStr, "\t$dst, $lhs, $rhs, $index"), "",
2534 [(set QPR:$dst, (Ty (NEONvext (Ty QPR:$lhs),
2535 (Ty QPR:$rhs), imm:$index)))]>;
2537 def VEXTd8 : VEXTd<"vext.8", v8i8>;
2538 def VEXTd16 : VEXTd<"vext.16", v4i16>;
2539 def VEXTd32 : VEXTd<"vext.32", v2i32>;
2540 def VEXTdf : VEXTd<"vext.32", v2f32>;
2542 def VEXTq8 : VEXTq<"vext.8", v16i8>;
2543 def VEXTq16 : VEXTq<"vext.16", v8i16>;
2544 def VEXTq32 : VEXTq<"vext.32", v4i32>;
2545 def VEXTqf : VEXTq<"vext.32", v4f32>;
2547 // VTRN : Vector Transpose
2549 def VTRNd8 : N2VDShuffle<0b00, 0b00001, "vtrn.8">;
2550 def VTRNd16 : N2VDShuffle<0b01, 0b00001, "vtrn.16">;
2551 def VTRNd32 : N2VDShuffle<0b10, 0b00001, "vtrn.32">;
2553 def VTRNq8 : N2VQShuffle<0b00, 0b00001, IIC_VPERMQ, "vtrn.8">;
2554 def VTRNq16 : N2VQShuffle<0b01, 0b00001, IIC_VPERMQ, "vtrn.16">;
2555 def VTRNq32 : N2VQShuffle<0b10, 0b00001, IIC_VPERMQ, "vtrn.32">;
2557 // VUZP : Vector Unzip (Deinterleave)
2559 def VUZPd8 : N2VDShuffle<0b00, 0b00010, "vuzp.8">;
2560 def VUZPd16 : N2VDShuffle<0b01, 0b00010, "vuzp.16">;
2561 def VUZPd32 : N2VDShuffle<0b10, 0b00010, "vuzp.32">;
2563 def VUZPq8 : N2VQShuffle<0b00, 0b00010, IIC_VPERMQ3, "vuzp.8">;
2564 def VUZPq16 : N2VQShuffle<0b01, 0b00010, IIC_VPERMQ3, "vuzp.16">;
2565 def VUZPq32 : N2VQShuffle<0b10, 0b00010, IIC_VPERMQ3, "vuzp.32">;
2567 // VZIP : Vector Zip (Interleave)
2569 def VZIPd8 : N2VDShuffle<0b00, 0b00011, "vzip.8">;
2570 def VZIPd16 : N2VDShuffle<0b01, 0b00011, "vzip.16">;
2571 def VZIPd32 : N2VDShuffle<0b10, 0b00011, "vzip.32">;
2573 def VZIPq8 : N2VQShuffle<0b00, 0b00011, IIC_VPERMQ3, "vzip.8">;
2574 def VZIPq16 : N2VQShuffle<0b01, 0b00011, IIC_VPERMQ3, "vzip.16">;
2575 def VZIPq32 : N2VQShuffle<0b10, 0b00011, IIC_VPERMQ3, "vzip.32">;
2577 // Vector Table Lookup and Table Extension.
2579 // VTBL : Vector Table Lookup
2581 : N3V<1,1,0b11,0b1000,0,0, (outs DPR:$dst),
2582 (ins DPR:$tbl1, DPR:$src), IIC_VTB1,
2583 "vtbl.8\t$dst, \\{$tbl1\\}, $src", "",
2584 [(set DPR:$dst, (v8i8 (int_arm_neon_vtbl1 DPR:$tbl1, DPR:$src)))]>;
2585 let hasExtraSrcRegAllocReq = 1 in {
2587 : N3V<1,1,0b11,0b1001,0,0, (outs DPR:$dst),
2588 (ins DPR:$tbl1, DPR:$tbl2, DPR:$src), IIC_VTB2,
2589 "vtbl.8\t$dst, \\{$tbl1,$tbl2\\}, $src", "",
2590 [(set DPR:$dst, (v8i8 (int_arm_neon_vtbl2
2591 DPR:$tbl1, DPR:$tbl2, DPR:$src)))]>;
2593 : N3V<1,1,0b11,0b1010,0,0, (outs DPR:$dst),
2594 (ins DPR:$tbl1, DPR:$tbl2, DPR:$tbl3, DPR:$src), IIC_VTB3,
2595 "vtbl.8\t$dst, \\{$tbl1,$tbl2,$tbl3\\}, $src", "",
2596 [(set DPR:$dst, (v8i8 (int_arm_neon_vtbl3
2597 DPR:$tbl1, DPR:$tbl2, DPR:$tbl3, DPR:$src)))]>;
2599 : N3V<1,1,0b11,0b1011,0,0, (outs DPR:$dst),
2600 (ins DPR:$tbl1, DPR:$tbl2, DPR:$tbl3, DPR:$tbl4, DPR:$src), IIC_VTB4,
2601 "vtbl.8\t$dst, \\{$tbl1,$tbl2,$tbl3,$tbl4\\}, $src", "",
2602 [(set DPR:$dst, (v8i8 (int_arm_neon_vtbl4 DPR:$tbl1, DPR:$tbl2,
2603 DPR:$tbl3, DPR:$tbl4, DPR:$src)))]>;
2604 } // hasExtraSrcRegAllocReq = 1
2606 // VTBX : Vector Table Extension
2608 : N3V<1,1,0b11,0b1000,1,0, (outs DPR:$dst),
2609 (ins DPR:$orig, DPR:$tbl1, DPR:$src), IIC_VTBX1,
2610 "vtbx.8\t$dst, \\{$tbl1\\}, $src", "$orig = $dst",
2611 [(set DPR:$dst, (v8i8 (int_arm_neon_vtbx1
2612 DPR:$orig, DPR:$tbl1, DPR:$src)))]>;
2613 let hasExtraSrcRegAllocReq = 1 in {
2615 : N3V<1,1,0b11,0b1001,1,0, (outs DPR:$dst),
2616 (ins DPR:$orig, DPR:$tbl1, DPR:$tbl2, DPR:$src), IIC_VTBX2,
2617 "vtbx.8\t$dst, \\{$tbl1,$tbl2\\}, $src", "$orig = $dst",
2618 [(set DPR:$dst, (v8i8 (int_arm_neon_vtbx2
2619 DPR:$orig, DPR:$tbl1, DPR:$tbl2, DPR:$src)))]>;
2621 : N3V<1,1,0b11,0b1010,1,0, (outs DPR:$dst),
2622 (ins DPR:$orig, DPR:$tbl1, DPR:$tbl2, DPR:$tbl3, DPR:$src), IIC_VTBX3,
2623 "vtbx.8\t$dst, \\{$tbl1,$tbl2,$tbl3\\}, $src", "$orig = $dst",
2624 [(set DPR:$dst, (v8i8 (int_arm_neon_vtbx3 DPR:$orig, DPR:$tbl1,
2625 DPR:$tbl2, DPR:$tbl3, DPR:$src)))]>;
2627 : N3V<1,1,0b11,0b1011,1,0, (outs DPR:$dst), (ins DPR:$orig, DPR:$tbl1,
2628 DPR:$tbl2, DPR:$tbl3, DPR:$tbl4, DPR:$src), IIC_VTBX4,
2629 "vtbx.8\t$dst, \\{$tbl1,$tbl2,$tbl3,$tbl4\\}, $src", "$orig = $dst",
2630 [(set DPR:$dst, (v8i8 (int_arm_neon_vtbx4 DPR:$orig, DPR:$tbl1,
2631 DPR:$tbl2, DPR:$tbl3, DPR:$tbl4, DPR:$src)))]>;
2632 } // hasExtraSrcRegAllocReq = 1
2634 //===----------------------------------------------------------------------===//
2635 // NEON instructions for single-precision FP math
2636 //===----------------------------------------------------------------------===//
2638 // These need separate instructions because they must use DPR_VFP2 register
2639 // class which have SPR sub-registers.
2641 // Vector Add Operations used for single-precision FP
2642 let neverHasSideEffects = 1 in
2643 def VADDfd_sfp : N3VDs<0, 0, 0b00, 0b1101, 0, "vadd.f32", v2f32, v2f32, fadd,1>;
2644 def : N3VDsPat<fadd, VADDfd_sfp>;
2646 // Vector Sub Operations used for single-precision FP
2647 let neverHasSideEffects = 1 in
2648 def VSUBfd_sfp : N3VDs<0, 0, 0b10, 0b1101, 0, "vsub.f32", v2f32, v2f32, fsub,0>;
2649 def : N3VDsPat<fsub, VSUBfd_sfp>;
2651 // Vector Multiply Operations used for single-precision FP
2652 let neverHasSideEffects = 1 in
2653 def VMULfd_sfp : N3VDs<1, 0, 0b00, 0b1101, 1, "vmul.f32", v2f32, v2f32, fmul,1>;
2654 def : N3VDsPat<fmul, VMULfd_sfp>;
2656 // Vector Multiply-Accumulate/Subtract used for single-precision FP
2657 let neverHasSideEffects = 1 in
2658 def VMLAfd_sfp : N3VDMulOps<0, 0, 0b00, 0b1101, 1, IIC_VMACD, "vmla.f32", v2f32,fmul,fadd>;
2659 def : N3VDMulOpsPat<fmul, fadd, VMLAfd_sfp>;
2661 let neverHasSideEffects = 1 in
2662 def VMLSfd_sfp : N3VDMulOps<0, 0, 0b10, 0b1101, 1, IIC_VMACD, "vmls.f32", v2f32,fmul,fsub>;
2663 def : N3VDMulOpsPat<fmul, fsub, VMLSfd_sfp>;
2665 // Vector Absolute used for single-precision FP
2666 let neverHasSideEffects = 1 in
2667 def VABSfd_sfp : N2VDInts<0b11, 0b11, 0b10, 0b01, 0b01110, 0,
2668 IIC_VUNAD, "vabs.f32",
2669 v2f32, v2f32, int_arm_neon_vabs>;
2670 def : N2VDIntsPat<fabs, VABSfd_sfp>;
2672 // Vector Negate used for single-precision FP
2673 let neverHasSideEffects = 1 in
2674 def VNEGf32d_sfp : N2V<0b11, 0b11, 0b10, 0b01, 0b01111, 0, 0,
2675 (outs DPR_VFP2:$dst), (ins DPR_VFP2:$src), IIC_VUNAD,
2676 "vneg.f32\t$dst, $src", "", []>;
2677 def : N2VDIntsPat<fneg, VNEGf32d_sfp>;
2679 // Vector Convert between single-precision FP and integer
2680 let neverHasSideEffects = 1 in
2681 def VCVTf2sd_sfp : N2VDs<0b11, 0b11, 0b10, 0b11, 0b01110, 0, "vcvt.s32.f32",
2682 v2i32, v2f32, fp_to_sint>;
2683 def : N2VDsPat<arm_ftosi, f32, v2f32, VCVTf2sd_sfp>;
2685 let neverHasSideEffects = 1 in
2686 def VCVTf2ud_sfp : N2VDs<0b11, 0b11, 0b10, 0b11, 0b01111, 0, "vcvt.u32.f32",
2687 v2i32, v2f32, fp_to_uint>;
2688 def : N2VDsPat<arm_ftoui, f32, v2f32, VCVTf2ud_sfp>;
2690 let neverHasSideEffects = 1 in
2691 def VCVTs2fd_sfp : N2VDs<0b11, 0b11, 0b10, 0b11, 0b01100, 0, "vcvt.f32.s32",
2692 v2f32, v2i32, sint_to_fp>;
2693 def : N2VDsPat<arm_sitof, f32, v2i32, VCVTs2fd_sfp>;
2695 let neverHasSideEffects = 1 in
2696 def VCVTu2fd_sfp : N2VDs<0b11, 0b11, 0b10, 0b11, 0b01101, 0, "vcvt.f32.u32",
2697 v2f32, v2i32, uint_to_fp>;
2698 def : N2VDsPat<arm_uitof, f32, v2i32, VCVTu2fd_sfp>;
2700 //===----------------------------------------------------------------------===//
2701 // Non-Instruction Patterns
2702 //===----------------------------------------------------------------------===//
2705 def : Pat<(v1i64 (bitconvert (v2i32 DPR:$src))), (v1i64 DPR:$src)>;
2706 def : Pat<(v1i64 (bitconvert (v4i16 DPR:$src))), (v1i64 DPR:$src)>;
2707 def : Pat<(v1i64 (bitconvert (v8i8 DPR:$src))), (v1i64 DPR:$src)>;
2708 def : Pat<(v1i64 (bitconvert (f64 DPR:$src))), (v1i64 DPR:$src)>;
2709 def : Pat<(v1i64 (bitconvert (v2f32 DPR:$src))), (v1i64 DPR:$src)>;
2710 def : Pat<(v2i32 (bitconvert (v1i64 DPR:$src))), (v2i32 DPR:$src)>;
2711 def : Pat<(v2i32 (bitconvert (v4i16 DPR:$src))), (v2i32 DPR:$src)>;
2712 def : Pat<(v2i32 (bitconvert (v8i8 DPR:$src))), (v2i32 DPR:$src)>;
2713 def : Pat<(v2i32 (bitconvert (f64 DPR:$src))), (v2i32 DPR:$src)>;
2714 def : Pat<(v2i32 (bitconvert (v2f32 DPR:$src))), (v2i32 DPR:$src)>;
2715 def : Pat<(v4i16 (bitconvert (v1i64 DPR:$src))), (v4i16 DPR:$src)>;
2716 def : Pat<(v4i16 (bitconvert (v2i32 DPR:$src))), (v4i16 DPR:$src)>;
2717 def : Pat<(v4i16 (bitconvert (v8i8 DPR:$src))), (v4i16 DPR:$src)>;
2718 def : Pat<(v4i16 (bitconvert (f64 DPR:$src))), (v4i16 DPR:$src)>;
2719 def : Pat<(v4i16 (bitconvert (v2f32 DPR:$src))), (v4i16 DPR:$src)>;
2720 def : Pat<(v8i8 (bitconvert (v1i64 DPR:$src))), (v8i8 DPR:$src)>;
2721 def : Pat<(v8i8 (bitconvert (v2i32 DPR:$src))), (v8i8 DPR:$src)>;
2722 def : Pat<(v8i8 (bitconvert (v4i16 DPR:$src))), (v8i8 DPR:$src)>;
2723 def : Pat<(v8i8 (bitconvert (f64 DPR:$src))), (v8i8 DPR:$src)>;
2724 def : Pat<(v8i8 (bitconvert (v2f32 DPR:$src))), (v8i8 DPR:$src)>;
2725 def : Pat<(f64 (bitconvert (v1i64 DPR:$src))), (f64 DPR:$src)>;
2726 def : Pat<(f64 (bitconvert (v2i32 DPR:$src))), (f64 DPR:$src)>;
2727 def : Pat<(f64 (bitconvert (v4i16 DPR:$src))), (f64 DPR:$src)>;
2728 def : Pat<(f64 (bitconvert (v8i8 DPR:$src))), (f64 DPR:$src)>;
2729 def : Pat<(f64 (bitconvert (v2f32 DPR:$src))), (f64 DPR:$src)>;
2730 def : Pat<(v2f32 (bitconvert (f64 DPR:$src))), (v2f32 DPR:$src)>;
2731 def : Pat<(v2f32 (bitconvert (v1i64 DPR:$src))), (v2f32 DPR:$src)>;
2732 def : Pat<(v2f32 (bitconvert (v2i32 DPR:$src))), (v2f32 DPR:$src)>;
2733 def : Pat<(v2f32 (bitconvert (v4i16 DPR:$src))), (v2f32 DPR:$src)>;
2734 def : Pat<(v2f32 (bitconvert (v8i8 DPR:$src))), (v2f32 DPR:$src)>;
2736 def : Pat<(v2i64 (bitconvert (v4i32 QPR:$src))), (v2i64 QPR:$src)>;
2737 def : Pat<(v2i64 (bitconvert (v8i16 QPR:$src))), (v2i64 QPR:$src)>;
2738 def : Pat<(v2i64 (bitconvert (v16i8 QPR:$src))), (v2i64 QPR:$src)>;
2739 def : Pat<(v2i64 (bitconvert (v2f64 QPR:$src))), (v2i64 QPR:$src)>;
2740 def : Pat<(v2i64 (bitconvert (v4f32 QPR:$src))), (v2i64 QPR:$src)>;
2741 def : Pat<(v4i32 (bitconvert (v2i64 QPR:$src))), (v4i32 QPR:$src)>;
2742 def : Pat<(v4i32 (bitconvert (v8i16 QPR:$src))), (v4i32 QPR:$src)>;
2743 def : Pat<(v4i32 (bitconvert (v16i8 QPR:$src))), (v4i32 QPR:$src)>;
2744 def : Pat<(v4i32 (bitconvert (v2f64 QPR:$src))), (v4i32 QPR:$src)>;
2745 def : Pat<(v4i32 (bitconvert (v4f32 QPR:$src))), (v4i32 QPR:$src)>;
2746 def : Pat<(v8i16 (bitconvert (v2i64 QPR:$src))), (v8i16 QPR:$src)>;
2747 def : Pat<(v8i16 (bitconvert (v4i32 QPR:$src))), (v8i16 QPR:$src)>;
2748 def : Pat<(v8i16 (bitconvert (v16i8 QPR:$src))), (v8i16 QPR:$src)>;
2749 def : Pat<(v8i16 (bitconvert (v2f64 QPR:$src))), (v8i16 QPR:$src)>;
2750 def : Pat<(v8i16 (bitconvert (v4f32 QPR:$src))), (v8i16 QPR:$src)>;
2751 def : Pat<(v16i8 (bitconvert (v2i64 QPR:$src))), (v16i8 QPR:$src)>;
2752 def : Pat<(v16i8 (bitconvert (v4i32 QPR:$src))), (v16i8 QPR:$src)>;
2753 def : Pat<(v16i8 (bitconvert (v8i16 QPR:$src))), (v16i8 QPR:$src)>;
2754 def : Pat<(v16i8 (bitconvert (v2f64 QPR:$src))), (v16i8 QPR:$src)>;
2755 def : Pat<(v16i8 (bitconvert (v4f32 QPR:$src))), (v16i8 QPR:$src)>;
2756 def : Pat<(v4f32 (bitconvert (v2i64 QPR:$src))), (v4f32 QPR:$src)>;
2757 def : Pat<(v4f32 (bitconvert (v4i32 QPR:$src))), (v4f32 QPR:$src)>;
2758 def : Pat<(v4f32 (bitconvert (v8i16 QPR:$src))), (v4f32 QPR:$src)>;
2759 def : Pat<(v4f32 (bitconvert (v16i8 QPR:$src))), (v4f32 QPR:$src)>;
2760 def : Pat<(v4f32 (bitconvert (v2f64 QPR:$src))), (v4f32 QPR:$src)>;
2761 def : Pat<(v2f64 (bitconvert (v2i64 QPR:$src))), (v2f64 QPR:$src)>;
2762 def : Pat<(v2f64 (bitconvert (v4i32 QPR:$src))), (v2f64 QPR:$src)>;
2763 def : Pat<(v2f64 (bitconvert (v8i16 QPR:$src))), (v2f64 QPR:$src)>;
2764 def : Pat<(v2f64 (bitconvert (v16i8 QPR:$src))), (v2f64 QPR:$src)>;
2765 def : Pat<(v2f64 (bitconvert (v4f32 QPR:$src))), (v2f64 QPR:$src)>;