[Hexagon] Replace incorrect pattern for vpackl HWI32 -> HVi8
[lldb.git] / llvm / lib / Target / Hexagon / HexagonPatternsHVX.td
1 def SDTVecUnaryOp:
2   SDTypeProfile<1, 1, [SDTCisVec<0>, SDTCisVec<1>]>;
3
4 def SDTVecBinOp:
5   SDTypeProfile<1, 2, [SDTCisVec<0>, SDTCisVec<1>, SDTCisSameAs<1,2>]>;
6
7 def SDTHexagonVEXTRACTW: SDTypeProfile<1, 2,
8   [SDTCisVT<0, i32>, SDTCisVec<1>, SDTCisVT<2, i32>]>;
9 def HexagonVEXTRACTW : SDNode<"HexagonISD::VEXTRACTW", SDTHexagonVEXTRACTW>;
10
11 def SDTHexagonVINSERTW0: SDTypeProfile<1, 2,
12   [SDTCisVec<0>, SDTCisSameAs<0, 1>, SDTCisVT<2, i32>]>;
13 def HexagonVINSERTW0: SDNode<"HexagonISD::VINSERTW0", SDTHexagonVINSERTW0>;
14
15 def SDTHexagonVSPLATW: SDTypeProfile<1, 1, [SDTCisVec<0>, SDTCisVT<1, i32>]>;
16 def HexagonVSPLATW: SDNode<"HexagonISD::VSPLATW", SDTHexagonVSPLATW>;
17
18 def HwLen2: SDNodeXForm<imm, [{
19   const auto &ST = static_cast<const HexagonSubtarget&>(CurDAG->getSubtarget());
20   return CurDAG->getTargetConstant(ST.getVectorLength()/2, SDLoc(N), MVT::i32);
21 }]>;
22
23 def Q2V: OutPatFrag<(ops node:$Qs), (V6_vandqrt $Qs, (A2_tfrsi -1))>;
24
25 def Combinev: OutPatFrag<(ops node:$Vs, node:$Vt),
26   (REG_SEQUENCE HvxWR, $Vs, vsub_hi, $Vt, vsub_lo)>;
27
28 def Combineq: OutPatFrag<(ops node:$Qs, node:$Qt),
29   (V6_vandvrt
30     (V6_vor
31       (V6_vror (V6_vpackeb (V6_vd0), (Q2V $Qs)),
32                (A2_tfrsi (HwLen2 (i32 0)))),  // Half the vector length
33       (V6_vpackeb (V6_vd0), (Q2V $Qt))),
34     (A2_tfrsi -1))>;
35
36 def LoVec: OutPatFrag<(ops node:$Vs), (EXTRACT_SUBREG $Vs, vsub_lo)>;
37 def HiVec: OutPatFrag<(ops node:$Vs), (EXTRACT_SUBREG $Vs, vsub_hi)>;
38
39 def HexagonVZERO:      SDNode<"HexagonISD::VZERO",      SDTVecLeaf>;
40 def HexagonQCAT:       SDNode<"HexagonISD::QCAT",       SDTVecBinOp>;
41 def HexagonQTRUE:      SDNode<"HexagonISD::QTRUE",      SDTVecLeaf>;
42 def HexagonQFALSE:     SDNode<"HexagonISD::QFALSE",     SDTVecLeaf>;
43 def HexagonVPACKL:     SDNode<"HexagonISD::VPACKL",     SDTVecUnaryOp>;
44 def HexagonVUNPACK:    SDNode<"HexagonISD::VUNPACK",    SDTVecUnaryOp>;
45 def HexagonVUNPACKU:   SDNode<"HexagonISD::VUNPACKU",   SDTVecUnaryOp>;
46
47 def vzero:  PatFrag<(ops), (HexagonVZERO)>;
48 def qtrue:  PatFrag<(ops), (HexagonQTRUE)>;
49 def qfalse: PatFrag<(ops), (HexagonQFALSE)>;
50 def qcat:   PatFrag<(ops node:$Qs, node:$Qt),
51                     (HexagonQCAT node:$Qs, node:$Qt)>;
52
53 def qnot:     PatFrag<(ops node:$Qs), (xor node:$Qs, qtrue)>;
54 def vpackl:   PatFrag<(ops node:$Vs), (HexagonVPACKL node:$Vs)>;
55 def vunpack:  PatFrag<(ops node:$Vs), (HexagonVUNPACK node:$Vs)>;
56 def vunpacku: PatFrag<(ops node:$Vs), (HexagonVUNPACKU node:$Vs)>;
57
58 def VSxtb: OutPatFrag<(ops node:$Vs), (V6_vunpackb  $Vs)>;
59 def VSxth: OutPatFrag<(ops node:$Vs), (V6_vunpackh  $Vs)>;
60 def VZxtb: OutPatFrag<(ops node:$Vs), (V6_vunpackub $Vs)>;
61 def VZxth: OutPatFrag<(ops node:$Vs), (V6_vunpackuh $Vs)>;
62
63 def SplatB: SDNodeXForm<imm, [{
64   uint32_t V = N->getZExtValue();
65   assert(isUInt<8>(V));
66   uint32_t S = V << 24 | V << 16 | V << 8 | V;
67   return CurDAG->getTargetConstant(S, SDLoc(N), MVT::i32);
68 }]>;
69
70 def SplatH: SDNodeXForm<imm, [{
71   uint32_t V = N->getZExtValue();
72   assert(isUInt<16>(V));
73   return CurDAG->getTargetConstant(V << 16 | V, SDLoc(N), MVT::i32);
74 }]>;
75
76 def IsVecOff : PatLeaf<(i32 imm), [{
77   int32_t V = N->getSExtValue();
78   int32_t VecSize = HRI->getSpillSize(Hexagon::HvxVRRegClass);
79   assert(isPowerOf2_32(VecSize));
80   if ((uint32_t(V) & (uint32_t(VecSize)-1)) != 0)
81     return false;
82   int32_t L = Log2_32(VecSize);
83   return isInt<4>(V >> L);
84 }]>;
85
86
87 def alignedload: PatFrag<(ops node:$a), (load $a), [{
88   return isAlignedMemNode(dyn_cast<MemSDNode>(N));
89 }]>;
90
91 def unalignedload: PatFrag<(ops node:$a), (load $a), [{
92   return !isAlignedMemNode(dyn_cast<MemSDNode>(N));
93 }]>;
94
95 def alignedstore: PatFrag<(ops node:$v, node:$a), (store $v, $a), [{
96   return isAlignedMemNode(dyn_cast<MemSDNode>(N));
97 }]>;
98
99 def unalignedstore: PatFrag<(ops node:$v, node:$a), (store $v, $a), [{
100   return !isAlignedMemNode(dyn_cast<MemSDNode>(N));
101 }]>;
102
103
104 // HVX loads
105
106 multiclass HvxLd_pat<InstHexagon MI, PatFrag Load, ValueType ResType,
107                      PatFrag ImmPred> {
108   def: Pat<(ResType (Load I32:$Rt)),
109            (MI I32:$Rt, 0)>;
110   def: Pat<(ResType (Load (add I32:$Rt, ImmPred:$s))),
111            (MI I32:$Rt, imm:$s)>;
112   // The HVX selection code for shuffles can generate vector constants.
113   // Calling "Select" on the resulting loads from CP fails without these
114   // patterns.
115   def: Pat<(ResType (Load (HexagonCP tconstpool:$A))),
116            (MI (A2_tfrsi imm:$A), 0)>;
117   def: Pat<(ResType (Load (HexagonAtPcrel tconstpool:$A))),
118            (MI (C4_addipc imm:$A), 0)>;
119 }
120
121 multiclass HvxLda_pat<InstHexagon MI, PatFrag Load, ValueType ResType,
122                       PatFrag ImmPred> {
123   let AddedComplexity = 50 in {
124     def: Pat<(ResType (Load (valignaddr I32:$Rt))),
125              (MI I32:$Rt, 0)>;
126     def: Pat<(ResType (Load (add (valignaddr I32:$Rt), ImmPred:$Off))),
127              (MI I32:$Rt, imm:$Off)>;
128   }
129   defm: HvxLd_pat<MI, Load, ResType, ImmPred>;
130 }
131
132 let Predicates = [UseHVX] in {
133   defm: HvxLda_pat<V6_vL32b_nt_ai, alignednontemporalload, VecI8,  IsVecOff>;
134   defm: HvxLda_pat<V6_vL32b_nt_ai, alignednontemporalload, VecI16, IsVecOff>;
135   defm: HvxLda_pat<V6_vL32b_nt_ai, alignednontemporalload, VecI32, IsVecOff>;
136
137   defm: HvxLda_pat<V6_vL32b_ai, alignedload, VecI8,  IsVecOff>;
138   defm: HvxLda_pat<V6_vL32b_ai, alignedload, VecI16, IsVecOff>;
139   defm: HvxLda_pat<V6_vL32b_ai, alignedload, VecI32, IsVecOff>;
140
141   defm: HvxLd_pat<V6_vL32Ub_ai,  unalignedload, VecI8,  IsVecOff>;
142   defm: HvxLd_pat<V6_vL32Ub_ai,  unalignedload, VecI16, IsVecOff>;
143   defm: HvxLd_pat<V6_vL32Ub_ai,  unalignedload, VecI32, IsVecOff>;
144 }
145
146 // HVX stores
147
148 multiclass HvxSt_pat<InstHexagon MI, PatFrag Store, PatFrag ImmPred,
149                      PatFrag Value> {
150   def: Pat<(Store Value:$Vs, I32:$Rt),
151            (MI I32:$Rt, 0, Value:$Vs)>;
152   def: Pat<(Store Value:$Vs, (add I32:$Rt, ImmPred:$s)),
153            (MI I32:$Rt, imm:$s, Value:$Vs)>;
154 }
155
156 let Predicates = [UseHVX] in {
157   defm: HvxSt_pat<V6_vS32b_nt_ai, alignednontemporalstore, IsVecOff, HVI8>;
158   defm: HvxSt_pat<V6_vS32b_nt_ai, alignednontemporalstore, IsVecOff, HVI16>;
159   defm: HvxSt_pat<V6_vS32b_nt_ai, alignednontemporalstore, IsVecOff, HVI32>;
160
161   defm: HvxSt_pat<V6_vS32b_ai, alignedstore, IsVecOff, HVI8>;
162   defm: HvxSt_pat<V6_vS32b_ai, alignedstore, IsVecOff, HVI16>;
163   defm: HvxSt_pat<V6_vS32b_ai, alignedstore, IsVecOff, HVI32>;
164
165   defm: HvxSt_pat<V6_vS32Ub_ai, unalignedstore, IsVecOff, HVI8>;
166   defm: HvxSt_pat<V6_vS32Ub_ai, unalignedstore, IsVecOff, HVI16>;
167   defm: HvxSt_pat<V6_vS32Ub_ai, unalignedstore, IsVecOff, HVI32>;
168 }
169
170 // Bitcasts between same-size vector types are no-ops, except for the
171 // actual type change.
172 let Predicates = [UseHVX] in {
173   defm: NopCast_pat<VecI8,   VecI16,  HvxVR>;
174   defm: NopCast_pat<VecI8,   VecI32,  HvxVR>;
175   defm: NopCast_pat<VecI16,  VecI32,  HvxVR>;
176
177   defm: NopCast_pat<VecPI8,  VecPI16, HvxWR>;
178   defm: NopCast_pat<VecPI8,  VecPI32, HvxWR>;
179   defm: NopCast_pat<VecPI16, VecPI32, HvxWR>;
180 }
181
182 let Predicates = [UseHVX] in {
183   def: Pat<(VecI8   vzero), (V6_vd0)>;
184   def: Pat<(VecI16  vzero), (V6_vd0)>;
185   def: Pat<(VecI32  vzero), (V6_vd0)>;
186   def: Pat<(VecPI8  vzero), (PS_vdd0)>;
187   def: Pat<(VecPI16 vzero), (PS_vdd0)>;
188   def: Pat<(VecPI32 vzero), (PS_vdd0)>;
189
190   def: Pat<(concat_vectors  (VecI8 vzero),  (VecI8 vzero)), (PS_vdd0)>;
191   def: Pat<(concat_vectors (VecI16 vzero), (VecI16 vzero)), (PS_vdd0)>;
192   def: Pat<(concat_vectors (VecI32 vzero), (VecI32 vzero)), (PS_vdd0)>;
193
194   def: Pat<(VecPI8 (concat_vectors HVI8:$Vs, HVI8:$Vt)),
195            (Combinev HvxVR:$Vt, HvxVR:$Vs)>;
196   def: Pat<(VecPI16 (concat_vectors HVI16:$Vs, HVI16:$Vt)),
197            (Combinev HvxVR:$Vt, HvxVR:$Vs)>;
198   def: Pat<(VecPI32 (concat_vectors HVI32:$Vs, HVI32:$Vt)),
199            (Combinev HvxVR:$Vt, HvxVR:$Vs)>;
200
201   def: Pat<(VecQ8  (qcat HQ16:$Qs, HQ16:$Qt)), (Combineq $Qt, $Qs)>;
202   def: Pat<(VecQ16 (qcat HQ32:$Qs, HQ32:$Qt)), (Combineq $Qt, $Qs)>;
203
204   def: Pat<(HexagonVEXTRACTW HVI8:$Vu, I32:$Rs),
205            (V6_extractw HvxVR:$Vu, I32:$Rs)>;
206   def: Pat<(HexagonVEXTRACTW HVI16:$Vu, I32:$Rs),
207            (V6_extractw HvxVR:$Vu, I32:$Rs)>;
208   def: Pat<(HexagonVEXTRACTW HVI32:$Vu, I32:$Rs),
209            (V6_extractw HvxVR:$Vu, I32:$Rs)>;
210
211   def: Pat<(HexagonVINSERTW0 HVI8:$Vu,  I32:$Rt),
212            (V6_vinsertwr HvxVR:$Vu, I32:$Rt)>;
213   def: Pat<(HexagonVINSERTW0 HVI16:$Vu, I32:$Rt),
214            (V6_vinsertwr HvxVR:$Vu, I32:$Rt)>;
215   def: Pat<(HexagonVINSERTW0 HVI32:$Vu, I32:$Rt),
216            (V6_vinsertwr HvxVR:$Vu, I32:$Rt)>;
217 }
218
219 def Vsplatib: OutPatFrag<(ops node:$V),  (V6_lvsplatw (ToI32 (SplatB $V)))>;
220 def Vsplatih: OutPatFrag<(ops node:$V),  (V6_lvsplatw (ToI32 (SplatH $V)))>;
221 def Vsplatiw: OutPatFrag<(ops node:$V),  (V6_lvsplatw (ToI32 $V))>;
222
223 def Vsplatrb: OutPatFrag<(ops node:$Rs), (V6_lvsplatw (S2_vsplatrb $Rs))>;
224 def Vsplatrh: OutPatFrag<(ops node:$Rs),
225                          (V6_lvsplatw (A2_combine_ll $Rs, $Rs))>;
226 def Vsplatrw: OutPatFrag<(ops node:$Rs), (V6_lvsplatw $Rs)>;
227
228 def Rep: OutPatFrag<(ops node:$N), (Combinev $N, $N)>;
229
230 let Predicates = [UseHVX] in {
231   let AddedComplexity = 10 in {
232     def: Pat<(VecI8   (HexagonVSPLAT u8_0ImmPred:$V)),  (Vsplatib $V)>;
233     def: Pat<(VecI16  (HexagonVSPLAT u16_0ImmPred:$V)), (Vsplatih $V)>;
234     def: Pat<(VecI32  (HexagonVSPLAT anyimm:$V)),       (Vsplatiw $V)>;
235     def: Pat<(VecPI8  (HexagonVSPLAT u8_0ImmPred:$V)),  (Rep (Vsplatib $V))>;
236     def: Pat<(VecPI16 (HexagonVSPLAT u16_0ImmPred:$V)), (Rep (Vsplatih $V))>;
237     def: Pat<(VecPI32 (HexagonVSPLAT anyimm:$V)),       (Rep (Vsplatiw $V))>;
238   }
239   def: Pat<(VecI8   (HexagonVSPLAT I32:$Rs)), (Vsplatrb $Rs)>;
240   def: Pat<(VecI16  (HexagonVSPLAT I32:$Rs)), (Vsplatrh $Rs)>;
241   def: Pat<(VecI32  (HexagonVSPLAT I32:$Rs)), (Vsplatrw $Rs)>;
242   def: Pat<(VecPI8  (HexagonVSPLAT I32:$Rs)), (Rep (Vsplatrb $Rs))>;
243   def: Pat<(VecPI16 (HexagonVSPLAT I32:$Rs)), (Rep (Vsplatrh $Rs))>;
244   def: Pat<(VecPI32 (HexagonVSPLAT I32:$Rs)), (Rep (Vsplatrw $Rs))>;
245
246   def: Pat<(VecI8   (HexagonVSPLATW I32:$Rs)), (Vsplatrw $Rs)>;
247   def: Pat<(VecI16  (HexagonVSPLATW I32:$Rs)), (Vsplatrw $Rs)>;
248   def: Pat<(VecI32  (HexagonVSPLATW I32:$Rs)), (Vsplatrw $Rs)>;
249   def: Pat<(VecPI8  (HexagonVSPLATW I32:$Rs)), (Rep (Vsplatrw $Rs))>;
250   def: Pat<(VecPI16 (HexagonVSPLATW I32:$Rs)), (Rep (Vsplatrw $Rs))>;
251   def: Pat<(VecPI32 (HexagonVSPLATW I32:$Rs)), (Rep (Vsplatrw $Rs))>;
252 }
253
254 class Vneg1<ValueType VecTy>
255   : PatFrag<(ops), (VecTy (HexagonVSPLATW (i32 -1)))>;
256
257 class Vnot<ValueType VecTy>
258   : PatFrag<(ops node:$Vs), (xor $Vs, Vneg1<VecTy>)>;
259
260 let Predicates = [UseHVX] in {
261   let AddedComplexity = 220 in {
262     defm: MinMax_pats<V6_vminb,  V6_vmaxb,  vselect,  setgt,  VecQ8,  HVI8>;
263     defm: MinMax_pats<V6_vminb,  V6_vmaxb,  vselect,  setge,  VecQ8,  HVI8>;
264     defm: MinMax_pats<V6_vminub, V6_vmaxub, vselect, setugt,  VecQ8,  HVI8>;
265     defm: MinMax_pats<V6_vminub, V6_vmaxub, vselect, setuge,  VecQ8,  HVI8>;
266     defm: MinMax_pats<V6_vminh,  V6_vmaxh,  vselect,  setgt, VecQ16, HVI16>;
267     defm: MinMax_pats<V6_vminh,  V6_vmaxh,  vselect,  setge, VecQ16, HVI16>;
268     defm: MinMax_pats<V6_vminuh, V6_vmaxuh, vselect, setugt, VecQ16, HVI16>;
269     defm: MinMax_pats<V6_vminuh, V6_vmaxuh, vselect, setuge, VecQ16, HVI16>;
270     defm: MinMax_pats<V6_vminw,  V6_vmaxw,  vselect,  setgt, VecQ32, HVI32>;
271     defm: MinMax_pats<V6_vminw,  V6_vmaxw,  vselect,  setge, VecQ32, HVI32>;
272   }
273 }
274
275 let Predicates = [UseHVX] in {
276   let AddedComplexity = 200 in {
277     def: Pat<(Vnot<VecI8>   HVI8:$Vs), (V6_vnot HvxVR:$Vs)>;
278     def: Pat<(Vnot<VecI16> HVI16:$Vs), (V6_vnot HvxVR:$Vs)>;
279     def: Pat<(Vnot<VecI32> HVI32:$Vs), (V6_vnot HvxVR:$Vs)>;
280   }
281
282   def: OpR_RR_pat<V6_vaddb,    Add,   VecI8,  HVI8>;
283   def: OpR_RR_pat<V6_vaddh,    Add,  VecI16, HVI16>;
284   def: OpR_RR_pat<V6_vaddw,    Add,  VecI32, HVI32>;
285   def: OpR_RR_pat<V6_vaddb_dv, Add,  VecPI8,  HWI8>;
286   def: OpR_RR_pat<V6_vaddh_dv, Add, VecPI16, HWI16>;
287   def: OpR_RR_pat<V6_vaddw_dv, Add, VecPI32, HWI32>;
288   def: OpR_RR_pat<V6_vsubb,    Sub,   VecI8,  HVI8>;
289   def: OpR_RR_pat<V6_vsubh,    Sub,  VecI16, HVI16>;
290   def: OpR_RR_pat<V6_vsubw,    Sub,  VecI32, HVI32>;
291   def: OpR_RR_pat<V6_vsubb_dv, Sub,  VecPI8,  HWI8>;
292   def: OpR_RR_pat<V6_vsubh_dv, Sub, VecPI16, HWI16>;
293   def: OpR_RR_pat<V6_vsubw_dv, Sub, VecPI32, HWI32>;
294   def: OpR_RR_pat<V6_vand,     And,   VecI8,  HVI8>;
295   def: OpR_RR_pat<V6_vand,     And,  VecI16, HVI16>;
296   def: OpR_RR_pat<V6_vand,     And,  VecI32, HVI32>;
297   def: OpR_RR_pat<V6_vor,       Or,   VecI8,  HVI8>;
298   def: OpR_RR_pat<V6_vor,       Or,  VecI16, HVI16>;
299   def: OpR_RR_pat<V6_vor,       Or,  VecI32, HVI32>;
300   def: OpR_RR_pat<V6_vxor,     Xor,   VecI8,  HVI8>;
301   def: OpR_RR_pat<V6_vxor,     Xor,  VecI16, HVI16>;
302   def: OpR_RR_pat<V6_vxor,     Xor,  VecI32, HVI32>;
303
304   def: Pat<(vselect HQ8:$Qu, HVI8:$Vs, HVI8:$Vt),
305            (V6_vmux HvxQR:$Qu, HvxVR:$Vs, HvxVR:$Vt)>;
306   def: Pat<(vselect HQ16:$Qu, HVI16:$Vs, HVI16:$Vt),
307            (V6_vmux HvxQR:$Qu, HvxVR:$Vs, HvxVR:$Vt)>;
308   def: Pat<(vselect HQ32:$Qu, HVI32:$Vs, HVI32:$Vt),
309            (V6_vmux HvxQR:$Qu, HvxVR:$Vs, HvxVR:$Vt)>;
310
311   def: Pat<(vselect (qnot HQ8:$Qu), HVI8:$Vs, HVI8:$Vt),
312            (V6_vmux HvxQR:$Qu, HvxVR:$Vt, HvxVR:$Vs)>;
313   def: Pat<(vselect (qnot HQ16:$Qu), HVI16:$Vs, HVI16:$Vt),
314            (V6_vmux HvxQR:$Qu, HvxVR:$Vt, HvxVR:$Vs)>;
315   def: Pat<(vselect (qnot HQ32:$Qu), HVI32:$Vs, HVI32:$Vt),
316            (V6_vmux HvxQR:$Qu, HvxVR:$Vt, HvxVR:$Vs)>;
317 }
318
319 let Predicates = [UseHVX] in {
320   def: Pat<(VecPI16 (sext HVI8:$Vs)),  (VSxtb $Vs)>;
321   def: Pat<(VecPI32 (sext HVI16:$Vs)), (VSxth $Vs)>;
322   def: Pat<(VecPI16 (zext HVI8:$Vs)),  (VZxtb $Vs)>;
323   def: Pat<(VecPI32 (zext HVI16:$Vs)), (VZxth $Vs)>;
324
325   def: Pat<(VecI16 (sext_invec HVI8:$Vs)),  (LoVec (VSxtb $Vs))>;
326   def: Pat<(VecI32 (sext_invec HVI16:$Vs)), (LoVec (VSxth $Vs))>;
327   def: Pat<(VecI32 (sext_invec HVI8:$Vs)),
328            (LoVec (VSxth (LoVec (VSxtb $Vs))))>;
329   def: Pat<(VecPI16 (sext_invec HWI8:$Vss)),  (VSxtb (LoVec $Vss))>;
330   def: Pat<(VecPI32 (sext_invec HWI16:$Vss)), (VSxth (LoVec $Vss))>;
331   def: Pat<(VecPI32 (sext_invec HWI8:$Vss)),
332            (VSxth (LoVec (VSxtb (LoVec $Vss))))>;
333
334   def: Pat<(VecI16 (zext_invec HVI8:$Vs)),  (LoVec (VZxtb $Vs))>;
335   def: Pat<(VecI32 (zext_invec HVI16:$Vs)), (LoVec (VZxth $Vs))>;
336   def: Pat<(VecI32 (zext_invec HVI8:$Vs)),
337            (LoVec (VZxth (LoVec (VZxtb $Vs))))>;
338   def: Pat<(VecPI16 (zext_invec HWI8:$Vss)),  (VZxtb (LoVec $Vss))>;
339   def: Pat<(VecPI32 (zext_invec HWI16:$Vss)), (VZxth (LoVec $Vss))>;
340   def: Pat<(VecPI32 (zext_invec HWI8:$Vss)),
341            (VZxth (LoVec (VZxtb (LoVec $Vss))))>;
342
343   def: Pat<(VecI8 (trunc HWI16:$Vss)),
344            (V6_vpackeb (HiVec $Vss), (LoVec $Vss))>;
345   def: Pat<(VecI16 (trunc HWI32:$Vss)),
346            (V6_vpackeh (HiVec $Vss), (LoVec $Vss))>;
347
348   def: Pat<(VecQ8 (trunc HVI8:$Vs)),
349            (V6_vandvrt HvxVR:$Vs, (A2_tfrsi 0x01010101))>;
350   def: Pat<(VecQ16 (trunc HVI16:$Vs)),
351            (V6_vandvrt HvxVR:$Vs, (A2_tfrsi 0x01010101))>;
352   def: Pat<(VecQ32 (trunc HVI32:$Vs)),
353            (V6_vandvrt HvxVR:$Vs, (A2_tfrsi 0x01010101))>;
354 }
355
356 let Predicates = [UseHVX] in {
357   // The "source" types are not legal, and there are no parameterized
358   // definitions for them, but they are length-specific.
359   let Predicates = [UseHVX,UseHVX64B] in {
360     def: Pat<(VecI16 (sext_inreg HVI16:$Vs, v32i8)),
361              (V6_vasrh (V6_vaslh HVI16:$Vs, (A2_tfrsi 8)), (A2_tfrsi 8))>;
362     def: Pat<(VecI32 (sext_inreg HVI32:$Vs, v16i8)),
363              (V6_vasrw (V6_vaslw HVI32:$Vs, (A2_tfrsi 24)), (A2_tfrsi 24))>;
364     def: Pat<(VecI32 (sext_inreg HVI32:$Vs, v16i16)),
365              (V6_vasrw (V6_vaslw HVI32:$Vs, (A2_tfrsi 16)), (A2_tfrsi 16))>;
366   }
367   let Predicates = [UseHVX,UseHVX128B] in {
368     def: Pat<(VecI16 (sext_inreg HVI16:$Vs, v64i8)),
369              (V6_vasrh (V6_vaslh HVI16:$Vs, (A2_tfrsi 8)), (A2_tfrsi 8))>;
370     def: Pat<(VecI32 (sext_inreg HVI32:$Vs, v32i8)),
371              (V6_vasrw (V6_vaslw HVI32:$Vs, (A2_tfrsi 24)), (A2_tfrsi 24))>;
372     def: Pat<(VecI32 (sext_inreg HVI32:$Vs, v32i16)),
373              (V6_vasrw (V6_vaslw HVI32:$Vs, (A2_tfrsi 16)), (A2_tfrsi 16))>;
374   }
375
376   // Take a pair of vectors Vt:Vs and shift them towards LSB by (Rt & HwLen).
377   def: Pat<(VecI8 (valign HVI8:$Vt, HVI8:$Vs, I32:$Rt)),
378            (LoVec (V6_valignb HvxVR:$Vt, HvxVR:$Vs, I32:$Rt))>;
379   def: Pat<(VecI16 (valign HVI16:$Vt, HVI16:$Vs, I32:$Rt)),
380            (LoVec (V6_valignb HvxVR:$Vt, HvxVR:$Vs, I32:$Rt))>;
381   def: Pat<(VecI32 (valign HVI32:$Vt, HVI32:$Vs, I32:$Rt)),
382            (LoVec (V6_valignb HvxVR:$Vt, HvxVR:$Vs, I32:$Rt))>;
383
384   def: Pat<(HexagonVASL HVI8:$Vs, I32:$Rt),
385            (V6_vpackeb (V6_vaslh (HiVec (VZxtb HvxVR:$Vs)), I32:$Rt),
386                        (V6_vaslh (LoVec (VZxtb HvxVR:$Vs)), I32:$Rt))>;
387   def: Pat<(HexagonVASR HVI8:$Vs, I32:$Rt),
388            (V6_vpackeb (V6_vasrh (HiVec (VSxtb HvxVR:$Vs)), I32:$Rt),
389                        (V6_vasrh (LoVec (VSxtb HvxVR:$Vs)), I32:$Rt))>;
390   def: Pat<(HexagonVLSR HVI8:$Vs, I32:$Rt),
391            (V6_vpackeb (V6_vlsrh (HiVec (VZxtb HvxVR:$Vs)), I32:$Rt),
392                        (V6_vlsrh (LoVec (VZxtb HvxVR:$Vs)), I32:$Rt))>;
393
394   def: Pat<(HexagonVASL HVI16:$Vs, I32:$Rt), (V6_vaslh HvxVR:$Vs, I32:$Rt)>;
395   def: Pat<(HexagonVASL HVI32:$Vs, I32:$Rt), (V6_vaslw HvxVR:$Vs, I32:$Rt)>;
396   def: Pat<(HexagonVASR HVI16:$Vs, I32:$Rt), (V6_vasrh HvxVR:$Vs, I32:$Rt)>;
397   def: Pat<(HexagonVASR HVI32:$Vs, I32:$Rt), (V6_vasrw HvxVR:$Vs, I32:$Rt)>;
398   def: Pat<(HexagonVLSR HVI16:$Vs, I32:$Rt), (V6_vlsrh HvxVR:$Vs, I32:$Rt)>;
399   def: Pat<(HexagonVLSR HVI32:$Vs, I32:$Rt), (V6_vlsrw HvxVR:$Vs, I32:$Rt)>;
400
401   def: Pat<(add HVI32:$Vx, (HexagonVASL HVI32:$Vu, I32:$Rt)),
402            (V6_vaslw_acc HvxVR:$Vx, HvxVR:$Vu, I32:$Rt)>;
403   def: Pat<(add HVI32:$Vx, (HexagonVASR HVI32:$Vu, I32:$Rt)),
404            (V6_vasrw_acc HvxVR:$Vx, HvxVR:$Vu, I32:$Rt)>;
405
406   def: Pat<(shl HVI16:$Vs, HVI16:$Vt), (V6_vaslhv HvxVR:$Vs, HvxVR:$Vt)>;
407   def: Pat<(shl HVI32:$Vs, HVI32:$Vt), (V6_vaslwv HvxVR:$Vs, HvxVR:$Vt)>;
408   def: Pat<(sra HVI16:$Vs, HVI16:$Vt), (V6_vasrhv HvxVR:$Vs, HvxVR:$Vt)>;
409   def: Pat<(sra HVI32:$Vs, HVI32:$Vt), (V6_vasrwv HvxVR:$Vs, HvxVR:$Vt)>;
410   def: Pat<(srl HVI16:$Vs, HVI16:$Vt), (V6_vlsrhv HvxVR:$Vs, HvxVR:$Vt)>;
411   def: Pat<(srl HVI32:$Vs, HVI32:$Vt), (V6_vlsrwv HvxVR:$Vs, HvxVR:$Vt)>;
412
413   // Vpackl is a pseudo-op that is used when legalizing widened truncates.
414   // It should never be produced with a register pair in the output, but
415   // it can happen to have a pair as an input.
416   def: Pat<(VecI8  (vpackl HVI16:$Vs)), (V6_vdealb HvxVR:$Vs)>;
417   def: Pat<(VecI8  (vpackl HVI32:$Vs)), (V6_vdealb4w (IMPLICIT_DEF), HvxVR:$Vs)>;
418   def: Pat<(VecI16 (vpackl HVI32:$Vs)), (V6_vdealh HvxVR:$Vs)>;
419   def: Pat<(VecI8  (vpackl HWI16:$Vs)), (V6_vpackeb (HiVec $Vs), (LoVec $Vs))>;
420   def: Pat<(VecI8  (vpackl HWI32:$Vs)),
421            (V6_vpackeb (IMPLICIT_DEF), (V6_vpackeh (HiVec $Vs), (LoVec $Vs)))>;
422   def: Pat<(VecI16 (vpackl HWI32:$Vs)), (V6_vpackeh (HiVec $Vs), (LoVec $Vs))>;
423
424   def: Pat<(VecI16  (vunpack   HVI8:$Vs)), (LoVec (VSxtb $Vs))>;
425   def: Pat<(VecI32  (vunpack   HVI8:$Vs)), (LoVec (VSxth (LoVec (VSxtb $Vs))))>;
426   def: Pat<(VecI32  (vunpack  HVI16:$Vs)), (LoVec (VSxth $Vs))>;
427   def: Pat<(VecPI16 (vunpack   HVI8:$Vs)), (VSxtb $Vs)>;
428   def: Pat<(VecPI32 (vunpack   HVI8:$Vs)), (VSxth (LoVec (VSxtb $Vs)))>;
429   def: Pat<(VecPI32 (vunpack  HVI32:$Vs)), (VSxth $Vs)>;
430
431   def: Pat<(VecI16  (vunpacku  HVI8:$Vs)), (LoVec (VZxtb $Vs))>;
432   def: Pat<(VecI32  (vunpacku  HVI8:$Vs)), (LoVec (VZxth (LoVec (VZxtb $Vs))))>;
433   def: Pat<(VecI32  (vunpacku HVI16:$Vs)), (LoVec (VZxth $Vs))>;
434   def: Pat<(VecPI16 (vunpacku  HVI8:$Vs)), (VZxtb $Vs)>;
435   def: Pat<(VecPI32 (vunpacku  HVI8:$Vs)), (VZxth (LoVec (VZxtb $Vs)))>;
436   def: Pat<(VecPI32 (vunpacku HVI32:$Vs)), (VZxth $Vs)>;
437
438   def: Pat<(VecI16 (bswap HVI16:$Vs)),
439            (V6_vdelta HvxVR:$Vs, (V6_lvsplatw (A2_tfrsi 0x01010101)))>;
440   def: Pat<(VecI32 (bswap HVI32:$Vs)),
441            (V6_vdelta HvxVR:$Vs, (V6_lvsplatw (A2_tfrsi 0x03030303)))>;
442
443   def: Pat<(VecI8 (ctpop HVI8:$Vs)),
444            (V6_vpackeb (V6_vpopcounth (HiVec (V6_vunpackub HvxVR:$Vs))),
445                        (V6_vpopcounth (LoVec (V6_vunpackub HvxVR:$Vs))))>;
446   def: Pat<(VecI16 (ctpop HVI16:$Vs)), (V6_vpopcounth HvxVR:$Vs)>;
447   def: Pat<(VecI32 (ctpop HVI32:$Vs)),
448            (V6_vaddw (LoVec (V6_vzh (V6_vpopcounth HvxVR:$Vs))),
449                      (HiVec (V6_vzh (V6_vpopcounth HvxVR:$Vs))))>;
450
451   def: Pat<(VecI8 (ctlz HVI8:$Vs)),
452            (V6_vsubb (V6_vpackeb (V6_vcl0h (HiVec (V6_vunpackub HvxVR:$Vs))),
453                                  (V6_vcl0h (LoVec (V6_vunpackub HvxVR:$Vs)))),
454                      (V6_lvsplatw (A2_tfrsi 0x08080808)))>;
455   def: Pat<(VecI16 (ctlz HVI16:$Vs)), (V6_vcl0h HvxVR:$Vs)>;
456   def: Pat<(VecI32 (ctlz HVI32:$Vs)), (V6_vcl0w HvxVR:$Vs)>;
457 }
458
459 class HvxSel_pat<InstHexagon MI, PatFrag RegPred>
460   : Pat<(select I1:$Pu, RegPred:$Vs, RegPred:$Vt),
461         (MI I1:$Pu, RegPred:$Vs, RegPred:$Vt)>;
462
463 let Predicates = [UseHVX] in {
464   def: HvxSel_pat<PS_vselect, HVI8>;
465   def: HvxSel_pat<PS_vselect, HVI16>;
466   def: HvxSel_pat<PS_vselect, HVI32>;
467   def: HvxSel_pat<PS_wselect, HWI8>;
468   def: HvxSel_pat<PS_wselect, HWI16>;
469   def: HvxSel_pat<PS_wselect, HWI32>;
470 }
471
472 let Predicates = [UseHVX] in {
473   def: Pat<(VecQ8   (qtrue)), (PS_qtrue)>;
474   def: Pat<(VecQ16  (qtrue)), (PS_qtrue)>;
475   def: Pat<(VecQ32  (qtrue)), (PS_qtrue)>;
476   def: Pat<(VecQ8  (qfalse)), (PS_qfalse)>;
477   def: Pat<(VecQ16 (qfalse)), (PS_qfalse)>;
478   def: Pat<(VecQ32 (qfalse)), (PS_qfalse)>;
479
480   def: Pat<(vnot  HQ8:$Qs), (V6_pred_not HvxQR:$Qs)>;
481   def: Pat<(vnot HQ16:$Qs), (V6_pred_not HvxQR:$Qs)>;
482   def: Pat<(vnot HQ32:$Qs), (V6_pred_not HvxQR:$Qs)>;
483   def: Pat<(qnot  HQ8:$Qs), (V6_pred_not HvxQR:$Qs)>;
484   def: Pat<(qnot HQ16:$Qs), (V6_pred_not HvxQR:$Qs)>;
485   def: Pat<(qnot HQ32:$Qs), (V6_pred_not HvxQR:$Qs)>;
486
487   def: OpR_RR_pat<V6_pred_and,         And,  VecQ8,   HQ8>;
488   def: OpR_RR_pat<V6_pred_and,         And, VecQ16,  HQ16>;
489   def: OpR_RR_pat<V6_pred_and,         And, VecQ32,  HQ32>;
490   def: OpR_RR_pat<V6_pred_or,           Or,  VecQ8,   HQ8>;
491   def: OpR_RR_pat<V6_pred_or,           Or, VecQ16,  HQ16>;
492   def: OpR_RR_pat<V6_pred_or,           Or, VecQ32,  HQ32>;
493   def: OpR_RR_pat<V6_pred_xor,         Xor,  VecQ8,   HQ8>;
494   def: OpR_RR_pat<V6_pred_xor,         Xor, VecQ16,  HQ16>;
495   def: OpR_RR_pat<V6_pred_xor,         Xor, VecQ32,  HQ32>;
496
497   def: OpR_RR_pat<V6_pred_and_n, Not2<And>,  VecQ8,   HQ8>;
498   def: OpR_RR_pat<V6_pred_and_n, Not2<And>, VecQ16,  HQ16>;
499   def: OpR_RR_pat<V6_pred_and_n, Not2<And>, VecQ32,  HQ32>;
500   def: OpR_RR_pat<V6_pred_or_n,   Not2<Or>,  VecQ8,   HQ8>;
501   def: OpR_RR_pat<V6_pred_or_n,   Not2<Or>, VecQ16,  HQ16>;
502   def: OpR_RR_pat<V6_pred_or_n,   Not2<Or>, VecQ32,  HQ32>;
503
504   def: OpR_RR_pat<V6_veqb,              seteq,  VecQ8,  HVI8>;
505   def: OpR_RR_pat<V6_veqh,              seteq, VecQ16, HVI16>;
506   def: OpR_RR_pat<V6_veqw,              seteq, VecQ32, HVI32>;
507   def: OpR_RR_pat<V6_vgtb,              setgt,  VecQ8,  HVI8>;
508   def: OpR_RR_pat<V6_vgth,              setgt, VecQ16, HVI16>;
509   def: OpR_RR_pat<V6_vgtw,              setgt, VecQ32, HVI32>;
510   def: OpR_RR_pat<V6_vgtub,            setugt,  VecQ8,  HVI8>;
511   def: OpR_RR_pat<V6_vgtuh,            setugt, VecQ16, HVI16>;
512   def: OpR_RR_pat<V6_vgtuw,            setugt, VecQ32, HVI32>;
513
514   def: AccRRR_pat<V6_veqb_and,    And,  seteq,    HQ8,  HVI8,  HVI8>;
515   def: AccRRR_pat<V6_veqb_or,      Or,  seteq,    HQ8,  HVI8,  HVI8>;
516   def: AccRRR_pat<V6_veqb_xor,    Xor,  seteq,    HQ8,  HVI8,  HVI8>;
517   def: AccRRR_pat<V6_veqh_and,    And,  seteq,   HQ16, HVI16, HVI16>;
518   def: AccRRR_pat<V6_veqh_or,      Or,  seteq,   HQ16, HVI16, HVI16>;
519   def: AccRRR_pat<V6_veqh_xor,    Xor,  seteq,   HQ16, HVI16, HVI16>;
520   def: AccRRR_pat<V6_veqw_and,    And,  seteq,   HQ32, HVI32, HVI32>;
521   def: AccRRR_pat<V6_veqw_or,      Or,  seteq,   HQ32, HVI32, HVI32>;
522   def: AccRRR_pat<V6_veqw_xor,    Xor,  seteq,   HQ32, HVI32, HVI32>;
523
524   def: AccRRR_pat<V6_vgtb_and,    And,  setgt,    HQ8,  HVI8,  HVI8>;
525   def: AccRRR_pat<V6_vgtb_or,      Or,  setgt,    HQ8,  HVI8,  HVI8>;
526   def: AccRRR_pat<V6_vgtb_xor,    Xor,  setgt,    HQ8,  HVI8,  HVI8>;
527   def: AccRRR_pat<V6_vgth_and,    And,  setgt,   HQ16, HVI16, HVI16>;
528   def: AccRRR_pat<V6_vgth_or,      Or,  setgt,   HQ16, HVI16, HVI16>;
529   def: AccRRR_pat<V6_vgth_xor,    Xor,  setgt,   HQ16, HVI16, HVI16>;
530   def: AccRRR_pat<V6_vgtw_and,    And,  setgt,   HQ32, HVI32, HVI32>;
531   def: AccRRR_pat<V6_vgtw_or,      Or,  setgt,   HQ32, HVI32, HVI32>;
532   def: AccRRR_pat<V6_vgtw_xor,    Xor,  setgt,   HQ32, HVI32, HVI32>;
533
534   def: AccRRR_pat<V6_vgtub_and,   And, setugt,    HQ8,  HVI8,  HVI8>;
535   def: AccRRR_pat<V6_vgtub_or,     Or, setugt,    HQ8,  HVI8,  HVI8>;
536   def: AccRRR_pat<V6_vgtub_xor,   Xor, setugt,    HQ8,  HVI8,  HVI8>;
537   def: AccRRR_pat<V6_vgtuh_and,   And, setugt,   HQ16, HVI16, HVI16>;
538   def: AccRRR_pat<V6_vgtuh_or,     Or, setugt,   HQ16, HVI16, HVI16>;
539   def: AccRRR_pat<V6_vgtuh_xor,   Xor, setugt,   HQ16, HVI16, HVI16>;
540   def: AccRRR_pat<V6_vgtuw_and,   And, setugt,   HQ32, HVI32, HVI32>;
541   def: AccRRR_pat<V6_vgtuw_or,     Or, setugt,   HQ32, HVI32, HVI32>;
542   def: AccRRR_pat<V6_vgtuw_xor,   Xor, setugt,   HQ32, HVI32, HVI32>;
543 }