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>,
88 def NEONzip : SDNode<"ARMISD::VZIP", SDTARMVSHUF2>;
89 def NEONuzp : SDNode<"ARMISD::VUZP", SDTARMVSHUF2>;
90 def NEONtrn : SDNode<"ARMISD::VTRN", SDTARMVSHUF2>;
92 def SDTARMFMAX : SDTypeProfile<1, 2, [SDTCisVT<0, f32>, SDTCisSameAs<0, 1>,
94 def NEONfmax : SDNode<"ARMISD::FMAX", SDTARMFMAX>;
95 def NEONfmin : SDNode<"ARMISD::FMIN", SDTARMFMAX>;
97 //===----------------------------------------------------------------------===//
98 // NEON operand definitions
99 //===----------------------------------------------------------------------===//
101 def h8imm : Operand<i8> {
102 let PrintMethod = "printHex8ImmOperand";
104 def h16imm : Operand<i16> {
105 let PrintMethod = "printHex16ImmOperand";
107 def h32imm : Operand<i32> {
108 let PrintMethod = "printHex32ImmOperand";
110 def h64imm : Operand<i64> {
111 let PrintMethod = "printHex64ImmOperand";
114 //===----------------------------------------------------------------------===//
115 // NEON load / store instructions
116 //===----------------------------------------------------------------------===//
118 // Use vldmia to load a Q register as a D register pair.
119 def VLDRQ : NI4<(outs QPR:$dst), (ins addrmode4:$addr), IIC_fpLoadm,
120 "vldmia", "$addr, ${dst:dregpair}",
121 [(set QPR:$dst, (v2f64 (load addrmode4:$addr)))]> {
122 let Inst{27-25} = 0b110;
123 let Inst{24} = 0; // P bit
124 let Inst{23} = 1; // U bit
126 let Inst{11-8} = 0b1011;
129 // Use vstmia to store a Q register as a D register pair.
130 def VSTRQ : NI4<(outs), (ins QPR:$src, addrmode4:$addr), IIC_fpStorem,
131 "vstmia", "$addr, ${src:dregpair}",
132 [(store (v2f64 QPR:$src), addrmode4:$addr)]> {
133 let Inst{27-25} = 0b110;
134 let Inst{24} = 0; // P bit
135 let Inst{23} = 1; // U bit
137 let Inst{11-8} = 0b1011;
140 // VLD1 : Vector Load (multiple single elements)
141 class VLD1D<bits<4> op7_4, string OpcodeStr, string Dt,
142 ValueType Ty, Intrinsic IntOp>
143 : NLdSt<0,0b10,0b0111,op7_4, (outs DPR:$dst), (ins addrmode6:$addr), IIC_VLD1,
144 OpcodeStr, Dt, "\\{$dst\\}, $addr", "",
145 [(set DPR:$dst, (Ty (IntOp addrmode6:$addr)))]>;
146 class VLD1Q<bits<4> op7_4, string OpcodeStr, string Dt,
147 ValueType Ty, Intrinsic IntOp>
148 : NLdSt<0,0b10,0b1010,op7_4, (outs QPR:$dst), (ins addrmode6:$addr), IIC_VLD1,
149 OpcodeStr, Dt, "${dst:dregpair}, $addr", "",
150 [(set QPR:$dst, (Ty (IntOp addrmode6:$addr)))]>;
152 def VLD1d8 : VLD1D<0b0000, "vld1", "8", v8i8, int_arm_neon_vld1>;
153 def VLD1d16 : VLD1D<0b0100, "vld1", "16", v4i16, int_arm_neon_vld1>;
154 def VLD1d32 : VLD1D<0b1000, "vld1", "32", v2i32, int_arm_neon_vld1>;
155 def VLD1df : VLD1D<0b1000, "vld1", "32", v2f32, int_arm_neon_vld1>;
156 def VLD1d64 : VLD1D<0b1100, "vld1", "64", v1i64, int_arm_neon_vld1>;
158 def VLD1q8 : VLD1Q<0b0000, "vld1", "8", v16i8, int_arm_neon_vld1>;
159 def VLD1q16 : VLD1Q<0b0100, "vld1", "16", v8i16, int_arm_neon_vld1>;
160 def VLD1q32 : VLD1Q<0b1000, "vld1", "32", v4i32, int_arm_neon_vld1>;
161 def VLD1qf : VLD1Q<0b1000, "vld1", "32", v4f32, int_arm_neon_vld1>;
162 def VLD1q64 : VLD1Q<0b1100, "vld1", "64", v2i64, int_arm_neon_vld1>;
164 // These (dreg triple/quadruple) are for disassembly only.
165 class VLD1D3<bits<4> op7_4, string OpcodeStr, string Dt>
166 : NLdSt<0, 0b10, 0b0110, op7_4, (outs DPR:$dst1, DPR:$dst2, DPR:$dst3),
167 (ins addrmode6:$addr), IIC_VLD1, OpcodeStr, Dt,
168 "\\{$dst1, $dst2, $dst3\\}, $addr", "",
169 [/* For disassembly only; pattern left blank */]>;
170 class VLD1D4<bits<4> op7_4, string OpcodeStr, string Dt>
171 : NLdSt<0,0b10,0b0010,op7_4,(outs DPR:$dst1, DPR:$dst2, DPR:$dst3, DPR:$dst4),
172 (ins addrmode6:$addr), IIC_VLD1, OpcodeStr, Dt,
173 "\\{$dst1, $dst2, $dst3, $dst4\\}, $addr", "",
174 [/* For disassembly only; pattern left blank */]>;
176 def VLD1d8T : VLD1D3<0b0000, "vld1", "8">;
177 def VLD1d16T : VLD1D3<0b0100, "vld1", "16">;
178 def VLD1d32T : VLD1D3<0b1000, "vld1", "32">;
179 //def VLD1d64T : VLD1D3<0b1100, "vld1", "64">;
181 def VLD1d8Q : VLD1D4<0b0000, "vld1", "8">;
182 def VLD1d16Q : VLD1D4<0b0100, "vld1", "16">;
183 def VLD1d32Q : VLD1D4<0b1000, "vld1", "32">;
184 //def VLD1d64Q : VLD1D4<0b1100, "vld1", "64">;
187 let mayLoad = 1, hasExtraDefRegAllocReq = 1 in {
189 // VLD2 : Vector Load (multiple 2-element structures)
190 class VLD2D<bits<4> op7_4, string OpcodeStr, string Dt>
191 : NLdSt<0,0b10,0b1000,op7_4, (outs DPR:$dst1, DPR:$dst2),
192 (ins addrmode6:$addr), IIC_VLD2,
193 OpcodeStr, Dt, "\\{$dst1, $dst2\\}, $addr", "", []>;
194 class VLD2Q<bits<4> op7_4, string OpcodeStr, string Dt>
195 : NLdSt<0,0b10,0b0011,op7_4,
196 (outs DPR:$dst1, DPR:$dst2, DPR:$dst3, DPR:$dst4),
197 (ins addrmode6:$addr), IIC_VLD2,
198 OpcodeStr, Dt, "\\{$dst1, $dst2, $dst3, $dst4\\}, $addr",
201 def VLD2d8 : VLD2D<0b0000, "vld2", "8">;
202 def VLD2d16 : VLD2D<0b0100, "vld2", "16">;
203 def VLD2d32 : VLD2D<0b1000, "vld2", "32">;
204 def VLD2d64 : NLdSt<0,0b10,0b1010,0b1100, (outs DPR:$dst1, DPR:$dst2),
205 (ins addrmode6:$addr), IIC_VLD1,
206 "vld1", "64", "\\{$dst1, $dst2\\}, $addr", "", []>;
208 def VLD2q8 : VLD2Q<0b0000, "vld2", "8">;
209 def VLD2q16 : VLD2Q<0b0100, "vld2", "16">;
210 def VLD2q32 : VLD2Q<0b1000, "vld2", "32">;
212 // These (double-spaced dreg pair) are for disassembly only.
213 class VLD2Ddbl<bits<4> op7_4, string OpcodeStr, string Dt>
214 : NLdSt<0,0b10,0b1001,op7_4, (outs DPR:$dst1, DPR:$dst2),
215 (ins addrmode6:$addr), IIC_VLD2,
216 OpcodeStr, Dt, "\\{$dst1, $dst2\\}, $addr", "", []> {
217 let NSF = VLDSTLaneDblFrm; // For disassembly.
218 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
221 def VLD2d8D : VLD2Ddbl<0b0000, "vld2", "8">;
222 def VLD2d16D : VLD2Ddbl<0b0100, "vld2", "16">;
223 def VLD2d32D : VLD2Ddbl<0b1000, "vld2", "32">;
225 // VLD3 : Vector Load (multiple 3-element structures)
226 class VLD3D<bits<4> op7_4, string OpcodeStr, string Dt>
227 : NLdSt<0,0b10,0b0100,op7_4, (outs DPR:$dst1, DPR:$dst2, DPR:$dst3),
228 (ins addrmode6:$addr), IIC_VLD3,
229 OpcodeStr, Dt, "\\{$dst1, $dst2, $dst3\\}, $addr", "", []>;
230 class VLD3WB<bits<4> op7_4, string OpcodeStr, string Dt>
231 : NLdSt<0,0b10,0b0101,op7_4, (outs DPR:$dst1, DPR:$dst2, DPR:$dst3, GPR:$wb),
232 (ins addrmode6:$addr), IIC_VLD3,
233 OpcodeStr, Dt, "\\{$dst1, $dst2, $dst3\\}, $addr",
234 "$addr.addr = $wb", []> {
235 let NSF = VLDSTLaneDblFrm; // For disassembly.
236 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
239 def VLD3d8 : VLD3D<0b0000, "vld3", "8">;
240 def VLD3d16 : VLD3D<0b0100, "vld3", "16">;
241 def VLD3d32 : VLD3D<0b1000, "vld3", "32">;
242 def VLD3d64 : NLdSt<0,0b10,0b0110,0b1100,
243 (outs DPR:$dst1, DPR:$dst2, DPR:$dst3),
244 (ins addrmode6:$addr), IIC_VLD1,
245 "vld1", "64", "\\{$dst1, $dst2, $dst3\\}, $addr", "", []>;
247 // vld3 to double-spaced even registers.
248 def VLD3q8a : VLD3WB<0b0000, "vld3", "8">;
249 def VLD3q16a : VLD3WB<0b0100, "vld3", "16">;
250 def VLD3q32a : VLD3WB<0b1000, "vld3", "32">;
252 // vld3 to double-spaced odd registers.
253 def VLD3q8b : VLD3WB<0b0000, "vld3", "8">;
254 def VLD3q16b : VLD3WB<0b0100, "vld3", "16">;
255 def VLD3q32b : VLD3WB<0b1000, "vld3", "32">;
257 // VLD4 : Vector Load (multiple 4-element structures)
258 class VLD4D<bits<4> op7_4, string OpcodeStr, string Dt>
259 : NLdSt<0,0b10,0b0000,op7_4,
260 (outs DPR:$dst1, DPR:$dst2, DPR:$dst3, DPR:$dst4),
261 (ins addrmode6:$addr), IIC_VLD4,
262 OpcodeStr, Dt, "\\{$dst1, $dst2, $dst3, $dst4\\}, $addr",
264 class VLD4WB<bits<4> op7_4, string OpcodeStr, string Dt>
265 : NLdSt<0,0b10,0b0001,op7_4,
266 (outs DPR:$dst1, DPR:$dst2, DPR:$dst3, DPR:$dst4, GPR:$wb),
267 (ins addrmode6:$addr), IIC_VLD4,
268 OpcodeStr, Dt, "\\{$dst1, $dst2, $dst3, $dst4\\}, $addr",
269 "$addr.addr = $wb", []> {
270 let NSF = VLDSTLaneDblFrm; // For disassembly.
271 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
274 def VLD4d8 : VLD4D<0b0000, "vld4", "8">;
275 def VLD4d16 : VLD4D<0b0100, "vld4", "16">;
276 def VLD4d32 : VLD4D<0b1000, "vld4", "32">;
277 def VLD4d64 : NLdSt<0,0b10,0b0010,0b1100,
278 (outs DPR:$dst1, DPR:$dst2, DPR:$dst3, DPR:$dst4),
279 (ins addrmode6:$addr), IIC_VLD1,
280 "vld1", "64", "\\{$dst1, $dst2, $dst3, $dst4\\}, $addr",
283 // vld4 to double-spaced even registers.
284 def VLD4q8a : VLD4WB<0b0000, "vld4", "8">;
285 def VLD4q16a : VLD4WB<0b0100, "vld4", "16">;
286 def VLD4q32a : VLD4WB<0b1000, "vld4", "32">;
288 // vld4 to double-spaced odd registers.
289 def VLD4q8b : VLD4WB<0b0000, "vld4", "8">;
290 def VLD4q16b : VLD4WB<0b0100, "vld4", "16">;
291 def VLD4q32b : VLD4WB<0b1000, "vld4", "32">;
293 // VLD1LN : Vector Load (single element to one lane)
294 // FIXME: Not yet implemented.
296 // VLD2LN : Vector Load (single 2-element structure to one lane)
297 class VLD2LN<bits<4> op11_8, string OpcodeStr, string Dt>
298 : NLdSt<1,0b10,op11_8,{?,?,?,?}, (outs DPR:$dst1, DPR:$dst2),
299 (ins addrmode6:$addr, DPR:$src1, DPR:$src2, nohash_imm:$lane),
300 IIC_VLD2, OpcodeStr, Dt, "\\{$dst1[$lane], $dst2[$lane]\\}, $addr",
301 "$src1 = $dst1, $src2 = $dst2", []>;
303 // vld2 to single-spaced registers.
304 def VLD2LNd8 : VLD2LN<0b0001, "vld2", "8">;
305 def VLD2LNd16 : VLD2LN<0b0101, "vld2", "16"> { let Inst{5} = 0; }
306 def VLD2LNd32 : VLD2LN<0b1001, "vld2", "32"> { let Inst{6} = 0; }
308 // vld2 to double-spaced even registers.
309 def VLD2LNq16a: VLD2LN<0b0101, "vld2", "16"> {
311 let NSF = VLDSTLaneDblFrm; // For disassembly.
312 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
314 def VLD2LNq32a: VLD2LN<0b1001, "vld2", "32"> {
316 let NSF = VLDSTLaneDblFrm; // For disassembly.
317 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
320 // vld2 to double-spaced odd registers.
321 def VLD2LNq16b: VLD2LN<0b0101, "vld2", "16"> {
323 let NSF = VLDSTLaneDblFrm; // For disassembly.
324 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
326 def VLD2LNq32b: VLD2LN<0b1001, "vld2", "32"> {
328 let NSF = VLDSTLaneDblFrm; // For disassembly.
329 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
332 // VLD3LN : Vector Load (single 3-element structure to one lane)
333 class VLD3LN<bits<4> op11_8, string OpcodeStr, string Dt>
334 : NLdSt<1,0b10,op11_8,{?,?,?,?}, (outs DPR:$dst1, DPR:$dst2, DPR:$dst3),
335 (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3,
336 nohash_imm:$lane), IIC_VLD3, OpcodeStr, Dt,
337 "\\{$dst1[$lane], $dst2[$lane], $dst3[$lane]\\}, $addr",
338 "$src1 = $dst1, $src2 = $dst2, $src3 = $dst3", []>;
340 // vld3 to single-spaced registers.
341 def VLD3LNd8 : VLD3LN<0b0010, "vld3", "8"> { let Inst{4} = 0; }
342 def VLD3LNd16 : VLD3LN<0b0110, "vld3", "16"> { let Inst{5-4} = 0b00; }
343 def VLD3LNd32 : VLD3LN<0b1010, "vld3", "32"> { let Inst{6-4} = 0b000; }
345 // vld3 to double-spaced even registers.
346 def VLD3LNq16a: VLD3LN<0b0110, "vld3", "16"> {
347 let Inst{5-4} = 0b10;
348 let NSF = VLDSTLaneDblFrm; // For disassembly.
349 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
351 def VLD3LNq32a: VLD3LN<0b1010, "vld3", "32"> { let Inst{6-4} = 0b100; }
353 // vld3 to double-spaced odd registers.
354 def VLD3LNq16b: VLD3LN<0b0110, "vld3", "16"> { let Inst{5-4} = 0b10; }
355 def VLD3LNq32b: VLD3LN<0b1010, "vld3", "32"> { let Inst{6-4} = 0b100; }
357 // VLD4LN : Vector Load (single 4-element structure to one lane)
358 class VLD4LN<bits<4> op11_8, string OpcodeStr, string Dt>
359 : NLdSt<1,0b10,op11_8,{?,?,?,?},
360 (outs DPR:$dst1, DPR:$dst2, DPR:$dst3, DPR:$dst4),
361 (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3, DPR:$src4,
362 nohash_imm:$lane), IIC_VLD4, OpcodeStr, Dt,
363 "\\{$dst1[$lane], $dst2[$lane], $dst3[$lane], $dst4[$lane]\\}, $addr",
364 "$src1 = $dst1, $src2 = $dst2, $src3 = $dst3, $src4 = $dst4", []>;
366 // vld4 to single-spaced registers.
367 def VLD4LNd8 : VLD4LN<0b0011, "vld4", "8">;
368 def VLD4LNd16 : VLD4LN<0b0111, "vld4", "16"> { let Inst{5} = 0; }
369 def VLD4LNd32 : VLD4LN<0b1011, "vld4", "32"> { let Inst{6} = 0; }
371 // vld4 to double-spaced even registers.
372 def VLD4LNq16a: VLD4LN<0b0111, "vld4", "16"> {
374 let NSF = VLDSTLaneDblFrm; // For disassembly.
375 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
377 def VLD4LNq32a: VLD4LN<0b1011, "vld4", "32"> {
379 let NSF = VLDSTLaneDblFrm; // For disassembly.
380 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
383 // vld4 to double-spaced odd registers.
384 def VLD4LNq16b: VLD4LN<0b0111, "vld4", "16"> {
386 let NSF = VLDSTLaneDblFrm; // For disassembly.
387 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
389 def VLD4LNq32b: VLD4LN<0b1011, "vld4", "32"> {
391 let NSF = VLDSTLaneDblFrm; // For disassembly.
392 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
395 // VLD1DUP : Vector Load (single element to all lanes)
396 // VLD2DUP : Vector Load (single 2-element structure to all lanes)
397 // VLD3DUP : Vector Load (single 3-element structure to all lanes)
398 // VLD4DUP : Vector Load (single 4-element structure to all lanes)
399 // FIXME: Not yet implemented.
400 } // mayLoad = 1, hasExtraDefRegAllocReq = 1
402 // VST1 : Vector Store (multiple single elements)
403 class VST1D<bits<4> op7_4, string OpcodeStr, string Dt,
404 ValueType Ty, Intrinsic IntOp>
405 : NLdSt<0,0b00,0b0111,op7_4, (outs), (ins addrmode6:$addr, DPR:$src), IIC_VST,
406 OpcodeStr, Dt, "\\{$src\\}, $addr", "",
407 [(IntOp addrmode6:$addr, (Ty DPR:$src))]>;
408 class VST1Q<bits<4> op7_4, string OpcodeStr, string Dt,
409 ValueType Ty, Intrinsic IntOp>
410 : NLdSt<0,0b00,0b1010,op7_4, (outs), (ins addrmode6:$addr, QPR:$src), IIC_VST,
411 OpcodeStr, Dt, "${src:dregpair}, $addr", "",
412 [(IntOp addrmode6:$addr, (Ty QPR:$src))]>;
414 let hasExtraSrcRegAllocReq = 1 in {
415 def VST1d8 : VST1D<0b0000, "vst1", "8", v8i8, int_arm_neon_vst1>;
416 def VST1d16 : VST1D<0b0100, "vst1", "16", v4i16, int_arm_neon_vst1>;
417 def VST1d32 : VST1D<0b1000, "vst1", "32", v2i32, int_arm_neon_vst1>;
418 def VST1df : VST1D<0b1000, "vst1", "32", v2f32, int_arm_neon_vst1>;
419 def VST1d64 : VST1D<0b1100, "vst1", "64", v1i64, int_arm_neon_vst1>;
421 def VST1q8 : VST1Q<0b0000, "vst1", "8", v16i8, int_arm_neon_vst1>;
422 def VST1q16 : VST1Q<0b0100, "vst1", "16", v8i16, int_arm_neon_vst1>;
423 def VST1q32 : VST1Q<0b1000, "vst1", "32", v4i32, int_arm_neon_vst1>;
424 def VST1qf : VST1Q<0b1000, "vst1", "32", v4f32, int_arm_neon_vst1>;
425 def VST1q64 : VST1Q<0b1100, "vst1", "64", v2i64, int_arm_neon_vst1>;
426 } // hasExtraSrcRegAllocReq
428 // These (dreg triple/quadruple) are for disassembly only.
429 class VST1D3<bits<4> op7_4, string OpcodeStr, string Dt>
430 : NLdSt<0, 0b00, 0b0110, op7_4, (outs),
431 (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3), IIC_VST,
433 "\\{$src1, $src2, $src3\\}, $addr", "",
434 [/* For disassembly only; pattern left blank */]>;
435 class VST1D4<bits<4> op7_4, string OpcodeStr, string Dt>
436 : NLdSt<0, 0b00, 0b0010, op7_4, (outs),
437 (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3, DPR:$src4),
438 IIC_VST, OpcodeStr, Dt,
439 "\\{$src1, $src2, $src3, $src4\\}, $addr", "",
440 [/* For disassembly only; pattern left blank */]>;
442 def VST1d8T : VST1D3<0b0000, "vst1", "8">;
443 def VST1d16T : VST1D3<0b0100, "vst1", "16">;
444 def VST1d32T : VST1D3<0b1000, "vst1", "32">;
445 //def VST1d64T : VST1D3<0b1100, "vst1", "64">;
447 def VST1d8Q : VST1D4<0b0000, "vst1", "8">;
448 def VST1d16Q : VST1D4<0b0100, "vst1", "16">;
449 def VST1d32Q : VST1D4<0b1000, "vst1", "32">;
450 //def VST1d64Q : VST1D4<0b1100, "vst1", "64">;
453 let mayStore = 1, hasExtraSrcRegAllocReq = 1 in {
455 // VST2 : Vector Store (multiple 2-element structures)
456 class VST2D<bits<4> op7_4, string OpcodeStr, string Dt>
457 : NLdSt<0,0b00,0b1000,op7_4, (outs),
458 (ins addrmode6:$addr, DPR:$src1, DPR:$src2), IIC_VST,
459 OpcodeStr, Dt, "\\{$src1, $src2\\}, $addr", "", []>;
460 class VST2Q<bits<4> op7_4, string OpcodeStr, string Dt>
461 : NLdSt<0,0b00,0b0011,op7_4, (outs),
462 (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3, DPR:$src4),
463 IIC_VST, OpcodeStr, Dt, "\\{$src1, $src2, $src3, $src4\\}, $addr",
466 def VST2d8 : VST2D<0b0000, "vst2", "8">;
467 def VST2d16 : VST2D<0b0100, "vst2", "16">;
468 def VST2d32 : VST2D<0b1000, "vst2", "32">;
469 def VST2d64 : NLdSt<0,0b00,0b1010,0b1100, (outs),
470 (ins addrmode6:$addr, DPR:$src1, DPR:$src2), IIC_VST,
471 "vst1", "64", "\\{$src1, $src2\\}, $addr", "", []>;
473 def VST2q8 : VST2Q<0b0000, "vst2", "8">;
474 def VST2q16 : VST2Q<0b0100, "vst2", "16">;
475 def VST2q32 : VST2Q<0b1000, "vst2", "32">;
477 // These (double-spaced dreg pair) are for disassembly only.
478 class VST2Ddbl<bits<4> op7_4, string OpcodeStr, string Dt>
479 : NLdSt<0, 0b00, 0b1001, op7_4, (outs),
480 (ins addrmode6:$addr, DPR:$src1, DPR:$src2), IIC_VST,
481 OpcodeStr, Dt, "\\{$src1, $src2\\}, $addr", "", []> {
482 let NSF = VLDSTLaneDblFrm; // For disassembly.
483 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
486 def VST2d8D : VST2Ddbl<0b0000, "vst2", "8">;
487 def VST2d16D : VST2Ddbl<0b0100, "vst2", "16">;
488 def VST2d32D : VST2Ddbl<0b1000, "vst2", "32">;
490 // VST3 : Vector Store (multiple 3-element structures)
491 class VST3D<bits<4> op7_4, string OpcodeStr, string Dt>
492 : NLdSt<0,0b00,0b0100,op7_4, (outs),
493 (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3), IIC_VST,
494 OpcodeStr, Dt, "\\{$src1, $src2, $src3\\}, $addr", "", []>;
495 class VST3WB<bits<4> op7_4, string OpcodeStr, string Dt>
496 : NLdSt<0,0b00,0b0101,op7_4, (outs GPR:$wb),
497 (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3), IIC_VST,
498 OpcodeStr, Dt, "\\{$src1, $src2, $src3\\}, $addr",
499 "$addr.addr = $wb", []> {
500 let NSF = VLDSTLaneDblFrm; // For disassembly.
501 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
504 def VST3d8 : VST3D<0b0000, "vst3", "8">;
505 def VST3d16 : VST3D<0b0100, "vst3", "16">;
506 def VST3d32 : VST3D<0b1000, "vst3", "32">;
507 def VST3d64 : NLdSt<0,0b00,0b0110,0b1100, (outs),
508 (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3),
510 "vst1", "64", "\\{$src1, $src2, $src3\\}, $addr", "", []>;
512 // vst3 to double-spaced even registers.
513 def VST3q8a : VST3WB<0b0000, "vst3", "8">;
514 def VST3q16a : VST3WB<0b0100, "vst3", "16">;
515 def VST3q32a : VST3WB<0b1000, "vst3", "32">;
517 // vst3 to double-spaced odd registers.
518 def VST3q8b : VST3WB<0b0000, "vst3", "8">;
519 def VST3q16b : VST3WB<0b0100, "vst3", "16">;
520 def VST3q32b : VST3WB<0b1000, "vst3", "32">;
522 // VST4 : Vector Store (multiple 4-element structures)
523 class VST4D<bits<4> op7_4, string OpcodeStr, string Dt>
524 : NLdSt<0,0b00,0b0000,op7_4, (outs),
525 (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3, DPR:$src4),
526 IIC_VST, OpcodeStr, Dt, "\\{$src1, $src2, $src3, $src4\\}, $addr",
528 class VST4WB<bits<4> op7_4, string OpcodeStr, string Dt>
529 : NLdSt<0,0b00,0b0001,op7_4, (outs GPR:$wb),
530 (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3, DPR:$src4),
531 IIC_VST, OpcodeStr, Dt, "\\{$src1, $src2, $src3, $src4\\}, $addr",
532 "$addr.addr = $wb", []> {
533 let NSF = VLDSTLaneDblFrm; // For disassembly.
534 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
537 def VST4d8 : VST4D<0b0000, "vst4", "8">;
538 def VST4d16 : VST4D<0b0100, "vst4", "16">;
539 def VST4d32 : VST4D<0b1000, "vst4", "32">;
540 def VST4d64 : NLdSt<0,0b00,0b0010,0b1100, (outs),
541 (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3,
543 "vst1", "64", "\\{$src1, $src2, $src3, $src4\\}, $addr",
546 // vst4 to double-spaced even registers.
547 def VST4q8a : VST4WB<0b0000, "vst4", "8">;
548 def VST4q16a : VST4WB<0b0100, "vst4", "16">;
549 def VST4q32a : VST4WB<0b1000, "vst4", "32">;
551 // vst4 to double-spaced odd registers.
552 def VST4q8b : VST4WB<0b0000, "vst4", "8">;
553 def VST4q16b : VST4WB<0b0100, "vst4", "16">;
554 def VST4q32b : VST4WB<0b1000, "vst4", "32">;
556 // VST1LN : Vector Store (single element from one lane)
557 // FIXME: Not yet implemented.
559 // VST2LN : Vector Store (single 2-element structure from one lane)
560 class VST2LN<bits<4> op11_8, string OpcodeStr, string Dt>
561 : NLdSt<1,0b00,op11_8,{?,?,?,?}, (outs),
562 (ins addrmode6:$addr, DPR:$src1, DPR:$src2, nohash_imm:$lane),
563 IIC_VST, OpcodeStr, Dt, "\\{$src1[$lane], $src2[$lane]\\}, $addr",
566 // vst2 to single-spaced registers.
567 def VST2LNd8 : VST2LN<0b0001, "vst2", "8">;
568 def VST2LNd16 : VST2LN<0b0101, "vst2", "16"> { let Inst{5} = 0; }
569 def VST2LNd32 : VST2LN<0b1001, "vst2", "32"> { let Inst{6} = 0; }
571 // vst2 to double-spaced even registers.
572 def VST2LNq16a: VST2LN<0b0101, "vst2", "16"> {
574 let NSF = VLDSTLaneDblFrm; // For disassembly.
575 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
577 def VST2LNq32a: VST2LN<0b1001, "vst2", "32"> {
579 let NSF = VLDSTLaneDblFrm; // For disassembly.
580 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
583 // vst2 to double-spaced odd registers.
584 def VST2LNq16b: VST2LN<0b0101, "vst2", "16"> {
586 let NSF = VLDSTLaneDblFrm; // For disassembly.
587 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
589 def VST2LNq32b: VST2LN<0b1001, "vst2", "32"> {
591 let NSF = VLDSTLaneDblFrm; // For disassembly.
592 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
595 // VST3LN : Vector Store (single 3-element structure from one lane)
596 class VST3LN<bits<4> op11_8, string OpcodeStr, string Dt>
597 : NLdSt<1,0b00,op11_8,{?,?,?,?}, (outs),
598 (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3,
599 nohash_imm:$lane), IIC_VST, OpcodeStr, Dt,
600 "\\{$src1[$lane], $src2[$lane], $src3[$lane]\\}, $addr", "", []>;
602 // vst3 to single-spaced registers.
603 def VST3LNd8 : VST3LN<0b0010, "vst3", "8"> { let Inst{4} = 0; }
604 def VST3LNd16 : VST3LN<0b0110, "vst3", "16"> { let Inst{5-4} = 0b00; }
605 def VST3LNd32 : VST3LN<0b1010, "vst3", "32"> { let Inst{6-4} = 0b000; }
607 // vst3 to double-spaced even registers.
608 def VST3LNq16a: VST3LN<0b0110, "vst3", "16"> {
609 let Inst{5-4} = 0b10;
610 let NSF = VLDSTLaneDblFrm; // For disassembly.
611 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
613 def VST3LNq32a: VST3LN<0b1010, "vst3", "32"> {
614 let Inst{6-4} = 0b100;
615 let NSF = VLDSTLaneDblFrm; // For disassembly.
616 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
619 // vst3 to double-spaced odd registers.
620 def VST3LNq16b: VST3LN<0b0110, "vst3", "16"> {
621 let Inst{5-4} = 0b10;
622 let NSF = VLDSTLaneDblFrm; // For disassembly.
623 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
625 def VST3LNq32b: VST3LN<0b1010, "vst3", "32"> {
626 let Inst{6-4} = 0b100;
627 let NSF = VLDSTLaneDblFrm; // For disassembly.
628 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
631 // VST4LN : Vector Store (single 4-element structure from one lane)
632 class VST4LN<bits<4> op11_8, string OpcodeStr, string Dt>
633 : NLdSt<1,0b00,op11_8,{?,?,?,?}, (outs),
634 (ins addrmode6:$addr, DPR:$src1, DPR:$src2, DPR:$src3, DPR:$src4,
635 nohash_imm:$lane), IIC_VST, OpcodeStr, Dt,
636 "\\{$src1[$lane], $src2[$lane], $src3[$lane], $src4[$lane]\\}, $addr",
639 // vst4 to single-spaced registers.
640 def VST4LNd8 : VST4LN<0b0011, "vst4", "8">;
641 def VST4LNd16 : VST4LN<0b0111, "vst4", "16"> { let Inst{5} = 0; }
642 def VST4LNd32 : VST4LN<0b1011, "vst4", "32"> { let Inst{6} = 0; }
644 // vst4 to double-spaced even registers.
645 def VST4LNq16a: VST4LN<0b0111, "vst4", "16"> {
647 let NSF = VLDSTLaneDblFrm; // For disassembly.
648 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
650 def VST4LNq32a: VST4LN<0b1011, "vst4", "32"> {
652 let NSF = VLDSTLaneDblFrm; // For disassembly.
653 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
656 // vst4 to double-spaced odd registers.
657 def VST4LNq16b: VST4LN<0b0111, "vst4", "16"> {
659 let NSF = VLDSTLaneDblFrm; // For disassembly.
660 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
662 def VST4LNq32b: VST4LN<0b1011, "vst4", "32"> {
664 let NSF = VLDSTLaneDblFrm; // For disassembly.
665 let NSForm = VLDSTLaneDblFrm.Value; // For disassembly.
668 } // mayStore = 1, hasExtraSrcRegAllocReq = 1
671 //===----------------------------------------------------------------------===//
672 // NEON pattern fragments
673 //===----------------------------------------------------------------------===//
675 // Extract D sub-registers of Q registers.
676 // (arm_dsubreg_0 is 5; arm_dsubreg_1 is 6)
677 def DSubReg_i8_reg : SDNodeXForm<imm, [{
678 return CurDAG->getTargetConstant(5 + N->getZExtValue() / 8, MVT::i32);
680 def DSubReg_i16_reg : SDNodeXForm<imm, [{
681 return CurDAG->getTargetConstant(5 + N->getZExtValue() / 4, MVT::i32);
683 def DSubReg_i32_reg : SDNodeXForm<imm, [{
684 return CurDAG->getTargetConstant(5 + N->getZExtValue() / 2, MVT::i32);
686 def DSubReg_f64_reg : SDNodeXForm<imm, [{
687 return CurDAG->getTargetConstant(5 + N->getZExtValue(), MVT::i32);
689 def DSubReg_f64_other_reg : SDNodeXForm<imm, [{
690 return CurDAG->getTargetConstant(5 + (1 - N->getZExtValue()), MVT::i32);
693 // Extract S sub-registers of Q/D registers.
694 // (arm_ssubreg_0 is 1; arm_ssubreg_1 is 2; etc.)
695 def SSubReg_f32_reg : SDNodeXForm<imm, [{
696 return CurDAG->getTargetConstant(1 + N->getZExtValue(), MVT::i32);
699 // Translate lane numbers from Q registers to D subregs.
700 def SubReg_i8_lane : SDNodeXForm<imm, [{
701 return CurDAG->getTargetConstant(N->getZExtValue() & 7, MVT::i32);
703 def SubReg_i16_lane : SDNodeXForm<imm, [{
704 return CurDAG->getTargetConstant(N->getZExtValue() & 3, MVT::i32);
706 def SubReg_i32_lane : SDNodeXForm<imm, [{
707 return CurDAG->getTargetConstant(N->getZExtValue() & 1, MVT::i32);
710 //===----------------------------------------------------------------------===//
711 // Instruction Classes
712 //===----------------------------------------------------------------------===//
714 // Basic 2-register operations: single-, double- and quad-register.
715 class N2VS<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
716 bits<2> op17_16, bits<5> op11_7, bit op4, string OpcodeStr,
717 string Dt, ValueType ResTy, ValueType OpTy, SDNode OpNode>
718 : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 0, op4,
719 (outs DPR_VFP2:$dst), (ins DPR_VFP2:$src),
720 IIC_VUNAD, OpcodeStr, Dt, "$dst, $src", "", []>;
721 class N2VD<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
722 bits<2> op17_16, bits<5> op11_7, bit op4, string OpcodeStr,
723 string Dt, ValueType ResTy, ValueType OpTy, SDNode OpNode>
724 : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 0, op4, (outs DPR:$dst),
725 (ins DPR:$src), IIC_VUNAD, OpcodeStr, Dt, "$dst, $src", "",
726 [(set DPR:$dst, (ResTy (OpNode (OpTy DPR:$src))))]>;
727 class N2VQ<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
728 bits<2> op17_16, bits<5> op11_7, bit op4, string OpcodeStr,
729 string Dt, ValueType ResTy, ValueType OpTy, SDNode OpNode>
730 : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 1, op4, (outs QPR:$dst),
731 (ins QPR:$src), IIC_VUNAQ, OpcodeStr, Dt, "$dst, $src", "",
732 [(set QPR:$dst, (ResTy (OpNode (OpTy QPR:$src))))]>;
734 // Basic 2-register intrinsics, both double- and quad-register.
735 class N2VDInt<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
736 bits<2> op17_16, bits<5> op11_7, bit op4,
737 InstrItinClass itin, string OpcodeStr, string Dt,
738 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
739 : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 0, op4, (outs DPR:$dst),
740 (ins DPR:$src), itin, OpcodeStr, Dt, "$dst, $src", "",
741 [(set DPR:$dst, (ResTy (IntOp (OpTy DPR:$src))))]>;
742 class N2VQInt<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
743 bits<2> op17_16, bits<5> op11_7, bit op4,
744 InstrItinClass itin, string OpcodeStr, string Dt,
745 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
746 : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 1, op4, (outs QPR:$dst),
747 (ins QPR:$src), itin, OpcodeStr, Dt, "$dst, $src", "",
748 [(set QPR:$dst, (ResTy (IntOp (OpTy QPR:$src))))]>;
750 // Narrow 2-register intrinsics.
751 class N2VNInt<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
752 bits<2> op17_16, bits<5> op11_7, bit op6, bit op4,
753 InstrItinClass itin, string OpcodeStr, string Dt,
754 ValueType TyD, ValueType TyQ, Intrinsic IntOp>
755 : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, op6, op4, (outs DPR:$dst),
756 (ins QPR:$src), itin, OpcodeStr, Dt, "$dst, $src", "",
757 [(set DPR:$dst, (TyD (IntOp (TyQ QPR:$src))))]>;
759 // Long 2-register intrinsics (currently only used for VMOVL).
760 class N2VLInt<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
761 bits<2> op17_16, bits<5> op11_7, bit op6, bit op4,
762 InstrItinClass itin, string OpcodeStr, string Dt,
763 ValueType TyQ, ValueType TyD, Intrinsic IntOp>
764 : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, op6, op4, (outs QPR:$dst),
765 (ins DPR:$src), itin, OpcodeStr, Dt, "$dst, $src", "",
766 [(set QPR:$dst, (TyQ (IntOp (TyD DPR:$src))))]>;
768 // 2-register shuffles (VTRN/VZIP/VUZP), both double- and quad-register.
769 class N2VDShuffle<bits<2> op19_18, bits<5> op11_7, string OpcodeStr, string Dt>
770 : N2V<0b11, 0b11, op19_18, 0b10, op11_7, 0, 0, (outs DPR:$dst1, DPR:$dst2),
771 (ins DPR:$src1, DPR:$src2), IIC_VPERMD,
772 OpcodeStr, Dt, "$dst1, $dst2",
773 "$src1 = $dst1, $src2 = $dst2", []> {
774 let NSF = NVectorShuffleFrm; // For disassembly.
775 let NSForm = NVectorShuffleFrm.Value; // For disassembly.
777 class N2VQShuffle<bits<2> op19_18, bits<5> op11_7,
778 InstrItinClass itin, string OpcodeStr, string Dt>
779 : N2V<0b11, 0b11, op19_18, 0b10, op11_7, 1, 0, (outs QPR:$dst1, QPR:$dst2),
780 (ins QPR:$src1, QPR:$src2), itin, OpcodeStr, Dt, "$dst1, $dst2",
781 "$src1 = $dst1, $src2 = $dst2", []> {
782 let NSF = NVectorShuffleFrm; // For disassembly.
783 let NSForm = NVectorShuffleFrm.Value; // For disassembly.
786 // Basic 3-register operations: single-, double- and quad-register.
787 class N3VS<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
788 string OpcodeStr, string Dt, ValueType ResTy, ValueType OpTy,
789 SDNode OpNode, bit Commutable>
790 : N3V<op24, op23, op21_20, op11_8, 0, op4,
791 (outs DPR_VFP2:$dst), (ins DPR_VFP2:$src1, DPR_VFP2:$src2), IIC_VBIND,
792 OpcodeStr, Dt, "$dst, $src1, $src2", "", []> {
793 let isCommutable = Commutable;
796 class N3VD<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
797 InstrItinClass itin, string OpcodeStr, string Dt,
798 ValueType ResTy, ValueType OpTy, SDNode OpNode, bit Commutable>
799 : N3V<op24, op23, op21_20, op11_8, 0, op4,
800 (outs DPR:$dst), (ins DPR:$src1, DPR:$src2), itin,
801 OpcodeStr, Dt, "$dst, $src1, $src2", "",
802 [(set DPR:$dst, (ResTy (OpNode (OpTy DPR:$src1), (OpTy DPR:$src2))))]> {
803 let isCommutable = Commutable;
805 // Same as N3VD but no data type.
806 class N3VDX<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
807 InstrItinClass itin, string OpcodeStr,
808 ValueType ResTy, ValueType OpTy,
809 SDNode OpNode, bit Commutable>
810 : N3VX<op24, op23, op21_20, op11_8, 0, op4,
811 (outs DPR:$dst), (ins DPR:$src1, DPR:$src2), itin,
812 OpcodeStr, "$dst, $src1, $src2", "",
813 [(set DPR:$dst, (ResTy (OpNode (OpTy DPR:$src1), (OpTy DPR:$src2))))]>{
814 let isCommutable = Commutable;
816 class N3VDSL<bits<2> op21_20, bits<4> op11_8,
817 InstrItinClass itin, string OpcodeStr, string Dt,
818 ValueType Ty, SDNode ShOp>
819 : N3V<0, 1, op21_20, op11_8, 1, 0,
820 (outs DPR:$dst), (ins DPR:$src1, DPR_VFP2:$src2, nohash_imm:$lane),
821 itin, OpcodeStr, Dt, "$dst, $src1, $src2[$lane]", "",
823 (Ty (ShOp (Ty DPR:$src1),
824 (Ty (NEONvduplane (Ty DPR_VFP2:$src2), imm:$lane)))))]>{
825 let isCommutable = 0;
826 let NSF = NVdVnVmImmMulScalarFrm; // For disassembly.
827 let NSForm = NVdVnVmImmMulScalarFrm.Value; // For disassembly.
829 class N3VDSL16<bits<2> op21_20, bits<4> op11_8,
830 string OpcodeStr, string Dt, ValueType Ty, SDNode ShOp>
831 : N3V<0, 1, op21_20, op11_8, 1, 0,
832 (outs DPR:$dst), (ins DPR:$src1, DPR_8:$src2, nohash_imm:$lane),
833 IIC_VMULi16D, OpcodeStr, Dt, "$dst, $src1, $src2[$lane]", "",
835 (Ty (ShOp (Ty DPR:$src1),
836 (Ty (NEONvduplane (Ty DPR_8:$src2), imm:$lane)))))]> {
837 let isCommutable = 0;
838 let NSF = NVdVnVmImmMulScalarFrm; // For disassembly.
839 let NSForm = NVdVnVmImmMulScalarFrm.Value; // For disassembly.
842 class N3VQ<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
843 InstrItinClass itin, string OpcodeStr, string Dt,
844 ValueType ResTy, ValueType OpTy, SDNode OpNode, bit Commutable>
845 : N3V<op24, op23, op21_20, op11_8, 1, op4,
846 (outs QPR:$dst), (ins QPR:$src1, QPR:$src2), itin,
847 OpcodeStr, Dt, "$dst, $src1, $src2", "",
848 [(set QPR:$dst, (ResTy (OpNode (OpTy QPR:$src1), (OpTy QPR:$src2))))]> {
849 let isCommutable = Commutable;
851 class N3VQX<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
852 InstrItinClass itin, string OpcodeStr,
853 ValueType ResTy, ValueType OpTy, SDNode OpNode, bit Commutable>
854 : N3VX<op24, op23, op21_20, op11_8, 1, op4,
855 (outs QPR:$dst), (ins QPR:$src1, QPR:$src2), itin,
856 OpcodeStr, "$dst, $src1, $src2", "",
857 [(set QPR:$dst, (ResTy (OpNode (OpTy QPR:$src1), (OpTy QPR:$src2))))]>{
858 let isCommutable = Commutable;
860 class N3VQSL<bits<2> op21_20, bits<4> op11_8,
861 InstrItinClass itin, string OpcodeStr, string Dt,
862 ValueType ResTy, ValueType OpTy, SDNode ShOp>
863 : N3V<1, 1, op21_20, op11_8, 1, 0,
864 (outs QPR:$dst), (ins QPR:$src1, DPR_VFP2:$src2, nohash_imm:$lane),
865 itin, OpcodeStr, Dt, "$dst, $src1, $src2[$lane]", "",
866 [(set (ResTy QPR:$dst),
867 (ResTy (ShOp (ResTy QPR:$src1),
868 (ResTy (NEONvduplane (OpTy DPR_VFP2:$src2),
870 let isCommutable = 0;
871 let NSF = NVdVnVmImmMulScalarFrm; // For disassembly.
872 let NSForm = NVdVnVmImmMulScalarFrm.Value; // For disassembly.
874 class N3VQSL16<bits<2> op21_20, bits<4> op11_8, string OpcodeStr, string Dt,
875 ValueType ResTy, ValueType OpTy, SDNode ShOp>
876 : N3V<1, 1, op21_20, op11_8, 1, 0,
877 (outs QPR:$dst), (ins QPR:$src1, DPR_8:$src2, nohash_imm:$lane),
878 IIC_VMULi16Q, OpcodeStr, Dt, "$dst, $src1, $src2[$lane]", "",
879 [(set (ResTy QPR:$dst),
880 (ResTy (ShOp (ResTy QPR:$src1),
881 (ResTy (NEONvduplane (OpTy DPR_8:$src2),
883 let isCommutable = 0;
884 let NSF = NVdVnVmImmMulScalarFrm; // For disassembly.
885 let NSForm = NVdVnVmImmMulScalarFrm.Value; // For disassembly.
888 // Basic 3-register intrinsics, both double- and quad-register.
889 class N3VDInt<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
890 InstrItinClass itin, string OpcodeStr, string Dt,
891 ValueType ResTy, ValueType OpTy, Intrinsic IntOp, bit Commutable>
892 : N3V<op24, op23, op21_20, op11_8, 0, op4,
893 (outs DPR:$dst), (ins DPR:$src1, DPR:$src2), itin,
894 OpcodeStr, Dt, "$dst, $src1, $src2", "",
895 [(set DPR:$dst, (ResTy (IntOp (OpTy DPR:$src1), (OpTy DPR:$src2))))]> {
896 let isCommutable = Commutable;
898 class N3VDIntSL<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
899 string OpcodeStr, string Dt, ValueType Ty, Intrinsic IntOp>
900 : N3V<0, 1, op21_20, op11_8, 1, 0,
901 (outs DPR:$dst), (ins DPR:$src1, DPR_VFP2:$src2, nohash_imm:$lane),
902 itin, OpcodeStr, Dt, "$dst, $src1, $src2[$lane]", "",
904 (Ty (IntOp (Ty DPR:$src1),
905 (Ty (NEONvduplane (Ty DPR_VFP2:$src2),
907 let isCommutable = 0;
908 let NSF = NVdVnVmImmMulScalarFrm; // For disassembly.
909 let NSForm = NVdVnVmImmMulScalarFrm.Value; // For disassembly.
911 class N3VDIntSL16<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
912 string OpcodeStr, string Dt, ValueType Ty, Intrinsic IntOp>
913 : N3V<0, 1, op21_20, op11_8, 1, 0,
914 (outs DPR:$dst), (ins DPR:$src1, DPR_8:$src2, nohash_imm:$lane),
915 itin, OpcodeStr, Dt, "$dst, $src1, $src2[$lane]", "",
917 (Ty (IntOp (Ty DPR:$src1),
918 (Ty (NEONvduplane (Ty DPR_8:$src2),
920 let isCommutable = 0;
921 let NSF = NVdVnVmImmMulScalarFrm; // For disassembly.
922 let NSForm = NVdVnVmImmMulScalarFrm.Value; // For disassembly.
925 class N3VQInt<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
926 InstrItinClass itin, string OpcodeStr, string Dt,
927 ValueType ResTy, ValueType OpTy, Intrinsic IntOp, bit Commutable>
928 : N3V<op24, op23, op21_20, op11_8, 1, op4,
929 (outs QPR:$dst), (ins QPR:$src1, QPR:$src2), itin,
930 OpcodeStr, Dt, "$dst, $src1, $src2", "",
931 [(set QPR:$dst, (ResTy (IntOp (OpTy QPR:$src1), (OpTy QPR:$src2))))]> {
932 let isCommutable = Commutable;
934 class N3VQIntSL<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
935 string OpcodeStr, string Dt,
936 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
937 : N3V<1, 1, op21_20, op11_8, 1, 0,
938 (outs QPR:$dst), (ins QPR:$src1, DPR_VFP2:$src2, nohash_imm:$lane),
939 itin, OpcodeStr, Dt, "$dst, $src1, $src2[$lane]", "",
940 [(set (ResTy QPR:$dst),
941 (ResTy (IntOp (ResTy QPR:$src1),
942 (ResTy (NEONvduplane (OpTy DPR_VFP2:$src2),
944 let isCommutable = 0;
945 let NSF = NVdVnVmImmMulScalarFrm; // For disassembly.
946 let NSForm = NVdVnVmImmMulScalarFrm.Value; // For disassembly.
948 class N3VQIntSL16<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
949 string OpcodeStr, string Dt,
950 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
951 : N3V<1, 1, op21_20, op11_8, 1, 0,
952 (outs QPR:$dst), (ins QPR:$src1, DPR_8:$src2, nohash_imm:$lane),
953 itin, OpcodeStr, Dt, "$dst, $src1, $src2[$lane]", "",
954 [(set (ResTy QPR:$dst),
955 (ResTy (IntOp (ResTy QPR:$src1),
956 (ResTy (NEONvduplane (OpTy DPR_8:$src2),
958 let isCommutable = 0;
959 let NSF = NVdVnVmImmMulScalarFrm; // For disassembly.
960 let NSForm = NVdVnVmImmMulScalarFrm.Value; // For disassembly.
963 // Multiply-Add/Sub operations: single-, double- and quad-register.
964 class N3VSMulOp<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
965 InstrItinClass itin, string OpcodeStr, string Dt,
966 ValueType Ty, SDNode MulOp, SDNode OpNode>
967 : N3V<op24, op23, op21_20, op11_8, 0, op4,
968 (outs DPR_VFP2:$dst),
969 (ins DPR_VFP2:$src1, DPR_VFP2:$src2, DPR_VFP2:$src3), itin,
970 OpcodeStr, Dt, "$dst, $src2, $src3", "$src1 = $dst", []>;
972 class N3VDMulOp<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
973 InstrItinClass itin, string OpcodeStr, string Dt,
974 ValueType Ty, SDNode MulOp, SDNode OpNode>
975 : N3V<op24, op23, op21_20, op11_8, 0, op4,
976 (outs DPR:$dst), (ins DPR:$src1, DPR:$src2, DPR:$src3), itin,
977 OpcodeStr, Dt, "$dst, $src2, $src3", "$src1 = $dst",
978 [(set DPR:$dst, (Ty (OpNode DPR:$src1,
979 (Ty (MulOp DPR:$src2, DPR:$src3)))))]>;
980 class N3VDMulOpSL<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
981 string OpcodeStr, string Dt,
982 ValueType Ty, SDNode MulOp, SDNode ShOp>
983 : N3V<0, 1, op21_20, op11_8, 1, 0,
985 (ins DPR:$src1, DPR:$src2, DPR_VFP2:$src3, nohash_imm:$lane), itin,
986 OpcodeStr, Dt, "$dst, $src2, $src3[$lane]", "$src1 = $dst",
988 (Ty (ShOp (Ty DPR:$src1),
989 (Ty (MulOp DPR:$src2,
990 (Ty (NEONvduplane (Ty DPR_VFP2:$src3),
992 let NSF = NVdVnVmImmMulScalarFrm; // For disassembly.
993 let NSForm = NVdVnVmImmMulScalarFrm.Value; // For disassembly.
995 class N3VDMulOpSL16<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
996 string OpcodeStr, string Dt,
997 ValueType Ty, SDNode MulOp, SDNode ShOp>
998 : N3V<0, 1, op21_20, op11_8, 1, 0,
1000 (ins DPR:$src1, DPR:$src2, DPR_8:$src3, nohash_imm:$lane), itin,
1001 OpcodeStr, Dt, "$dst, $src2, $src3[$lane]", "$src1 = $dst",
1002 [(set (Ty DPR:$dst),
1003 (Ty (ShOp (Ty DPR:$src1),
1004 (Ty (MulOp DPR:$src2,
1005 (Ty (NEONvduplane (Ty DPR_8:$src3),
1006 imm:$lane)))))))]> {
1007 let NSF = NVdVnVmImmMulScalarFrm; // For disassembly.
1008 let NSForm = NVdVnVmImmMulScalarFrm.Value; // For disassembly.
1011 class N3VQMulOp<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
1012 InstrItinClass itin, string OpcodeStr, string Dt, ValueType Ty,
1013 SDNode MulOp, SDNode OpNode>
1014 : N3V<op24, op23, op21_20, op11_8, 1, op4,
1015 (outs QPR:$dst), (ins QPR:$src1, QPR:$src2, QPR:$src3), itin,
1016 OpcodeStr, Dt, "$dst, $src2, $src3", "$src1 = $dst",
1017 [(set QPR:$dst, (Ty (OpNode QPR:$src1,
1018 (Ty (MulOp QPR:$src2, QPR:$src3)))))]>;
1019 class N3VQMulOpSL<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
1020 string OpcodeStr, string Dt, ValueType ResTy, ValueType OpTy,
1021 SDNode MulOp, SDNode ShOp>
1022 : N3V<1, 1, op21_20, op11_8, 1, 0,
1024 (ins QPR:$src1, QPR:$src2, DPR_VFP2:$src3, nohash_imm:$lane), itin,
1025 OpcodeStr, Dt, "$dst, $src2, $src3[$lane]", "$src1 = $dst",
1026 [(set (ResTy QPR:$dst),
1027 (ResTy (ShOp (ResTy QPR:$src1),
1028 (ResTy (MulOp QPR:$src2,
1029 (ResTy (NEONvduplane (OpTy DPR_VFP2:$src3),
1030 imm:$lane)))))))]> {
1031 let NSF = NVdVnVmImmMulScalarFrm; // For disassembly.
1032 let NSForm = NVdVnVmImmMulScalarFrm.Value; // For disassembly.
1034 class N3VQMulOpSL16<bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
1035 string OpcodeStr, string Dt,
1036 ValueType ResTy, ValueType OpTy,
1037 SDNode MulOp, SDNode ShOp>
1038 : N3V<1, 1, op21_20, op11_8, 1, 0,
1040 (ins QPR:$src1, QPR:$src2, DPR_8:$src3, nohash_imm:$lane), itin,
1041 OpcodeStr, Dt, "$dst, $src2, $src3[$lane]", "$src1 = $dst",
1042 [(set (ResTy QPR:$dst),
1043 (ResTy (ShOp (ResTy QPR:$src1),
1044 (ResTy (MulOp QPR:$src2,
1045 (ResTy (NEONvduplane (OpTy DPR_8:$src3),
1046 imm:$lane)))))))]> {
1047 let NSF = NVdVnVmImmMulScalarFrm; // For disassembly.
1048 let NSForm = NVdVnVmImmMulScalarFrm.Value; // For disassembly.
1051 // Neon 3-argument intrinsics, both double- and quad-register.
1052 // The destination register is also used as the first source operand register.
1053 class N3VDInt3<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
1054 InstrItinClass itin, string OpcodeStr, string Dt,
1055 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
1056 : N3V<op24, op23, op21_20, op11_8, 0, op4,
1057 (outs DPR:$dst), (ins DPR:$src1, DPR:$src2, DPR:$src3), itin,
1058 OpcodeStr, Dt, "$dst, $src2, $src3", "$src1 = $dst",
1059 [(set DPR:$dst, (ResTy (IntOp (OpTy DPR:$src1),
1060 (OpTy DPR:$src2), (OpTy DPR:$src3))))]>;
1061 class N3VQInt3<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
1062 InstrItinClass itin, string OpcodeStr, string Dt,
1063 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
1064 : N3V<op24, op23, op21_20, op11_8, 1, op4,
1065 (outs QPR:$dst), (ins QPR:$src1, QPR:$src2, QPR:$src3), itin,
1066 OpcodeStr, Dt, "$dst, $src2, $src3", "$src1 = $dst",
1067 [(set QPR:$dst, (ResTy (IntOp (OpTy QPR:$src1),
1068 (OpTy QPR:$src2), (OpTy QPR:$src3))))]>;
1070 // Neon Long 3-argument intrinsic. The destination register is
1071 // a quad-register and is also used as the first source operand register.
1072 class N3VLInt3<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
1073 InstrItinClass itin, string OpcodeStr, string Dt,
1074 ValueType TyQ, ValueType TyD, Intrinsic IntOp>
1075 : N3V<op24, op23, op21_20, op11_8, 0, op4,
1076 (outs QPR:$dst), (ins QPR:$src1, DPR:$src2, DPR:$src3), itin,
1077 OpcodeStr, Dt, "$dst, $src2, $src3", "$src1 = $dst",
1079 (TyQ (IntOp (TyQ QPR:$src1), (TyD DPR:$src2), (TyD DPR:$src3))))]>;
1080 class N3VLInt3SL<bit op24, bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
1081 string OpcodeStr, string Dt,
1082 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
1083 : N3V<op24, 1, op21_20, op11_8, 1, 0,
1085 (ins QPR:$src1, DPR:$src2, DPR_VFP2:$src3, nohash_imm:$lane), itin,
1086 OpcodeStr, Dt, "$dst, $src2, $src3[$lane]", "$src1 = $dst",
1087 [(set (ResTy QPR:$dst),
1088 (ResTy (IntOp (ResTy QPR:$src1),
1090 (OpTy (NEONvduplane (OpTy DPR_VFP2:$src3),
1092 class N3VLInt3SL16<bit op24, bits<2> op21_20, bits<4> op11_8,
1093 InstrItinClass itin, string OpcodeStr, string Dt,
1094 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
1095 : N3V<op24, 1, op21_20, op11_8, 1, 0,
1097 (ins QPR:$src1, DPR:$src2, DPR_8:$src3, nohash_imm:$lane), itin,
1098 OpcodeStr, Dt, "$dst, $src2, $src3[$lane]", "$src1 = $dst",
1099 [(set (ResTy QPR:$dst),
1100 (ResTy (IntOp (ResTy QPR:$src1),
1102 (OpTy (NEONvduplane (OpTy DPR_8:$src3),
1105 // Narrowing 3-register intrinsics.
1106 class N3VNInt<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
1107 string OpcodeStr, string Dt, ValueType TyD, ValueType TyQ,
1108 Intrinsic IntOp, bit Commutable>
1109 : N3V<op24, op23, op21_20, op11_8, 0, op4,
1110 (outs DPR:$dst), (ins QPR:$src1, QPR:$src2), IIC_VBINi4D,
1111 OpcodeStr, Dt, "$dst, $src1, $src2", "",
1112 [(set DPR:$dst, (TyD (IntOp (TyQ QPR:$src1), (TyQ QPR:$src2))))]> {
1113 let isCommutable = Commutable;
1116 // Long 3-register intrinsics.
1117 class N3VLInt<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
1118 InstrItinClass itin, string OpcodeStr, string Dt,
1119 ValueType TyQ, ValueType TyD, Intrinsic IntOp, bit Commutable>
1120 : N3V<op24, op23, op21_20, op11_8, 0, op4,
1121 (outs QPR:$dst), (ins DPR:$src1, DPR:$src2), itin,
1122 OpcodeStr, Dt, "$dst, $src1, $src2", "",
1123 [(set QPR:$dst, (TyQ (IntOp (TyD DPR:$src1), (TyD DPR:$src2))))]> {
1124 let isCommutable = Commutable;
1126 class N3VLIntSL<bit op24, bits<2> op21_20, bits<4> op11_8, InstrItinClass itin,
1127 string OpcodeStr, string Dt,
1128 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
1129 : N3V<op24, 1, op21_20, op11_8, 1, 0,
1130 (outs QPR:$dst), (ins DPR:$src1, DPR_VFP2:$src2, nohash_imm:$lane),
1131 itin, OpcodeStr, Dt, "$dst, $src1, $src2[$lane]", "",
1132 [(set (ResTy QPR:$dst),
1133 (ResTy (IntOp (OpTy DPR:$src1),
1134 (OpTy (NEONvduplane (OpTy DPR_VFP2:$src2),
1136 let NSF = NVdVnVmImmMulScalarFrm; // For disassembly.
1137 let NSForm = NVdVnVmImmMulScalarFrm.Value; // For disassembly.
1139 class N3VLIntSL16<bit op24, bits<2> op21_20, bits<4> op11_8,
1140 InstrItinClass itin, string OpcodeStr, string Dt,
1141 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
1142 : N3V<op24, 1, op21_20, op11_8, 1, 0,
1143 (outs QPR:$dst), (ins DPR:$src1, DPR_8:$src2, nohash_imm:$lane),
1144 itin, OpcodeStr, Dt, "$dst, $src1, $src2[$lane]", "",
1145 [(set (ResTy QPR:$dst),
1146 (ResTy (IntOp (OpTy DPR:$src1),
1147 (OpTy (NEONvduplane (OpTy DPR_8:$src2),
1149 let NSF = NVdVnVmImmMulScalarFrm; // For disassembly.
1150 let NSForm = NVdVnVmImmMulScalarFrm.Value; // For disassembly.
1153 // Wide 3-register intrinsics.
1154 class N3VWInt<bit op24, bit op23, bits<2> op21_20, bits<4> op11_8, bit op4,
1155 string OpcodeStr, string Dt, ValueType TyQ, ValueType TyD,
1156 Intrinsic IntOp, bit Commutable>
1157 : N3V<op24, op23, op21_20, op11_8, 0, op4,
1158 (outs QPR:$dst), (ins QPR:$src1, DPR:$src2), IIC_VSUBiD,
1159 OpcodeStr, Dt, "$dst, $src1, $src2", "",
1160 [(set QPR:$dst, (TyQ (IntOp (TyQ QPR:$src1), (TyD DPR:$src2))))]> {
1161 let isCommutable = Commutable;
1164 // Pairwise long 2-register intrinsics, both double- and quad-register.
1165 class N2VDPLInt<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
1166 bits<2> op17_16, bits<5> op11_7, bit op4,
1167 string OpcodeStr, string Dt,
1168 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
1169 : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 0, op4, (outs DPR:$dst),
1170 (ins DPR:$src), IIC_VSHLiD, OpcodeStr, Dt, "$dst, $src", "",
1171 [(set DPR:$dst, (ResTy (IntOp (OpTy DPR:$src))))]>;
1172 class N2VQPLInt<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
1173 bits<2> op17_16, bits<5> op11_7, bit op4,
1174 string OpcodeStr, string Dt,
1175 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
1176 : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 1, op4, (outs QPR:$dst),
1177 (ins QPR:$src), IIC_VSHLiD, OpcodeStr, Dt, "$dst, $src", "",
1178 [(set QPR:$dst, (ResTy (IntOp (OpTy QPR:$src))))]>;
1180 // Pairwise long 2-register accumulate intrinsics,
1181 // both double- and quad-register.
1182 // The destination register is also used as the first source operand register.
1183 class N2VDPLInt2<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
1184 bits<2> op17_16, bits<5> op11_7, bit op4,
1185 string OpcodeStr, string Dt,
1186 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
1187 : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 0, op4,
1188 (outs DPR:$dst), (ins DPR:$src1, DPR:$src2), IIC_VPALiD,
1189 OpcodeStr, Dt, "$dst, $src2", "$src1 = $dst",
1190 [(set DPR:$dst, (ResTy (IntOp (ResTy DPR:$src1), (OpTy DPR:$src2))))]>;
1191 class N2VQPLInt2<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
1192 bits<2> op17_16, bits<5> op11_7, bit op4,
1193 string OpcodeStr, string Dt,
1194 ValueType ResTy, ValueType OpTy, Intrinsic IntOp>
1195 : N2V<op24_23, op21_20, op19_18, op17_16, op11_7, 1, op4,
1196 (outs QPR:$dst), (ins QPR:$src1, QPR:$src2), IIC_VPALiQ,
1197 OpcodeStr, Dt, "$dst, $src2", "$src1 = $dst",
1198 [(set QPR:$dst, (ResTy (IntOp (ResTy QPR:$src1), (OpTy QPR:$src2))))]>;
1200 // This is a big let * in block to mark these instructions NVectorShiftFrm to
1201 // help the disassembler.
1202 let NSF = NVectorShiftFrm, NSForm = NVectorShiftFrm.Value in {
1204 // Shift by immediate,
1205 // both double- and quad-register.
1206 class N2VDSh<bit op24, bit op23, bits<4> op11_8, bit op7, bit op4,
1207 InstrItinClass itin, string OpcodeStr, string Dt,
1208 ValueType Ty, SDNode OpNode>
1209 : N2VImm<op24, op23, op11_8, op7, 0, op4,
1210 (outs DPR:$dst), (ins DPR:$src, i32imm:$SIMM), itin,
1211 OpcodeStr, Dt, "$dst, $src, $SIMM", "",
1212 [(set DPR:$dst, (Ty (OpNode (Ty DPR:$src), (i32 imm:$SIMM))))]>;
1213 class N2VQSh<bit op24, bit op23, bits<4> op11_8, bit op7, bit op4,
1214 InstrItinClass itin, string OpcodeStr, string Dt,
1215 ValueType Ty, SDNode OpNode>
1216 : N2VImm<op24, op23, op11_8, op7, 1, op4,
1217 (outs QPR:$dst), (ins QPR:$src, i32imm:$SIMM), itin,
1218 OpcodeStr, Dt, "$dst, $src, $SIMM", "",
1219 [(set QPR:$dst, (Ty (OpNode (Ty QPR:$src), (i32 imm:$SIMM))))]>;
1221 // Narrow shift by immediate.
1222 class N2VNSh<bit op24, bit op23, bits<4> op11_8, bit op7, bit op6, bit op4,
1223 InstrItinClass itin, string OpcodeStr, string Dt,
1224 ValueType ResTy, ValueType OpTy, SDNode OpNode>
1225 : N2VImm<op24, op23, op11_8, op7, op6, op4,
1226 (outs DPR:$dst), (ins QPR:$src, i32imm:$SIMM), itin,
1227 OpcodeStr, Dt, "$dst, $src, $SIMM", "",
1228 [(set DPR:$dst, (ResTy (OpNode (OpTy QPR:$src),
1229 (i32 imm:$SIMM))))]>;
1231 // Shift right by immediate and accumulate,
1232 // both double- and quad-register.
1233 class N2VDShAdd<bit op24, bit op23, bits<4> op11_8, bit op7, bit op4,
1234 string OpcodeStr, string Dt, ValueType Ty, SDNode ShOp>
1235 : N2VImm<op24, op23, op11_8, op7, 0, op4, (outs DPR:$dst),
1236 (ins DPR:$src1, DPR:$src2, i32imm:$SIMM), IIC_VPALiD,
1237 OpcodeStr, Dt, "$dst, $src2, $SIMM", "$src1 = $dst",
1238 [(set DPR:$dst, (Ty (add DPR:$src1,
1239 (Ty (ShOp DPR:$src2, (i32 imm:$SIMM))))))]>;
1240 class N2VQShAdd<bit op24, bit op23, bits<4> op11_8, bit op7, bit op4,
1241 string OpcodeStr, string Dt, ValueType Ty, SDNode ShOp>
1242 : N2VImm<op24, op23, op11_8, op7, 1, op4, (outs QPR:$dst),
1243 (ins QPR:$src1, QPR:$src2, i32imm:$SIMM), IIC_VPALiD,
1244 OpcodeStr, Dt, "$dst, $src2, $SIMM", "$src1 = $dst",
1245 [(set QPR:$dst, (Ty (add QPR:$src1,
1246 (Ty (ShOp QPR:$src2, (i32 imm:$SIMM))))))]>;
1248 // Shift by immediate and insert,
1249 // both double- and quad-register.
1250 class N2VDShIns<bit op24, bit op23, bits<4> op11_8, bit op7, bit op4,
1251 string OpcodeStr, string Dt, ValueType Ty, SDNode ShOp>
1252 : N2VImm<op24, op23, op11_8, op7, 0, op4, (outs DPR:$dst),
1253 (ins DPR:$src1, DPR:$src2, i32imm:$SIMM), IIC_VSHLiD,
1254 OpcodeStr, Dt, "$dst, $src2, $SIMM", "$src1 = $dst",
1255 [(set DPR:$dst, (Ty (ShOp DPR:$src1, DPR:$src2, (i32 imm:$SIMM))))]>;
1256 class N2VQShIns<bit op24, bit op23, bits<4> op11_8, bit op7, bit op4,
1257 string OpcodeStr, string Dt, ValueType Ty, SDNode ShOp>
1258 : N2VImm<op24, op23, op11_8, op7, 1, op4, (outs QPR:$dst),
1259 (ins QPR:$src1, QPR:$src2, i32imm:$SIMM), IIC_VSHLiQ,
1260 OpcodeStr, Dt, "$dst, $src2, $SIMM", "$src1 = $dst",
1261 [(set QPR:$dst, (Ty (ShOp QPR:$src1, QPR:$src2, (i32 imm:$SIMM))))]>;
1263 } // End of "let NSF = NVectorShiftFrm, ..."
1265 // Long shift by immediate.
1266 class N2VLSh<bit op24, bit op23, bits<4> op11_8, bit op7, bit op6, bit op4,
1267 string OpcodeStr, string Dt,
1268 ValueType ResTy, ValueType OpTy, SDNode OpNode>
1269 : N2VImm<op24, op23, op11_8, op7, op6, op4,
1270 (outs QPR:$dst), (ins DPR:$src, i32imm:$SIMM), IIC_VSHLiD,
1271 OpcodeStr, Dt, "$dst, $src, $SIMM", "",
1272 [(set QPR:$dst, (ResTy (OpNode (OpTy DPR:$src),
1273 (i32 imm:$SIMM))))]> {
1274 // This has a different interpretation of the shift amount encoding than
1276 let NSF = NVectorShift2Frm; // For disassembly.
1277 let NSForm = NVectorShift2Frm.Value; // For disassembly.
1280 // Convert, with fractional bits immediate,
1281 // both double- and quad-register.
1282 let NSF = NVdVmImmVCVTFrm, NSForm = NVdVmImmVCVTFrm.Value in {
1283 class N2VCvtD<bit op24, bit op23, bits<4> op11_8, bit op7, bit op4,
1284 string OpcodeStr, string Dt, ValueType ResTy, ValueType OpTy,
1286 : N2VImm<op24, op23, op11_8, op7, 0, op4,
1287 (outs DPR:$dst), (ins DPR:$src, i32imm:$SIMM), IIC_VUNAD,
1288 OpcodeStr, Dt, "$dst, $src, $SIMM", "",
1289 [(set DPR:$dst, (ResTy (IntOp (OpTy DPR:$src), (i32 imm:$SIMM))))]>;
1290 class N2VCvtQ<bit op24, bit op23, bits<4> op11_8, bit op7, bit op4,
1291 string OpcodeStr, string Dt, ValueType ResTy, ValueType OpTy,
1293 : N2VImm<op24, op23, op11_8, op7, 1, op4,
1294 (outs QPR:$dst), (ins QPR:$src, i32imm:$SIMM), IIC_VUNAQ,
1295 OpcodeStr, Dt, "$dst, $src, $SIMM", "",
1296 [(set QPR:$dst, (ResTy (IntOp (OpTy QPR:$src), (i32 imm:$SIMM))))]>;
1299 //===----------------------------------------------------------------------===//
1301 //===----------------------------------------------------------------------===//
1303 // Abbreviations used in multiclass suffixes:
1304 // Q = quarter int (8 bit) elements
1305 // H = half int (16 bit) elements
1306 // S = single int (32 bit) elements
1307 // D = double int (64 bit) elements
1309 // Neon 2-register vector operations -- for disassembly only.
1311 // First with only element sizes of 8, 16 and 32 bits:
1312 multiclass N2V_QHS_cmp<bits<2> op24_23, bits<2> op21_20, bits<2> op17_16,
1313 bits<5> op11_7, bit op4, string opc, string Dt,
1315 // 64-bit vector types.
1316 def v8i8 : N2V<op24_23, op21_20, 0b00, op17_16, op11_7, 0, op4,
1317 (outs DPR:$dst), (ins DPR:$src), NoItinerary,
1318 opc, !strconcat(Dt, "8"), asm, "", []>;
1319 def v4i16 : N2V<op24_23, op21_20, 0b01, op17_16, op11_7, 0, op4,
1320 (outs DPR:$dst), (ins DPR:$src), NoItinerary,
1321 opc, !strconcat(Dt, "16"), asm, "", []>;
1322 def v2i32 : N2V<op24_23, op21_20, 0b10, op17_16, op11_7, 0, op4,
1323 (outs DPR:$dst), (ins DPR:$src), NoItinerary,
1324 opc, !strconcat(Dt, "32"), asm, "", []>;
1325 def v2f32 : N2V<op24_23, op21_20, 0b10, op17_16, op11_7, 0, op4,
1326 (outs DPR:$dst), (ins DPR:$src), NoItinerary,
1327 opc, "f32", asm, "", []> {
1328 let Inst{10} = 1; // overwrite F = 1
1331 // 128-bit vector types.
1332 def v16i8 : N2V<op24_23, op21_20, 0b00, op17_16, op11_7, 1, op4,
1333 (outs QPR:$dst), (ins QPR:$src), NoItinerary,
1334 opc, !strconcat(Dt, "8"), asm, "", []>;
1335 def v8i16 : N2V<op24_23, op21_20, 0b01, op17_16, op11_7, 1, op4,
1336 (outs QPR:$dst), (ins QPR:$src), NoItinerary,
1337 opc, !strconcat(Dt, "16"), asm, "", []>;
1338 def v4i32 : N2V<op24_23, op21_20, 0b10, op17_16, op11_7, 1, op4,
1339 (outs QPR:$dst), (ins QPR:$src), NoItinerary,
1340 opc, !strconcat(Dt, "32"), asm, "", []>;
1341 def v4f32 : N2V<op24_23, op21_20, 0b10, op17_16, op11_7, 1, op4,
1342 (outs QPR:$dst), (ins QPR:$src), NoItinerary,
1343 opc, "f32", asm, "", []> {
1344 let Inst{10} = 1; // overwrite F = 1
1348 // Neon 3-register vector operations.
1350 // First with only element sizes of 8, 16 and 32 bits:
1351 multiclass N3V_QHS<bit op24, bit op23, bits<4> op11_8, bit op4,
1352 InstrItinClass itinD16, InstrItinClass itinD32,
1353 InstrItinClass itinQ16, InstrItinClass itinQ32,
1354 string OpcodeStr, string Dt,
1355 SDNode OpNode, bit Commutable = 0> {
1356 // 64-bit vector types.
1357 def v8i8 : N3VD<op24, op23, 0b00, op11_8, op4, itinD16,
1358 OpcodeStr, !strconcat(Dt, "8"),
1359 v8i8, v8i8, OpNode, Commutable>;
1360 def v4i16 : N3VD<op24, op23, 0b01, op11_8, op4, itinD16,
1361 OpcodeStr, !strconcat(Dt, "16"),
1362 v4i16, v4i16, OpNode, Commutable>;
1363 def v2i32 : N3VD<op24, op23, 0b10, op11_8, op4, itinD32,
1364 OpcodeStr, !strconcat(Dt, "32"),
1365 v2i32, v2i32, OpNode, Commutable>;
1367 // 128-bit vector types.
1368 def v16i8 : N3VQ<op24, op23, 0b00, op11_8, op4, itinQ16,
1369 OpcodeStr, !strconcat(Dt, "8"),
1370 v16i8, v16i8, OpNode, Commutable>;
1371 def v8i16 : N3VQ<op24, op23, 0b01, op11_8, op4, itinQ16,
1372 OpcodeStr, !strconcat(Dt, "16"),
1373 v8i16, v8i16, OpNode, Commutable>;
1374 def v4i32 : N3VQ<op24, op23, 0b10, op11_8, op4, itinQ32,
1375 OpcodeStr, !strconcat(Dt, "32"),
1376 v4i32, v4i32, OpNode, Commutable>;
1379 multiclass N3VSL_HS<bits<4> op11_8, string OpcodeStr, string Dt, SDNode ShOp> {
1380 def v4i16 : N3VDSL16<0b01, op11_8, OpcodeStr, !strconcat(Dt, "16"),
1382 def v2i32 : N3VDSL<0b10, op11_8, IIC_VMULi32D, OpcodeStr, !strconcat(Dt,"32"),
1384 def v8i16 : N3VQSL16<0b01, op11_8, OpcodeStr, !strconcat(Dt, "16"),
1385 v8i16, v4i16, ShOp>;
1386 def v4i32 : N3VQSL<0b10, op11_8, IIC_VMULi32Q, OpcodeStr, !strconcat(Dt,"32"),
1387 v4i32, v2i32, ShOp>;
1390 // ....then also with element size 64 bits:
1391 multiclass N3V_QHSD<bit op24, bit op23, bits<4> op11_8, bit op4,
1392 InstrItinClass itinD, InstrItinClass itinQ,
1393 string OpcodeStr, string Dt,
1394 SDNode OpNode, bit Commutable = 0>
1395 : N3V_QHS<op24, op23, op11_8, op4, itinD, itinD, itinQ, itinQ,
1396 OpcodeStr, Dt, OpNode, Commutable> {
1397 def v1i64 : N3VD<op24, op23, 0b11, op11_8, op4, itinD,
1398 OpcodeStr, !strconcat(Dt, "64"),
1399 v1i64, v1i64, OpNode, Commutable>;
1400 def v2i64 : N3VQ<op24, op23, 0b11, op11_8, op4, itinQ,
1401 OpcodeStr, !strconcat(Dt, "64"),
1402 v2i64, v2i64, OpNode, Commutable>;
1406 // Neon Narrowing 2-register vector intrinsics,
1407 // source operand element sizes of 16, 32 and 64 bits:
1408 multiclass N2VNInt_HSD<bits<2> op24_23, bits<2> op21_20, bits<2> op17_16,
1409 bits<5> op11_7, bit op6, bit op4,
1410 InstrItinClass itin, string OpcodeStr, string Dt,
1412 def v8i8 : N2VNInt<op24_23, op21_20, 0b00, op17_16, op11_7, op6, op4,
1413 itin, OpcodeStr, !strconcat(Dt, "16"),
1414 v8i8, v8i16, IntOp>;
1415 def v4i16 : N2VNInt<op24_23, op21_20, 0b01, op17_16, op11_7, op6, op4,
1416 itin, OpcodeStr, !strconcat(Dt, "32"),
1417 v4i16, v4i32, IntOp>;
1418 def v2i32 : N2VNInt<op24_23, op21_20, 0b10, op17_16, op11_7, op6, op4,
1419 itin, OpcodeStr, !strconcat(Dt, "64"),
1420 v2i32, v2i64, IntOp>;
1424 // Neon Lengthening 2-register vector intrinsic (currently specific to VMOVL).
1425 // source operand element sizes of 16, 32 and 64 bits:
1426 multiclass N2VLInt_QHS<bits<2> op24_23, bits<5> op11_7, bit op6, bit op4,
1427 string OpcodeStr, string Dt, Intrinsic IntOp> {
1428 def v8i16 : N2VLInt<op24_23, 0b00, 0b10, 0b00, op11_7, op6, op4, IIC_VQUNAiD,
1429 OpcodeStr, !strconcat(Dt, "8"), v8i16, v8i8, IntOp>;
1430 def v4i32 : N2VLInt<op24_23, 0b01, 0b00, 0b00, op11_7, op6, op4, IIC_VQUNAiD,
1431 OpcodeStr, !strconcat(Dt, "16"), v4i32, v4i16, IntOp>;
1432 def v2i64 : N2VLInt<op24_23, 0b10, 0b00, 0b00, op11_7, op6, op4, IIC_VQUNAiD,
1433 OpcodeStr, !strconcat(Dt, "32"), v2i64, v2i32, IntOp>;
1437 // Neon 3-register vector intrinsics.
1439 // First with only element sizes of 16 and 32 bits:
1440 multiclass N3VInt_HS<bit op24, bit op23, bits<4> op11_8, bit op4,
1441 InstrItinClass itinD16, InstrItinClass itinD32,
1442 InstrItinClass itinQ16, InstrItinClass itinQ32,
1443 string OpcodeStr, string Dt,
1444 Intrinsic IntOp, bit Commutable = 0> {
1445 // 64-bit vector types.
1446 def v4i16 : N3VDInt<op24, op23, 0b01, op11_8, op4, itinD16,
1447 OpcodeStr, !strconcat(Dt, "16"),
1448 v4i16, v4i16, IntOp, Commutable>;
1449 def v2i32 : N3VDInt<op24, op23, 0b10, op11_8, op4, itinD32,
1450 OpcodeStr, !strconcat(Dt, "32"),
1451 v2i32, v2i32, IntOp, Commutable>;
1453 // 128-bit vector types.
1454 def v8i16 : N3VQInt<op24, op23, 0b01, op11_8, op4, itinQ16,
1455 OpcodeStr, !strconcat(Dt, "16"),
1456 v8i16, v8i16, IntOp, Commutable>;
1457 def v4i32 : N3VQInt<op24, op23, 0b10, op11_8, op4, itinQ32,
1458 OpcodeStr, !strconcat(Dt, "32"),
1459 v4i32, v4i32, IntOp, Commutable>;
1462 multiclass N3VIntSL_HS<bits<4> op11_8,
1463 InstrItinClass itinD16, InstrItinClass itinD32,
1464 InstrItinClass itinQ16, InstrItinClass itinQ32,
1465 string OpcodeStr, string Dt, Intrinsic IntOp> {
1466 def v4i16 : N3VDIntSL16<0b01, op11_8, itinD16,
1467 OpcodeStr, !strconcat(Dt, "16"), v4i16, IntOp>;
1468 def v2i32 : N3VDIntSL<0b10, op11_8, itinD32,
1469 OpcodeStr, !strconcat(Dt, "32"), v2i32, IntOp>;
1470 def v8i16 : N3VQIntSL16<0b01, op11_8, itinQ16,
1471 OpcodeStr, !strconcat(Dt, "16"), v8i16, v4i16, IntOp>;
1472 def v4i32 : N3VQIntSL<0b10, op11_8, itinQ32,
1473 OpcodeStr, !strconcat(Dt, "32"), v4i32, v2i32, IntOp>;
1476 // ....then also with element size of 8 bits:
1477 multiclass N3VInt_QHS<bit op24, bit op23, bits<4> op11_8, bit op4,
1478 InstrItinClass itinD16, InstrItinClass itinD32,
1479 InstrItinClass itinQ16, InstrItinClass itinQ32,
1480 string OpcodeStr, string Dt,
1481 Intrinsic IntOp, bit Commutable = 0>
1482 : N3VInt_HS<op24, op23, op11_8, op4, itinD16, itinD32, itinQ16, itinQ32,
1483 OpcodeStr, Dt, IntOp, Commutable> {
1484 def v8i8 : N3VDInt<op24, op23, 0b00, op11_8, op4, itinD16,
1485 OpcodeStr, !strconcat(Dt, "8"),
1486 v8i8, v8i8, IntOp, Commutable>;
1487 def v16i8 : N3VQInt<op24, op23, 0b00, op11_8, op4, itinQ16,
1488 OpcodeStr, !strconcat(Dt, "8"),
1489 v16i8, v16i8, IntOp, Commutable>;
1492 // ....then also with element size of 64 bits:
1493 multiclass N3VInt_QHSD<bit op24, bit op23, bits<4> op11_8, bit op4,
1494 InstrItinClass itinD16, InstrItinClass itinD32,
1495 InstrItinClass itinQ16, InstrItinClass itinQ32,
1496 string OpcodeStr, string Dt,
1497 Intrinsic IntOp, bit Commutable = 0>
1498 : N3VInt_QHS<op24, op23, op11_8, op4, itinD16, itinD32, itinQ16, itinQ32,
1499 OpcodeStr, Dt, IntOp, Commutable> {
1500 def v1i64 : N3VDInt<op24, op23, 0b11, op11_8, op4, itinD32,
1501 OpcodeStr, !strconcat(Dt, "64"),
1502 v1i64, v1i64, IntOp, Commutable>;
1503 def v2i64 : N3VQInt<op24, op23, 0b11, op11_8, op4, itinQ32,
1504 OpcodeStr, !strconcat(Dt, "64"),
1505 v2i64, v2i64, IntOp, Commutable>;
1508 // Same as N3VInt_QHSD, except they're for Vector Shift (Register) Instructions.
1509 // D:Vd M:Vm N:Vn (notice that M:Vm is the first operand)
1510 // This helps the disassembler.
1511 let NSF = NVdVnVmImmVectorShiftFrm, NSForm = NVdVnVmImmVectorShiftFrm.Value in {
1512 multiclass N3VInt_HS2<bit op24, bit op23, bits<4> op11_8, bit op4,
1513 InstrItinClass itinD16, InstrItinClass itinD32,
1514 InstrItinClass itinQ16, InstrItinClass itinQ32,
1515 string OpcodeStr, string Dt,
1516 Intrinsic IntOp, bit Commutable = 0> {
1517 // 64-bit vector types.
1518 def v4i16 : N3VDInt<op24, op23, 0b01, op11_8, op4, itinD16,
1519 OpcodeStr, !strconcat(Dt, "16"),
1520 v4i16, v4i16, IntOp, Commutable>;
1521 def v2i32 : N3VDInt<op24, op23, 0b10, op11_8, op4, itinD32,
1522 OpcodeStr, !strconcat(Dt, "32"),
1523 v2i32, v2i32, IntOp, Commutable>;
1525 // 128-bit vector types.
1526 def v8i16 : N3VQInt<op24, op23, 0b01, op11_8, op4, itinQ16,
1527 OpcodeStr, !strconcat(Dt, "16"),
1528 v8i16, v8i16, IntOp, Commutable>;
1529 def v4i32 : N3VQInt<op24, op23, 0b10, op11_8, op4, itinQ32,
1530 OpcodeStr, !strconcat(Dt, "32"),
1531 v4i32, v4i32, IntOp, Commutable>;
1533 multiclass N3VInt_QHS2<bit op24, bit op23, bits<4> op11_8, bit op4,
1534 InstrItinClass itinD16, InstrItinClass itinD32,
1535 InstrItinClass itinQ16, InstrItinClass itinQ32,
1536 string OpcodeStr, string Dt,
1537 Intrinsic IntOp, bit Commutable = 0>
1538 : N3VInt_HS2<op24, op23, op11_8, op4, itinD16, itinD32, itinQ16, itinQ32,
1539 OpcodeStr, Dt, IntOp, Commutable> {
1540 def v8i8 : N3VDInt<op24, op23, 0b00, op11_8, op4, itinD16,
1541 OpcodeStr, !strconcat(Dt, "8"),
1542 v8i8, v8i8, IntOp, Commutable>;
1543 def v16i8 : N3VQInt<op24, op23, 0b00, op11_8, op4, itinQ16,
1544 OpcodeStr, !strconcat(Dt, "8"),
1545 v16i8, v16i8, IntOp, Commutable>;
1547 multiclass N3VInt_QHSD2<bit op24, bit op23, bits<4> op11_8, bit op4,
1548 InstrItinClass itinD16, InstrItinClass itinD32,
1549 InstrItinClass itinQ16, InstrItinClass itinQ32,
1550 string OpcodeStr, string Dt,
1551 Intrinsic IntOp, bit Commutable = 0>
1552 : N3VInt_QHS2<op24, op23, op11_8, op4, itinD16, itinD32, itinQ16, itinQ32,
1553 OpcodeStr, Dt, IntOp, Commutable> {
1554 def v1i64 : N3VDInt<op24, op23, 0b11, op11_8, op4, itinD32,
1555 OpcodeStr, !strconcat(Dt, "64"),
1556 v1i64, v1i64, IntOp, Commutable>;
1557 def v2i64 : N3VQInt<op24, op23, 0b11, op11_8, op4, itinQ32,
1558 OpcodeStr, !strconcat(Dt, "64"),
1559 v2i64, v2i64, IntOp, Commutable>;
1563 // Neon Narrowing 3-register vector intrinsics,
1564 // source operand element sizes of 16, 32 and 64 bits:
1565 multiclass N3VNInt_HSD<bit op24, bit op23, bits<4> op11_8, bit op4,
1566 string OpcodeStr, string Dt,
1567 Intrinsic IntOp, bit Commutable = 0> {
1568 def v8i8 : N3VNInt<op24, op23, 0b00, op11_8, op4,
1569 OpcodeStr, !strconcat(Dt, "16"),
1570 v8i8, v8i16, IntOp, Commutable>;
1571 def v4i16 : N3VNInt<op24, op23, 0b01, op11_8, op4,
1572 OpcodeStr, !strconcat(Dt, "32"),
1573 v4i16, v4i32, IntOp, Commutable>;
1574 def v2i32 : N3VNInt<op24, op23, 0b10, op11_8, op4,
1575 OpcodeStr, !strconcat(Dt, "64"),
1576 v2i32, v2i64, IntOp, Commutable>;
1580 // Neon Long 3-register vector intrinsics.
1582 // First with only element sizes of 16 and 32 bits:
1583 multiclass N3VLInt_HS<bit op24, bit op23, bits<4> op11_8, bit op4,
1584 InstrItinClass itin, string OpcodeStr, string Dt,
1585 Intrinsic IntOp, bit Commutable = 0> {
1586 def v4i32 : N3VLInt<op24, op23, 0b01, op11_8, op4, itin,
1587 OpcodeStr, !strconcat(Dt, "16"),
1588 v4i32, v4i16, IntOp, Commutable>;
1589 def v2i64 : N3VLInt<op24, op23, 0b10, op11_8, op4, itin,
1590 OpcodeStr, !strconcat(Dt, "32"),
1591 v2i64, v2i32, IntOp, Commutable>;
1594 multiclass N3VLIntSL_HS<bit op24, bits<4> op11_8,
1595 InstrItinClass itin, string OpcodeStr, string Dt,
1597 def v4i16 : N3VLIntSL16<op24, 0b01, op11_8, itin,
1598 OpcodeStr, !strconcat(Dt, "16"), v4i32, v4i16, IntOp>;
1599 def v2i32 : N3VLIntSL<op24, 0b10, op11_8, itin,
1600 OpcodeStr, !strconcat(Dt, "32"), v2i64, v2i32, IntOp>;
1603 // ....then also with element size of 8 bits:
1604 multiclass N3VLInt_QHS<bit op24, bit op23, bits<4> op11_8, bit op4,
1605 InstrItinClass itin, string OpcodeStr, string Dt,
1606 Intrinsic IntOp, bit Commutable = 0>
1607 : N3VLInt_HS<op24, op23, op11_8, op4, itin, OpcodeStr, Dt,
1608 IntOp, Commutable> {
1609 def v8i16 : N3VLInt<op24, op23, 0b00, op11_8, op4, itin,
1610 OpcodeStr, !strconcat(Dt, "8"),
1611 v8i16, v8i8, IntOp, Commutable>;
1615 // Neon Wide 3-register vector intrinsics,
1616 // source operand element sizes of 8, 16 and 32 bits:
1617 multiclass N3VWInt_QHS<bit op24, bit op23, bits<4> op11_8, bit op4,
1618 string OpcodeStr, string Dt,
1619 Intrinsic IntOp, bit Commutable = 0> {
1620 def v8i16 : N3VWInt<op24, op23, 0b00, op11_8, op4,
1621 OpcodeStr, !strconcat(Dt, "8"),
1622 v8i16, v8i8, IntOp, Commutable>;
1623 def v4i32 : N3VWInt<op24, op23, 0b01, op11_8, op4,
1624 OpcodeStr, !strconcat(Dt, "16"),
1625 v4i32, v4i16, IntOp, Commutable>;
1626 def v2i64 : N3VWInt<op24, op23, 0b10, op11_8, op4,
1627 OpcodeStr, !strconcat(Dt, "32"),
1628 v2i64, v2i32, IntOp, Commutable>;
1632 // Neon Multiply-Op vector operations,
1633 // element sizes of 8, 16 and 32 bits:
1634 multiclass N3VMulOp_QHS<bit op24, bit op23, bits<4> op11_8, bit op4,
1635 InstrItinClass itinD16, InstrItinClass itinD32,
1636 InstrItinClass itinQ16, InstrItinClass itinQ32,
1637 string OpcodeStr, string Dt, SDNode OpNode> {
1638 // 64-bit vector types.
1639 def v8i8 : N3VDMulOp<op24, op23, 0b00, op11_8, op4, itinD16,
1640 OpcodeStr, !strconcat(Dt, "8"), v8i8, mul, OpNode>;
1641 def v4i16 : N3VDMulOp<op24, op23, 0b01, op11_8, op4, itinD16,
1642 OpcodeStr, !strconcat(Dt, "16"), v4i16, mul, OpNode>;
1643 def v2i32 : N3VDMulOp<op24, op23, 0b10, op11_8, op4, itinD32,
1644 OpcodeStr, !strconcat(Dt, "32"), v2i32, mul, OpNode>;
1646 // 128-bit vector types.
1647 def v16i8 : N3VQMulOp<op24, op23, 0b00, op11_8, op4, itinQ16,
1648 OpcodeStr, !strconcat(Dt, "8"), v16i8, mul, OpNode>;
1649 def v8i16 : N3VQMulOp<op24, op23, 0b01, op11_8, op4, itinQ16,
1650 OpcodeStr, !strconcat(Dt, "16"), v8i16, mul, OpNode>;
1651 def v4i32 : N3VQMulOp<op24, op23, 0b10, op11_8, op4, itinQ32,
1652 OpcodeStr, !strconcat(Dt, "32"), v4i32, mul, OpNode>;
1655 multiclass N3VMulOpSL_HS<bits<4> op11_8,
1656 InstrItinClass itinD16, InstrItinClass itinD32,
1657 InstrItinClass itinQ16, InstrItinClass itinQ32,
1658 string OpcodeStr, string Dt, SDNode ShOp> {
1659 def v4i16 : N3VDMulOpSL16<0b01, op11_8, itinD16,
1660 OpcodeStr, !strconcat(Dt, "16"), v4i16, mul, ShOp>;
1661 def v2i32 : N3VDMulOpSL<0b10, op11_8, itinD32,
1662 OpcodeStr, !strconcat(Dt, "32"), v2i32, mul, ShOp>;
1663 def v8i16 : N3VQMulOpSL16<0b01, op11_8, itinQ16,
1664 OpcodeStr, !strconcat(Dt, "16"), v8i16, v4i16,
1666 def v4i32 : N3VQMulOpSL<0b10, op11_8, itinQ32,
1667 OpcodeStr, !strconcat(Dt, "32"), v4i32, v2i32,
1671 // Neon 3-argument intrinsics,
1672 // element sizes of 8, 16 and 32 bits:
1673 multiclass N3VInt3_QHS<bit op24, bit op23, bits<4> op11_8, bit op4,
1674 string OpcodeStr, string Dt, Intrinsic IntOp> {
1675 // 64-bit vector types.
1676 def v8i8 : N3VDInt3<op24, op23, 0b00, op11_8, op4, IIC_VMACi16D,
1677 OpcodeStr, !strconcat(Dt, "8"), v8i8, v8i8, IntOp>;
1678 def v4i16 : N3VDInt3<op24, op23, 0b01, op11_8, op4, IIC_VMACi16D,
1679 OpcodeStr, !strconcat(Dt, "16"), v4i16, v4i16, IntOp>;
1680 def v2i32 : N3VDInt3<op24, op23, 0b10, op11_8, op4, IIC_VMACi32D,
1681 OpcodeStr, !strconcat(Dt, "32"), v2i32, v2i32, IntOp>;
1683 // 128-bit vector types.
1684 def v16i8 : N3VQInt3<op24, op23, 0b00, op11_8, op4, IIC_VMACi16Q,
1685 OpcodeStr, !strconcat(Dt, "8"), v16i8, v16i8, IntOp>;
1686 def v8i16 : N3VQInt3<op24, op23, 0b01, op11_8, op4, IIC_VMACi16Q,
1687 OpcodeStr, !strconcat(Dt, "16"), v8i16, v8i16, IntOp>;
1688 def v4i32 : N3VQInt3<op24, op23, 0b10, op11_8, op4, IIC_VMACi32Q,
1689 OpcodeStr, !strconcat(Dt, "32"), v4i32, v4i32, IntOp>;
1693 // Neon Long 3-argument intrinsics.
1695 // First with only element sizes of 16 and 32 bits:
1696 multiclass N3VLInt3_HS<bit op24, bit op23, bits<4> op11_8, bit op4,
1697 string OpcodeStr, string Dt, Intrinsic IntOp> {
1698 def v4i32 : N3VLInt3<op24, op23, 0b01, op11_8, op4, IIC_VMACi16D,
1699 OpcodeStr, !strconcat(Dt, "16"), v4i32, v4i16, IntOp>;
1700 def v2i64 : N3VLInt3<op24, op23, 0b10, op11_8, op4, IIC_VMACi16D,
1701 OpcodeStr, !strconcat(Dt, "32"), v2i64, v2i32, IntOp>;
1704 multiclass N3VLInt3SL_HS<bit op24, bits<4> op11_8,
1705 string OpcodeStr, string Dt, Intrinsic IntOp> {
1706 def v4i16 : N3VLInt3SL16<op24, 0b01, op11_8, IIC_VMACi16D,
1707 OpcodeStr, !strconcat(Dt,"16"), v4i32, v4i16, IntOp>;
1708 def v2i32 : N3VLInt3SL<op24, 0b10, op11_8, IIC_VMACi32D,
1709 OpcodeStr, !strconcat(Dt, "32"), v2i64, v2i32, IntOp>;
1712 // ....then also with element size of 8 bits:
1713 multiclass N3VLInt3_QHS<bit op24, bit op23, bits<4> op11_8, bit op4,
1714 string OpcodeStr, string Dt, Intrinsic IntOp>
1715 : N3VLInt3_HS<op24, op23, op11_8, op4, OpcodeStr, Dt, IntOp> {
1716 def v8i16 : N3VLInt3<op24, op23, 0b00, op11_8, op4, IIC_VMACi16D,
1717 OpcodeStr, !strconcat(Dt, "8"), v8i16, v8i8, IntOp>;
1721 // Neon 2-register vector intrinsics,
1722 // element sizes of 8, 16 and 32 bits:
1723 multiclass N2VInt_QHS<bits<2> op24_23, bits<2> op21_20, bits<2> op17_16,
1724 bits<5> op11_7, bit op4,
1725 InstrItinClass itinD, InstrItinClass itinQ,
1726 string OpcodeStr, string Dt, Intrinsic IntOp> {
1727 // 64-bit vector types.
1728 def v8i8 : N2VDInt<op24_23, op21_20, 0b00, op17_16, op11_7, op4,
1729 itinD, OpcodeStr, !strconcat(Dt, "8"), v8i8, v8i8, IntOp>;
1730 def v4i16 : N2VDInt<op24_23, op21_20, 0b01, op17_16, op11_7, op4,
1731 itinD, OpcodeStr, !strconcat(Dt, "16"),v4i16,v4i16,IntOp>;
1732 def v2i32 : N2VDInt<op24_23, op21_20, 0b10, op17_16, op11_7, op4,
1733 itinD, OpcodeStr, !strconcat(Dt, "32"),v2i32,v2i32,IntOp>;
1735 // 128-bit vector types.
1736 def v16i8 : N2VQInt<op24_23, op21_20, 0b00, op17_16, op11_7, op4,
1737 itinQ, OpcodeStr, !strconcat(Dt, "8"), v16i8,v16i8,IntOp>;
1738 def v8i16 : N2VQInt<op24_23, op21_20, 0b01, op17_16, op11_7, op4,
1739 itinQ, OpcodeStr, !strconcat(Dt, "16"),v8i16,v8i16,IntOp>;
1740 def v4i32 : N2VQInt<op24_23, op21_20, 0b10, op17_16, op11_7, op4,
1741 itinQ, OpcodeStr, !strconcat(Dt, "32"),v4i32,v4i32,IntOp>;
1745 // Neon Pairwise long 2-register intrinsics,
1746 // element sizes of 8, 16 and 32 bits:
1747 multiclass N2VPLInt_QHS<bits<2> op24_23, bits<2> op21_20, bits<2> op17_16,
1748 bits<5> op11_7, bit op4,
1749 string OpcodeStr, string Dt, Intrinsic IntOp> {
1750 // 64-bit vector types.
1751 def v8i8 : N2VDPLInt<op24_23, op21_20, 0b00, op17_16, op11_7, op4,
1752 OpcodeStr, !strconcat(Dt, "8"), v4i16, v8i8, IntOp>;
1753 def v4i16 : N2VDPLInt<op24_23, op21_20, 0b01, op17_16, op11_7, op4,
1754 OpcodeStr, !strconcat(Dt, "16"), v2i32, v4i16, IntOp>;
1755 def v2i32 : N2VDPLInt<op24_23, op21_20, 0b10, op17_16, op11_7, op4,
1756 OpcodeStr, !strconcat(Dt, "32"), v1i64, v2i32, IntOp>;
1758 // 128-bit vector types.
1759 def v16i8 : N2VQPLInt<op24_23, op21_20, 0b00, op17_16, op11_7, op4,
1760 OpcodeStr, !strconcat(Dt, "8"), v8i16, v16i8, IntOp>;
1761 def v8i16 : N2VQPLInt<op24_23, op21_20, 0b01, op17_16, op11_7, op4,
1762 OpcodeStr, !strconcat(Dt, "16"), v4i32, v8i16, IntOp>;
1763 def v4i32 : N2VQPLInt<op24_23, op21_20, 0b10, op17_16, op11_7, op4,
1764 OpcodeStr, !strconcat(Dt, "32"), v2i64, v4i32, IntOp>;
1768 // Neon Pairwise long 2-register accumulate intrinsics,
1769 // element sizes of 8, 16 and 32 bits:
1770 multiclass N2VPLInt2_QHS<bits<2> op24_23, bits<2> op21_20, bits<2> op17_16,
1771 bits<5> op11_7, bit op4,
1772 string OpcodeStr, string Dt, Intrinsic IntOp> {
1773 // 64-bit vector types.
1774 def v8i8 : N2VDPLInt2<op24_23, op21_20, 0b00, op17_16, op11_7, op4,
1775 OpcodeStr, !strconcat(Dt, "8"), v4i16, v8i8, IntOp>;
1776 def v4i16 : N2VDPLInt2<op24_23, op21_20, 0b01, op17_16, op11_7, op4,
1777 OpcodeStr, !strconcat(Dt, "16"), v2i32, v4i16, IntOp>;
1778 def v2i32 : N2VDPLInt2<op24_23, op21_20, 0b10, op17_16, op11_7, op4,
1779 OpcodeStr, !strconcat(Dt, "32"), v1i64, v2i32, IntOp>;
1781 // 128-bit vector types.
1782 def v16i8 : N2VQPLInt2<op24_23, op21_20, 0b00, op17_16, op11_7, op4,
1783 OpcodeStr, !strconcat(Dt, "8"), v8i16, v16i8, IntOp>;
1784 def v8i16 : N2VQPLInt2<op24_23, op21_20, 0b01, op17_16, op11_7, op4,
1785 OpcodeStr, !strconcat(Dt, "16"), v4i32, v8i16, IntOp>;
1786 def v4i32 : N2VQPLInt2<op24_23, op21_20, 0b10, op17_16, op11_7, op4,
1787 OpcodeStr, !strconcat(Dt, "32"), v2i64, v4i32, IntOp>;
1791 // Neon 2-register vector shift by immediate,
1792 // element sizes of 8, 16, 32 and 64 bits:
1793 multiclass N2VSh_QHSD<bit op24, bit op23, bits<4> op11_8, bit op4,
1794 InstrItinClass itin, string OpcodeStr, string Dt,
1796 // 64-bit vector types.
1797 def v8i8 : N2VDSh<op24, op23, op11_8, 0, op4, itin,
1798 OpcodeStr, !strconcat(Dt, "8"), v8i8, OpNode> {
1799 let Inst{21-19} = 0b001; // imm6 = 001xxx
1801 def v4i16 : N2VDSh<op24, op23, op11_8, 0, op4, itin,
1802 OpcodeStr, !strconcat(Dt, "16"), v4i16, OpNode> {
1803 let Inst{21-20} = 0b01; // imm6 = 01xxxx
1805 def v2i32 : N2VDSh<op24, op23, op11_8, 0, op4, itin,
1806 OpcodeStr, !strconcat(Dt, "32"), v2i32, OpNode> {
1807 let Inst{21} = 0b1; // imm6 = 1xxxxx
1809 def v1i64 : N2VDSh<op24, op23, op11_8, 1, op4, itin,
1810 OpcodeStr, !strconcat(Dt, "64"), v1i64, OpNode>;
1813 // 128-bit vector types.
1814 def v16i8 : N2VQSh<op24, op23, op11_8, 0, op4, itin,
1815 OpcodeStr, !strconcat(Dt, "8"), v16i8, OpNode> {
1816 let Inst{21-19} = 0b001; // imm6 = 001xxx
1818 def v8i16 : N2VQSh<op24, op23, op11_8, 0, op4, itin,
1819 OpcodeStr, !strconcat(Dt, "16"), v8i16, OpNode> {
1820 let Inst{21-20} = 0b01; // imm6 = 01xxxx
1822 def v4i32 : N2VQSh<op24, op23, op11_8, 0, op4, itin,
1823 OpcodeStr, !strconcat(Dt, "32"), v4i32, OpNode> {
1824 let Inst{21} = 0b1; // imm6 = 1xxxxx
1826 def v2i64 : N2VQSh<op24, op23, op11_8, 1, op4, itin,
1827 OpcodeStr, !strconcat(Dt, "64"), v2i64, OpNode>;
1831 // Same as N2VSh_QHSD, except the instructions have a differnt interpretation of
1832 // the shift amount. This helps the disassembler.
1833 let NSF = NVectorShift2Frm, NSForm = NVectorShift2Frm.Value in {
1834 multiclass N2VSh_QHSD2<bit op24, bit op23, bits<4> op11_8, bit op4,
1835 InstrItinClass itin, string OpcodeStr, string Dt,
1837 // 64-bit vector types.
1838 def v8i8 : N2VDSh<op24, op23, op11_8, 0, op4, itin,
1839 OpcodeStr, !strconcat(Dt, "8"), v8i8, OpNode> {
1840 let Inst{21-19} = 0b001; // imm6 = 001xxx
1842 def v4i16 : N2VDSh<op24, op23, op11_8, 0, op4, itin,
1843 OpcodeStr, !strconcat(Dt, "16"), v4i16, OpNode> {
1844 let Inst{21-20} = 0b01; // imm6 = 01xxxx
1846 def v2i32 : N2VDSh<op24, op23, op11_8, 0, op4, itin,
1847 OpcodeStr, !strconcat(Dt, "32"), v2i32, OpNode> {
1848 let Inst{21} = 0b1; // imm6 = 1xxxxx
1850 def v1i64 : N2VDSh<op24, op23, op11_8, 1, op4, itin,
1851 OpcodeStr, !strconcat(Dt, "64"), v1i64, OpNode>;
1854 // 128-bit vector types.
1855 def v16i8 : N2VQSh<op24, op23, op11_8, 0, op4, itin,
1856 OpcodeStr, !strconcat(Dt, "8"), v16i8, OpNode> {
1857 let Inst{21-19} = 0b001; // imm6 = 001xxx
1859 def v8i16 : N2VQSh<op24, op23, op11_8, 0, op4, itin,
1860 OpcodeStr, !strconcat(Dt, "16"), v8i16, OpNode> {
1861 let Inst{21-20} = 0b01; // imm6 = 01xxxx
1863 def v4i32 : N2VQSh<op24, op23, op11_8, 0, op4, itin,
1864 OpcodeStr, !strconcat(Dt, "32"), v4i32, OpNode> {
1865 let Inst{21} = 0b1; // imm6 = 1xxxxx
1867 def v2i64 : N2VQSh<op24, op23, op11_8, 1, op4, itin,
1868 OpcodeStr, !strconcat(Dt, "64"), v2i64, OpNode>;
1873 // Neon Shift-Accumulate vector operations,
1874 // element sizes of 8, 16, 32 and 64 bits:
1875 multiclass N2VShAdd_QHSD<bit op24, bit op23, bits<4> op11_8, bit op4,
1876 string OpcodeStr, string Dt, SDNode ShOp> {
1877 // 64-bit vector types.
1878 def v8i8 : N2VDShAdd<op24, op23, op11_8, 0, op4,
1879 OpcodeStr, !strconcat(Dt, "8"), v8i8, ShOp> {
1880 let Inst{21-19} = 0b001; // imm6 = 001xxx
1882 def v4i16 : N2VDShAdd<op24, op23, op11_8, 0, op4,
1883 OpcodeStr, !strconcat(Dt, "16"), v4i16, ShOp> {
1884 let Inst{21-20} = 0b01; // imm6 = 01xxxx
1886 def v2i32 : N2VDShAdd<op24, op23, op11_8, 0, op4,
1887 OpcodeStr, !strconcat(Dt, "32"), v2i32, ShOp> {
1888 let Inst{21} = 0b1; // imm6 = 1xxxxx
1890 def v1i64 : N2VDShAdd<op24, op23, op11_8, 1, op4,
1891 OpcodeStr, !strconcat(Dt, "64"), v1i64, ShOp>;
1894 // 128-bit vector types.
1895 def v16i8 : N2VQShAdd<op24, op23, op11_8, 0, op4,
1896 OpcodeStr, !strconcat(Dt, "8"), v16i8, ShOp> {
1897 let Inst{21-19} = 0b001; // imm6 = 001xxx
1899 def v8i16 : N2VQShAdd<op24, op23, op11_8, 0, op4,
1900 OpcodeStr, !strconcat(Dt, "16"), v8i16, ShOp> {
1901 let Inst{21-20} = 0b01; // imm6 = 01xxxx
1903 def v4i32 : N2VQShAdd<op24, op23, op11_8, 0, op4,
1904 OpcodeStr, !strconcat(Dt, "32"), v4i32, ShOp> {
1905 let Inst{21} = 0b1; // imm6 = 1xxxxx
1907 def v2i64 : N2VQShAdd<op24, op23, op11_8, 1, op4,
1908 OpcodeStr, !strconcat(Dt, "64"), v2i64, ShOp>;
1913 // Neon Shift-Insert vector operations,
1914 // element sizes of 8, 16, 32 and 64 bits:
1915 multiclass N2VShIns_QHSD<bit op24, bit op23, bits<4> op11_8, bit op4,
1916 string OpcodeStr, SDNode ShOp> {
1917 // 64-bit vector types.
1918 def v8i8 : N2VDShIns<op24, op23, op11_8, 0, op4,
1919 OpcodeStr, "8", v8i8, ShOp> {
1920 let Inst{21-19} = 0b001; // imm6 = 001xxx
1922 def v4i16 : N2VDShIns<op24, op23, op11_8, 0, op4,
1923 OpcodeStr, "16", v4i16, ShOp> {
1924 let Inst{21-20} = 0b01; // imm6 = 01xxxx
1926 def v2i32 : N2VDShIns<op24, op23, op11_8, 0, op4,
1927 OpcodeStr, "32", v2i32, ShOp> {
1928 let Inst{21} = 0b1; // imm6 = 1xxxxx
1930 def v1i64 : N2VDShIns<op24, op23, op11_8, 1, op4,
1931 OpcodeStr, "64", v1i64, ShOp>;
1934 // 128-bit vector types.
1935 def v16i8 : N2VQShIns<op24, op23, op11_8, 0, op4,
1936 OpcodeStr, "8", v16i8, ShOp> {
1937 let Inst{21-19} = 0b001; // imm6 = 001xxx
1939 def v8i16 : N2VQShIns<op24, op23, op11_8, 0, op4,
1940 OpcodeStr, "16", v8i16, ShOp> {
1941 let Inst{21-20} = 0b01; // imm6 = 01xxxx
1943 def v4i32 : N2VQShIns<op24, op23, op11_8, 0, op4,
1944 OpcodeStr, "32", v4i32, ShOp> {
1945 let Inst{21} = 0b1; // imm6 = 1xxxxx
1947 def v2i64 : N2VQShIns<op24, op23, op11_8, 1, op4,
1948 OpcodeStr, "64", v2i64, ShOp>;
1952 // Same as N2VShIns_QHSD, except the instructions have a differnt interpretation
1953 // of the shift amount. This helps the disassembler.
1954 let NSF = NVectorShift2Frm, NSForm = NVectorShift2Frm.Value in {
1955 multiclass N2VShIns_QHSD2<bit op24, bit op23, bits<4> op11_8, bit op4,
1956 string OpcodeStr, SDNode ShOp> {
1957 // 64-bit vector types.
1958 def v8i8 : N2VDShIns<op24, op23, op11_8, 0, op4,
1959 OpcodeStr, "8", v8i8, ShOp> {
1960 let Inst{21-19} = 0b001; // imm6 = 001xxx
1962 def v4i16 : N2VDShIns<op24, op23, op11_8, 0, op4,
1963 OpcodeStr, "16", v4i16, ShOp> {
1964 let Inst{21-20} = 0b01; // imm6 = 01xxxx
1966 def v2i32 : N2VDShIns<op24, op23, op11_8, 0, op4,
1967 OpcodeStr, "32", v2i32, ShOp> {
1968 let Inst{21} = 0b1; // imm6 = 1xxxxx
1970 def v1i64 : N2VDShIns<op24, op23, op11_8, 1, op4,
1971 OpcodeStr, "64", v1i64, ShOp>;
1974 // 128-bit vector types.
1975 def v16i8 : N2VQShIns<op24, op23, op11_8, 0, op4,
1976 OpcodeStr, "8", v16i8, ShOp> {
1977 let Inst{21-19} = 0b001; // imm6 = 001xxx
1979 def v8i16 : N2VQShIns<op24, op23, op11_8, 0, op4,
1980 OpcodeStr, "16", v8i16, ShOp> {
1981 let Inst{21-20} = 0b01; // imm6 = 01xxxx
1983 def v4i32 : N2VQShIns<op24, op23, op11_8, 0, op4,
1984 OpcodeStr, "32", v4i32, ShOp> {
1985 let Inst{21} = 0b1; // imm6 = 1xxxxx
1987 def v2i64 : N2VQShIns<op24, op23, op11_8, 1, op4,
1988 OpcodeStr, "64", v2i64, ShOp>;
1993 // Neon Shift Long operations,
1994 // element sizes of 8, 16, 32 bits:
1995 multiclass N2VLSh_QHS<bit op24, bit op23, bits<4> op11_8, bit op7, bit op6,
1996 bit op4, string OpcodeStr, string Dt, SDNode OpNode> {
1997 def v8i16 : N2VLSh<op24, op23, op11_8, op7, op6, op4,
1998 OpcodeStr, !strconcat(Dt, "8"), v8i16, v8i8, OpNode> {
1999 let Inst{21-19} = 0b001; // imm6 = 001xxx
2001 def v4i32 : N2VLSh<op24, op23, op11_8, op7, op6, op4,
2002 OpcodeStr, !strconcat(Dt, "16"), v4i32, v4i16, OpNode> {
2003 let Inst{21-20} = 0b01; // imm6 = 01xxxx
2005 def v2i64 : N2VLSh<op24, op23, op11_8, op7, op6, op4,
2006 OpcodeStr, !strconcat(Dt, "32"), v2i64, v2i32, OpNode> {
2007 let Inst{21} = 0b1; // imm6 = 1xxxxx
2011 // Neon Shift Narrow operations,
2012 // element sizes of 16, 32, 64 bits:
2013 multiclass N2VNSh_HSD<bit op24, bit op23, bits<4> op11_8, bit op7, bit op6,
2014 bit op4, InstrItinClass itin, string OpcodeStr, string Dt,
2016 def v8i8 : N2VNSh<op24, op23, op11_8, op7, op6, op4, itin,
2017 OpcodeStr, !strconcat(Dt, "16"), v8i8, v8i16, OpNode> {
2018 let Inst{21-19} = 0b001; // imm6 = 001xxx
2020 def v4i16 : N2VNSh<op24, op23, op11_8, op7, op6, op4, itin,
2021 OpcodeStr, !strconcat(Dt, "32"), v4i16, v4i32, OpNode> {
2022 let Inst{21-20} = 0b01; // imm6 = 01xxxx
2024 def v2i32 : N2VNSh<op24, op23, op11_8, op7, op6, op4, itin,
2025 OpcodeStr, !strconcat(Dt, "64"), v2i32, v2i64, OpNode> {
2026 let Inst{21} = 0b1; // imm6 = 1xxxxx
2030 //===----------------------------------------------------------------------===//
2031 // Instruction Definitions.
2032 //===----------------------------------------------------------------------===//
2034 // Vector Add Operations.
2036 // VADD : Vector Add (integer and floating-point)
2037 defm VADD : N3V_QHSD<0, 0, 0b1000, 0, IIC_VBINiD, IIC_VBINiQ, "vadd", "i",
2039 def VADDfd : N3VD<0, 0, 0b00, 0b1101, 0, IIC_VBIND, "vadd", "f32",
2040 v2f32, v2f32, fadd, 1>;
2041 def VADDfq : N3VQ<0, 0, 0b00, 0b1101, 0, IIC_VBINQ, "vadd", "f32",
2042 v4f32, v4f32, fadd, 1>;
2043 // VADDL : Vector Add Long (Q = D + D)
2044 defm VADDLs : N3VLInt_QHS<0,1,0b0000,0, IIC_VSHLiD, "vaddl", "s",
2045 int_arm_neon_vaddls, 1>;
2046 defm VADDLu : N3VLInt_QHS<1,1,0b0000,0, IIC_VSHLiD, "vaddl", "u",
2047 int_arm_neon_vaddlu, 1>;
2048 // VADDW : Vector Add Wide (Q = Q + D)
2049 defm VADDWs : N3VWInt_QHS<0,1,0b0001,0, "vaddw", "s", int_arm_neon_vaddws, 0>;
2050 defm VADDWu : N3VWInt_QHS<1,1,0b0001,0, "vaddw", "u", int_arm_neon_vaddwu, 0>;
2051 // VHADD : Vector Halving Add
2052 defm VHADDs : N3VInt_QHS<0,0,0b0000,0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2053 IIC_VBINi4Q, "vhadd", "s", int_arm_neon_vhadds, 1>;
2054 defm VHADDu : N3VInt_QHS<1,0,0b0000,0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2055 IIC_VBINi4Q, "vhadd", "u", int_arm_neon_vhaddu, 1>;
2056 // VRHADD : Vector Rounding Halving Add
2057 defm VRHADDs : N3VInt_QHS<0,0,0b0001,0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2058 IIC_VBINi4Q, "vrhadd", "s", int_arm_neon_vrhadds, 1>;
2059 defm VRHADDu : N3VInt_QHS<1,0,0b0001,0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2060 IIC_VBINi4Q, "vrhadd", "u", int_arm_neon_vrhaddu, 1>;
2061 // VQADD : Vector Saturating Add
2062 defm VQADDs : N3VInt_QHSD<0,0,0b0000,1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2063 IIC_VBINi4Q, "vqadd", "s", int_arm_neon_vqadds, 1>;
2064 defm VQADDu : N3VInt_QHSD<1,0,0b0000,1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2065 IIC_VBINi4Q, "vqadd", "u", int_arm_neon_vqaddu, 1>;
2066 // VADDHN : Vector Add and Narrow Returning High Half (D = Q + Q)
2067 defm VADDHN : N3VNInt_HSD<0,1,0b0100,0, "vaddhn", "i",
2068 int_arm_neon_vaddhn, 1>;
2069 // VRADDHN : Vector Rounding Add and Narrow Returning High Half (D = Q + Q)
2070 defm VRADDHN : N3VNInt_HSD<1,1,0b0100,0, "vraddhn", "i",
2071 int_arm_neon_vraddhn, 1>;
2073 // Vector Multiply Operations.
2075 // VMUL : Vector Multiply (integer, polynomial and floating-point)
2076 defm VMUL : N3V_QHS<0, 0, 0b1001, 1, IIC_VMULi16D, IIC_VMULi32D,
2077 IIC_VMULi16Q, IIC_VMULi32Q, "vmul", "i", mul, 1>;
2078 def VMULpd : N3VDInt<1, 0, 0b00, 0b1001, 1, IIC_VMULi16D, "vmul", "p8",
2079 v8i8, v8i8, int_arm_neon_vmulp, 1>;
2080 def VMULpq : N3VQInt<1, 0, 0b00, 0b1001, 1, IIC_VMULi16Q, "vmul", "p8",
2081 v16i8, v16i8, int_arm_neon_vmulp, 1>;
2082 def VMULfd : N3VD<1, 0, 0b00, 0b1101, 1, IIC_VBIND, "vmul", "f32",
2083 v2f32, v2f32, fmul, 1>;
2084 def VMULfq : N3VQ<1, 0, 0b00, 0b1101, 1, IIC_VBINQ, "vmul", "f32",
2085 v4f32, v4f32, fmul, 1>;
2086 defm VMULsl : N3VSL_HS<0b1000, "vmul", "i", mul>;
2087 def VMULslfd : N3VDSL<0b10, 0b1001, IIC_VBIND, "vmul", "f32", v2f32, fmul>;
2088 def VMULslfq : N3VQSL<0b10, 0b1001, IIC_VBINQ, "vmul", "f32", v4f32,
2091 def : Pat<(v8i16 (mul (v8i16 QPR:$src1),
2092 (v8i16 (NEONvduplane (v8i16 QPR:$src2), imm:$lane)))),
2093 (v8i16 (VMULslv8i16 (v8i16 QPR:$src1),
2094 (v4i16 (EXTRACT_SUBREG QPR:$src2,
2095 (DSubReg_i16_reg imm:$lane))),
2096 (SubReg_i16_lane imm:$lane)))>;
2097 def : Pat<(v4i32 (mul (v4i32 QPR:$src1),
2098 (v4i32 (NEONvduplane (v4i32 QPR:$src2), imm:$lane)))),
2099 (v4i32 (VMULslv4i32 (v4i32 QPR:$src1),
2100 (v2i32 (EXTRACT_SUBREG QPR:$src2,
2101 (DSubReg_i32_reg imm:$lane))),
2102 (SubReg_i32_lane imm:$lane)))>;
2103 def : Pat<(v4f32 (fmul (v4f32 QPR:$src1),
2104 (v4f32 (NEONvduplane (v4f32 QPR:$src2), imm:$lane)))),
2105 (v4f32 (VMULslfq (v4f32 QPR:$src1),
2106 (v2f32 (EXTRACT_SUBREG QPR:$src2,
2107 (DSubReg_i32_reg imm:$lane))),
2108 (SubReg_i32_lane imm:$lane)))>;
2110 // VQDMULH : Vector Saturating Doubling Multiply Returning High Half
2111 defm VQDMULH : N3VInt_HS<0, 0, 0b1011, 0, IIC_VMULi16D, IIC_VMULi32D,
2112 IIC_VMULi16Q, IIC_VMULi32Q,
2113 "vqdmulh", "s", int_arm_neon_vqdmulh, 1>;
2114 defm VQDMULHsl: N3VIntSL_HS<0b1100, IIC_VMULi16D, IIC_VMULi32D,
2115 IIC_VMULi16Q, IIC_VMULi32Q,
2116 "vqdmulh", "s", int_arm_neon_vqdmulh>;
2117 def : Pat<(v8i16 (int_arm_neon_vqdmulh (v8i16 QPR:$src1),
2118 (v8i16 (NEONvduplane (v8i16 QPR:$src2),
2120 (v8i16 (VQDMULHslv8i16 (v8i16 QPR:$src1),
2121 (v4i16 (EXTRACT_SUBREG QPR:$src2,
2122 (DSubReg_i16_reg imm:$lane))),
2123 (SubReg_i16_lane imm:$lane)))>;
2124 def : Pat<(v4i32 (int_arm_neon_vqdmulh (v4i32 QPR:$src1),
2125 (v4i32 (NEONvduplane (v4i32 QPR:$src2),
2127 (v4i32 (VQDMULHslv4i32 (v4i32 QPR:$src1),
2128 (v2i32 (EXTRACT_SUBREG QPR:$src2,
2129 (DSubReg_i32_reg imm:$lane))),
2130 (SubReg_i32_lane imm:$lane)))>;
2132 // VQRDMULH : Vector Rounding Saturating Doubling Multiply Returning High Half
2133 defm VQRDMULH : N3VInt_HS<1, 0, 0b1011, 0, IIC_VMULi16D, IIC_VMULi32D,
2134 IIC_VMULi16Q, IIC_VMULi32Q,
2135 "vqrdmulh", "s", int_arm_neon_vqrdmulh, 1>;
2136 defm VQRDMULHsl : N3VIntSL_HS<0b1101, IIC_VMULi16D, IIC_VMULi32D,
2137 IIC_VMULi16Q, IIC_VMULi32Q,
2138 "vqrdmulh", "s", int_arm_neon_vqrdmulh>;
2139 def : Pat<(v8i16 (int_arm_neon_vqrdmulh (v8i16 QPR:$src1),
2140 (v8i16 (NEONvduplane (v8i16 QPR:$src2),
2142 (v8i16 (VQRDMULHslv8i16 (v8i16 QPR:$src1),
2143 (v4i16 (EXTRACT_SUBREG QPR:$src2,
2144 (DSubReg_i16_reg imm:$lane))),
2145 (SubReg_i16_lane imm:$lane)))>;
2146 def : Pat<(v4i32 (int_arm_neon_vqrdmulh (v4i32 QPR:$src1),
2147 (v4i32 (NEONvduplane (v4i32 QPR:$src2),
2149 (v4i32 (VQRDMULHslv4i32 (v4i32 QPR:$src1),
2150 (v2i32 (EXTRACT_SUBREG QPR:$src2,
2151 (DSubReg_i32_reg imm:$lane))),
2152 (SubReg_i32_lane imm:$lane)))>;
2154 // VMULL : Vector Multiply Long (integer and polynomial) (Q = D * D)
2155 defm VMULLs : N3VLInt_QHS<0,1,0b1100,0, IIC_VMULi16D, "vmull", "s",
2156 int_arm_neon_vmulls, 1>;
2157 defm VMULLu : N3VLInt_QHS<1,1,0b1100,0, IIC_VMULi16D, "vmull", "u",
2158 int_arm_neon_vmullu, 1>;
2159 def VMULLp : N3VLInt<0, 1, 0b00, 0b1110, 0, IIC_VMULi16D, "vmull", "p8",
2160 v8i16, v8i8, int_arm_neon_vmullp, 1>;
2161 defm VMULLsls : N3VLIntSL_HS<0, 0b1010, IIC_VMULi16D, "vmull", "s",
2162 int_arm_neon_vmulls>;
2163 defm VMULLslu : N3VLIntSL_HS<1, 0b1010, IIC_VMULi16D, "vmull", "u",
2164 int_arm_neon_vmullu>;
2166 // VQDMULL : Vector Saturating Doubling Multiply Long (Q = D * D)
2167 defm VQDMULL : N3VLInt_HS<0,1,0b1101,0, IIC_VMULi16D, "vqdmull", "s",
2168 int_arm_neon_vqdmull, 1>;
2169 defm VQDMULLsl: N3VLIntSL_HS<0, 0b1011, IIC_VMULi16D, "vqdmull", "s",
2170 int_arm_neon_vqdmull>;
2172 // Vector Multiply-Accumulate and Multiply-Subtract Operations.
2174 // VMLA : Vector Multiply Accumulate (integer and floating-point)
2175 defm VMLA : N3VMulOp_QHS<0, 0, 0b1001, 0, IIC_VMACi16D, IIC_VMACi32D,
2176 IIC_VMACi16Q, IIC_VMACi32Q, "vmla", "i", add>;
2177 def VMLAfd : N3VDMulOp<0, 0, 0b00, 0b1101, 1, IIC_VMACD, "vmla", "f32",
2179 def VMLAfq : N3VQMulOp<0, 0, 0b00, 0b1101, 1, IIC_VMACQ, "vmla", "f32",
2181 defm VMLAsl : N3VMulOpSL_HS<0b0000, IIC_VMACi16D, IIC_VMACi32D,
2182 IIC_VMACi16Q, IIC_VMACi32Q, "vmla", "i", add>;
2183 def VMLAslfd : N3VDMulOpSL<0b10, 0b0001, IIC_VMACD, "vmla", "f32",
2185 def VMLAslfq : N3VQMulOpSL<0b10, 0b0001, IIC_VMACQ, "vmla", "f32",
2186 v4f32, v2f32, fmul, fadd>;
2188 def : Pat<(v8i16 (add (v8i16 QPR:$src1),
2189 (mul (v8i16 QPR:$src2),
2190 (v8i16 (NEONvduplane (v8i16 QPR:$src3), imm:$lane))))),
2191 (v8i16 (VMLAslv8i16 (v8i16 QPR:$src1), (v8i16 QPR:$src2),
2192 (v4i16 (EXTRACT_SUBREG QPR:$src3,
2193 (DSubReg_i16_reg imm:$lane))),
2194 (SubReg_i16_lane imm:$lane)))>;
2196 def : Pat<(v4i32 (add (v4i32 QPR:$src1),
2197 (mul (v4i32 QPR:$src2),
2198 (v4i32 (NEONvduplane (v4i32 QPR:$src3), imm:$lane))))),
2199 (v4i32 (VMLAslv4i32 (v4i32 QPR:$src1), (v4i32 QPR:$src2),
2200 (v2i32 (EXTRACT_SUBREG QPR:$src3,
2201 (DSubReg_i32_reg imm:$lane))),
2202 (SubReg_i32_lane imm:$lane)))>;
2204 def : Pat<(v4f32 (fadd (v4f32 QPR:$src1),
2205 (fmul (v4f32 QPR:$src2),
2206 (v4f32 (NEONvduplane (v4f32 QPR:$src3), imm:$lane))))),
2207 (v4f32 (VMLAslfq (v4f32 QPR:$src1),
2209 (v2f32 (EXTRACT_SUBREG QPR:$src3,
2210 (DSubReg_i32_reg imm:$lane))),
2211 (SubReg_i32_lane imm:$lane)))>;
2213 // VMLAL : Vector Multiply Accumulate Long (Q += D * D)
2214 defm VMLALs : N3VLInt3_QHS<0,1,0b1000,0, "vmlal", "s", int_arm_neon_vmlals>;
2215 defm VMLALu : N3VLInt3_QHS<1,1,0b1000,0, "vmlal", "u", int_arm_neon_vmlalu>;
2217 defm VMLALsls : N3VLInt3SL_HS<0, 0b0010, "vmlal", "s", int_arm_neon_vmlals>;
2218 defm VMLALslu : N3VLInt3SL_HS<1, 0b0010, "vmlal", "u", int_arm_neon_vmlalu>;
2220 // VQDMLAL : Vector Saturating Doubling Multiply Accumulate Long (Q += D * D)
2221 defm VQDMLAL : N3VLInt3_HS<0, 1, 0b1001, 0, "vqdmlal", "s",
2222 int_arm_neon_vqdmlal>;
2223 defm VQDMLALsl: N3VLInt3SL_HS<0, 0b0011, "vqdmlal", "s", int_arm_neon_vqdmlal>;
2225 // VMLS : Vector Multiply Subtract (integer and floating-point)
2226 defm VMLS : N3VMulOp_QHS<1, 0, 0b1001, 0, IIC_VMACi16D, IIC_VMACi32D,
2227 IIC_VMACi16Q, IIC_VMACi32Q, "vmls", "i", sub>;
2228 def VMLSfd : N3VDMulOp<0, 0, 0b10, 0b1101, 1, IIC_VMACD, "vmls", "f32",
2230 def VMLSfq : N3VQMulOp<0, 0, 0b10, 0b1101, 1, IIC_VMACQ, "vmls", "f32",
2232 defm VMLSsl : N3VMulOpSL_HS<0b0100, IIC_VMACi16D, IIC_VMACi32D,
2233 IIC_VMACi16Q, IIC_VMACi32Q, "vmls", "i", sub>;
2234 def VMLSslfd : N3VDMulOpSL<0b10, 0b0101, IIC_VMACD, "vmls", "f32",
2236 def VMLSslfq : N3VQMulOpSL<0b10, 0b0101, IIC_VMACQ, "vmls", "f32",
2237 v4f32, v2f32, fmul, fsub>;
2239 def : Pat<(v8i16 (sub (v8i16 QPR:$src1),
2240 (mul (v8i16 QPR:$src2),
2241 (v8i16 (NEONvduplane (v8i16 QPR:$src3), imm:$lane))))),
2242 (v8i16 (VMLSslv8i16 (v8i16 QPR:$src1), (v8i16 QPR:$src2),
2243 (v4i16 (EXTRACT_SUBREG QPR:$src3,
2244 (DSubReg_i16_reg imm:$lane))),
2245 (SubReg_i16_lane imm:$lane)))>;
2247 def : Pat<(v4i32 (sub (v4i32 QPR:$src1),
2248 (mul (v4i32 QPR:$src2),
2249 (v4i32 (NEONvduplane (v4i32 QPR:$src3), imm:$lane))))),
2250 (v4i32 (VMLSslv4i32 (v4i32 QPR:$src1), (v4i32 QPR:$src2),
2251 (v2i32 (EXTRACT_SUBREG QPR:$src3,
2252 (DSubReg_i32_reg imm:$lane))),
2253 (SubReg_i32_lane imm:$lane)))>;
2255 def : Pat<(v4f32 (fsub (v4f32 QPR:$src1),
2256 (fmul (v4f32 QPR:$src2),
2257 (v4f32 (NEONvduplane (v4f32 QPR:$src3), imm:$lane))))),
2258 (v4f32 (VMLSslfq (v4f32 QPR:$src1), (v4f32 QPR:$src2),
2259 (v2f32 (EXTRACT_SUBREG QPR:$src3,
2260 (DSubReg_i32_reg imm:$lane))),
2261 (SubReg_i32_lane imm:$lane)))>;
2263 // VMLSL : Vector Multiply Subtract Long (Q -= D * D)
2264 defm VMLSLs : N3VLInt3_QHS<0,1,0b1010,0, "vmlsl", "s", int_arm_neon_vmlsls>;
2265 defm VMLSLu : N3VLInt3_QHS<1,1,0b1010,0, "vmlsl", "u", int_arm_neon_vmlslu>;
2267 defm VMLSLsls : N3VLInt3SL_HS<0, 0b0110, "vmlsl", "s", int_arm_neon_vmlsls>;
2268 defm VMLSLslu : N3VLInt3SL_HS<1, 0b0110, "vmlsl", "u", int_arm_neon_vmlslu>;
2270 // VQDMLSL : Vector Saturating Doubling Multiply Subtract Long (Q -= D * D)
2271 defm VQDMLSL : N3VLInt3_HS<0, 1, 0b1011, 0, "vqdmlsl", "s",
2272 int_arm_neon_vqdmlsl>;
2273 defm VQDMLSLsl: N3VLInt3SL_HS<0, 0b111, "vqdmlsl", "s", int_arm_neon_vqdmlsl>;
2275 // Vector Subtract Operations.
2277 // VSUB : Vector Subtract (integer and floating-point)
2278 defm VSUB : N3V_QHSD<1, 0, 0b1000, 0, IIC_VSUBiD, IIC_VSUBiQ,
2279 "vsub", "i", sub, 0>;
2280 def VSUBfd : N3VD<0, 0, 0b10, 0b1101, 0, IIC_VBIND, "vsub", "f32",
2281 v2f32, v2f32, fsub, 0>;
2282 def VSUBfq : N3VQ<0, 0, 0b10, 0b1101, 0, IIC_VBINQ, "vsub", "f32",
2283 v4f32, v4f32, fsub, 0>;
2284 // VSUBL : Vector Subtract Long (Q = D - D)
2285 defm VSUBLs : N3VLInt_QHS<0,1,0b0010,0, IIC_VSHLiD, "vsubl", "s",
2286 int_arm_neon_vsubls, 1>;
2287 defm VSUBLu : N3VLInt_QHS<1,1,0b0010,0, IIC_VSHLiD, "vsubl", "u",
2288 int_arm_neon_vsublu, 1>;
2289 // VSUBW : Vector Subtract Wide (Q = Q - D)
2290 defm VSUBWs : N3VWInt_QHS<0,1,0b0011,0, "vsubw", "s", int_arm_neon_vsubws, 0>;
2291 defm VSUBWu : N3VWInt_QHS<1,1,0b0011,0, "vsubw", "u", int_arm_neon_vsubwu, 0>;
2292 // VHSUB : Vector Halving Subtract
2293 defm VHSUBs : N3VInt_QHS<0, 0, 0b0010, 0, IIC_VBINi4D, IIC_VBINi4D,
2294 IIC_VBINi4Q, IIC_VBINi4Q,
2295 "vhsub", "s", int_arm_neon_vhsubs, 0>;
2296 defm VHSUBu : N3VInt_QHS<1, 0, 0b0010, 0, IIC_VBINi4D, IIC_VBINi4D,
2297 IIC_VBINi4Q, IIC_VBINi4Q,
2298 "vhsub", "u", int_arm_neon_vhsubu, 0>;
2299 // VQSUB : Vector Saturing Subtract
2300 defm VQSUBs : N3VInt_QHSD<0, 0, 0b0010, 1, IIC_VBINi4D, IIC_VBINi4D,
2301 IIC_VBINi4Q, IIC_VBINi4Q,
2302 "vqsub", "s", int_arm_neon_vqsubs, 0>;
2303 defm VQSUBu : N3VInt_QHSD<1, 0, 0b0010, 1, IIC_VBINi4D, IIC_VBINi4D,
2304 IIC_VBINi4Q, IIC_VBINi4Q,
2305 "vqsub", "u", int_arm_neon_vqsubu, 0>;
2306 // VSUBHN : Vector Subtract and Narrow Returning High Half (D = Q - Q)
2307 defm VSUBHN : N3VNInt_HSD<0,1,0b0110,0, "vsubhn", "i",
2308 int_arm_neon_vsubhn, 0>;
2309 // VRSUBHN : Vector Rounding Subtract and Narrow Returning High Half (D=Q-Q)
2310 defm VRSUBHN : N3VNInt_HSD<1,1,0b0110,0, "vrsubhn", "i",
2311 int_arm_neon_vrsubhn, 0>;
2313 // Vector Comparisons.
2315 // VCEQ : Vector Compare Equal
2316 defm VCEQ : N3V_QHS<1, 0, 0b1000, 1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2317 IIC_VBINi4Q, "vceq", "i", NEONvceq, 1>;
2318 def VCEQfd : N3VD<0,0,0b00,0b1110,0, IIC_VBIND, "vceq", "f32", v2i32, v2f32,
2320 def VCEQfq : N3VQ<0,0,0b00,0b1110,0, IIC_VBINQ, "vceq", "f32", v4i32, v4f32,
2322 // For disassembly only.
2323 defm VCEQz : N2V_QHS_cmp<0b11, 0b11, 0b01, 0b00010, 0, "vceq", "i",
2326 // VCGE : Vector Compare Greater Than or Equal
2327 defm VCGEs : N3V_QHS<0, 0, 0b0011, 1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2328 IIC_VBINi4Q, "vcge", "s", NEONvcge, 0>;
2329 defm VCGEu : N3V_QHS<1, 0, 0b0011, 1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2330 IIC_VBINi4Q, "vcge", "u", NEONvcgeu, 0>;
2331 def VCGEfd : N3VD<1,0,0b00,0b1110,0, IIC_VBIND, "vcge", "f32",
2332 v2i32, v2f32, NEONvcge, 0>;
2333 def VCGEfq : N3VQ<1,0,0b00,0b1110,0, IIC_VBINQ, "vcge", "f32", v4i32, v4f32,
2335 // For disassembly only.
2336 defm VCGEz : N2V_QHS_cmp<0b11, 0b11, 0b01, 0b00001, 0, "vcge", "s",
2338 // For disassembly only.
2339 defm VCLEz : N2V_QHS_cmp<0b11, 0b11, 0b01, 0b00011, 0, "vcle", "s",
2342 // VCGT : Vector Compare Greater Than
2343 defm VCGTs : N3V_QHS<0, 0, 0b0011, 0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2344 IIC_VBINi4Q, "vcgt", "s", NEONvcgt, 0>;
2345 defm VCGTu : N3V_QHS<1, 0, 0b0011, 0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2346 IIC_VBINi4Q, "vcgt", "u", NEONvcgtu, 0>;
2347 def VCGTfd : N3VD<1,0,0b10,0b1110,0, IIC_VBIND, "vcgt", "f32", v2i32, v2f32,
2349 def VCGTfq : N3VQ<1,0,0b10,0b1110,0, IIC_VBINQ, "vcgt", "f32", v4i32, v4f32,
2351 // For disassembly only.
2352 defm VCGTz : N2V_QHS_cmp<0b11, 0b11, 0b01, 0b00000, 0, "vcgt", "s",
2354 // For disassembly only.
2355 defm VCLTz : N2V_QHS_cmp<0b11, 0b11, 0b01, 0b00100, 0, "vclt", "s",
2358 // VACGE : Vector Absolute Compare Greater Than or Equal (aka VCAGE)
2359 def VACGEd : N3VDInt<1, 0, 0b00, 0b1110, 1, IIC_VBIND, "vacge", "f32",
2360 v2i32, v2f32, int_arm_neon_vacged, 0>;
2361 def VACGEq : N3VQInt<1, 0, 0b00, 0b1110, 1, IIC_VBINQ, "vacge", "f32",
2362 v4i32, v4f32, int_arm_neon_vacgeq, 0>;
2363 // VACGT : Vector Absolute Compare Greater Than (aka VCAGT)
2364 def VACGTd : N3VDInt<1, 0, 0b10, 0b1110, 1, IIC_VBIND, "vacgt", "f32",
2365 v2i32, v2f32, int_arm_neon_vacgtd, 0>;
2366 def VACGTq : N3VQInt<1, 0, 0b10, 0b1110, 1, IIC_VBINQ, "vacgt", "f32",
2367 v4i32, v4f32, int_arm_neon_vacgtq, 0>;
2368 // VTST : Vector Test Bits
2369 defm VTST : N3V_QHS<0, 0, 0b1000, 1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2370 IIC_VBINi4Q, "vtst", "", NEONvtst, 1>;
2372 // Vector Bitwise Operations.
2374 // VAND : Vector Bitwise AND
2375 def VANDd : N3VDX<0, 0, 0b00, 0b0001, 1, IIC_VBINiD, "vand",
2376 v2i32, v2i32, and, 1>;
2377 def VANDq : N3VQX<0, 0, 0b00, 0b0001, 1, IIC_VBINiQ, "vand",
2378 v4i32, v4i32, and, 1>;
2380 // VEOR : Vector Bitwise Exclusive OR
2381 def VEORd : N3VDX<1, 0, 0b00, 0b0001, 1, IIC_VBINiD, "veor",
2382 v2i32, v2i32, xor, 1>;
2383 def VEORq : N3VQX<1, 0, 0b00, 0b0001, 1, IIC_VBINiQ, "veor",
2384 v4i32, v4i32, xor, 1>;
2386 // VORR : Vector Bitwise OR
2387 def VORRd : N3VDX<0, 0, 0b10, 0b0001, 1, IIC_VBINiD, "vorr",
2388 v2i32, v2i32, or, 1>;
2389 def VORRq : N3VQX<0, 0, 0b10, 0b0001, 1, IIC_VBINiQ, "vorr",
2390 v4i32, v4i32, or, 1>;
2392 // VBIC : Vector Bitwise Bit Clear (AND NOT)
2393 def VBICd : N3VX<0, 0, 0b01, 0b0001, 0, 1, (outs DPR:$dst),
2394 (ins DPR:$src1, DPR:$src2), IIC_VBINiD,
2395 "vbic", "$dst, $src1, $src2", "",
2396 [(set DPR:$dst, (v2i32 (and DPR:$src1,
2397 (vnot_conv DPR:$src2))))]>;
2398 def VBICq : N3VX<0, 0, 0b01, 0b0001, 1, 1, (outs QPR:$dst),
2399 (ins QPR:$src1, QPR:$src2), IIC_VBINiQ,
2400 "vbic", "$dst, $src1, $src2", "",
2401 [(set QPR:$dst, (v4i32 (and QPR:$src1,
2402 (vnot_conv QPR:$src2))))]>;
2404 // VORN : Vector Bitwise OR NOT
2405 def VORNd : N3VX<0, 0, 0b11, 0b0001, 0, 1, (outs DPR:$dst),
2406 (ins DPR:$src1, DPR:$src2), IIC_VBINiD,
2407 "vorn", "$dst, $src1, $src2", "",
2408 [(set DPR:$dst, (v2i32 (or DPR:$src1,
2409 (vnot_conv DPR:$src2))))]>;
2410 def VORNq : N3VX<0, 0, 0b11, 0b0001, 1, 1, (outs QPR:$dst),
2411 (ins QPR:$src1, QPR:$src2), IIC_VBINiQ,
2412 "vorn", "$dst, $src1, $src2", "",
2413 [(set QPR:$dst, (v4i32 (or QPR:$src1,
2414 (vnot_conv QPR:$src2))))]>;
2416 // VMVN : Vector Bitwise NOT
2417 def VMVNd : N2VX<0b11, 0b11, 0b00, 0b00, 0b01011, 0, 0,
2418 (outs DPR:$dst), (ins DPR:$src), IIC_VSHLiD,
2419 "vmvn", "$dst, $src", "",
2420 [(set DPR:$dst, (v2i32 (vnot DPR:$src)))]>;
2421 def VMVNq : N2VX<0b11, 0b11, 0b00, 0b00, 0b01011, 1, 0,
2422 (outs QPR:$dst), (ins QPR:$src), IIC_VSHLiD,
2423 "vmvn", "$dst, $src", "",
2424 [(set QPR:$dst, (v4i32 (vnot QPR:$src)))]>;
2425 def : Pat<(v2i32 (vnot_conv DPR:$src)), (VMVNd DPR:$src)>;
2426 def : Pat<(v4i32 (vnot_conv QPR:$src)), (VMVNq QPR:$src)>;
2428 // VBSL : Vector Bitwise Select
2429 def VBSLd : N3VX<1, 0, 0b01, 0b0001, 0, 1, (outs DPR:$dst),
2430 (ins DPR:$src1, DPR:$src2, DPR:$src3), IIC_VCNTiD,
2431 "vbsl", "$dst, $src2, $src3", "$src1 = $dst",
2433 (v2i32 (or (and DPR:$src2, DPR:$src1),
2434 (and DPR:$src3, (vnot_conv DPR:$src1)))))]>;
2435 def VBSLq : N3VX<1, 0, 0b01, 0b0001, 1, 1, (outs QPR:$dst),
2436 (ins QPR:$src1, QPR:$src2, QPR:$src3), IIC_VCNTiQ,
2437 "vbsl", "$dst, $src2, $src3", "$src1 = $dst",
2439 (v4i32 (or (and QPR:$src2, QPR:$src1),
2440 (and QPR:$src3, (vnot_conv QPR:$src1)))))]>;
2442 // VBIF : Vector Bitwise Insert if False
2443 // like VBSL but with: "vbif $dst, $src3, $src1", "$src2 = $dst",
2444 def VBIFd : N3VX<1, 0, 0b11, 0b0001, 0, 1,
2445 (outs DPR:$dst), (ins DPR:$src1, DPR:$src2, DPR:$src3),
2446 IIC_VBINiD, "vbif", "$dst, $src2, $src3", "$src1 = $dst",
2447 [/* For disassembly only; pattern left blank */]>;
2448 def VBIFq : N3VX<1, 0, 0b11, 0b0001, 1, 1,
2449 (outs QPR:$dst), (ins QPR:$src1, QPR:$src2, QPR:$src3),
2450 IIC_VBINiQ, "vbif", "$dst, $src2, $src3", "$src1 = $dst",
2451 [/* For disassembly only; pattern left blank */]>;
2453 // VBIT : Vector Bitwise Insert if True
2454 // like VBSL but with: "vbit $dst, $src2, $src1", "$src3 = $dst",
2455 def VBITd : N3VX<1, 0, 0b10, 0b0001, 0, 1,
2456 (outs DPR:$dst), (ins DPR:$src1, DPR:$src2, DPR:$src3),
2457 IIC_VBINiD, "vbit", "$dst, $src2, $src3", "$src1 = $dst",
2458 [/* For disassembly only; pattern left blank */]>;
2459 def VBITq : N3VX<1, 0, 0b10, 0b0001, 1, 1,
2460 (outs QPR:$dst), (ins QPR:$src1, QPR:$src2, QPR:$src3),
2461 IIC_VBINiQ, "vbit", "$dst, $src2, $src3", "$src1 = $dst",
2462 [/* For disassembly only; pattern left blank */]>;
2464 // VBIT/VBIF are not yet implemented. The TwoAddress pass will not go looking
2465 // for equivalent operations with different register constraints; it just
2468 // Vector Absolute Differences.
2470 // VABD : Vector Absolute Difference
2471 defm VABDs : N3VInt_QHS<0, 0, 0b0111, 0, IIC_VBINi4D, IIC_VBINi4D,
2472 IIC_VBINi4Q, IIC_VBINi4Q,
2473 "vabd", "s", int_arm_neon_vabds, 0>;
2474 defm VABDu : N3VInt_QHS<1, 0, 0b0111, 0, IIC_VBINi4D, IIC_VBINi4D,
2475 IIC_VBINi4Q, IIC_VBINi4Q,
2476 "vabd", "u", int_arm_neon_vabdu, 0>;
2477 def VABDfd : N3VDInt<1, 0, 0b10, 0b1101, 0, IIC_VBIND,
2478 "vabd", "f32", v2f32, v2f32, int_arm_neon_vabds, 0>;
2479 def VABDfq : N3VQInt<1, 0, 0b10, 0b1101, 0, IIC_VBINQ,
2480 "vabd", "f32", v4f32, v4f32, int_arm_neon_vabds, 0>;
2482 // VABDL : Vector Absolute Difference Long (Q = | D - D |)
2483 defm VABDLs : N3VLInt_QHS<0,1,0b0111,0, IIC_VBINi4Q,
2484 "vabdl", "s", int_arm_neon_vabdls, 0>;
2485 defm VABDLu : N3VLInt_QHS<1,1,0b0111,0, IIC_VBINi4Q,
2486 "vabdl", "u", int_arm_neon_vabdlu, 0>;
2488 // VABA : Vector Absolute Difference and Accumulate
2489 defm VABAs : N3VInt3_QHS<0,0,0b0111,1, "vaba", "s", int_arm_neon_vabas>;
2490 defm VABAu : N3VInt3_QHS<1,0,0b0111,1, "vaba", "u", int_arm_neon_vabau>;
2492 // VABAL : Vector Absolute Difference and Accumulate Long (Q += | D - D |)
2493 defm VABALs : N3VLInt3_QHS<0,1,0b0101,0, "vabal", "s", int_arm_neon_vabals>;
2494 defm VABALu : N3VLInt3_QHS<1,1,0b0101,0, "vabal", "u", int_arm_neon_vabalu>;
2496 // Vector Maximum and Minimum.
2498 // VMAX : Vector Maximum
2499 defm VMAXs : N3VInt_QHS<0,0,0b0110,0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2500 IIC_VBINi4Q, "vmax", "s", int_arm_neon_vmaxs, 1>;
2501 defm VMAXu : N3VInt_QHS<1,0,0b0110,0, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2502 IIC_VBINi4Q, "vmax", "u", int_arm_neon_vmaxu, 1>;
2503 def VMAXfd : N3VDInt<0, 0, 0b00, 0b1111, 0, IIC_VBIND, "vmax", "f32",
2504 v2f32, v2f32, int_arm_neon_vmaxs, 1>;
2505 def VMAXfq : N3VQInt<0, 0, 0b00, 0b1111, 0, IIC_VBINQ, "vmax", "f32",
2506 v4f32, v4f32, int_arm_neon_vmaxs, 1>;
2508 // VMIN : Vector Minimum
2509 defm VMINs : N3VInt_QHS<0,0,0b0110,1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2510 IIC_VBINi4Q, "vmin", "s", int_arm_neon_vmins, 1>;
2511 defm VMINu : N3VInt_QHS<1,0,0b0110,1, IIC_VBINi4D, IIC_VBINi4D, IIC_VBINi4Q,
2512 IIC_VBINi4Q, "vmin", "u", int_arm_neon_vminu, 1>;
2513 def VMINfd : N3VDInt<0, 0, 0b10, 0b1111, 0, IIC_VBIND, "vmin", "f32",
2514 v2f32, v2f32, int_arm_neon_vmins, 1>;
2515 def VMINfq : N3VQInt<0, 0, 0b10, 0b1111, 0, IIC_VBINQ, "vmin", "f32",
2516 v4f32, v4f32, int_arm_neon_vmins, 1>;
2518 // Vector Pairwise Operations.
2520 // VPADD : Vector Pairwise Add
2521 def VPADDi8 : N3VDInt<0, 0, 0b00, 0b1011, 1, IIC_VBINiD, "vpadd", "i8",
2522 v8i8, v8i8, int_arm_neon_vpadd, 0>;
2523 def VPADDi16 : N3VDInt<0, 0, 0b01, 0b1011, 1, IIC_VBINiD, "vpadd", "i16",
2524 v4i16, v4i16, int_arm_neon_vpadd, 0>;
2525 def VPADDi32 : N3VDInt<0, 0, 0b10, 0b1011, 1, IIC_VBINiD, "vpadd", "i32",
2526 v2i32, v2i32, int_arm_neon_vpadd, 0>;
2527 def VPADDf : N3VDInt<1, 0, 0b00, 0b1101, 0, IIC_VBIND, "vpadd", "f32",
2528 v2f32, v2f32, int_arm_neon_vpadd, 0>;
2530 // VPADDL : Vector Pairwise Add Long
2531 defm VPADDLs : N2VPLInt_QHS<0b11, 0b11, 0b00, 0b00100, 0, "vpaddl", "s",
2532 int_arm_neon_vpaddls>;
2533 defm VPADDLu : N2VPLInt_QHS<0b11, 0b11, 0b00, 0b00101, 0, "vpaddl", "u",
2534 int_arm_neon_vpaddlu>;
2536 // VPADAL : Vector Pairwise Add and Accumulate Long
2537 defm VPADALs : N2VPLInt2_QHS<0b11, 0b11, 0b00, 0b01100, 0, "vpadal", "s",
2538 int_arm_neon_vpadals>;
2539 defm VPADALu : N2VPLInt2_QHS<0b11, 0b11, 0b00, 0b01101, 0, "vpadal", "u",
2540 int_arm_neon_vpadalu>;
2542 // VPMAX : Vector Pairwise Maximum
2543 def VPMAXs8 : N3VDInt<0, 0, 0b00, 0b1010, 0, IIC_VBINi4D, "vpmax", "s8",
2544 v8i8, v8i8, int_arm_neon_vpmaxs, 0>;
2545 def VPMAXs16 : N3VDInt<0, 0, 0b01, 0b1010, 0, IIC_VBINi4D, "vpmax", "s16",
2546 v4i16, v4i16, int_arm_neon_vpmaxs, 0>;
2547 def VPMAXs32 : N3VDInt<0, 0, 0b10, 0b1010, 0, IIC_VBINi4D, "vpmax", "s32",
2548 v2i32, v2i32, int_arm_neon_vpmaxs, 0>;
2549 def VPMAXu8 : N3VDInt<1, 0, 0b00, 0b1010, 0, IIC_VBINi4D, "vpmax", "u8",
2550 v8i8, v8i8, int_arm_neon_vpmaxu, 0>;
2551 def VPMAXu16 : N3VDInt<1, 0, 0b01, 0b1010, 0, IIC_VBINi4D, "vpmax", "u16",
2552 v4i16, v4i16, int_arm_neon_vpmaxu, 0>;
2553 def VPMAXu32 : N3VDInt<1, 0, 0b10, 0b1010, 0, IIC_VBINi4D, "vpmax", "u32",
2554 v2i32, v2i32, int_arm_neon_vpmaxu, 0>;
2555 def VPMAXf : N3VDInt<1, 0, 0b00, 0b1111, 0, IIC_VBINi4D, "vpmax", "f32",
2556 v2f32, v2f32, int_arm_neon_vpmaxs, 0>;
2558 // VPMIN : Vector Pairwise Minimum
2559 def VPMINs8 : N3VDInt<0, 0, 0b00, 0b1010, 1, IIC_VBINi4D, "vpmin", "s8",
2560 v8i8, v8i8, int_arm_neon_vpmins, 0>;
2561 def VPMINs16 : N3VDInt<0, 0, 0b01, 0b1010, 1, IIC_VBINi4D, "vpmin", "s16",
2562 v4i16, v4i16, int_arm_neon_vpmins, 0>;
2563 def VPMINs32 : N3VDInt<0, 0, 0b10, 0b1010, 1, IIC_VBINi4D, "vpmin", "s32",
2564 v2i32, v2i32, int_arm_neon_vpmins, 0>;
2565 def VPMINu8 : N3VDInt<1, 0, 0b00, 0b1010, 1, IIC_VBINi4D, "vpmin", "u8",
2566 v8i8, v8i8, int_arm_neon_vpminu, 0>;
2567 def VPMINu16 : N3VDInt<1, 0, 0b01, 0b1010, 1, IIC_VBINi4D, "vpmin", "u16",
2568 v4i16, v4i16, int_arm_neon_vpminu, 0>;
2569 def VPMINu32 : N3VDInt<1, 0, 0b10, 0b1010, 1, IIC_VBINi4D, "vpmin", "u32",
2570 v2i32, v2i32, int_arm_neon_vpminu, 0>;
2571 def VPMINf : N3VDInt<1, 0, 0b10, 0b1111, 0, IIC_VBINi4D, "vpmin", "f32",
2572 v2f32, v2f32, int_arm_neon_vpmins, 0>;
2574 // Vector Reciprocal and Reciprocal Square Root Estimate and Step.
2576 // VRECPE : Vector Reciprocal Estimate
2577 def VRECPEd : N2VDInt<0b11, 0b11, 0b10, 0b11, 0b01000, 0,
2578 IIC_VUNAD, "vrecpe", "u32",
2579 v2i32, v2i32, int_arm_neon_vrecpe>;
2580 def VRECPEq : N2VQInt<0b11, 0b11, 0b10, 0b11, 0b01000, 0,
2581 IIC_VUNAQ, "vrecpe", "u32",
2582 v4i32, v4i32, int_arm_neon_vrecpe>;
2583 def VRECPEfd : N2VDInt<0b11, 0b11, 0b10, 0b11, 0b01010, 0,
2584 IIC_VUNAD, "vrecpe", "f32",
2585 v2f32, v2f32, int_arm_neon_vrecpe>;
2586 def VRECPEfq : N2VQInt<0b11, 0b11, 0b10, 0b11, 0b01010, 0,
2587 IIC_VUNAQ, "vrecpe", "f32",
2588 v4f32, v4f32, int_arm_neon_vrecpe>;
2590 // VRECPS : Vector Reciprocal Step
2591 def VRECPSfd : N3VDInt<0, 0, 0b00, 0b1111, 1,
2592 IIC_VRECSD, "vrecps", "f32",
2593 v2f32, v2f32, int_arm_neon_vrecps, 1>;
2594 def VRECPSfq : N3VQInt<0, 0, 0b00, 0b1111, 1,
2595 IIC_VRECSQ, "vrecps", "f32",
2596 v4f32, v4f32, int_arm_neon_vrecps, 1>;
2598 // VRSQRTE : Vector Reciprocal Square Root Estimate
2599 def VRSQRTEd : N2VDInt<0b11, 0b11, 0b10, 0b11, 0b01001, 0,
2600 IIC_VUNAD, "vrsqrte", "u32",
2601 v2i32, v2i32, int_arm_neon_vrsqrte>;
2602 def VRSQRTEq : N2VQInt<0b11, 0b11, 0b10, 0b11, 0b01001, 0,
2603 IIC_VUNAQ, "vrsqrte", "u32",
2604 v4i32, v4i32, int_arm_neon_vrsqrte>;
2605 def VRSQRTEfd : N2VDInt<0b11, 0b11, 0b10, 0b11, 0b01011, 0,
2606 IIC_VUNAD, "vrsqrte", "f32",
2607 v2f32, v2f32, int_arm_neon_vrsqrte>;
2608 def VRSQRTEfq : N2VQInt<0b11, 0b11, 0b10, 0b11, 0b01011, 0,
2609 IIC_VUNAQ, "vrsqrte", "f32",
2610 v4f32, v4f32, int_arm_neon_vrsqrte>;
2612 // VRSQRTS : Vector Reciprocal Square Root Step
2613 def VRSQRTSfd : N3VDInt<0, 0, 0b10, 0b1111, 1,
2614 IIC_VRECSD, "vrsqrts", "f32",
2615 v2f32, v2f32, int_arm_neon_vrsqrts, 1>;
2616 def VRSQRTSfq : N3VQInt<0, 0, 0b10, 0b1111, 1,
2617 IIC_VRECSQ, "vrsqrts", "f32",
2618 v4f32, v4f32, int_arm_neon_vrsqrts, 1>;
2622 // VSHL : Vector Shift
2623 defm VSHLs : N3VInt_QHSD2<0,0, 0b0100, 0, IIC_VSHLiD, IIC_VSHLiD, IIC_VSHLiQ,
2624 IIC_VSHLiQ, "vshl", "s", int_arm_neon_vshifts, 0>;
2625 defm VSHLu : N3VInt_QHSD2<1,0, 0b0100, 0, IIC_VSHLiD, IIC_VSHLiD, IIC_VSHLiQ,
2626 IIC_VSHLiQ, "vshl", "u", int_arm_neon_vshiftu, 0>;
2627 // VSHL : Vector Shift Left (Immediate)
2628 // (disassembly note: this has a different interpretation of the shift amont)
2629 defm VSHLi : N2VSh_QHSD2<0, 1, 0b0101, 1, IIC_VSHLiD, "vshl", "i", NEONvshl>;
2630 // VSHR : Vector Shift Right (Immediate)
2631 defm VSHRs : N2VSh_QHSD<0, 1, 0b0000, 1, IIC_VSHLiD, "vshr", "s", NEONvshrs>;
2632 defm VSHRu : N2VSh_QHSD<1, 1, 0b0000, 1, IIC_VSHLiD, "vshr", "u", NEONvshru>;
2634 // VSHLL : Vector Shift Left Long
2635 // (disassembly note: this has a different interpretation of the shift amont)
2636 defm VSHLLs : N2VLSh_QHS<0, 1, 0b1010, 0, 0, 1, "vshll", "s", NEONvshlls>;
2637 // (disassembly note: this has a different interpretation of the shift amont)
2638 defm VSHLLu : N2VLSh_QHS<1, 1, 0b1010, 0, 0, 1, "vshll", "u", NEONvshllu>;
2640 // VSHLL : Vector Shift Left Long (with maximum shift count)
2641 class N2VLShMax<bit op24, bit op23, bits<6> op21_16, bits<4> op11_8, bit op7,
2642 bit op6, bit op4, string OpcodeStr, string Dt, ValueType ResTy,
2643 ValueType OpTy, SDNode OpNode>
2644 : N2VLSh<op24, op23, op11_8, op7, op6, op4, OpcodeStr, Dt,
2645 ResTy, OpTy, OpNode> {
2646 let Inst{21-16} = op21_16;
2647 let NSF = NVdVmImmVSHLLFrm; // For disassembly.
2648 let NSForm = NVdVmImmVSHLLFrm.Value; // For disassembly.
2650 def VSHLLi8 : N2VLShMax<1, 1, 0b110010, 0b0011, 0, 0, 0, "vshll", "i8",
2651 v8i16, v8i8, NEONvshlli>;
2652 def VSHLLi16 : N2VLShMax<1, 1, 0b110110, 0b0011, 0, 0, 0, "vshll", "i16",
2653 v4i32, v4i16, NEONvshlli>;
2654 def VSHLLi32 : N2VLShMax<1, 1, 0b111010, 0b0011, 0, 0, 0, "vshll", "i32",
2655 v2i64, v2i32, NEONvshlli>;
2657 // VSHRN : Vector Shift Right and Narrow
2658 defm VSHRN : N2VNSh_HSD<0,1,0b1000,0,0,1, IIC_VSHLiD, "vshrn", "i",
2661 // VRSHL : Vector Rounding Shift
2662 defm VRSHLs : N3VInt_QHSD2<0,0,0b0101,0,IIC_VSHLi4D, IIC_VSHLi4D, IIC_VSHLi4Q,
2663 IIC_VSHLi4Q,"vrshl", "s", int_arm_neon_vrshifts,0>;
2664 defm VRSHLu : N3VInt_QHSD2<1,0,0b0101,0,IIC_VSHLi4D, IIC_VSHLi4D, IIC_VSHLi4Q,
2665 IIC_VSHLi4Q,"vrshl", "u", int_arm_neon_vrshiftu,0>;
2666 // VRSHR : Vector Rounding Shift Right
2667 defm VRSHRs : N2VSh_QHSD<0,1,0b0010,1, IIC_VSHLi4D, "vrshr", "s", NEONvrshrs>;
2668 defm VRSHRu : N2VSh_QHSD<1,1,0b0010,1, IIC_VSHLi4D, "vrshr", "u", NEONvrshru>;
2670 // VRSHRN : Vector Rounding Shift Right and Narrow
2671 defm VRSHRN : N2VNSh_HSD<0, 1, 0b1000, 0, 1, 1, IIC_VSHLi4D, "vrshrn", "i",
2674 // VQSHL : Vector Saturating Shift
2675 defm VQSHLs : N3VInt_QHSD2<0,0,0b0100,1,IIC_VSHLi4D, IIC_VSHLi4D, IIC_VSHLi4Q,
2676 IIC_VSHLi4Q, "vqshl", "s", int_arm_neon_vqshifts,0>;
2677 defm VQSHLu : N3VInt_QHSD2<1,0,0b0100,1,IIC_VSHLi4D, IIC_VSHLi4D, IIC_VSHLi4Q,
2678 IIC_VSHLi4Q, "vqshl", "u", int_arm_neon_vqshiftu,0>;
2679 // VQSHL : Vector Saturating Shift Left (Immediate)
2680 // (disassembly note: this has a different interpretation of the shift amont)
2681 defm VQSHLsi : N2VSh_QHSD2<0,1,0b0111,1, IIC_VSHLi4D, "vqshl", "s", NEONvqshls>;
2682 // (disassembly note: this has a different interpretation of the shift amont)
2683 defm VQSHLui : N2VSh_QHSD2<1,1,0b0111,1, IIC_VSHLi4D, "vqshl", "u", NEONvqshlu>;
2684 // VQSHLU : Vector Saturating Shift Left (Immediate, Unsigned)
2685 // (disassembly note: this has a different interpretation of the shift amont)
2686 defm VQSHLsu : N2VSh_QHSD2<1,1,0b0110,1, IIC_VSHLi4D, "vqshlu","s",NEONvqshlsu>;
2688 // VQSHRN : Vector Saturating Shift Right and Narrow
2689 defm VQSHRNs : N2VNSh_HSD<0, 1, 0b1001, 0, 0, 1, IIC_VSHLi4D, "vqshrn", "s",
2691 defm VQSHRNu : N2VNSh_HSD<1, 1, 0b1001, 0, 0, 1, IIC_VSHLi4D, "vqshrn", "u",
2694 // VQSHRUN : Vector Saturating Shift Right and Narrow (Unsigned)
2695 defm VQSHRUN : N2VNSh_HSD<1, 1, 0b1000, 0, 0, 1, IIC_VSHLi4D, "vqshrun", "s",
2698 // VQRSHL : Vector Saturating Rounding Shift
2699 defm VQRSHLs : N3VInt_QHSD2<0,0,0b0101,1, IIC_VSHLi4D, IIC_VSHLi4D, IIC_VSHLi4Q,
2700 IIC_VSHLi4Q, "vqrshl", "s",
2701 int_arm_neon_vqrshifts, 0>;
2702 defm VQRSHLu : N3VInt_QHSD2<1,0,0b0101,1, IIC_VSHLi4D, IIC_VSHLi4D, IIC_VSHLi4Q,
2703 IIC_VSHLi4Q, "vqrshl", "u",
2704 int_arm_neon_vqrshiftu, 0>;
2706 // VQRSHRN : Vector Saturating Rounding Shift Right and Narrow
2707 defm VQRSHRNs : N2VNSh_HSD<0, 1, 0b1001, 0, 1, 1, IIC_VSHLi4D, "vqrshrn", "s",
2709 defm VQRSHRNu : N2VNSh_HSD<1, 1, 0b1001, 0, 1, 1, IIC_VSHLi4D, "vqrshrn", "u",
2712 // VQRSHRUN : Vector Saturating Rounding Shift Right and Narrow (Unsigned)
2713 defm VQRSHRUN : N2VNSh_HSD<1, 1, 0b1000, 0, 1, 1, IIC_VSHLi4D, "vqrshrun", "s",
2716 // VSRA : Vector Shift Right and Accumulate
2717 defm VSRAs : N2VShAdd_QHSD<0, 1, 0b0001, 1, "vsra", "s", NEONvshrs>;
2718 defm VSRAu : N2VShAdd_QHSD<1, 1, 0b0001, 1, "vsra", "u", NEONvshru>;
2719 // VRSRA : Vector Rounding Shift Right and Accumulate
2720 defm VRSRAs : N2VShAdd_QHSD<0, 1, 0b0011, 1, "vrsra", "s", NEONvrshrs>;
2721 defm VRSRAu : N2VShAdd_QHSD<1, 1, 0b0011, 1, "vrsra", "u", NEONvrshru>;
2723 // VSLI : Vector Shift Left and Insert
2724 // (disassembly note: this has a different interpretation of the shift amont)
2725 defm VSLI : N2VShIns_QHSD2<1, 1, 0b0101, 1, "vsli", NEONvsli>;
2726 // VSRI : Vector Shift Right and Insert
2727 defm VSRI : N2VShIns_QHSD<1, 1, 0b0100, 1, "vsri", NEONvsri>;
2729 // Vector Absolute and Saturating Absolute.
2731 // VABS : Vector Absolute Value
2732 defm VABS : N2VInt_QHS<0b11, 0b11, 0b01, 0b00110, 0,
2733 IIC_VUNAiD, IIC_VUNAiQ, "vabs", "s",
2735 def VABSfd : N2VDInt<0b11, 0b11, 0b10, 0b01, 0b01110, 0,
2736 IIC_VUNAD, "vabs", "f32",
2737 v2f32, v2f32, int_arm_neon_vabs>;
2738 def VABSfq : N2VQInt<0b11, 0b11, 0b10, 0b01, 0b01110, 0,
2739 IIC_VUNAQ, "vabs", "f32",
2740 v4f32, v4f32, int_arm_neon_vabs>;
2742 // VQABS : Vector Saturating Absolute Value
2743 defm VQABS : N2VInt_QHS<0b11, 0b11, 0b00, 0b01110, 0,
2744 IIC_VQUNAiD, IIC_VQUNAiQ, "vqabs", "s",
2745 int_arm_neon_vqabs>;
2749 def vneg : PatFrag<(ops node:$in), (sub immAllZerosV, node:$in)>;
2750 def vneg_conv : PatFrag<(ops node:$in), (sub immAllZerosV_bc, node:$in)>;
2752 class VNEGD<bits<2> size, string OpcodeStr, string Dt, ValueType Ty>
2753 : N2V<0b11, 0b11, size, 0b01, 0b00111, 0, 0, (outs DPR:$dst), (ins DPR:$src),
2754 IIC_VSHLiD, OpcodeStr, Dt, "$dst, $src", "",
2755 [(set DPR:$dst, (Ty (vneg DPR:$src)))]>;
2756 class VNEGQ<bits<2> size, string OpcodeStr, string Dt, ValueType Ty>
2757 : N2V<0b11, 0b11, size, 0b01, 0b00111, 1, 0, (outs QPR:$dst), (ins QPR:$src),
2758 IIC_VSHLiD, OpcodeStr, Dt, "$dst, $src", "",
2759 [(set QPR:$dst, (Ty (vneg QPR:$src)))]>;
2761 // VNEG : Vector Negate
2762 def VNEGs8d : VNEGD<0b00, "vneg", "s8", v8i8>;
2763 def VNEGs16d : VNEGD<0b01, "vneg", "s16", v4i16>;
2764 def VNEGs32d : VNEGD<0b10, "vneg", "s32", v2i32>;
2765 def VNEGs8q : VNEGQ<0b00, "vneg", "s8", v16i8>;
2766 def VNEGs16q : VNEGQ<0b01, "vneg", "s16", v8i16>;
2767 def VNEGs32q : VNEGQ<0b10, "vneg", "s32", v4i32>;
2769 // VNEG : Vector Negate (floating-point)
2770 def VNEGfd : N2V<0b11, 0b11, 0b10, 0b01, 0b01111, 0, 0,
2771 (outs DPR:$dst), (ins DPR:$src), IIC_VUNAD,
2772 "vneg", "f32", "$dst, $src", "",
2773 [(set DPR:$dst, (v2f32 (fneg DPR:$src)))]>;
2774 def VNEGf32q : N2V<0b11, 0b11, 0b10, 0b01, 0b01111, 1, 0,
2775 (outs QPR:$dst), (ins QPR:$src), IIC_VUNAQ,
2776 "vneg", "f32", "$dst, $src", "",
2777 [(set QPR:$dst, (v4f32 (fneg QPR:$src)))]>;
2779 def : Pat<(v8i8 (vneg_conv DPR:$src)), (VNEGs8d DPR:$src)>;
2780 def : Pat<(v4i16 (vneg_conv DPR:$src)), (VNEGs16d DPR:$src)>;
2781 def : Pat<(v2i32 (vneg_conv DPR:$src)), (VNEGs32d DPR:$src)>;
2782 def : Pat<(v16i8 (vneg_conv QPR:$src)), (VNEGs8q QPR:$src)>;
2783 def : Pat<(v8i16 (vneg_conv QPR:$src)), (VNEGs16q QPR:$src)>;
2784 def : Pat<(v4i32 (vneg_conv QPR:$src)), (VNEGs32q QPR:$src)>;
2786 // VQNEG : Vector Saturating Negate
2787 defm VQNEG : N2VInt_QHS<0b11, 0b11, 0b00, 0b01111, 0,
2788 IIC_VQUNAiD, IIC_VQUNAiQ, "vqneg", "s",
2789 int_arm_neon_vqneg>;
2791 // Vector Bit Counting Operations.
2793 // VCLS : Vector Count Leading Sign Bits
2794 defm VCLS : N2VInt_QHS<0b11, 0b11, 0b00, 0b01000, 0,
2795 IIC_VCNTiD, IIC_VCNTiQ, "vcls", "s",
2797 // VCLZ : Vector Count Leading Zeros
2798 defm VCLZ : N2VInt_QHS<0b11, 0b11, 0b00, 0b01001, 0,
2799 IIC_VCNTiD, IIC_VCNTiQ, "vclz", "i",
2801 // VCNT : Vector Count One Bits
2802 def VCNTd : N2VDInt<0b11, 0b11, 0b00, 0b00, 0b01010, 0,
2803 IIC_VCNTiD, "vcnt", "8",
2804 v8i8, v8i8, int_arm_neon_vcnt>;
2805 def VCNTq : N2VQInt<0b11, 0b11, 0b00, 0b00, 0b01010, 0,
2806 IIC_VCNTiQ, "vcnt", "8",
2807 v16i8, v16i8, int_arm_neon_vcnt>;
2809 // Vector Swap -- for disassembly only.
2810 def VSWPd : N2VX<0b11, 0b11, 0b00, 0b10, 0b00000, 0, 0,
2811 (outs DPR:$dst), (ins DPR:$src), NoItinerary,
2812 "vswp", "$dst, $src", "", []>;
2813 def VSWPq : N2VX<0b11, 0b11, 0b00, 0b10, 0b00000, 1, 0,
2814 (outs QPR:$dst), (ins QPR:$src), NoItinerary,
2815 "vswp", "$dst, $src", "", []>;
2817 // Vector Move Operations.
2819 // VMOV : Vector Move (Register)
2821 // Mark these instructions as 2-register instructions to help the disassembler.
2822 let NSF = NVdVmImmFrm, NSForm = NVdVmImmFrm.Value in {
2823 def VMOVDneon: N3VX<0, 0, 0b10, 0b0001, 0, 1, (outs DPR:$dst), (ins DPR:$src),
2824 IIC_VMOVD, "vmov", "$dst, $src", "", []>;
2825 def VMOVQ : N3VX<0, 0, 0b10, 0b0001, 1, 1, (outs QPR:$dst), (ins QPR:$src),
2826 IIC_VMOVD, "vmov", "$dst, $src", "", []>;
2829 // VMOV : Vector Move (Immediate)
2831 // VMOV_get_imm8 xform function: convert build_vector to VMOV.i8 imm.
2832 def VMOV_get_imm8 : SDNodeXForm<build_vector, [{
2833 return ARM::getVMOVImm(N, 1, *CurDAG);
2835 def vmovImm8 : PatLeaf<(build_vector), [{
2836 return ARM::getVMOVImm(N, 1, *CurDAG).getNode() != 0;
2839 // VMOV_get_imm16 xform function: convert build_vector to VMOV.i16 imm.
2840 def VMOV_get_imm16 : SDNodeXForm<build_vector, [{
2841 return ARM::getVMOVImm(N, 2, *CurDAG);
2843 def vmovImm16 : PatLeaf<(build_vector), [{
2844 return ARM::getVMOVImm(N, 2, *CurDAG).getNode() != 0;
2845 }], VMOV_get_imm16>;
2847 // VMOV_get_imm32 xform function: convert build_vector to VMOV.i32 imm.
2848 def VMOV_get_imm32 : SDNodeXForm<build_vector, [{
2849 return ARM::getVMOVImm(N, 4, *CurDAG);
2851 def vmovImm32 : PatLeaf<(build_vector), [{
2852 return ARM::getVMOVImm(N, 4, *CurDAG).getNode() != 0;
2853 }], VMOV_get_imm32>;
2855 // VMOV_get_imm64 xform function: convert build_vector to VMOV.i64 imm.
2856 def VMOV_get_imm64 : SDNodeXForm<build_vector, [{
2857 return ARM::getVMOVImm(N, 8, *CurDAG);
2859 def vmovImm64 : PatLeaf<(build_vector), [{
2860 return ARM::getVMOVImm(N, 8, *CurDAG).getNode() != 0;
2861 }], VMOV_get_imm64>;
2863 // Note: Some of the cmode bits in the following VMOV instructions need to
2864 // be encoded based on the immed values.
2866 def VMOVv8i8 : N1ModImm<1, 0b000, 0b1110, 0, 0, 0, 1, (outs DPR:$dst),
2867 (ins h8imm:$SIMM), IIC_VMOVImm,
2868 "vmov", "i8", "$dst, $SIMM", "",
2869 [(set DPR:$dst, (v8i8 vmovImm8:$SIMM))]>;
2870 def VMOVv16i8 : N1ModImm<1, 0b000, 0b1110, 0, 1, 0, 1, (outs QPR:$dst),
2871 (ins h8imm:$SIMM), IIC_VMOVImm,
2872 "vmov", "i8", "$dst, $SIMM", "",
2873 [(set QPR:$dst, (v16i8 vmovImm8:$SIMM))]>;
2875 def VMOVv4i16 : N1ModImm<1, 0b000, {1,0,?,?}, 0, 0, {?}, 1, (outs DPR:$dst),
2876 (ins h16imm:$SIMM), IIC_VMOVImm,
2877 "vmov", "i16", "$dst, $SIMM", "",
2878 [(set DPR:$dst, (v4i16 vmovImm16:$SIMM))]>;
2879 def VMOVv8i16 : N1ModImm<1, 0b000, {1,0,?,?}, 0, 1, {?}, 1, (outs QPR:$dst),
2880 (ins h16imm:$SIMM), IIC_VMOVImm,
2881 "vmov", "i16", "$dst, $SIMM", "",
2882 [(set QPR:$dst, (v8i16 vmovImm16:$SIMM))]>;
2884 def VMOVv2i32 : N1ModImm<1, 0b000, {?,?,?,?}, 0, 0, {?}, 1, (outs DPR:$dst),
2885 (ins h32imm:$SIMM), IIC_VMOVImm,
2886 "vmov", "i32", "$dst, $SIMM", "",
2887 [(set DPR:$dst, (v2i32 vmovImm32:$SIMM))]>;
2888 def VMOVv4i32 : N1ModImm<1, 0b000, {?,?,?,?}, 0, 1, {?}, 1, (outs QPR:$dst),
2889 (ins h32imm:$SIMM), IIC_VMOVImm,
2890 "vmov", "i32", "$dst, $SIMM", "",
2891 [(set QPR:$dst, (v4i32 vmovImm32:$SIMM))]>;
2893 def VMOVv1i64 : N1ModImm<1, 0b000, 0b1110, 0, 0, 1, 1, (outs DPR:$dst),
2894 (ins h64imm:$SIMM), IIC_VMOVImm,
2895 "vmov", "i64", "$dst, $SIMM", "",
2896 [(set DPR:$dst, (v1i64 vmovImm64:$SIMM))]>;
2897 def VMOVv2i64 : N1ModImm<1, 0b000, 0b1110, 0, 1, 1, 1, (outs QPR:$dst),
2898 (ins h64imm:$SIMM), IIC_VMOVImm,
2899 "vmov", "i64", "$dst, $SIMM", "",
2900 [(set QPR:$dst, (v2i64 vmovImm64:$SIMM))]>;
2902 // VMOV : Vector Get Lane (move scalar to ARM core register)
2904 def VGETLNs8 : NVGetLane<{1,1,1,0,0,1,?,1}, 0b1011, {?,?},
2905 (outs GPR:$dst), (ins DPR:$src, nohash_imm:$lane),
2906 IIC_VMOVSI, "vmov", "s8", "$dst, $src[$lane]",
2907 [(set GPR:$dst, (NEONvgetlanes (v8i8 DPR:$src),
2909 def VGETLNs16 : NVGetLane<{1,1,1,0,0,0,?,1}, 0b1011, {?,1},
2910 (outs GPR:$dst), (ins DPR:$src, nohash_imm:$lane),
2911 IIC_VMOVSI, "vmov", "s16", "$dst, $src[$lane]",
2912 [(set GPR:$dst, (NEONvgetlanes (v4i16 DPR:$src),
2914 def VGETLNu8 : NVGetLane<{1,1,1,0,1,1,?,1}, 0b1011, {?,?},
2915 (outs GPR:$dst), (ins DPR:$src, nohash_imm:$lane),
2916 IIC_VMOVSI, "vmov", "u8", "$dst, $src[$lane]",
2917 [(set GPR:$dst, (NEONvgetlaneu (v8i8 DPR:$src),
2919 def VGETLNu16 : NVGetLane<{1,1,1,0,1,0,?,1}, 0b1011, {?,1},
2920 (outs GPR:$dst), (ins DPR:$src, nohash_imm:$lane),
2921 IIC_VMOVSI, "vmov", "u16", "$dst, $src[$lane]",
2922 [(set GPR:$dst, (NEONvgetlaneu (v4i16 DPR:$src),
2924 def VGETLNi32 : NVGetLane<{1,1,1,0,0,0,?,1}, 0b1011, 0b00,
2925 (outs GPR:$dst), (ins DPR:$src, nohash_imm:$lane),
2926 IIC_VMOVSI, "vmov", "32", "$dst, $src[$lane]",
2927 [(set GPR:$dst, (extractelt (v2i32 DPR:$src),
2929 // def VGETLNf32: see FMRDH and FMRDL in ARMInstrVFP.td
2930 def : Pat<(NEONvgetlanes (v16i8 QPR:$src), imm:$lane),
2931 (VGETLNs8 (v8i8 (EXTRACT_SUBREG QPR:$src,
2932 (DSubReg_i8_reg imm:$lane))),
2933 (SubReg_i8_lane imm:$lane))>;
2934 def : Pat<(NEONvgetlanes (v8i16 QPR:$src), imm:$lane),
2935 (VGETLNs16 (v4i16 (EXTRACT_SUBREG QPR:$src,
2936 (DSubReg_i16_reg imm:$lane))),
2937 (SubReg_i16_lane imm:$lane))>;
2938 def : Pat<(NEONvgetlaneu (v16i8 QPR:$src), imm:$lane),
2939 (VGETLNu8 (v8i8 (EXTRACT_SUBREG QPR:$src,
2940 (DSubReg_i8_reg imm:$lane))),
2941 (SubReg_i8_lane imm:$lane))>;
2942 def : Pat<(NEONvgetlaneu (v8i16 QPR:$src), imm:$lane),
2943 (VGETLNu16 (v4i16 (EXTRACT_SUBREG QPR:$src,
2944 (DSubReg_i16_reg imm:$lane))),
2945 (SubReg_i16_lane imm:$lane))>;
2946 def : Pat<(extractelt (v4i32 QPR:$src), imm:$lane),
2947 (VGETLNi32 (v2i32 (EXTRACT_SUBREG QPR:$src,
2948 (DSubReg_i32_reg imm:$lane))),
2949 (SubReg_i32_lane imm:$lane))>;
2950 def : Pat<(extractelt (v2f32 DPR:$src1), imm:$src2),
2951 (EXTRACT_SUBREG (v2f32 (COPY_TO_REGCLASS (v2f32 DPR:$src1),DPR_VFP2)),
2952 (SSubReg_f32_reg imm:$src2))>;
2953 def : Pat<(extractelt (v4f32 QPR:$src1), imm:$src2),
2954 (EXTRACT_SUBREG (v4f32 (COPY_TO_REGCLASS (v4f32 QPR:$src1),QPR_VFP2)),
2955 (SSubReg_f32_reg imm:$src2))>;
2956 //def : Pat<(extractelt (v2i64 QPR:$src1), imm:$src2),
2957 // (EXTRACT_SUBREG QPR:$src1, (DSubReg_f64_reg imm:$src2))>;
2958 def : Pat<(extractelt (v2f64 QPR:$src1), imm:$src2),
2959 (EXTRACT_SUBREG QPR:$src1, (DSubReg_f64_reg imm:$src2))>;
2962 // VMOV : Vector Set Lane (move ARM core register to scalar)
2964 let Constraints = "$src1 = $dst" in {
2965 def VSETLNi8 : NVSetLane<{1,1,1,0,0,1,?,0}, 0b1011, {?,?}, (outs DPR:$dst),
2966 (ins DPR:$src1, GPR:$src2, nohash_imm:$lane),
2967 IIC_VMOVISL, "vmov", "8", "$dst[$lane], $src2",
2968 [(set DPR:$dst, (vector_insert (v8i8 DPR:$src1),
2969 GPR:$src2, imm:$lane))]>;
2970 def VSETLNi16 : NVSetLane<{1,1,1,0,0,0,?,0}, 0b1011, {?,1}, (outs DPR:$dst),
2971 (ins DPR:$src1, GPR:$src2, nohash_imm:$lane),
2972 IIC_VMOVISL, "vmov", "16", "$dst[$lane], $src2",
2973 [(set DPR:$dst, (vector_insert (v4i16 DPR:$src1),
2974 GPR:$src2, imm:$lane))]>;
2975 def VSETLNi32 : NVSetLane<{1,1,1,0,0,0,?,0}, 0b1011, 0b00, (outs DPR:$dst),
2976 (ins DPR:$src1, GPR:$src2, nohash_imm:$lane),
2977 IIC_VMOVISL, "vmov", "32", "$dst[$lane], $src2",
2978 [(set DPR:$dst, (insertelt (v2i32 DPR:$src1),
2979 GPR:$src2, imm:$lane))]>;
2981 def : Pat<(vector_insert (v16i8 QPR:$src1), GPR:$src2, imm:$lane),
2982 (v16i8 (INSERT_SUBREG QPR:$src1,
2983 (v8i8 (VSETLNi8 (v8i8 (EXTRACT_SUBREG QPR:$src1,
2984 (DSubReg_i8_reg imm:$lane))),
2985 GPR:$src2, (SubReg_i8_lane imm:$lane))),
2986 (DSubReg_i8_reg imm:$lane)))>;
2987 def : Pat<(vector_insert (v8i16 QPR:$src1), GPR:$src2, imm:$lane),
2988 (v8i16 (INSERT_SUBREG QPR:$src1,
2989 (v4i16 (VSETLNi16 (v4i16 (EXTRACT_SUBREG QPR:$src1,
2990 (DSubReg_i16_reg imm:$lane))),
2991 GPR:$src2, (SubReg_i16_lane imm:$lane))),
2992 (DSubReg_i16_reg imm:$lane)))>;
2993 def : Pat<(insertelt (v4i32 QPR:$src1), GPR:$src2, imm:$lane),
2994 (v4i32 (INSERT_SUBREG QPR:$src1,
2995 (v2i32 (VSETLNi32 (v2i32 (EXTRACT_SUBREG QPR:$src1,
2996 (DSubReg_i32_reg imm:$lane))),
2997 GPR:$src2, (SubReg_i32_lane imm:$lane))),
2998 (DSubReg_i32_reg imm:$lane)))>;
3000 def : Pat<(v2f32 (insertelt DPR:$src1, SPR:$src2, imm:$src3)),
3001 (INSERT_SUBREG (v2f32 (COPY_TO_REGCLASS DPR:$src1, DPR_VFP2)),
3002 SPR:$src2, (SSubReg_f32_reg imm:$src3))>;
3003 def : Pat<(v4f32 (insertelt QPR:$src1, SPR:$src2, imm:$src3)),
3004 (INSERT_SUBREG (v4f32 (COPY_TO_REGCLASS QPR:$src1, QPR_VFP2)),
3005 SPR:$src2, (SSubReg_f32_reg imm:$src3))>;
3007 //def : Pat<(v2i64 (insertelt QPR:$src1, DPR:$src2, imm:$src3)),
3008 // (INSERT_SUBREG QPR:$src1, DPR:$src2, (DSubReg_f64_reg imm:$src3))>;
3009 def : Pat<(v2f64 (insertelt QPR:$src1, DPR:$src2, imm:$src3)),
3010 (INSERT_SUBREG QPR:$src1, DPR:$src2, (DSubReg_f64_reg imm:$src3))>;
3012 def : Pat<(v2f32 (scalar_to_vector SPR:$src)),
3013 (INSERT_SUBREG (v2f32 (IMPLICIT_DEF)), SPR:$src, arm_ssubreg_0)>;
3014 def : Pat<(v2f64 (scalar_to_vector (f64 DPR:$src))),
3015 (INSERT_SUBREG (v2f64 (IMPLICIT_DEF)), DPR:$src, arm_dsubreg_0)>;
3016 def : Pat<(v4f32 (scalar_to_vector SPR:$src)),
3017 (INSERT_SUBREG (v4f32 (IMPLICIT_DEF)), SPR:$src, arm_ssubreg_0)>;
3019 def : Pat<(v8i8 (scalar_to_vector GPR:$src)),
3020 (VSETLNi8 (v8i8 (IMPLICIT_DEF)), GPR:$src, (i32 0))>;
3021 def : Pat<(v4i16 (scalar_to_vector GPR:$src)),
3022 (VSETLNi16 (v4i16 (IMPLICIT_DEF)), GPR:$src, (i32 0))>;
3023 def : Pat<(v2i32 (scalar_to_vector GPR:$src)),
3024 (VSETLNi32 (v2i32 (IMPLICIT_DEF)), GPR:$src, (i32 0))>;
3026 def : Pat<(v16i8 (scalar_to_vector GPR:$src)),
3027 (INSERT_SUBREG (v16i8 (IMPLICIT_DEF)),
3028 (VSETLNi8 (v8i8 (IMPLICIT_DEF)), GPR:$src, (i32 0)),
3030 def : Pat<(v8i16 (scalar_to_vector GPR:$src)),
3031 (INSERT_SUBREG (v8i16 (IMPLICIT_DEF)),
3032 (VSETLNi16 (v4i16 (IMPLICIT_DEF)), GPR:$src, (i32 0)),
3034 def : Pat<(v4i32 (scalar_to_vector GPR:$src)),
3035 (INSERT_SUBREG (v4i32 (IMPLICIT_DEF)),
3036 (VSETLNi32 (v2i32 (IMPLICIT_DEF)), GPR:$src, (i32 0)),
3039 // VDUP : Vector Duplicate (from ARM core register to all elements)
3041 class VDUPD<bits<8> opcod1, bits<2> opcod3, string Dt, ValueType Ty>
3042 : NVDup<opcod1, 0b1011, opcod3, (outs DPR:$dst), (ins GPR:$src),
3043 IIC_VMOVIS, "vdup", Dt, "$dst, $src",
3044 [(set DPR:$dst, (Ty (NEONvdup (i32 GPR:$src))))]>;
3045 class VDUPQ<bits<8> opcod1, bits<2> opcod3, string Dt, ValueType Ty>
3046 : NVDup<opcod1, 0b1011, opcod3, (outs QPR:$dst), (ins GPR:$src),
3047 IIC_VMOVIS, "vdup", Dt, "$dst, $src",
3048 [(set QPR:$dst, (Ty (NEONvdup (i32 GPR:$src))))]>;
3050 def VDUP8d : VDUPD<0b11101100, 0b00, "8", v8i8>;
3051 def VDUP16d : VDUPD<0b11101000, 0b01, "16", v4i16>;
3052 def VDUP32d : VDUPD<0b11101000, 0b00, "32", v2i32>;
3053 def VDUP8q : VDUPQ<0b11101110, 0b00, "8", v16i8>;
3054 def VDUP16q : VDUPQ<0b11101010, 0b01, "16", v8i16>;
3055 def VDUP32q : VDUPQ<0b11101010, 0b00, "32", v4i32>;
3057 def VDUPfd : NVDup<0b11101000, 0b1011, 0b00, (outs DPR:$dst), (ins GPR:$src),
3058 IIC_VMOVIS, "vdup", "32", "$dst, $src",
3059 [(set DPR:$dst, (v2f32 (NEONvdup
3060 (f32 (bitconvert GPR:$src)))))]>;
3061 def VDUPfq : NVDup<0b11101010, 0b1011, 0b00, (outs QPR:$dst), (ins GPR:$src),
3062 IIC_VMOVIS, "vdup", "32", "$dst, $src",
3063 [(set QPR:$dst, (v4f32 (NEONvdup
3064 (f32 (bitconvert GPR:$src)))))]>;
3066 // VDUP : Vector Duplicate Lane (from scalar to all elements)
3068 let NSF = NVdVmImmVDupLaneFrm, NSForm = NVdVmImmVDupLaneFrm.Value in {
3069 class VDUPLND<bits<2> op19_18, bits<2> op17_16,
3070 string OpcodeStr, string Dt, ValueType Ty>
3071 : N2V<0b11, 0b11, op19_18, op17_16, 0b11000, 0, 0,
3072 (outs DPR:$dst), (ins DPR:$src, nohash_imm:$lane), IIC_VMOVD,
3073 OpcodeStr, Dt, "$dst, $src[$lane]", "",
3074 [(set DPR:$dst, (Ty (NEONvduplane (Ty DPR:$src), imm:$lane)))]>;
3076 class VDUPLNQ<bits<2> op19_18, bits<2> op17_16, string OpcodeStr, string Dt,
3077 ValueType ResTy, ValueType OpTy>
3078 : N2V<0b11, 0b11, op19_18, op17_16, 0b11000, 1, 0,
3079 (outs QPR:$dst), (ins DPR:$src, nohash_imm:$lane), IIC_VMOVD,
3080 OpcodeStr, Dt, "$dst, $src[$lane]", "",
3081 [(set QPR:$dst, (ResTy (NEONvduplane (OpTy DPR:$src), imm:$lane)))]>;
3084 // Inst{19-16} is partially specified depending on the element size.
3086 def VDUPLN8d : VDUPLND<{?,?}, {?,1}, "vdup", "8", v8i8>;
3087 def VDUPLN16d : VDUPLND<{?,?}, {1,0}, "vdup", "16", v4i16>;
3088 def VDUPLN32d : VDUPLND<{?,1}, {0,0}, "vdup", "32", v2i32>;
3089 def VDUPLNfd : VDUPLND<{?,1}, {0,0}, "vdup", "32", v2f32>;
3090 def VDUPLN8q : VDUPLNQ<{?,?}, {?,1}, "vdup", "8", v16i8, v8i8>;
3091 def VDUPLN16q : VDUPLNQ<{?,?}, {1,0}, "vdup", "16", v8i16, v4i16>;
3092 def VDUPLN32q : VDUPLNQ<{?,1}, {0,0}, "vdup", "32", v4i32, v2i32>;
3093 def VDUPLNfq : VDUPLNQ<{?,1}, {0,0}, "vdup", "32", v4f32, v2f32>;
3095 def : Pat<(v16i8 (NEONvduplane (v16i8 QPR:$src), imm:$lane)),
3096 (v16i8 (VDUPLN8q (v8i8 (EXTRACT_SUBREG QPR:$src,
3097 (DSubReg_i8_reg imm:$lane))),
3098 (SubReg_i8_lane imm:$lane)))>;
3099 def : Pat<(v8i16 (NEONvduplane (v8i16 QPR:$src), imm:$lane)),
3100 (v8i16 (VDUPLN16q (v4i16 (EXTRACT_SUBREG QPR:$src,
3101 (DSubReg_i16_reg imm:$lane))),
3102 (SubReg_i16_lane imm:$lane)))>;
3103 def : Pat<(v4i32 (NEONvduplane (v4i32 QPR:$src), imm:$lane)),
3104 (v4i32 (VDUPLN32q (v2i32 (EXTRACT_SUBREG QPR:$src,
3105 (DSubReg_i32_reg imm:$lane))),
3106 (SubReg_i32_lane imm:$lane)))>;
3107 def : Pat<(v4f32 (NEONvduplane (v4f32 QPR:$src), imm:$lane)),
3108 (v4f32 (VDUPLNfq (v2f32 (EXTRACT_SUBREG QPR:$src,
3109 (DSubReg_i32_reg imm:$lane))),
3110 (SubReg_i32_lane imm:$lane)))>;
3112 def VDUPfdf : N2V<0b11, 0b11, {?,1}, {0,0}, 0b11000, 0, 0,
3113 (outs DPR:$dst), (ins SPR:$src),
3114 IIC_VMOVD, "vdup", "32", "$dst, ${src:lane}", "",
3115 [(set DPR:$dst, (v2f32 (NEONvdup (f32 SPR:$src))))]>;
3117 def VDUPfqf : N2V<0b11, 0b11, {?,1}, {0,0}, 0b11000, 1, 0,
3118 (outs QPR:$dst), (ins SPR:$src),
3119 IIC_VMOVD, "vdup", "32", "$dst, ${src:lane}", "",
3120 [(set QPR:$dst, (v4f32 (NEONvdup (f32 SPR:$src))))]>;
3122 def : Pat<(v2i64 (NEONvduplane (v2i64 QPR:$src), imm:$lane)),
3123 (INSERT_SUBREG QPR:$src,
3124 (i64 (EXTRACT_SUBREG QPR:$src,
3125 (DSubReg_f64_reg imm:$lane))),
3126 (DSubReg_f64_other_reg imm:$lane))>;
3127 def : Pat<(v2f64 (NEONvduplane (v2f64 QPR:$src), imm:$lane)),
3128 (INSERT_SUBREG QPR:$src,
3129 (f64 (EXTRACT_SUBREG QPR:$src,
3130 (DSubReg_f64_reg imm:$lane))),
3131 (DSubReg_f64_other_reg imm:$lane))>;
3133 // VMOVN : Vector Narrowing Move
3134 defm VMOVN : N2VNInt_HSD<0b11,0b11,0b10,0b00100,0,0, IIC_VMOVD,
3135 "vmovn", "i", int_arm_neon_vmovn>;
3136 // VQMOVN : Vector Saturating Narrowing Move
3137 defm VQMOVNs : N2VNInt_HSD<0b11,0b11,0b10,0b00101,0,0, IIC_VQUNAiD,
3138 "vqmovn", "s", int_arm_neon_vqmovns>;
3139 defm VQMOVNu : N2VNInt_HSD<0b11,0b11,0b10,0b00101,1,0, IIC_VQUNAiD,
3140 "vqmovn", "u", int_arm_neon_vqmovnu>;
3141 defm VQMOVNsu : N2VNInt_HSD<0b11,0b11,0b10,0b00100,1,0, IIC_VQUNAiD,
3142 "vqmovun", "s", int_arm_neon_vqmovnsu>;
3143 // VMOVL : Vector Lengthening Move
3144 defm VMOVLs : N2VLInt_QHS<0b01,0b10100,0,1, "vmovl", "s",
3145 int_arm_neon_vmovls>;
3146 defm VMOVLu : N2VLInt_QHS<0b11,0b10100,0,1, "vmovl", "u",
3147 int_arm_neon_vmovlu>;
3149 // Vector Conversions.
3151 let NSF = NVdVmImmVCVTFrm, NSForm = NVdVmImmVCVTFrm.Value in {
3152 class N2VDX<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
3153 bits<2> op17_16, bits<5> op11_7, bit op4, string OpcodeStr,
3154 string Dt, ValueType ResTy, ValueType OpTy, SDNode OpNode>
3155 : N2VD<op24_23, op21_20, op19_18, op17_16, op11_7, op4, OpcodeStr, Dt,
3156 ResTy, OpTy, OpNode>;
3157 class N2VQX<bits<2> op24_23, bits<2> op21_20, bits<2> op19_18,
3158 bits<2> op17_16, bits<5> op11_7, bit op4, string OpcodeStr,
3159 string Dt, ValueType ResTy, ValueType OpTy, SDNode OpNode>
3160 : N2VQ<op24_23, op21_20, op19_18, op17_16, op11_7, op4, OpcodeStr, Dt,
3161 ResTy, OpTy, OpNode>;
3164 // VCVT : Vector Convert Between Floating-Point and Integers
3165 def VCVTf2sd : N2VDX<0b11, 0b11, 0b10, 0b11, 0b01110, 0, "vcvt", "s32.f32",
3166 v2i32, v2f32, fp_to_sint>;
3167 def VCVTf2ud : N2VDX<0b11, 0b11, 0b10, 0b11, 0b01111, 0, "vcvt", "u32.f32",
3168 v2i32, v2f32, fp_to_uint>;
3169 def VCVTs2fd : N2VDX<0b11, 0b11, 0b10, 0b11, 0b01100, 0, "vcvt", "f32.s32",
3170 v2f32, v2i32, sint_to_fp>;
3171 def VCVTu2fd : N2VDX<0b11, 0b11, 0b10, 0b11, 0b01101, 0, "vcvt", "f32.u32",
3172 v2f32, v2i32, uint_to_fp>;
3174 def VCVTf2sq : N2VQX<0b11, 0b11, 0b10, 0b11, 0b01110, 0, "vcvt", "s32.f32",
3175 v4i32, v4f32, fp_to_sint>;
3176 def VCVTf2uq : N2VQX<0b11, 0b11, 0b10, 0b11, 0b01111, 0, "vcvt", "u32.f32",
3177 v4i32, v4f32, fp_to_uint>;
3178 def VCVTs2fq : N2VQX<0b11, 0b11, 0b10, 0b11, 0b01100, 0, "vcvt", "f32.s32",
3179 v4f32, v4i32, sint_to_fp>;
3180 def VCVTu2fq : N2VQX<0b11, 0b11, 0b10, 0b11, 0b01101, 0, "vcvt", "f32.u32",
3181 v4f32, v4i32, uint_to_fp>;
3183 // VCVT : Vector Convert Between Floating-Point and Fixed-Point.
3184 def VCVTf2xsd : N2VCvtD<0, 1, 0b1111, 0, 1, "vcvt", "s32.f32",
3185 v2i32, v2f32, int_arm_neon_vcvtfp2fxs>;
3186 def VCVTf2xud : N2VCvtD<1, 1, 0b1111, 0, 1, "vcvt", "u32.f32",
3187 v2i32, v2f32, int_arm_neon_vcvtfp2fxu>;
3188 def VCVTxs2fd : N2VCvtD<0, 1, 0b1110, 0, 1, "vcvt", "f32.s32",
3189 v2f32, v2i32, int_arm_neon_vcvtfxs2fp>;
3190 def VCVTxu2fd : N2VCvtD<1, 1, 0b1110, 0, 1, "vcvt", "f32.u32",
3191 v2f32, v2i32, int_arm_neon_vcvtfxu2fp>;
3193 def VCVTf2xsq : N2VCvtQ<0, 1, 0b1111, 0, 1, "vcvt", "s32.f32",
3194 v4i32, v4f32, int_arm_neon_vcvtfp2fxs>;
3195 def VCVTf2xuq : N2VCvtQ<1, 1, 0b1111, 0, 1, "vcvt", "u32.f32",
3196 v4i32, v4f32, int_arm_neon_vcvtfp2fxu>;
3197 def VCVTxs2fq : N2VCvtQ<0, 1, 0b1110, 0, 1, "vcvt", "f32.s32",
3198 v4f32, v4i32, int_arm_neon_vcvtfxs2fp>;
3199 def VCVTxu2fq : N2VCvtQ<1, 1, 0b1110, 0, 1, "vcvt", "f32.u32",
3200 v4f32, v4i32, int_arm_neon_vcvtfxu2fp>;
3204 // VREV64 : Vector Reverse elements within 64-bit doublewords
3206 class VREV64D<bits<2> op19_18, string OpcodeStr, string Dt, ValueType Ty>
3207 : N2V<0b11, 0b11, op19_18, 0b00, 0b00000, 0, 0, (outs DPR:$dst),
3208 (ins DPR:$src), IIC_VMOVD,
3209 OpcodeStr, Dt, "$dst, $src", "",
3210 [(set DPR:$dst, (Ty (NEONvrev64 (Ty DPR:$src))))]>;
3211 class VREV64Q<bits<2> op19_18, string OpcodeStr, string Dt, ValueType Ty>
3212 : N2V<0b11, 0b11, op19_18, 0b00, 0b00000, 1, 0, (outs QPR:$dst),
3213 (ins QPR:$src), IIC_VMOVD,
3214 OpcodeStr, Dt, "$dst, $src", "",
3215 [(set QPR:$dst, (Ty (NEONvrev64 (Ty QPR:$src))))]>;
3217 def VREV64d8 : VREV64D<0b00, "vrev64", "8", v8i8>;
3218 def VREV64d16 : VREV64D<0b01, "vrev64", "16", v4i16>;
3219 def VREV64d32 : VREV64D<0b10, "vrev64", "32", v2i32>;
3220 def VREV64df : VREV64D<0b10, "vrev64", "32", v2f32>;
3222 def VREV64q8 : VREV64Q<0b00, "vrev64", "8", v16i8>;
3223 def VREV64q16 : VREV64Q<0b01, "vrev64", "16", v8i16>;
3224 def VREV64q32 : VREV64Q<0b10, "vrev64", "32", v4i32>;
3225 def VREV64qf : VREV64Q<0b10, "vrev64", "32", v4f32>;
3227 // VREV32 : Vector Reverse elements within 32-bit words
3229 class VREV32D<bits<2> op19_18, string OpcodeStr, string Dt, ValueType Ty>
3230 : N2V<0b11, 0b11, op19_18, 0b00, 0b00001, 0, 0, (outs DPR:$dst),
3231 (ins DPR:$src), IIC_VMOVD,
3232 OpcodeStr, Dt, "$dst, $src", "",
3233 [(set DPR:$dst, (Ty (NEONvrev32 (Ty DPR:$src))))]>;
3234 class VREV32Q<bits<2> op19_18, string OpcodeStr, string Dt, ValueType Ty>
3235 : N2V<0b11, 0b11, op19_18, 0b00, 0b00001, 1, 0, (outs QPR:$dst),
3236 (ins QPR:$src), IIC_VMOVD,
3237 OpcodeStr, Dt, "$dst, $src", "",
3238 [(set QPR:$dst, (Ty (NEONvrev32 (Ty QPR:$src))))]>;
3240 def VREV32d8 : VREV32D<0b00, "vrev32", "8", v8i8>;
3241 def VREV32d16 : VREV32D<0b01, "vrev32", "16", v4i16>;
3243 def VREV32q8 : VREV32Q<0b00, "vrev32", "8", v16i8>;
3244 def VREV32q16 : VREV32Q<0b01, "vrev32", "16", v8i16>;
3246 // VREV16 : Vector Reverse elements within 16-bit halfwords
3248 class VREV16D<bits<2> op19_18, string OpcodeStr, string Dt, ValueType Ty>
3249 : N2V<0b11, 0b11, op19_18, 0b00, 0b00010, 0, 0, (outs DPR:$dst),
3250 (ins DPR:$src), IIC_VMOVD,
3251 OpcodeStr, Dt, "$dst, $src", "",
3252 [(set DPR:$dst, (Ty (NEONvrev16 (Ty DPR:$src))))]>;
3253 class VREV16Q<bits<2> op19_18, string OpcodeStr, string Dt, ValueType Ty>
3254 : N2V<0b11, 0b11, op19_18, 0b00, 0b00010, 1, 0, (outs QPR:$dst),
3255 (ins QPR:$src), IIC_VMOVD,
3256 OpcodeStr, Dt, "$dst, $src", "",
3257 [(set QPR:$dst, (Ty (NEONvrev16 (Ty QPR:$src))))]>;
3259 def VREV16d8 : VREV16D<0b00, "vrev16", "8", v8i8>;
3260 def VREV16q8 : VREV16Q<0b00, "vrev16", "8", v16i8>;
3262 // Other Vector Shuffles.
3264 // VEXT : Vector Extract
3266 let NSF = NVdVnVmImmVectorExtractFrm,
3267 NSForm = NVdVnVmImmVectorExtractFrm.Value in {
3268 class VEXTd<string OpcodeStr, string Dt, ValueType Ty>
3269 : N3V<0,1,0b11,{?,?,?,?},0,0, (outs DPR:$dst),
3270 (ins DPR:$lhs, DPR:$rhs, i32imm:$index), IIC_VEXTD,
3271 OpcodeStr, Dt, "$dst, $lhs, $rhs, $index", "",
3272 [(set DPR:$dst, (Ty (NEONvext (Ty DPR:$lhs),
3273 (Ty DPR:$rhs), imm:$index)))]>;
3275 class VEXTq<string OpcodeStr, string Dt, ValueType Ty>
3276 : N3V<0,1,0b11,{?,?,?,?},1,0, (outs QPR:$dst),
3277 (ins QPR:$lhs, QPR:$rhs, i32imm:$index), IIC_VEXTQ,
3278 OpcodeStr, Dt, "$dst, $lhs, $rhs, $index", "",
3279 [(set QPR:$dst, (Ty (NEONvext (Ty QPR:$lhs),
3280 (Ty QPR:$rhs), imm:$index)))]>;
3283 def VEXTd8 : VEXTd<"vext", "8", v8i8>;
3284 def VEXTd16 : VEXTd<"vext", "16", v4i16>;
3285 def VEXTd32 : VEXTd<"vext", "32", v2i32>;
3286 def VEXTdf : VEXTd<"vext", "32", v2f32>;
3288 def VEXTq8 : VEXTq<"vext", "8", v16i8>;
3289 def VEXTq16 : VEXTq<"vext", "16", v8i16>;
3290 def VEXTq32 : VEXTq<"vext", "32", v4i32>;
3291 def VEXTqf : VEXTq<"vext", "32", v4f32>;
3293 // VTRN : Vector Transpose
3295 def VTRNd8 : N2VDShuffle<0b00, 0b00001, "vtrn", "8">;
3296 def VTRNd16 : N2VDShuffle<0b01, 0b00001, "vtrn", "16">;
3297 def VTRNd32 : N2VDShuffle<0b10, 0b00001, "vtrn", "32">;
3299 def VTRNq8 : N2VQShuffle<0b00, 0b00001, IIC_VPERMQ, "vtrn", "8">;
3300 def VTRNq16 : N2VQShuffle<0b01, 0b00001, IIC_VPERMQ, "vtrn", "16">;
3301 def VTRNq32 : N2VQShuffle<0b10, 0b00001, IIC_VPERMQ, "vtrn", "32">;
3303 // VUZP : Vector Unzip (Deinterleave)
3305 def VUZPd8 : N2VDShuffle<0b00, 0b00010, "vuzp", "8">;
3306 def VUZPd16 : N2VDShuffle<0b01, 0b00010, "vuzp", "16">;
3307 def VUZPd32 : N2VDShuffle<0b10, 0b00010, "vuzp", "32">;
3309 def VUZPq8 : N2VQShuffle<0b00, 0b00010, IIC_VPERMQ3, "vuzp", "8">;
3310 def VUZPq16 : N2VQShuffle<0b01, 0b00010, IIC_VPERMQ3, "vuzp", "16">;
3311 def VUZPq32 : N2VQShuffle<0b10, 0b00010, IIC_VPERMQ3, "vuzp", "32">;
3313 // VZIP : Vector Zip (Interleave)
3315 def VZIPd8 : N2VDShuffle<0b00, 0b00011, "vzip", "8">;
3316 def VZIPd16 : N2VDShuffle<0b01, 0b00011, "vzip", "16">;
3317 def VZIPd32 : N2VDShuffle<0b10, 0b00011, "vzip", "32">;
3319 def VZIPq8 : N2VQShuffle<0b00, 0b00011, IIC_VPERMQ3, "vzip", "8">;
3320 def VZIPq16 : N2VQShuffle<0b01, 0b00011, IIC_VPERMQ3, "vzip", "16">;
3321 def VZIPq32 : N2VQShuffle<0b10, 0b00011, IIC_VPERMQ3, "vzip", "32">;
3323 // Vector Table Lookup and Table Extension.
3325 let NSF = VTBLFrm, NSForm = VTBLFrm.Value in {
3327 // VTBL : Vector Table Lookup
3329 : N3V<1,1,0b11,0b1000,0,0, (outs DPR:$dst),
3330 (ins DPR:$tbl1, DPR:$src), IIC_VTB1,
3331 "vtbl", "8", "$dst, \\{$tbl1\\}, $src", "",
3332 [(set DPR:$dst, (v8i8 (int_arm_neon_vtbl1 DPR:$tbl1, DPR:$src)))]>;
3333 let hasExtraSrcRegAllocReq = 1 in {
3335 : N3V<1,1,0b11,0b1001,0,0, (outs DPR:$dst),
3336 (ins DPR:$tbl1, DPR:$tbl2, DPR:$src), IIC_VTB2,
3337 "vtbl", "8", "$dst, \\{$tbl1, $tbl2\\}, $src", "",
3338 [(set DPR:$dst, (v8i8 (int_arm_neon_vtbl2
3339 DPR:$tbl1, DPR:$tbl2, DPR:$src)))]>;
3341 : N3V<1,1,0b11,0b1010,0,0, (outs DPR:$dst),
3342 (ins DPR:$tbl1, DPR:$tbl2, DPR:$tbl3, DPR:$src), IIC_VTB3,
3343 "vtbl", "8", "$dst, \\{$tbl1, $tbl2, $tbl3\\}, $src", "",
3344 [(set DPR:$dst, (v8i8 (int_arm_neon_vtbl3
3345 DPR:$tbl1, DPR:$tbl2, DPR:$tbl3, DPR:$src)))]>;
3347 : N3V<1,1,0b11,0b1011,0,0, (outs DPR:$dst),
3348 (ins DPR:$tbl1, DPR:$tbl2, DPR:$tbl3, DPR:$tbl4, DPR:$src), IIC_VTB4,
3349 "vtbl", "8", "$dst, \\{$tbl1, $tbl2, $tbl3, $tbl4\\}, $src", "",
3350 [(set DPR:$dst, (v8i8 (int_arm_neon_vtbl4 DPR:$tbl1, DPR:$tbl2,
3351 DPR:$tbl3, DPR:$tbl4, DPR:$src)))]>;
3352 } // hasExtraSrcRegAllocReq = 1
3354 // VTBX : Vector Table Extension
3356 : N3V<1,1,0b11,0b1000,1,0, (outs DPR:$dst),
3357 (ins DPR:$orig, DPR:$tbl1, DPR:$src), IIC_VTBX1,
3358 "vtbx", "8", "$dst, \\{$tbl1\\}, $src", "$orig = $dst",
3359 [(set DPR:$dst, (v8i8 (int_arm_neon_vtbx1
3360 DPR:$orig, DPR:$tbl1, DPR:$src)))]>;
3361 let hasExtraSrcRegAllocReq = 1 in {
3363 : N3V<1,1,0b11,0b1001,1,0, (outs DPR:$dst),
3364 (ins DPR:$orig, DPR:$tbl1, DPR:$tbl2, DPR:$src), IIC_VTBX2,
3365 "vtbx", "8", "$dst, \\{$tbl1, $tbl2\\}, $src", "$orig = $dst",
3366 [(set DPR:$dst, (v8i8 (int_arm_neon_vtbx2
3367 DPR:$orig, DPR:$tbl1, DPR:$tbl2, DPR:$src)))]>;
3369 : N3V<1,1,0b11,0b1010,1,0, (outs DPR:$dst),
3370 (ins DPR:$orig, DPR:$tbl1, DPR:$tbl2, DPR:$tbl3, DPR:$src), IIC_VTBX3,
3371 "vtbx", "8", "$dst, \\{$tbl1, $tbl2, $tbl3\\}, $src", "$orig = $dst",
3372 [(set DPR:$dst, (v8i8 (int_arm_neon_vtbx3 DPR:$orig, DPR:$tbl1,
3373 DPR:$tbl2, DPR:$tbl3, DPR:$src)))]>;
3375 : N3V<1,1,0b11,0b1011,1,0, (outs DPR:$dst), (ins DPR:$orig, DPR:$tbl1,
3376 DPR:$tbl2, DPR:$tbl3, DPR:$tbl4, DPR:$src), IIC_VTBX4,
3377 "vtbx", "8", "$dst, \\{$tbl1, $tbl2, $tbl3, $tbl4\\}, $src",
3379 [(set DPR:$dst, (v8i8 (int_arm_neon_vtbx4 DPR:$orig, DPR:$tbl1,
3380 DPR:$tbl2, DPR:$tbl3, DPR:$tbl4, DPR:$src)))]>;
3381 } // hasExtraSrcRegAllocReq = 1
3383 } // End of "let NSF = VTBLFrm, ..."
3385 //===----------------------------------------------------------------------===//
3386 // NEON instructions for single-precision FP math
3387 //===----------------------------------------------------------------------===//
3389 class N2VSPat<SDNode OpNode, ValueType ResTy, ValueType OpTy, NeonI Inst>
3390 : NEONFPPat<(ResTy (OpNode SPR:$a)),
3391 (EXTRACT_SUBREG (OpTy (Inst (INSERT_SUBREG (OpTy (IMPLICIT_DEF)),
3392 SPR:$a, arm_ssubreg_0))),
3395 class N3VSPat<SDNode OpNode, NeonI Inst>
3396 : NEONFPPat<(f32 (OpNode SPR:$a, SPR:$b)),
3397 (EXTRACT_SUBREG (v2f32
3398 (Inst (INSERT_SUBREG (v2f32 (IMPLICIT_DEF)),
3399 SPR:$a, arm_ssubreg_0),
3400 (INSERT_SUBREG (v2f32 (IMPLICIT_DEF)),
3401 SPR:$b, arm_ssubreg_0))),
3404 class N3VSMulOpPat<SDNode MulNode, SDNode OpNode, NeonI Inst>
3405 : NEONFPPat<(f32 (OpNode SPR:$acc, (f32 (MulNode SPR:$a, SPR:$b)))),
3406 (EXTRACT_SUBREG (Inst (INSERT_SUBREG (v2f32 (IMPLICIT_DEF)),
3407 SPR:$acc, arm_ssubreg_0),
3408 (INSERT_SUBREG (v2f32 (IMPLICIT_DEF)),
3409 SPR:$a, arm_ssubreg_0),
3410 (INSERT_SUBREG (v2f32 (IMPLICIT_DEF)),
3411 SPR:$b, arm_ssubreg_0)),
3414 // These need separate instructions because they must use DPR_VFP2 register
3415 // class which have SPR sub-registers.
3417 // Vector Add Operations used for single-precision FP
3418 let neverHasSideEffects = 1 in
3419 def VADDfd_sfp : N3VS<0,0,0b00,0b1101,0, "vadd", "f32", v2f32, v2f32, fadd, 1>;
3420 def : N3VSPat<fadd, VADDfd_sfp>;
3422 // Vector Sub Operations used for single-precision FP
3423 let neverHasSideEffects = 1 in
3424 def VSUBfd_sfp : N3VS<0,0,0b10,0b1101,0, "vsub", "f32", v2f32, v2f32, fsub, 0>;
3425 def : N3VSPat<fsub, VSUBfd_sfp>;
3427 // Vector Multiply Operations used for single-precision FP
3428 let neverHasSideEffects = 1 in
3429 def VMULfd_sfp : N3VS<1,0,0b00,0b1101,1, "vmul", "f32", v2f32, v2f32, fmul, 1>;
3430 def : N3VSPat<fmul, VMULfd_sfp>;
3432 // Vector Multiply-Accumulate/Subtract used for single-precision FP
3433 // vml[as].f32 can cause 4-8 cycle stalls in following ASIMD instructions, so
3434 // we want to avoid them for now. e.g., alternating vmla/vadd instructions.
3436 //let neverHasSideEffects = 1 in
3437 //def VMLAfd_sfp : N3VSMulOp<0,0,0b00,0b1101,1, IIC_VMACD, "vmla", "f32",
3438 // v2f32, fmul, fadd>;
3439 //def : N3VSMulOpPat<fmul, fadd, VMLAfd_sfp>;
3441 //let neverHasSideEffects = 1 in
3442 //def VMLSfd_sfp : N3VSMulOp<0,0,0b10,0b1101,1, IIC_VMACD, "vmls", "f32",
3443 // v2f32, fmul, fsub>;
3444 //def : N3VSMulOpPat<fmul, fsub, VMLSfd_sfp>;
3446 // Vector Absolute used for single-precision FP
3447 let neverHasSideEffects = 1 in
3448 def VABSfd_sfp : N2V<0b11, 0b11, 0b10, 0b01, 0b01110, 0, 0,
3449 (outs DPR_VFP2:$dst), (ins DPR_VFP2:$src), IIC_VUNAD,
3450 "vabs", "f32", "$dst, $src", "", []>;
3451 def : N2VSPat<fabs, f32, v2f32, VABSfd_sfp>;
3453 // Vector Negate used for single-precision FP
3454 let neverHasSideEffects = 1 in
3455 def VNEGfd_sfp : N2V<0b11, 0b11, 0b10, 0b01, 0b01111, 0, 0,
3456 (outs DPR_VFP2:$dst), (ins DPR_VFP2:$src), IIC_VUNAD,
3457 "vneg", "f32", "$dst, $src", "", []>;
3458 def : N2VSPat<fneg, f32, v2f32, VNEGfd_sfp>;
3460 // Vector Maximum used for single-precision FP
3461 let neverHasSideEffects = 1 in
3462 def VMAXfd_sfp : N3V<0, 0, 0b00, 0b1111, 0, 0, (outs DPR_VFP2:$dst),
3463 (ins DPR_VFP2:$src1, DPR_VFP2:$src2), IIC_VBIND,
3464 "vmax", "f32", "$dst, $src1, $src2", "", []>;
3465 def : N3VSPat<NEONfmax, VMAXfd_sfp>;
3467 // Vector Minimum used for single-precision FP
3468 let neverHasSideEffects = 1 in
3469 def VMINfd_sfp : N3V<0, 0, 0b00, 0b1111, 0, 0, (outs DPR_VFP2:$dst),
3470 (ins DPR_VFP2:$src1, DPR_VFP2:$src2), IIC_VBIND,
3471 "vmin", "f32", "$dst, $src1, $src2", "", []>;
3472 def : N3VSPat<NEONfmin, VMINfd_sfp>;
3474 // Vector Convert between single-precision FP and integer
3475 let neverHasSideEffects = 1 in
3476 def VCVTf2sd_sfp : N2VS<0b11, 0b11, 0b10, 0b11, 0b01110, 0, "vcvt", "s32.f32",
3477 v2i32, v2f32, fp_to_sint>;
3478 def : N2VSPat<arm_ftosi, f32, v2f32, VCVTf2sd_sfp>;
3480 let neverHasSideEffects = 1 in
3481 def VCVTf2ud_sfp : N2VS<0b11, 0b11, 0b10, 0b11, 0b01111, 0, "vcvt", "u32.f32",
3482 v2i32, v2f32, fp_to_uint>;
3483 def : N2VSPat<arm_ftoui, f32, v2f32, VCVTf2ud_sfp>;
3485 let neverHasSideEffects = 1 in
3486 def VCVTs2fd_sfp : N2VS<0b11, 0b11, 0b10, 0b11, 0b01100, 0, "vcvt", "f32.s32",
3487 v2f32, v2i32, sint_to_fp>;
3488 def : N2VSPat<arm_sitof, f32, v2i32, VCVTs2fd_sfp>;
3490 let neverHasSideEffects = 1 in
3491 def VCVTu2fd_sfp : N2VS<0b11, 0b11, 0b10, 0b11, 0b01101, 0, "vcvt", "f32.u32",
3492 v2f32, v2i32, uint_to_fp>;
3493 def : N2VSPat<arm_uitof, f32, v2i32, VCVTu2fd_sfp>;
3495 //===----------------------------------------------------------------------===//
3496 // Non-Instruction Patterns
3497 //===----------------------------------------------------------------------===//
3500 def : Pat<(v1i64 (bitconvert (v2i32 DPR:$src))), (v1i64 DPR:$src)>;
3501 def : Pat<(v1i64 (bitconvert (v4i16 DPR:$src))), (v1i64 DPR:$src)>;
3502 def : Pat<(v1i64 (bitconvert (v8i8 DPR:$src))), (v1i64 DPR:$src)>;
3503 def : Pat<(v1i64 (bitconvert (f64 DPR:$src))), (v1i64 DPR:$src)>;
3504 def : Pat<(v1i64 (bitconvert (v2f32 DPR:$src))), (v1i64 DPR:$src)>;
3505 def : Pat<(v2i32 (bitconvert (v1i64 DPR:$src))), (v2i32 DPR:$src)>;
3506 def : Pat<(v2i32 (bitconvert (v4i16 DPR:$src))), (v2i32 DPR:$src)>;
3507 def : Pat<(v2i32 (bitconvert (v8i8 DPR:$src))), (v2i32 DPR:$src)>;
3508 def : Pat<(v2i32 (bitconvert (f64 DPR:$src))), (v2i32 DPR:$src)>;
3509 def : Pat<(v2i32 (bitconvert (v2f32 DPR:$src))), (v2i32 DPR:$src)>;
3510 def : Pat<(v4i16 (bitconvert (v1i64 DPR:$src))), (v4i16 DPR:$src)>;
3511 def : Pat<(v4i16 (bitconvert (v2i32 DPR:$src))), (v4i16 DPR:$src)>;
3512 def : Pat<(v4i16 (bitconvert (v8i8 DPR:$src))), (v4i16 DPR:$src)>;
3513 def : Pat<(v4i16 (bitconvert (f64 DPR:$src))), (v4i16 DPR:$src)>;
3514 def : Pat<(v4i16 (bitconvert (v2f32 DPR:$src))), (v4i16 DPR:$src)>;
3515 def : Pat<(v8i8 (bitconvert (v1i64 DPR:$src))), (v8i8 DPR:$src)>;
3516 def : Pat<(v8i8 (bitconvert (v2i32 DPR:$src))), (v8i8 DPR:$src)>;
3517 def : Pat<(v8i8 (bitconvert (v4i16 DPR:$src))), (v8i8 DPR:$src)>;
3518 def : Pat<(v8i8 (bitconvert (f64 DPR:$src))), (v8i8 DPR:$src)>;
3519 def : Pat<(v8i8 (bitconvert (v2f32 DPR:$src))), (v8i8 DPR:$src)>;
3520 def : Pat<(f64 (bitconvert (v1i64 DPR:$src))), (f64 DPR:$src)>;
3521 def : Pat<(f64 (bitconvert (v2i32 DPR:$src))), (f64 DPR:$src)>;
3522 def : Pat<(f64 (bitconvert (v4i16 DPR:$src))), (f64 DPR:$src)>;
3523 def : Pat<(f64 (bitconvert (v8i8 DPR:$src))), (f64 DPR:$src)>;
3524 def : Pat<(f64 (bitconvert (v2f32 DPR:$src))), (f64 DPR:$src)>;
3525 def : Pat<(v2f32 (bitconvert (f64 DPR:$src))), (v2f32 DPR:$src)>;
3526 def : Pat<(v2f32 (bitconvert (v1i64 DPR:$src))), (v2f32 DPR:$src)>;
3527 def : Pat<(v2f32 (bitconvert (v2i32 DPR:$src))), (v2f32 DPR:$src)>;
3528 def : Pat<(v2f32 (bitconvert (v4i16 DPR:$src))), (v2f32 DPR:$src)>;
3529 def : Pat<(v2f32 (bitconvert (v8i8 DPR:$src))), (v2f32 DPR:$src)>;
3531 def : Pat<(v2i64 (bitconvert (v4i32 QPR:$src))), (v2i64 QPR:$src)>;
3532 def : Pat<(v2i64 (bitconvert (v8i16 QPR:$src))), (v2i64 QPR:$src)>;
3533 def : Pat<(v2i64 (bitconvert (v16i8 QPR:$src))), (v2i64 QPR:$src)>;
3534 def : Pat<(v2i64 (bitconvert (v2f64 QPR:$src))), (v2i64 QPR:$src)>;
3535 def : Pat<(v2i64 (bitconvert (v4f32 QPR:$src))), (v2i64 QPR:$src)>;
3536 def : Pat<(v4i32 (bitconvert (v2i64 QPR:$src))), (v4i32 QPR:$src)>;
3537 def : Pat<(v4i32 (bitconvert (v8i16 QPR:$src))), (v4i32 QPR:$src)>;
3538 def : Pat<(v4i32 (bitconvert (v16i8 QPR:$src))), (v4i32 QPR:$src)>;
3539 def : Pat<(v4i32 (bitconvert (v2f64 QPR:$src))), (v4i32 QPR:$src)>;
3540 def : Pat<(v4i32 (bitconvert (v4f32 QPR:$src))), (v4i32 QPR:$src)>;
3541 def : Pat<(v8i16 (bitconvert (v2i64 QPR:$src))), (v8i16 QPR:$src)>;
3542 def : Pat<(v8i16 (bitconvert (v4i32 QPR:$src))), (v8i16 QPR:$src)>;
3543 def : Pat<(v8i16 (bitconvert (v16i8 QPR:$src))), (v8i16 QPR:$src)>;
3544 def : Pat<(v8i16 (bitconvert (v2f64 QPR:$src))), (v8i16 QPR:$src)>;
3545 def : Pat<(v8i16 (bitconvert (v4f32 QPR:$src))), (v8i16 QPR:$src)>;
3546 def : Pat<(v16i8 (bitconvert (v2i64 QPR:$src))), (v16i8 QPR:$src)>;
3547 def : Pat<(v16i8 (bitconvert (v4i32 QPR:$src))), (v16i8 QPR:$src)>;
3548 def : Pat<(v16i8 (bitconvert (v8i16 QPR:$src))), (v16i8 QPR:$src)>;
3549 def : Pat<(v16i8 (bitconvert (v2f64 QPR:$src))), (v16i8 QPR:$src)>;
3550 def : Pat<(v16i8 (bitconvert (v4f32 QPR:$src))), (v16i8 QPR:$src)>;
3551 def : Pat<(v4f32 (bitconvert (v2i64 QPR:$src))), (v4f32 QPR:$src)>;
3552 def : Pat<(v4f32 (bitconvert (v4i32 QPR:$src))), (v4f32 QPR:$src)>;
3553 def : Pat<(v4f32 (bitconvert (v8i16 QPR:$src))), (v4f32 QPR:$src)>;
3554 def : Pat<(v4f32 (bitconvert (v16i8 QPR:$src))), (v4f32 QPR:$src)>;
3555 def : Pat<(v4f32 (bitconvert (v2f64 QPR:$src))), (v4f32 QPR:$src)>;
3556 def : Pat<(v2f64 (bitconvert (v2i64 QPR:$src))), (v2f64 QPR:$src)>;
3557 def : Pat<(v2f64 (bitconvert (v4i32 QPR:$src))), (v2f64 QPR:$src)>;
3558 def : Pat<(v2f64 (bitconvert (v8i16 QPR:$src))), (v2f64 QPR:$src)>;
3559 def : Pat<(v2f64 (bitconvert (v16i8 QPR:$src))), (v2f64 QPR:$src)>;
3560 def : Pat<(v2f64 (bitconvert (v4f32 QPR:$src))), (v2f64 QPR:$src)>;