OSDN Git Service

gcc/
[pf3gnuchains/gcc-fork.git] / gcc / config / arm / neon.md
1 ;; ARM NEON coprocessor Machine Description
2 ;; Copyright (C) 2006 Free Software Foundation, Inc.
3 ;; Written by CodeSourcery.
4 ;;
5 ;; This file is part of GCC.
6 ;;
7 ;; GCC is free software; you can redistribute it and/or modify it
8 ;; under the terms of the GNU General Public License as published by
9 ;; the Free Software Foundation; either version 2, or (at your option)
10 ;; any later version.
11 ;;
12 ;; GCC is distributed in the hope that it will be useful, but
13 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
14 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 ;; General Public License for more details.
16 ;;
17 ;; You should have received a copy of the GNU General Public License
18 ;; along with GCC; see the file COPYING.  If not, write to the Free
19 ;; Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
20 ;; 02110-1301, USA.
21
22 ;; Constants for unspecs.
23 (define_constants
24   [(UNSPEC_ASHIFT_SIGNED        65)
25    (UNSPEC_ASHIFT_UNSIGNED      66)
26    (UNSPEC_VABA                 67)
27    (UNSPEC_VABAL                68)
28    (UNSPEC_VABD                 69)
29    (UNSPEC_VABDL                70)
30    (UNSPEC_VABS                 71)
31    (UNSPEC_VADD                 72)
32    (UNSPEC_VADDHN               73)
33    (UNSPEC_VADDL                74)
34    (UNSPEC_VADDW                75)
35    (UNSPEC_VAND                 76)
36    (UNSPEC_VBIC                 77)
37    (UNSPEC_VBSL                 78)
38    (UNSPEC_VCAGE                79)
39    (UNSPEC_VCAGT                80)
40    (UNSPEC_VCEQ                 81)
41    (UNSPEC_VCGE                 82)
42    (UNSPEC_VCGT                 83)
43    (UNSPEC_VCLS                 84)
44    (UNSPEC_VCLZ                 85)
45    (UNSPEC_VCNT                 86)
46    (UNSPEC_VCOMBINE             87)
47    (UNSPEC_VCVT                 88)
48    (UNSPEC_VCVT_N               89)
49    (UNSPEC_VDUP_LANE            90)
50    (UNSPEC_VDUP_N               91)
51    (UNSPEC_VEOR                 92)
52    (UNSPEC_VEXT                 93)
53    (UNSPEC_VGET_HIGH            94)
54    (UNSPEC_VGET_LANE            95)
55    (UNSPEC_VGET_LOW             96)
56    (UNSPEC_VHADD                97)
57    (UNSPEC_VHSUB                98)
58    (UNSPEC_VLD1                 99)
59    (UNSPEC_VLD1_DUP             100)
60    (UNSPEC_VLD1_LANE            101)
61    (UNSPEC_VLD2                 102)
62    (UNSPEC_VLD2_DUP             103)
63    (UNSPEC_VLD2_LANE            104)
64    (UNSPEC_VLD3                 105)
65    (UNSPEC_VLD3A                106)
66    (UNSPEC_VLD3B                107)
67    (UNSPEC_VLD3_DUP             108)
68    (UNSPEC_VLD3_LANE            109)
69    (UNSPEC_VLD4                 110)
70    (UNSPEC_VLD4A                111)
71    (UNSPEC_VLD4B                112)
72    (UNSPEC_VLD4_DUP             113)
73    (UNSPEC_VLD4_LANE            114)
74    (UNSPEC_VMAX                 115)
75    (UNSPEC_VMIN                 116)
76    (UNSPEC_VMLA                 117)
77    (UNSPEC_VMLAL                118)
78    (UNSPEC_VMLA_LANE            119)
79    (UNSPEC_VMLAL_LANE           120)
80    (UNSPEC_VMLS                 121)
81    (UNSPEC_VMLSL                122)
82    (UNSPEC_VMLS_LANE            123)
83    (UNSPEC_VMLSL_LANE           124)
84    (UNSPEC_VMOVL                125)
85    (UNSPEC_VMOVN                126)
86    (UNSPEC_VMUL                 127)
87    (UNSPEC_VMULL                128)
88    (UNSPEC_VMUL_LANE            129)
89    (UNSPEC_VMULL_LANE           130)
90    (UNSPEC_VMUL_N               131)
91    (UNSPEC_VMVN                 132)
92    (UNSPEC_VORN                 133)
93    (UNSPEC_VORR                 134)
94    (UNSPEC_VPADAL               135)
95    (UNSPEC_VPADD                136)
96    (UNSPEC_VPADDL               137)
97    (UNSPEC_VPMAX                138)
98    (UNSPEC_VPMIN                139)
99    (UNSPEC_VPSMAX               140)
100    (UNSPEC_VPSMIN               141)
101    (UNSPEC_VPUMAX               142)
102    (UNSPEC_VPUMIN               143)
103    (UNSPEC_VQABS                144)
104    (UNSPEC_VQADD                145)
105    (UNSPEC_VQDMLAL              146)
106    (UNSPEC_VQDMLAL_LANE         147)
107    (UNSPEC_VQDMLSL              148)
108    (UNSPEC_VQDMLSL_LANE         149)
109    (UNSPEC_VQDMULH              150)
110    (UNSPEC_VQDMULH_LANE         151)
111    (UNSPEC_VQDMULL              152)
112    (UNSPEC_VQDMULL_LANE         153)
113    (UNSPEC_VQMOVN               154)
114    (UNSPEC_VQMOVUN              155)
115    (UNSPEC_VQNEG                156)
116    (UNSPEC_VQSHL                157)
117    (UNSPEC_VQSHL_N              158)
118    (UNSPEC_VQSHLU_N             159)
119    (UNSPEC_VQSHRN_N             160)
120    (UNSPEC_VQSHRUN_N            161)
121    (UNSPEC_VQSUB                162)
122    (UNSPEC_VRECPE               163)
123    (UNSPEC_VRECPS               164)
124    (UNSPEC_VREV16               165)
125    (UNSPEC_VREV32               166)
126    (UNSPEC_VREV64               167)
127    (UNSPEC_VRSQRTE              168)
128    (UNSPEC_VRSQRTS              169)
129    (UNSPEC_VSET_LANE            170)
130    (UNSPEC_VSHL                 171)
131    (UNSPEC_VSHLL_N              172)
132    (UNSPEC_VSHL_N               173)
133    (UNSPEC_VSHR_N               174)
134    (UNSPEC_VSHRN_N              175)
135    (UNSPEC_VSLI                 176)
136    (UNSPEC_VSRA_N               177)
137    (UNSPEC_VSRI                 178)
138    (UNSPEC_VST1                 179)
139    (UNSPEC_VST1_LANE            180)
140    (UNSPEC_VST2                 181)
141    (UNSPEC_VST2_LANE            182)
142    (UNSPEC_VST3                 183)
143    (UNSPEC_VST3A                184)
144    (UNSPEC_VST3B                185)
145    (UNSPEC_VST3_LANE            186)
146    (UNSPEC_VST4                 187)
147    (UNSPEC_VST4A                188)
148    (UNSPEC_VST4B                189)
149    (UNSPEC_VST4_LANE            190)
150    (UNSPEC_VSTRUCTDUMMY         191)
151    (UNSPEC_VSUB                 192)
152    (UNSPEC_VSUBHN               193)
153    (UNSPEC_VSUBL                194)
154    (UNSPEC_VSUBW                195)
155    (UNSPEC_VTBL                 196)
156    (UNSPEC_VTBX                 197)
157    (UNSPEC_VTRN1                198)
158    (UNSPEC_VTRN2                199)
159    (UNSPEC_VTST                 200)
160    (UNSPEC_VUZP1                201)
161    (UNSPEC_VUZP2                202)
162    (UNSPEC_VZIP1                203)
163    (UNSPEC_VZIP2                204)])
164
165 ;; Double-width vector modes.
166 (define_mode_macro VD [V8QI V4HI V2SI V2SF])
167
168 ;; Double-width vector modes plus 64-bit elements.
169 (define_mode_macro VDX [V8QI V4HI V2SI V2SF DI])
170
171 ;; Same, without floating-point elements.
172 (define_mode_macro VDI [V8QI V4HI V2SI])
173
174 ;; Quad-width vector modes.
175 (define_mode_macro VQ [V16QI V8HI V4SI V4SF])
176
177 ;; Quad-width vector modes plus 64-bit elements.
178 (define_mode_macro VQX [V16QI V8HI V4SI V4SF V2DI])
179
180 ;; Same, without floating-point elements.
181 (define_mode_macro VQI [V16QI V8HI V4SI])
182
183 ;; Same, with TImode added, for moves.
184 (define_mode_macro VQXMOV [V16QI V8HI V4SI V4SF V2DI TI])
185
186 ;; Opaque structure types wider than TImode.
187 (define_mode_macro VSTRUCT [EI OI CI XI])
188
189 ;; Number of instructions needed to load/store struct elements. FIXME!
190 (define_mode_attr V_slen [(EI "2") (OI "2") (CI "3") (XI "4")])
191
192 ;; Opaque structure types used in table lookups (except vtbl1/vtbx1).
193 (define_mode_macro VTAB [TI EI OI])
194
195 ;; vtbl<n> suffix for above modes.
196 (define_mode_attr VTAB_n [(TI "2") (EI "3") (OI "4")])
197
198 ;; Widenable modes.
199 (define_mode_macro VW [V8QI V4HI V2SI])
200
201 ;; Narrowable modes.
202 (define_mode_macro VN [V8HI V4SI V2DI])
203
204 ;; All supported vector modes (except singleton DImode).
205 (define_mode_macro VDQ [V8QI V16QI V4HI V8HI V2SI V4SI V2SF V4SF V2DI])
206
207 ;; All supported vector modes (except those with 64-bit integer elements).
208 (define_mode_macro VDQW [V8QI V16QI V4HI V8HI V2SI V4SI V2SF V4SF])
209
210 ;; Supported integer vector modes (not 64 bit elements).
211 (define_mode_macro VDQIW [V8QI V16QI V4HI V8HI V2SI V4SI])
212
213 ;; Supported integer vector modes (not singleton DI)
214 (define_mode_macro VDQI [V8QI V16QI V4HI V8HI V2SI V4SI V2DI])
215
216 ;; Vector modes, including 64-bit integer elements.
217 (define_mode_macro VDQX [V8QI V16QI V4HI V8HI V2SI V4SI V2SF V4SF DI V2DI])
218
219 ;; Vector modes including 64-bit integer elements, but no floats.
220 (define_mode_macro VDQIX [V8QI V16QI V4HI V8HI V2SI V4SI DI V2DI])
221
222 ;; Vector modes for float->int conversions.
223 (define_mode_macro VCVTF [V2SF V4SF])
224
225 ;; Vector modes form int->float conversions.
226 (define_mode_macro VCVTI [V2SI V4SI])
227
228 ;; Vector modes for doubleword multiply-accumulate, etc. insns.
229 (define_mode_macro VMD [V4HI V2SI V2SF])
230
231 ;; Vector modes for quadword multiply-accumulate, etc. insns.
232 (define_mode_macro VMQ [V8HI V4SI V4SF])
233
234 ;; Above modes combined.
235 (define_mode_macro VMDQ [V4HI V2SI V2SF V8HI V4SI V4SF])
236
237 ;; As VMD, but integer modes only.
238 (define_mode_macro VMDI [V4HI V2SI])
239
240 ;; As VMQ, but integer modes only.
241 (define_mode_macro VMQI [V8HI V4SI])
242
243 ;; Above modes combined.
244 (define_mode_macro VMDQI [V4HI V2SI V8HI V4SI])
245
246 ;; Modes with 8-bit and 16-bit elements.
247 (define_mode_macro VX [V8QI V4HI V16QI V8HI])
248
249 ;; Modes with 8-bit elements.
250 (define_mode_macro VE [V8QI V16QI])
251
252 ;; Modes with 64-bit elements only.
253 (define_mode_macro V64 [DI V2DI])
254
255 ;; Modes with 32-bit elements only.
256 (define_mode_macro V32 [V2SI V2SF V4SI V4SF])
257
258 ;; (Opposite) mode to convert to/from for above conversions.
259 (define_mode_attr V_CVTTO [(V2SI "V2SF") (V2SF "V2SI")
260                            (V4SI "V4SF") (V4SF "V4SI")])
261
262 ;; Define element mode for each vector mode.
263 (define_mode_attr V_elem [(V8QI "QI") (V16QI "QI")
264                           (V4HI "HI") (V8HI "HI")
265                           (V2SI "SI") (V4SI "SI")
266                           (V2SF "SF") (V4SF "SF")
267                           (DI "DI")   (V2DI "DI")])
268
269 ;; Element modes for vector extraction, padded up to register size.
270
271 (define_mode_attr V_ext [(V8QI "SI") (V16QI "SI")
272                          (V4HI "SI") (V8HI "SI")
273                          (V2SI "SI") (V4SI "SI")
274                          (V2SF "SF") (V4SF "SF")
275                          (DI "DI") (V2DI "DI")])
276
277 ;; Mode of pair of elements for each vector mode, to define transfer
278 ;; size for structure lane/dup loads and stores.
279 (define_mode_attr V_two_elem [(V8QI "HI") (V16QI "HI")
280                               (V4HI "SI") (V8HI "SI")
281                               (V2SI "V2SI") (V4SI "V2SI")
282                               (V2SF "V2SF") (V4SF "V2SF")
283                               (DI "V2DI")   (V2DI "V2DI")])
284
285 ;; Similar, for three elements.
286 ;; ??? Should we define extra modes so that sizes of all three-element
287 ;; accesses can be accurately represented?
288 (define_mode_attr V_three_elem [(V8QI "SI")   (V16QI "SI")
289                                 (V4HI "V4HI") (V8HI "V4HI")
290                                 (V2SI "V4SI") (V4SI "V4SI")
291                                 (V2SF "V4SF") (V4SF "V4SF")
292                                 (DI "EI")     (V2DI "EI")])
293
294 ;; Similar, for four elements.
295 (define_mode_attr V_four_elem [(V8QI "SI")   (V16QI "SI")
296                                (V4HI "V4HI") (V8HI "V4HI")
297                                (V2SI "V4SI") (V4SI "V4SI")
298                                (V2SF "V4SF") (V4SF "V4SF")
299                                (DI "OI")     (V2DI "OI")])
300
301 ;; Register width from element mode
302 (define_mode_attr V_reg [(V8QI "P") (V16QI "q")
303                          (V4HI "P") (V8HI  "q")
304                          (V2SI "P") (V4SI  "q")
305                          (V2SF "P") (V4SF  "q")
306                          (DI   "P") (V2DI  "q")])
307
308 ;; Wider modes with the same number of elements.
309 (define_mode_attr V_widen [(V8QI "V8HI") (V4HI "V4SI") (V2SI "V2DI")])
310
311 ;; Narrower modes with the same number of elements.
312 (define_mode_attr V_narrow [(V8HI "V8QI") (V4SI "V4HI") (V2DI "V2SI")])
313
314 ;; Modes with half the number of equal-sized elements.
315 (define_mode_attr V_HALF [(V16QI "V8QI") (V8HI "V4HI")
316                           (V4SI  "V2SI") (V4SF "V2SF")
317                           (V2DI "DI")])
318
319 ;; Same, but lower-case.
320 (define_mode_attr V_half [(V16QI "v8qi") (V8HI "v4hi")
321                           (V4SI  "v2si") (V4SF "v2sf")
322                           (V2DI "di")])
323
324 ;; Modes with twice the number of equal-sized elements.
325 (define_mode_attr V_DOUBLE [(V8QI "V16QI") (V4HI "V8HI")
326                             (V2SI "V4SI") (V2SF "V4SF")
327                             (DI "V2DI")])
328
329 ;; Same, but lower-case.
330 (define_mode_attr V_double [(V8QI "v16qi") (V4HI "v8hi")
331                             (V2SI "v4si") (V2SF "v4sf")
332                             (DI "v2di")])
333
334 ;; Modes with double-width elements.
335 (define_mode_attr V_double_width [(V8QI "V4HI") (V16QI "V8HI")
336                                   (V4HI "V2SI") (V8HI "V4SI")
337                                   (V2SI "DI")   (V4SI "V2DI")])
338
339 ;; Mode of result of comparison operations (and bit-select operand 1).
340 (define_mode_attr V_cmp_result [(V8QI "V8QI") (V16QI "V16QI")
341                                 (V4HI "V4HI") (V8HI  "V8HI")
342                                 (V2SI "V2SI") (V4SI  "V4SI")
343                                 (V2SF "V2SI") (V4SF  "V4SI")
344                                 (DI   "DI")   (V2DI  "V2DI")])
345
346 ;; Get element type from double-width mode, for operations where we don't care
347 ;; about signedness.
348 (define_mode_attr V_if_elem [(V8QI "i8")  (V16QI "i8")
349                              (V4HI "i16") (V8HI  "i16")
350                              (V2SI "i32") (V4SI  "i32")
351                              (DI   "i64") (V2DI  "i64")
352                              (V2SF "f32") (V4SF  "f32")])
353
354 ;; Same, but for operations which work on signed values.
355 (define_mode_attr V_s_elem [(V8QI "s8")  (V16QI "s8")
356                             (V4HI "s16") (V8HI  "s16")
357                             (V2SI "s32") (V4SI  "s32")
358                             (DI   "s64") (V2DI  "s64")
359                             (V2SF "f32") (V4SF  "f32")])
360
361 ;; Same, but for operations which work on unsigned values.
362 (define_mode_attr V_u_elem [(V8QI "u8")  (V16QI "u8")
363                             (V4HI "u16") (V8HI  "u16")
364                             (V2SI "u32") (V4SI  "u32")
365                             (DI   "u64") (V2DI  "u64")
366                             (V2SF "f32") (V4SF  "f32")])
367
368 ;; Element types for extraction of unsigned scalars.
369 (define_mode_attr V_uf_sclr [(V8QI "u8")  (V16QI "u8")
370                              (V4HI "u16") (V8HI "u16")
371                              (V2SI "32") (V4SI "32")
372                              (V2SF "32") (V4SF "32")])
373
374 (define_mode_attr V_sz_elem [(V8QI "8")  (V16QI "8")
375                              (V4HI "16") (V8HI  "16")
376                              (V2SI "32") (V4SI  "32")
377                              (DI   "64") (V2DI  "64")
378                              (V2SF "32") (V4SF  "32")])
379
380 ;; Element sizes for duplicating ARM registers to all elements of a vector.
381 (define_mode_attr VD_dup [(V8QI "8") (V4HI "16") (V2SI "32") (V2SF "32")])
382
383 ;; Opaque integer types for results of pair-forming intrinsics (vtrn, etc.)
384 (define_mode_attr V_PAIR [(V8QI "TI") (V16QI "OI")
385                           (V4HI "TI") (V8HI  "OI")
386                           (V2SI "TI") (V4SI  "OI")
387                           (V2SF "TI") (V4SF  "OI")
388                           (DI   "TI") (V2DI  "OI")])
389
390 ;; Same, but lower-case.
391 (define_mode_attr V_pair [(V8QI "ti") (V16QI "oi")
392                           (V4HI "ti") (V8HI  "oi")
393                           (V2SI "ti") (V4SI  "oi")
394                           (V2SF "ti") (V4SF  "oi")
395                           (DI   "ti") (V2DI  "oi")])
396
397 ;; Operations on two halves of a quadword vector.
398 (define_code_macro vqh_ops [plus smin smax umin umax])
399
400 ;; Same, without unsigned variants (for use with *SFmode pattern).
401 (define_code_macro vqhs_ops [plus smin smax])
402
403 ;; Assembler mnemonics for above codes.
404 (define_code_attr VQH_mnem [(plus "vadd") (smin "vmin") (smax "vmax")
405                             (umin "vmin") (umax "vmax")])
406
407 ;; Signs of above, where relevant.
408 (define_code_attr VQH_sign [(plus "i") (smin "s") (smax "s") (umin "u")
409                             (umax "u")])
410
411 ;; Extra suffix on some 64-bit insn names (to avoid collision with standard
412 ;; names which we don't want to define).
413 (define_mode_attr V_suf64 [(V8QI "") (V16QI "")
414                            (V4HI "") (V8HI "")
415                            (V2SI "") (V4SI "")
416                            (V2SF "") (V4SF "")
417                            (DI "_neon") (V2DI "")])
418
419 ;; Scalars to be presented to scalar multiplication instructions
420 ;; must satisfy the following constraints.
421 ;; 1. If the mode specifies 16-bit elements, the scalar must be in D0-D7.
422 ;; 2. If the mode specifies 32-bit elements, the scalar must be in D0-D15.
423 ;; This mode attribute is used to obtain the correct register constraints.
424 (define_mode_attr scalar_mul_constraint [(V4HI "x") (V2SI "t") (V2SF "t")
425                                          (V8HI "x") (V4SI "t") (V4SF "t")])
426
427 ;; Attribute used to permit string comparisons against <VQH_mnem> in
428 ;; neon_type attribute definitions.
429 (define_attr "vqh_mnem" "vadd,vmin,vmax" (const_string "vadd"))
430
431 ;; Classification of NEON instructions for scheduling purposes.
432 ;; Do not set this attribute and the "type" attribute together in
433 ;; any one instruction pattern.
434 (define_attr "neon_type"
435    "neon_int_1,\
436    neon_int_2,\
437    neon_int_3,\
438    neon_int_4,\
439    neon_int_5,\
440    neon_vqneg_vqabs,\
441    neon_vmov,\
442    neon_vaba,\
443    neon_vsma,\
444    neon_vaba_qqq,\
445    neon_mul_ddd_8_16_qdd_16_8_long_32_16_long,\
446    neon_mul_qqq_8_16_32_ddd_32,\
447    neon_mul_qdd_64_32_long_qqd_16_ddd_32_scalar_64_32_long_scalar,\
448    neon_mla_ddd_8_16_qdd_16_8_long_32_16_long,\
449    neon_mla_qqq_8_16,\
450    neon_mla_ddd_32_qqd_16_ddd_32_scalar_qdd_64_32_long_scalar_qdd_64_32_long,\
451    neon_mla_qqq_32_qqd_32_scalar,\
452    neon_mul_ddd_16_scalar_32_16_long_scalar,\
453    neon_mul_qqd_32_scalar,\
454    neon_mla_ddd_16_scalar_qdd_32_16_long_scalar,\
455    neon_shift_1,\
456    neon_shift_2,\
457    neon_shift_3,\
458    neon_vshl_ddd,\
459    neon_vqshl_vrshl_vqrshl_qqq,\
460    neon_vsra_vrsra,\
461    neon_fp_vadd_ddd_vabs_dd,\
462    neon_fp_vadd_qqq_vabs_qq,\
463    neon_fp_vsum,\
464    neon_fp_vmul_ddd,\
465    neon_fp_vmul_qqd,\
466    neon_fp_vmla_ddd,\
467    neon_fp_vmla_qqq,\
468    neon_fp_vmla_ddd_scalar,\
469    neon_fp_vmla_qqq_scalar,\
470    neon_fp_vrecps_vrsqrts_ddd,\
471    neon_fp_vrecps_vrsqrts_qqq,\
472    neon_bp_simple,\
473    neon_bp_2cycle,\
474    neon_bp_3cycle,\
475    neon_ldr,\
476    neon_str,\
477    neon_vld1_1_2_regs,\
478    neon_vld1_3_4_regs,\
479    neon_vld2_2_regs_vld1_vld2_all_lanes,\
480    neon_vld2_4_regs,\
481    neon_vld3_vld4,\
482    neon_vst1_1_2_regs_vst2_2_regs,\
483    neon_vst1_3_4_regs,\
484    neon_vst2_4_regs_vst3_vst4,\
485    neon_vst3_vst4,\
486    neon_vld1_vld2_lane,\
487    neon_vld3_vld4_lane,\
488    neon_vst1_vst2_lane,\
489    neon_vst3_vst4_lane,\
490    neon_vld3_vld4_all_lanes,\
491    neon_mcr,\
492    neon_mcr_2_mcrr,\
493    neon_mrc,\
494    neon_mrrc,\
495    neon_ldm_2,\
496    neon_stm_2,\
497    none"
498  (const_string "none"))
499
500 ;; Predicates used for setting the above attribute.
501
502 (define_mode_attr Is_float_mode [(V8QI "false") (V16QI "false")
503                                  (V4HI "false") (V8HI "false")
504                                  (V2SI "false") (V4SI "false")
505                                  (V2SF "true") (V4SF "true")
506                                  (DI "false") (V2DI "false")])
507
508 (define_mode_attr Scalar_mul_8_16 [(V8QI "true") (V16QI "true")
509                                    (V4HI "true") (V8HI "true")
510                                    (V2SI "false") (V4SI "false")
511                                    (V2SF "false") (V4SF "false")
512                                    (DI "false") (V2DI "false")])
513
514
515 (define_mode_attr Is_d_reg [(V8QI "true") (V16QI "false")
516                             (V4HI "true") (V8HI  "false")
517                             (V2SI "true") (V4SI  "false")
518                             (V2SF "true") (V4SF  "false")
519                             (DI   "true") (V2DI  "false")])
520
521 (define_mode_attr V_mode_nunits [(V8QI "8") (V16QI "16")
522                                  (V4HI "4") (V8HI "8")
523                                  (V2SI "2") (V4SI "4")
524                                  (V2SF "2") (V4SF "4")
525                                  (DI "1")   (V2DI "2")])
526
527 (define_insn "*neon_mov<mode>"
528   [(set (match_operand:VD 0 "nonimmediate_operand"
529           "=w,Uv,w, w,  ?r,?w,?r,?r, ?Us")
530         (match_operand:VD 1 "general_operand"
531           " w,w, Dn,Uvi, w, r, r, Usi,r"))]
532   "TARGET_NEON"
533 {
534   if (which_alternative == 2)
535     {
536       int width, is_valid;
537       static char templ[40];
538
539       is_valid = neon_immediate_valid_for_move (operands[1], <MODE>mode,
540         &operands[1], &width);
541
542       gcc_assert (is_valid != 0);
543
544       if (width == 0)
545         return "vmov.f32\t%P0, %1  @ <mode>";
546       else
547         sprintf (templ, "vmov.i%d\t%%P0, %%1  @ <mode>", width);
548
549       return templ;
550     }
551
552   /* FIXME: If the memory layout is changed in big-endian mode, output_move_vfp
553      below must be changed to output_move_neon (which will use the
554      element/structure loads/stores), and the constraint changed to 'Un' instead
555      of 'Uv'.  */
556
557   switch (which_alternative)
558     {
559     case 0: return "vmov\t%P0, %P1  @ <mode>";
560     case 1: case 3: return output_move_vfp (operands);
561     case 2: gcc_unreachable ();
562     case 4: return "vmov\t%Q0, %R0, %P1  @ <mode>";
563     case 5: return "vmov\t%P0, %Q1, %R1  @ <mode>";
564     default: return output_move_double (operands);
565     }
566 }
567  [(set_attr "neon_type" "neon_int_1,*,neon_vmov,*,neon_mrrc,neon_mcr_2_mcrr,*,*,*")
568   (set_attr "type" "*,f_stored,*,f_loadd,*,*,alu,load2,store2")
569   (set_attr "insn" "*,*,*,*,*,*,mov,*,*")
570   (set_attr "length" "4,4,4,4,4,4,8,8,8")
571   (set_attr "pool_range"     "*,*,*,1020,*,*,*,1020,*")
572   (set_attr "neg_pool_range" "*,*,*,1008,*,*,*,1008,*")])
573
574 (define_insn "*neon_mov<mode>"
575   [(set (match_operand:VQXMOV 0 "nonimmediate_operand"
576           "=w,Un,w, w,  ?r,?w,?r,?r,  ?Us")
577         (match_operand:VQXMOV 1 "general_operand"
578           " w,w, Dn,Uni, w, r, r, Usi, r"))]
579   "TARGET_NEON"
580 {
581   if (which_alternative == 2)
582     {
583       int width, is_valid;
584       static char templ[40];
585
586       is_valid = neon_immediate_valid_for_move (operands[1], <MODE>mode,
587         &operands[1], &width);
588
589       gcc_assert (is_valid != 0);
590
591       if (width == 0)
592         return "vmov.f32\t%q0, %1  @ <mode>";
593       else
594         sprintf (templ, "vmov.i%d\t%%q0, %%1  @ <mode>", width);
595
596       return templ;
597     }
598
599   switch (which_alternative)
600     {
601     case 0: return "vmov\t%q0, %q1  @ <mode>";
602     case 1: case 3: return output_move_neon (operands);
603     case 2: gcc_unreachable ();
604     case 4: return "vmov\t%Q0, %R0, %e1  @ <mode>\;vmov\t%J0, %K0, %f1";
605     case 5: return "vmov\t%e0, %Q1, %R1  @ <mode>\;vmov\t%f0, %J1, %K1";
606     default: return output_move_quad (operands);
607     }
608 }
609   [(set_attr "neon_type" "neon_int_1,neon_stm_2,neon_vmov,neon_ldm_2,\
610                           neon_mrrc,neon_mcr_2_mcrr,*,*,*")
611    (set_attr "type" "*,*,*,*,*,*,alu,load4,store4")
612    (set_attr "insn" "*,*,*,*,*,*,mov,*,*")
613    (set_attr "length" "4,8,4,8,8,8,16,8,16")
614    (set_attr "pool_range" "*,*,*,1020,*,*,*,1020,*")
615    (set_attr "neg_pool_range" "*,*,*,1008,*,*,*,1008,*")])
616
617 (define_expand "movti"
618   [(set (match_operand:TI 0 "nonimmediate_operand" "")
619         (match_operand:TI 1 "general_operand" ""))]
620   "TARGET_NEON"
621 {
622 })
623
624 (define_expand "mov<mode>"
625   [(set (match_operand:VSTRUCT 0 "nonimmediate_operand" "")
626         (match_operand:VSTRUCT 1 "general_operand" ""))]
627   "TARGET_NEON"
628 {
629 })
630
631 (define_insn "*neon_mov<mode>"
632   [(set (match_operand:VSTRUCT 0 "nonimmediate_operand" "=w,Ut,w")
633         (match_operand:VSTRUCT 1 "general_operand"      " w,w, Ut"))]
634   "TARGET_NEON"
635 {
636   switch (which_alternative)
637     {
638     case 0: return "#";
639     case 1: case 2: return output_move_neon (operands);
640     default: gcc_unreachable ();
641     }
642 }
643   [(set_attr "length" "<V_slen>,<V_slen>,<V_slen>")])
644
645 (define_split
646   [(set (match_operand:EI 0 "s_register_operand" "")
647         (match_operand:EI 1 "s_register_operand" ""))]
648   "TARGET_NEON && reload_completed"
649   [(set (match_dup 0) (match_dup 1))
650    (set (match_dup 2) (match_dup 3))]
651 {
652   int rdest = REGNO (operands[0]);
653   int rsrc = REGNO (operands[1]);
654   rtx dest[2], src[2];
655
656   dest[0] = gen_rtx_REG (TImode, rdest);
657   src[0] = gen_rtx_REG (TImode, rsrc);
658   dest[1] = gen_rtx_REG (DImode, rdest + 4);
659   src[1] = gen_rtx_REG (DImode, rsrc + 4);
660
661   neon_disambiguate_copy (operands, dest, src, 2);
662 })
663
664 (define_split
665   [(set (match_operand:OI 0 "s_register_operand" "")
666         (match_operand:OI 1 "s_register_operand" ""))]
667   "TARGET_NEON && reload_completed"
668   [(set (match_dup 0) (match_dup 1))
669    (set (match_dup 2) (match_dup 3))]
670 {
671   int rdest = REGNO (operands[0]);
672   int rsrc = REGNO (operands[1]);
673   rtx dest[2], src[2];
674
675   dest[0] = gen_rtx_REG (TImode, rdest);
676   src[0] = gen_rtx_REG (TImode, rsrc);
677   dest[1] = gen_rtx_REG (TImode, rdest + 4);
678   src[1] = gen_rtx_REG (TImode, rsrc + 4);
679
680   neon_disambiguate_copy (operands, dest, src, 2);
681 })
682
683 (define_split
684   [(set (match_operand:CI 0 "s_register_operand" "")
685         (match_operand:CI 1 "s_register_operand" ""))]
686   "TARGET_NEON && reload_completed"
687   [(set (match_dup 0) (match_dup 1))
688    (set (match_dup 2) (match_dup 3))
689    (set (match_dup 4) (match_dup 5))]
690 {
691   int rdest = REGNO (operands[0]);
692   int rsrc = REGNO (operands[1]);
693   rtx dest[3], src[3];
694
695   dest[0] = gen_rtx_REG (TImode, rdest);
696   src[0] = gen_rtx_REG (TImode, rsrc);
697   dest[1] = gen_rtx_REG (TImode, rdest + 4);
698   src[1] = gen_rtx_REG (TImode, rsrc + 4);
699   dest[2] = gen_rtx_REG (TImode, rdest + 8);
700   src[2] = gen_rtx_REG (TImode, rsrc + 8);
701
702   neon_disambiguate_copy (operands, dest, src, 3);
703 })
704
705 (define_split
706   [(set (match_operand:XI 0 "s_register_operand" "")
707         (match_operand:XI 1 "s_register_operand" ""))]
708   "TARGET_NEON && reload_completed"
709   [(set (match_dup 0) (match_dup 1))
710    (set (match_dup 2) (match_dup 3))
711    (set (match_dup 4) (match_dup 5))
712    (set (match_dup 6) (match_dup 7))]
713 {
714   int rdest = REGNO (operands[0]);
715   int rsrc = REGNO (operands[1]);
716   rtx dest[4], src[4];
717
718   dest[0] = gen_rtx_REG (TImode, rdest);
719   src[0] = gen_rtx_REG (TImode, rsrc);
720   dest[1] = gen_rtx_REG (TImode, rdest + 4);
721   src[1] = gen_rtx_REG (TImode, rsrc + 4);
722   dest[2] = gen_rtx_REG (TImode, rdest + 8);
723   src[2] = gen_rtx_REG (TImode, rsrc + 8);
724   dest[3] = gen_rtx_REG (TImode, rdest + 12);
725   src[3] = gen_rtx_REG (TImode, rsrc + 12);
726
727   neon_disambiguate_copy (operands, dest, src, 4);
728 })
729
730 (define_insn "vec_set<mode>"
731   [(set (match_operand:VD 0 "s_register_operand" "+w")
732         (vec_merge:VD
733           (match_operand:VD 3 "s_register_operand" "0")
734           (vec_duplicate:VD
735             (match_operand:<V_elem> 1 "s_register_operand" "r"))
736           (ashift:SI (const_int 1)
737                      (match_operand:SI 2 "immediate_operand" "i"))))]
738   "TARGET_NEON"
739   "vmov%?.<V_uf_sclr>\t%P0[%c2], %1"
740   [(set_attr "predicable" "yes")
741    (set_attr "neon_type" "neon_mcr")]
742 )
743
744 (define_insn "vec_set<mode>"
745   [(set (match_operand:VQ 0 "s_register_operand" "+w")
746         (vec_merge:VQ
747           (match_operand:VQ 3 "s_register_operand" "0")
748           (vec_duplicate:VQ
749             (match_operand:<V_elem> 1 "s_register_operand" "r"))
750           (ashift:SI (const_int 1)
751                      (match_operand:SI 2 "immediate_operand" "i"))))]
752   "TARGET_NEON"
753 {
754   int half_elts = GET_MODE_NUNITS (<MODE>mode) / 2;
755   int elt = INTVAL (operands[2]) % half_elts;
756   int hi = (INTVAL (operands[2]) / half_elts) * 2;
757   int regno = REGNO (operands[0]);
758
759   operands[0] = gen_rtx_REG (<V_HALF>mode, regno + hi);
760   operands[2] = GEN_INT (elt);
761
762   return "vmov%?.<V_uf_sclr>\t%P0[%c2], %1";
763 }
764   [(set_attr "predicable" "yes")
765    (set_attr "neon_type" "neon_mcr")]
766 )
767
768 (define_insn "vec_setv2di"
769   [(set (match_operand:V2DI 0 "s_register_operand" "+w")
770         (vec_merge:V2DI
771           (match_operand:V2DI 3 "s_register_operand" "0")
772           (vec_duplicate:V2DI
773             (match_operand:DI 1 "s_register_operand" "r"))
774           (ashift:SI (const_int 1)
775                      (match_operand:SI 2 "immediate_operand" "i"))))]
776   "TARGET_NEON"
777 {
778   int regno = REGNO (operands[0]) + INTVAL (operands[2]);
779
780   operands[0] = gen_rtx_REG (DImode, regno);
781
782   return "vmov%?.64\t%P0, %Q1, %R1";
783 }
784   [(set_attr "predicable" "yes")
785    (set_attr "neon_type" "neon_mcr_2_mcrr")]
786 )
787
788 (define_insn "vec_extract<mode>"
789   [(set (match_operand:<V_elem> 0 "s_register_operand" "=r")
790         (vec_select:<V_elem>
791           (match_operand:VD 1 "s_register_operand" "w")
792           (parallel [(match_operand:SI 2 "immediate_operand" "i")])))]
793   "TARGET_NEON"
794   "vmov%?.<V_uf_sclr>\t%0, %P1[%c2]"
795   [(set_attr "predicable" "yes")
796    (set_attr "neon_type" "neon_bp_simple")]
797 )
798
799 (define_insn "vec_extract<mode>"
800   [(set (match_operand:<V_elem> 0 "s_register_operand" "=r")
801         (vec_select:<V_elem>
802           (match_operand:VQ 1 "s_register_operand" "w")
803           (parallel [(match_operand:SI 2 "immediate_operand" "i")])))]
804   "TARGET_NEON"
805 {
806   int half_elts = GET_MODE_NUNITS (<MODE>mode) / 2;
807   int elt = INTVAL (operands[2]) % half_elts;
808   int hi = (INTVAL (operands[2]) / half_elts) * 2;
809   int regno = REGNO (operands[1]);
810
811   operands[1] = gen_rtx_REG (<V_HALF>mode, regno + hi);
812   operands[2] = GEN_INT (elt);
813
814   return "vmov%?.<V_uf_sclr>\t%0, %P1[%c2]";
815 }
816   [(set_attr "predicable" "yes")
817    (set_attr "neon_type" "neon_bp_simple")]
818 )
819
820 (define_insn "vec_extractv2di"
821   [(set (match_operand:DI 0 "s_register_operand" "=r")
822         (vec_select:DI
823           (match_operand:V2DI 1 "s_register_operand" "w")
824           (parallel [(match_operand:SI 2 "immediate_operand" "i")])))]
825   "TARGET_NEON"
826 {
827   int regno = REGNO (operands[1]) + INTVAL (operands[2]);
828
829   operands[1] = gen_rtx_REG (DImode, regno);
830
831   return "vmov%?.64\t%Q0, %R0, %P1";
832 }
833   [(set_attr "predicable" "yes")
834    (set_attr "neon_type" "neon_int_1")]
835 )
836
837 (define_expand "vec_init<mode>"
838   [(match_operand:VDQ 0 "s_register_operand" "")
839    (match_operand 1 "" "")]
840   "TARGET_NEON"
841 {
842   neon_expand_vector_init (operands[0], operands[1]);
843   DONE;
844 })
845
846 ;; Doubleword and quadword arithmetic.
847
848 ;; NOTE: vadd/vsub and some other instructions also support 64-bit integer
849 ;; element size, which we could potentially use for "long long" operations. We
850 ;; don't want to do this at present though, because moving values from the
851 ;; vector unit to the ARM core is currently slow and 64-bit addition (etc.) is
852 ;; easy to do with ARM instructions anyway.
853
854 (define_insn "*add<mode>3_neon"
855   [(set (match_operand:VDQ 0 "s_register_operand" "=w")
856         (plus:VDQ (match_operand:VDQ 1 "s_register_operand" "w")
857                   (match_operand:VDQ 2 "s_register_operand" "w")))]
858   "TARGET_NEON"
859   "vadd.<V_if_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
860   [(set (attr "neon_type")
861       (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
862                     (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
863                                   (const_string "neon_fp_vadd_ddd_vabs_dd")
864                                   (const_string "neon_fp_vadd_qqq_vabs_qq"))
865                     (const_string "neon_int_1")))]
866 )
867
868 (define_insn "*sub<mode>3_neon"
869   [(set (match_operand:VDQ 0 "s_register_operand" "=w")
870         (minus:VDQ (match_operand:VDQ 1 "s_register_operand" "w")
871                    (match_operand:VDQ 2 "s_register_operand" "w")))]
872   "TARGET_NEON"
873   "vsub.<V_if_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
874   [(set (attr "neon_type")
875       (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
876                     (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
877                                   (const_string "neon_fp_vadd_ddd_vabs_dd")
878                                   (const_string "neon_fp_vadd_qqq_vabs_qq"))
879                     (const_string "neon_int_2")))]
880 )
881
882 (define_insn "*mul<mode>3_neon"
883   [(set (match_operand:VDQ 0 "s_register_operand" "=w")
884         (mult:VDQ (match_operand:VDQ 1 "s_register_operand" "w")
885                   (match_operand:VDQ 2 "s_register_operand" "w")))]
886   "TARGET_NEON"
887   "vmul.<V_if_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
888   [(set (attr "neon_type")
889       (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
890                     (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
891                                   (const_string "neon_fp_vadd_ddd_vabs_dd")
892                                   (const_string "neon_fp_vadd_qqq_vabs_qq"))
893                     (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
894                                   (if_then_else
895                                     (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
896                                     (const_string "neon_mul_ddd_8_16_qdd_16_8_long_32_16_long")
897                                     (const_string "neon_mul_qqq_8_16_32_ddd_32"))
898                                   (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
899                                     (const_string "neon_mul_qqq_8_16_32_ddd_32")
900                                     (const_string "neon_mul_qqq_8_16_32_ddd_32")))))]
901 )
902
903 (define_insn "ior<mode>3"
904   [(set (match_operand:VDQ 0 "s_register_operand" "=w,w")
905         (ior:VDQ (match_operand:VDQ 1 "s_register_operand" "w,0")
906                  (match_operand:VDQ 2 "neon_logic_op2" "w,Dl")))]
907   "TARGET_NEON"
908 {
909   switch (which_alternative)
910     {
911     case 0: return "vorr\t%<V_reg>0, %<V_reg>1, %<V_reg>2";
912     case 1: return neon_output_logic_immediate ("vorr", &operands[2],
913                      <MODE>mode, 0, VALID_NEON_QREG_MODE (<MODE>mode));
914     default: gcc_unreachable ();
915     }
916 }
917   [(set_attr "neon_type" "neon_int_1")]
918 )
919
920 (define_insn "iordi3_neon"
921   [(set (match_operand:DI 0 "s_register_operand" "=w,w")
922         (unspec:DI [(match_operand:DI 1 "s_register_operand" "w,0")
923                     (match_operand:DI 2 "neon_logic_op2" "w,Dl")]
924                     UNSPEC_VORR))]
925   "TARGET_NEON"
926 {
927   switch (which_alternative)
928     {
929     case 0: return "vorr\t%P0, %P1, %P2";
930     case 1: return neon_output_logic_immediate ("vorr", &operands[2],
931                      DImode, 0, VALID_NEON_QREG_MODE (DImode));
932     default: gcc_unreachable ();
933     }
934 }
935   [(set_attr "neon_type" "neon_int_1")]
936 )
937
938 ;; The concrete forms of the Neon immediate-logic instructions are vbic and
939 ;; vorr. We support the pseudo-instruction vand instead, because that
940 ;; corresponds to the canonical form the middle-end expects to use for
941 ;; immediate bitwise-ANDs.
942
943 (define_insn "and<mode>3"
944   [(set (match_operand:VDQ 0 "s_register_operand" "=w,w")
945         (and:VDQ (match_operand:VDQ 1 "s_register_operand" "w,0")
946                  (match_operand:VDQ 2 "neon_inv_logic_op2" "w,DL")))]
947   "TARGET_NEON"
948 {
949   switch (which_alternative)
950     {
951     case 0: return "vand\t%<V_reg>0, %<V_reg>1, %<V_reg>2";
952     case 1: return neon_output_logic_immediate ("vand", &operands[2],
953                      <MODE>mode, 1, VALID_NEON_QREG_MODE (<MODE>mode));
954     default: gcc_unreachable ();
955     }
956 }
957   [(set_attr "neon_type" "neon_int_1")]
958 )
959
960 (define_insn "anddi3_neon"
961   [(set (match_operand:DI 0 "s_register_operand" "=w,w")
962         (unspec:DI [(match_operand:DI 1 "s_register_operand" "w,0")
963                     (match_operand:DI 2 "neon_inv_logic_op2" "w,DL")]
964                     UNSPEC_VAND))]
965   "TARGET_NEON"
966 {
967   switch (which_alternative)
968     {
969     case 0: return "vand\t%P0, %P1, %P2";
970     case 1: return neon_output_logic_immediate ("vand", &operands[2],
971                      DImode, 1, VALID_NEON_QREG_MODE (DImode));
972     default: gcc_unreachable ();
973     }
974 }
975   [(set_attr "neon_type" "neon_int_1")]
976 )
977
978 (define_insn "orn<mode>3_neon"
979   [(set (match_operand:VDQ 0 "s_register_operand" "=w")
980         (ior:VDQ (match_operand:VDQ 1 "s_register_operand" "w")
981                  (not:VDQ (match_operand:VDQ 2 "s_register_operand" "w"))))]
982   "TARGET_NEON"
983   "vorn\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
984   [(set_attr "neon_type" "neon_int_1")]
985 )
986
987 (define_insn "orndi3_neon"
988   [(set (match_operand:DI 0 "s_register_operand" "=w")
989         (unspec:DI [(match_operand:DI 1 "s_register_operand" "w")
990                     (match_operand:DI 2 "s_register_operand" "w")]
991                     UNSPEC_VORN))]
992   "TARGET_NEON"
993   "vorn\t%P0, %P1, %P2"
994   [(set_attr "neon_type" "neon_int_1")]
995 )
996
997 (define_insn "bic<mode>3_neon"
998   [(set (match_operand:VDQ 0 "s_register_operand" "=w")
999         (and:VDQ (match_operand:VDQ 1 "s_register_operand" "w")
1000                   (not:VDQ (match_operand:VDQ 2 "s_register_operand" "w"))))]
1001   "TARGET_NEON"
1002   "vbic\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
1003   [(set_attr "neon_type" "neon_int_1")]
1004 )
1005
1006 (define_insn "bicdi3_neon"
1007   [(set (match_operand:DI 0 "s_register_operand" "=w")
1008         (unspec:DI [(match_operand:DI 1 "s_register_operand" "w")
1009                      (match_operand:DI 2 "s_register_operand" "w")]
1010                     UNSPEC_VBIC))]
1011   "TARGET_NEON"
1012   "vbic\t%P0, %P1, %P2"
1013   [(set_attr "neon_type" "neon_int_1")]
1014 )
1015
1016 (define_insn "xor<mode>3"
1017   [(set (match_operand:VDQ 0 "s_register_operand" "=w")
1018         (xor:VDQ (match_operand:VDQ 1 "s_register_operand" "w")
1019                  (match_operand:VDQ 2 "s_register_operand" "w")))]
1020   "TARGET_NEON"
1021   "veor\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
1022   [(set_attr "neon_type" "neon_int_1")]
1023 )
1024
1025 (define_insn "xordi3_neon"
1026   [(set (match_operand:DI 0 "s_register_operand" "=w")
1027         (unspec:DI [(match_operand:DI 1 "s_register_operand" "w")
1028                      (match_operand:DI 2 "s_register_operand" "w")]
1029                     UNSPEC_VEOR))]
1030   "TARGET_NEON"
1031   "veor\t%P0, %P1, %P2"
1032   [(set_attr "neon_type" "neon_int_1")]
1033 )
1034
1035 (define_insn "one_cmpl<mode>2"
1036   [(set (match_operand:VDQ 0 "s_register_operand" "=w")
1037         (not:VDQ (match_operand:VDQ 1 "s_register_operand" "w")))]
1038   "TARGET_NEON"
1039   "vmvn\t%<V_reg>0, %<V_reg>1"
1040   [(set_attr "neon_type" "neon_int_1")]
1041 )
1042
1043 (define_insn "abs<mode>2"
1044   [(set (match_operand:VDQW 0 "s_register_operand" "=w")
1045         (abs:VDQW (match_operand:VDQW 1 "s_register_operand" "w")))]
1046   "TARGET_NEON"
1047   "vabs.<V_s_elem>\t%<V_reg>0, %<V_reg>1"
1048   [(set (attr "neon_type")
1049       (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
1050                     (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
1051                                   (const_string "neon_fp_vadd_ddd_vabs_dd")
1052                                   (const_string "neon_fp_vadd_qqq_vabs_qq"))
1053                     (const_string "neon_int_3")))]
1054 )
1055
1056 (define_insn "neg<mode>2"
1057   [(set (match_operand:VDQW 0 "s_register_operand" "=w")
1058         (neg:VDQW (match_operand:VDQW 1 "s_register_operand" "w")))]
1059   "TARGET_NEON"
1060   "vneg.<V_s_elem>\t%<V_reg>0, %<V_reg>1"
1061   [(set (attr "neon_type")
1062       (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
1063                     (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
1064                                   (const_string "neon_fp_vadd_ddd_vabs_dd")
1065                                   (const_string "neon_fp_vadd_qqq_vabs_qq"))
1066                     (const_string "neon_int_3")))]
1067 )
1068
1069 (define_insn "*umin<mode>3_neon"
1070   [(set (match_operand:VDQIW 0 "s_register_operand" "=w")
1071         (umin:VDQIW (match_operand:VDQIW 1 "s_register_operand" "w")
1072                     (match_operand:VDQIW 2 "s_register_operand" "w")))]
1073   "TARGET_NEON"
1074   "vmin.<V_u_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
1075   [(set_attr "neon_type" "neon_int_5")]
1076 )
1077
1078 (define_insn "*umax<mode>3_neon"
1079   [(set (match_operand:VDQIW 0 "s_register_operand" "=w")
1080         (umax:VDQIW (match_operand:VDQIW 1 "s_register_operand" "w")
1081                     (match_operand:VDQIW 2 "s_register_operand" "w")))]
1082   "TARGET_NEON"
1083   "vmax.<V_u_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
1084   [(set_attr "neon_type" "neon_int_5")]
1085 )
1086
1087 (define_insn "*smin<mode>3_neon"
1088   [(set (match_operand:VDQW 0 "s_register_operand" "=w")
1089         (smin:VDQW (match_operand:VDQW 1 "s_register_operand" "w")
1090                    (match_operand:VDQW 2 "s_register_operand" "w")))]
1091   "TARGET_NEON"
1092   "vmin.<V_s_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
1093   [(set (attr "neon_type")
1094       (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
1095                     (const_string "neon_fp_vadd_ddd_vabs_dd")
1096                     (const_string "neon_int_5")))]
1097 )
1098
1099 (define_insn "*smax<mode>3_neon"
1100   [(set (match_operand:VDQW 0 "s_register_operand" "=w")
1101         (smax:VDQW (match_operand:VDQW 1 "s_register_operand" "w")
1102                    (match_operand:VDQW 2 "s_register_operand" "w")))]
1103   "TARGET_NEON"
1104   "vmax.<V_s_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
1105   [(set (attr "neon_type")
1106       (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
1107                     (const_string "neon_fp_vadd_ddd_vabs_dd")
1108                     (const_string "neon_int_5")))]
1109 )
1110
1111 ; TODO: V2DI shifts are current disabled because there are bugs in the
1112 ; generic vectorizer code.  It ends up creating a V2DI constructor with
1113 ; SImode elements.
1114
1115 (define_insn "ashl<mode>3"
1116   [(set (match_operand:VDQIW 0 "s_register_operand" "=w")
1117         (ashift:VDQIW (match_operand:VDQIW 1 "s_register_operand" "w")
1118                       (match_operand:VDQIW 2 "s_register_operand" "w")))]
1119   "TARGET_NEON"
1120   "vshl.<V_s_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
1121   [(set (attr "neon_type")
1122       (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
1123                     (const_string "neon_vshl_ddd")
1124                     (const_string "neon_shift_3")))]
1125 )
1126
1127 ; Used for implementing logical shift-right, which is a left-shift by a negative
1128 ; amount, with signed operands. This is essentially the same as ashl<mode>3
1129 ; above, but using an unspec in case GCC tries anything tricky with negative
1130 ; shift amounts.
1131
1132 (define_insn "ashl<mode>3_signed"
1133   [(set (match_operand:VDQI 0 "s_register_operand" "=w")
1134         (unspec:VDQI [(match_operand:VDQI 1 "s_register_operand" "w")
1135                       (match_operand:VDQI 2 "s_register_operand" "w")]
1136                      UNSPEC_ASHIFT_SIGNED))]
1137   "TARGET_NEON"
1138   "vshl.<V_s_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
1139   [(set (attr "neon_type")
1140       (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
1141                     (const_string "neon_vshl_ddd")
1142                     (const_string "neon_shift_3")))]
1143 )
1144
1145 ; Used for implementing logical shift-right, which is a left-shift by a negative
1146 ; amount, with unsigned operands.
1147
1148 (define_insn "ashl<mode>3_unsigned"
1149   [(set (match_operand:VDQI 0 "s_register_operand" "=w")
1150         (unspec:VDQI [(match_operand:VDQI 1 "s_register_operand" "w")
1151                       (match_operand:VDQI 2 "s_register_operand" "w")]
1152                      UNSPEC_ASHIFT_UNSIGNED))]
1153   "TARGET_NEON"
1154   "vshl.<V_u_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
1155   [(set (attr "neon_type")
1156       (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
1157                     (const_string "neon_vshl_ddd")
1158                     (const_string "neon_shift_3")))]
1159 )
1160
1161 (define_expand "ashr<mode>3"
1162   [(set (match_operand:VDQIW 0 "s_register_operand" "")
1163         (ashiftrt:VDQIW (match_operand:VDQIW 1 "s_register_operand" "")
1164                         (match_operand:VDQIW 2 "s_register_operand" "")))]
1165   "TARGET_NEON"
1166 {
1167   rtx neg = gen_reg_rtx (<MODE>mode);
1168
1169   emit_insn (gen_neg<mode>2 (neg, operands[2]));
1170   emit_insn (gen_ashl<mode>3_signed (operands[0], operands[1], neg));
1171
1172   DONE;
1173 })
1174
1175 (define_expand "lshr<mode>3"
1176   [(set (match_operand:VDQIW 0 "s_register_operand" "")
1177         (lshiftrt:VDQIW (match_operand:VDQIW 1 "s_register_operand" "")
1178                         (match_operand:VDQIW 2 "s_register_operand" "")))]
1179   "TARGET_NEON"
1180 {
1181   rtx neg = gen_reg_rtx (<MODE>mode);
1182
1183   emit_insn (gen_neg<mode>2 (neg, operands[2]));
1184   emit_insn (gen_ashl<mode>3_unsigned (operands[0], operands[1], neg));
1185
1186   DONE;
1187 })
1188
1189 ;; Widening operations
1190
1191 (define_insn "widen_ssum<mode>3"
1192   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
1193         (plus:<V_widen> (sign_extend:<V_widen>
1194                           (match_operand:VW 1 "s_register_operand" "%w"))
1195                         (match_operand:<V_widen> 2 "s_register_operand" "w")))]
1196   "TARGET_NEON"
1197   "vaddw.<V_s_elem>\t%q0, %q2, %P1"
1198   [(set_attr "neon_type" "neon_int_3")]
1199 )
1200
1201 (define_insn "widen_usum<mode>3"
1202   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
1203         (plus:<V_widen> (zero_extend:<V_widen>
1204                           (match_operand:VW 1 "s_register_operand" "%w"))
1205                         (match_operand:<V_widen> 2 "s_register_operand" "w")))]
1206   "TARGET_NEON"
1207   "vaddw.<V_u_elem>\t%q0, %q2, %P1"
1208   [(set_attr "neon_type" "neon_int_3")]
1209 )
1210
1211 ;; VEXT can be used to synthesize coarse whole-vector shifts with 8-bit
1212 ;; shift-count granularity. That's good enough for the middle-end's current
1213 ;; needs.
1214
1215 (define_expand "vec_shr_<mode>"
1216   [(match_operand:VDQ 0 "s_register_operand" "")
1217    (match_operand:VDQ 1 "s_register_operand" "")
1218    (match_operand:SI 2 "const_multiple_of_8_operand" "")]
1219   "TARGET_NEON"
1220 {
1221   rtx zero_reg;
1222   HOST_WIDE_INT num_bits = INTVAL (operands[2]);
1223   const int width = GET_MODE_BITSIZE (<MODE>mode);
1224   const enum machine_mode bvecmode = (width == 128) ? V16QImode : V8QImode;
1225   rtx (*gen_ext) (rtx, rtx, rtx, rtx) =
1226     (width == 128) ? gen_neon_vextv16qi : gen_neon_vextv8qi;
1227
1228   if (num_bits == width)
1229     {
1230       emit_move_insn (operands[0], operands[1]);
1231       DONE;
1232     }
1233
1234   zero_reg = force_reg (bvecmode, CONST0_RTX (bvecmode));
1235   operands[0] = gen_lowpart (bvecmode, operands[0]);
1236   operands[1] = gen_lowpart (bvecmode, operands[1]);
1237
1238   emit_insn (gen_ext (operands[0], operands[1], zero_reg,
1239                       GEN_INT (num_bits / BITS_PER_UNIT)));
1240   DONE;
1241 })
1242
1243 (define_expand "vec_shl_<mode>"
1244   [(match_operand:VDQ 0 "s_register_operand" "")
1245    (match_operand:VDQ 1 "s_register_operand" "")
1246    (match_operand:SI 2 "const_multiple_of_8_operand" "")]
1247   "TARGET_NEON"
1248 {
1249   rtx zero_reg;
1250   HOST_WIDE_INT num_bits = INTVAL (operands[2]);
1251   const int width = GET_MODE_BITSIZE (<MODE>mode);
1252   const enum machine_mode bvecmode = (width == 128) ? V16QImode : V8QImode;
1253   rtx (*gen_ext) (rtx, rtx, rtx, rtx) =
1254     (width == 128) ? gen_neon_vextv16qi : gen_neon_vextv8qi;
1255
1256   if (num_bits == 0)
1257     {
1258       emit_move_insn (operands[0], CONST0_RTX (<MODE>mode));
1259       DONE;
1260     }
1261
1262   num_bits = width - num_bits;
1263
1264   zero_reg = force_reg (bvecmode, CONST0_RTX (bvecmode));
1265   operands[0] = gen_lowpart (bvecmode, operands[0]);
1266   operands[1] = gen_lowpart (bvecmode, operands[1]);
1267
1268   emit_insn (gen_ext (operands[0], zero_reg, operands[1],
1269                       GEN_INT (num_bits / BITS_PER_UNIT)));
1270   DONE;
1271 })
1272
1273 ;; Helpers for quad-word reduction operations
1274
1275 ; Add (or smin, smax...) the low N/2 elements of the N-element vector
1276 ; operand[1] to the high N/2 elements of same. Put the result in operand[0], an
1277 ; N/2-element vector.
1278
1279 (define_insn "quad_halves_<code>v4si"
1280   [(set (match_operand:V2SI 0 "s_register_operand" "=w")
1281         (vqh_ops:V2SI
1282           (vec_select:V2SI (match_operand:V4SI 1 "s_register_operand" "w")
1283                            (parallel [(const_int 0) (const_int 1)]))
1284           (vec_select:V2SI (match_dup 1)
1285                            (parallel [(const_int 2) (const_int 3)]))))]
1286   "TARGET_NEON"
1287   "<VQH_mnem>.<VQH_sign>32\t%P0, %e1, %f1"
1288   [(set_attr "vqh_mnem" "<VQH_mnem>")
1289    (set (attr "neon_type")
1290       (if_then_else (eq_attr "vqh_mnem" "vadd")
1291                     (const_string "neon_int_1") (const_string "neon_int_5")))]
1292 )
1293
1294 (define_insn "quad_halves_<code>v4sf"
1295   [(set (match_operand:V2SF 0 "s_register_operand" "=w")
1296         (vqhs_ops:V2SF
1297           (vec_select:V2SF (match_operand:V4SF 1 "s_register_operand" "w")
1298                            (parallel [(const_int 0) (const_int 1)]))
1299           (vec_select:V2SF (match_dup 1)
1300                            (parallel [(const_int 2) (const_int 3)]))))]
1301   "TARGET_NEON"
1302   "<VQH_mnem>.f32\t%P0, %e1, %f1"
1303   [(set_attr "vqh_mnem" "<VQH_mnem>")
1304    (set (attr "neon_type")
1305       (if_then_else (eq_attr "vqh_mnem" "vadd")
1306                     (const_string "neon_int_1") (const_string "neon_int_5")))]
1307 )
1308
1309 (define_insn "quad_halves_<code>v8hi"
1310   [(set (match_operand:V4HI 0 "s_register_operand" "+w")
1311         (vqh_ops:V4HI
1312           (vec_select:V4HI (match_operand:V8HI 1 "s_register_operand" "w")
1313                            (parallel [(const_int 0) (const_int 1)
1314                                       (const_int 2) (const_int 3)]))
1315           (vec_select:V4HI (match_dup 1)
1316                            (parallel [(const_int 4) (const_int 5)
1317                                       (const_int 6) (const_int 7)]))))]
1318   "TARGET_NEON"
1319   "<VQH_mnem>.<VQH_sign>16\t%P0, %e1, %f1"
1320   [(set_attr "vqh_mnem" "<VQH_mnem>")
1321    (set (attr "neon_type")
1322       (if_then_else (eq_attr "vqh_mnem" "vadd")
1323                     (const_string "neon_int_1") (const_string "neon_int_5")))]
1324 )
1325
1326 (define_insn "quad_halves_<code>v16qi"
1327   [(set (match_operand:V8QI 0 "s_register_operand" "+w")
1328         (vqh_ops:V8QI
1329           (vec_select:V8QI (match_operand:V16QI 1 "s_register_operand" "w")
1330                            (parallel [(const_int 0) (const_int 1)
1331                                       (const_int 2) (const_int 3)
1332                                       (const_int 4) (const_int 5)
1333                                       (const_int 6) (const_int 7)]))
1334           (vec_select:V8QI (match_dup 1)
1335                            (parallel [(const_int 8) (const_int 9)
1336                                       (const_int 10) (const_int 11)
1337                                       (const_int 12) (const_int 13)
1338                                       (const_int 14) (const_int 15)]))))]
1339   "TARGET_NEON"
1340   "<VQH_mnem>.<VQH_sign>8\t%P0, %e1, %f1"
1341   [(set_attr "vqh_mnem" "<VQH_mnem>")
1342    (set (attr "neon_type")
1343       (if_then_else (eq_attr "vqh_mnem" "vadd")
1344                     (const_string "neon_int_1") (const_string "neon_int_5")))]
1345 )
1346
1347 ; FIXME: We wouldn't need the following insns if we could write subregs of
1348 ; vector registers. Make an attempt at removing unnecessary moves, though
1349 ; we're really at the mercy of the register allocator.
1350
1351 (define_insn "move_lo_quad_v4si"
1352   [(set (match_operand:V4SI 0 "s_register_operand" "+w")
1353         (vec_concat:V4SI
1354           (match_operand:V2SI 1 "s_register_operand" "w")
1355           (vec_select:V2SI (match_dup 0)
1356                            (parallel [(const_int 2) (const_int 3)]))))]
1357   "TARGET_NEON"
1358 {
1359   int dest = REGNO (operands[0]);
1360   int src = REGNO (operands[1]);
1361
1362   if (dest != src)
1363     return "vmov\t%e0, %P1";
1364   else
1365     return "";
1366 }
1367   [(set_attr "neon_type" "neon_bp_simple")]
1368 )
1369
1370 (define_insn "move_lo_quad_v4sf"
1371   [(set (match_operand:V4SF 0 "s_register_operand" "+w")
1372         (vec_concat:V4SF
1373           (match_operand:V2SF 1 "s_register_operand" "w")
1374           (vec_select:V2SF (match_dup 0)
1375                            (parallel [(const_int 2) (const_int 3)]))))]
1376   "TARGET_NEON"
1377 {
1378   int dest = REGNO (operands[0]);
1379   int src = REGNO (operands[1]);
1380
1381   if (dest != src)
1382     return "vmov\t%e0, %P1";
1383   else
1384     return "";
1385 }
1386   [(set_attr "neon_type" "neon_bp_simple")]
1387 )
1388
1389 (define_insn "move_lo_quad_v8hi"
1390   [(set (match_operand:V8HI 0 "s_register_operand" "+w")
1391         (vec_concat:V8HI
1392           (match_operand:V4HI 1 "s_register_operand" "w")
1393           (vec_select:V4HI (match_dup 0)
1394                            (parallel [(const_int 4) (const_int 5)
1395                                       (const_int 6) (const_int 7)]))))]
1396   "TARGET_NEON"
1397 {
1398   int dest = REGNO (operands[0]);
1399   int src = REGNO (operands[1]);
1400
1401   if (dest != src)
1402     return "vmov\t%e0, %P1";
1403   else
1404     return "";
1405 }
1406   [(set_attr "neon_type" "neon_bp_simple")]
1407 )
1408
1409 (define_insn "move_lo_quad_v16qi"
1410   [(set (match_operand:V16QI 0 "s_register_operand" "+w")
1411         (vec_concat:V16QI
1412           (match_operand:V8QI 1 "s_register_operand" "w")
1413           (vec_select:V8QI (match_dup 0)
1414                            (parallel [(const_int 8)  (const_int 9)
1415                                       (const_int 10) (const_int 11)
1416                                       (const_int 12) (const_int 13)
1417                                       (const_int 14) (const_int 15)]))))]
1418   "TARGET_NEON"
1419 {
1420   int dest = REGNO (operands[0]);
1421   int src = REGNO (operands[1]);
1422
1423   if (dest != src)
1424     return "vmov\t%e0, %P1";
1425   else
1426     return "";
1427 }
1428   [(set_attr "neon_type" "neon_bp_simple")]
1429 )
1430
1431 ;; Reduction operations
1432
1433 (define_expand "reduc_splus_<mode>"
1434   [(match_operand:VD 0 "s_register_operand" "")
1435    (match_operand:VD 1 "s_register_operand" "")]
1436   "TARGET_NEON"
1437 {
1438   neon_pairwise_reduce (operands[0], operands[1], <MODE>mode,
1439                         &gen_neon_vpadd_internal<mode>);
1440   DONE;
1441 })
1442
1443 (define_expand "reduc_splus_<mode>"
1444   [(match_operand:VQ 0 "s_register_operand" "")
1445    (match_operand:VQ 1 "s_register_operand" "")]
1446   "TARGET_NEON"
1447 {
1448   rtx step1 = gen_reg_rtx (<V_HALF>mode);
1449   rtx res_d = gen_reg_rtx (<V_HALF>mode);
1450
1451   emit_insn (gen_quad_halves_plus<mode> (step1, operands[1]));
1452   emit_insn (gen_reduc_splus_<V_half> (res_d, step1));
1453   emit_insn (gen_move_lo_quad_<mode> (operands[0], res_d));
1454
1455   DONE;
1456 })
1457
1458 (define_insn "reduc_splus_v2di"
1459   [(set (match_operand:V2DI 0 "s_register_operand" "=w")
1460         (unspec:V2DI [(match_operand:V2DI 1 "s_register_operand" "w")]
1461                      UNSPEC_VPADD))]
1462   "TARGET_NEON"
1463   "vadd.i64\t%e0, %e1, %f1"
1464   [(set_attr "neon_type" "neon_int_1")]
1465 )
1466
1467 ;; NEON does not distinguish between signed and unsigned addition except on
1468 ;; widening operations.
1469 (define_expand "reduc_uplus_<mode>"
1470   [(match_operand:VDQI 0 "s_register_operand" "")
1471    (match_operand:VDQI 1 "s_register_operand" "")]
1472   "TARGET_NEON"
1473 {
1474   emit_insn (gen_reduc_splus_<mode> (operands[0], operands[1]));
1475   DONE;
1476 })
1477
1478 (define_expand "reduc_smin_<mode>"
1479   [(match_operand:VD 0 "s_register_operand" "")
1480    (match_operand:VD 1 "s_register_operand" "")]
1481   "TARGET_NEON"
1482 {
1483   neon_pairwise_reduce (operands[0], operands[1], <MODE>mode,
1484                         &gen_neon_vpsmin<mode>);
1485   DONE;
1486 })
1487
1488 (define_expand "reduc_smin_<mode>"
1489   [(match_operand:VQ 0 "s_register_operand" "")
1490    (match_operand:VQ 1 "s_register_operand" "")]
1491   "TARGET_NEON"
1492 {
1493   rtx step1 = gen_reg_rtx (<V_HALF>mode);
1494   rtx res_d = gen_reg_rtx (<V_HALF>mode);
1495
1496   emit_insn (gen_quad_halves_smin<mode> (step1, operands[1]));
1497   emit_insn (gen_reduc_smin_<V_half> (res_d, step1));
1498   emit_insn (gen_move_lo_quad_<mode> (operands[0], res_d));
1499
1500   DONE;
1501 })
1502
1503 (define_expand "reduc_smax_<mode>"
1504   [(match_operand:VD 0 "s_register_operand" "")
1505    (match_operand:VD 1 "s_register_operand" "")]
1506   "TARGET_NEON"
1507 {
1508   neon_pairwise_reduce (operands[0], operands[1], <MODE>mode,
1509                         &gen_neon_vpsmax<mode>);
1510   DONE;
1511 })
1512
1513 (define_expand "reduc_smax_<mode>"
1514   [(match_operand:VQ 0 "s_register_operand" "")
1515    (match_operand:VQ 1 "s_register_operand" "")]
1516   "TARGET_NEON"
1517 {
1518   rtx step1 = gen_reg_rtx (<V_HALF>mode);
1519   rtx res_d = gen_reg_rtx (<V_HALF>mode);
1520
1521   emit_insn (gen_quad_halves_smax<mode> (step1, operands[1]));
1522   emit_insn (gen_reduc_smax_<V_half> (res_d, step1));
1523   emit_insn (gen_move_lo_quad_<mode> (operands[0], res_d));
1524
1525   DONE;
1526 })
1527
1528 (define_expand "reduc_umin_<mode>"
1529   [(match_operand:VDI 0 "s_register_operand" "")
1530    (match_operand:VDI 1 "s_register_operand" "")]
1531   "TARGET_NEON"
1532 {
1533   neon_pairwise_reduce (operands[0], operands[1], <MODE>mode,
1534                         &gen_neon_vpumin<mode>);
1535   DONE;
1536 })
1537
1538 (define_expand "reduc_umin_<mode>"
1539   [(match_operand:VQI 0 "s_register_operand" "")
1540    (match_operand:VQI 1 "s_register_operand" "")]
1541   "TARGET_NEON"
1542 {
1543   rtx step1 = gen_reg_rtx (<V_HALF>mode);
1544   rtx res_d = gen_reg_rtx (<V_HALF>mode);
1545
1546   emit_insn (gen_quad_halves_umin<mode> (step1, operands[1]));
1547   emit_insn (gen_reduc_umin_<V_half> (res_d, step1));
1548   emit_insn (gen_move_lo_quad_<mode> (operands[0], res_d));
1549
1550   DONE;
1551 })
1552
1553 (define_expand "reduc_umax_<mode>"
1554   [(match_operand:VDI 0 "s_register_operand" "")
1555    (match_operand:VDI 1 "s_register_operand" "")]
1556   "TARGET_NEON"
1557 {
1558   neon_pairwise_reduce (operands[0], operands[1], <MODE>mode,
1559                         &gen_neon_vpumax<mode>);
1560   DONE;
1561 })
1562
1563 (define_expand "reduc_umax_<mode>"
1564   [(match_operand:VQI 0 "s_register_operand" "")
1565    (match_operand:VQI 1 "s_register_operand" "")]
1566   "TARGET_NEON"
1567 {
1568   rtx step1 = gen_reg_rtx (<V_HALF>mode);
1569   rtx res_d = gen_reg_rtx (<V_HALF>mode);
1570
1571   emit_insn (gen_quad_halves_umax<mode> (step1, operands[1]));
1572   emit_insn (gen_reduc_umax_<V_half> (res_d, step1));
1573   emit_insn (gen_move_lo_quad_<mode> (operands[0], res_d));
1574
1575   DONE;
1576 })
1577
1578 (define_insn "neon_vpadd_internal<mode>"
1579   [(set (match_operand:VD 0 "s_register_operand" "=w")
1580         (unspec:VD [(match_operand:VD 1 "s_register_operand" "w")
1581                     (match_operand:VD 2 "s_register_operand" "w")]
1582                    UNSPEC_VPADD))]
1583   "TARGET_NEON"
1584   "vpadd.<V_if_elem>\t%P0, %P1, %P2"
1585   ;; Assume this schedules like vadd.
1586   [(set (attr "neon_type")
1587       (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
1588                     (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
1589                                   (const_string "neon_fp_vadd_ddd_vabs_dd")
1590                                   (const_string "neon_fp_vadd_qqq_vabs_qq"))
1591                     (const_string "neon_int_1")))]
1592 )
1593
1594 (define_insn "neon_vpsmin<mode>"
1595   [(set (match_operand:VD 0 "s_register_operand" "=w")
1596         (unspec:VD [(match_operand:VD 1 "s_register_operand" "w")
1597                     (match_operand:VD 2 "s_register_operand" "w")]
1598                    UNSPEC_VPSMIN))]
1599   "TARGET_NEON"
1600   "vpmin.<V_s_elem>\t%P0, %P1, %P2"
1601   ;; Assume this schedules like vmin.
1602   [(set (attr "neon_type")
1603       (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
1604                     (const_string "neon_fp_vadd_ddd_vabs_dd")
1605                     (const_string "neon_int_5")))]
1606 )
1607
1608 (define_insn "neon_vpsmax<mode>"
1609   [(set (match_operand:VD 0 "s_register_operand" "=w")
1610         (unspec:VD [(match_operand:VD 1 "s_register_operand" "w")
1611                     (match_operand:VD 2 "s_register_operand" "w")]
1612                    UNSPEC_VPSMAX))]
1613   "TARGET_NEON"
1614   "vpmax.<V_s_elem>\t%P0, %P1, %P2"
1615   ;; Assume this schedules like vmax.
1616   [(set (attr "neon_type")
1617       (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
1618                     (const_string "neon_fp_vadd_ddd_vabs_dd")
1619                     (const_string "neon_int_5")))]
1620 )
1621
1622 (define_insn "neon_vpumin<mode>"
1623   [(set (match_operand:VDI 0 "s_register_operand" "=w")
1624         (unspec:VDI [(match_operand:VDI 1 "s_register_operand" "w")
1625                      (match_operand:VDI 2 "s_register_operand" "w")]
1626                    UNSPEC_VPUMIN))]
1627   "TARGET_NEON"
1628   "vpmin.<V_u_elem>\t%P0, %P1, %P2"
1629   ;; Assume this schedules like umin.
1630   [(set_attr "neon_type" "neon_int_5")]
1631 )
1632
1633 (define_insn "neon_vpumax<mode>"
1634   [(set (match_operand:VDI 0 "s_register_operand" "=w")
1635         (unspec:VDI [(match_operand:VDI 1 "s_register_operand" "w")
1636                      (match_operand:VDI 2 "s_register_operand" "w")]
1637                    UNSPEC_VPUMAX))]
1638   "TARGET_NEON"
1639   "vpmax.<V_u_elem>\t%P0, %P1, %P2"
1640   ;; Assume this schedules like umax.
1641   [(set_attr "neon_type" "neon_int_5")]
1642 )
1643
1644 ;; Saturating arithmetic
1645
1646 ; NOTE: Neon supports many more saturating variants of instructions than the
1647 ; following, but these are all GCC currently understands.
1648 ; FIXME: Actually, GCC doesn't know how to create saturating add/sub by itself
1649 ; yet either, although these patterns may be used by intrinsics when they're
1650 ; added.
1651
1652 (define_insn "*ss_add<mode>_neon"
1653   [(set (match_operand:VD 0 "s_register_operand" "=w")
1654        (ss_plus:VD (match_operand:VD 1 "s_register_operand" "w")
1655                    (match_operand:VD 2 "s_register_operand" "w")))]
1656   "TARGET_NEON"
1657   "vqadd.<V_s_elem>\t%P0, %P1, %P2"
1658   [(set_attr "neon_type" "neon_int_4")]
1659 )
1660
1661 (define_insn "*us_add<mode>_neon"
1662   [(set (match_operand:VD 0 "s_register_operand" "=w")
1663        (us_plus:VD (match_operand:VD 1 "s_register_operand" "w")
1664                    (match_operand:VD 2 "s_register_operand" "w")))]
1665   "TARGET_NEON"
1666   "vqadd.<V_u_elem>\t%P0, %P1, %P2"
1667   [(set_attr "neon_type" "neon_int_4")]
1668 )
1669
1670 (define_insn "*ss_sub<mode>_neon"
1671   [(set (match_operand:VD 0 "s_register_operand" "=w")
1672        (ss_minus:VD (match_operand:VD 1 "s_register_operand" "w")
1673                     (match_operand:VD 2 "s_register_operand" "w")))]
1674   "TARGET_NEON"
1675   "vqsub.<V_s_elem>\t%P0, %P1, %P2"
1676   [(set_attr "neon_type" "neon_int_5")]
1677 )
1678
1679 (define_insn "*us_sub<mode>_neon"
1680   [(set (match_operand:VD 0 "s_register_operand" "=w")
1681        (us_minus:VD (match_operand:VD 1 "s_register_operand" "w")
1682                     (match_operand:VD 2 "s_register_operand" "w")))]
1683   "TARGET_NEON"
1684   "vqsub.<V_u_elem>\t%P0, %P1, %P2"
1685   [(set_attr "neon_type" "neon_int_5")]
1686 )
1687
1688 ;; Patterns for builtins.
1689
1690 ; good for plain vadd, vaddq.
1691
1692 (define_insn "neon_vadd<mode>"
1693   [(set (match_operand:VDQX 0 "s_register_operand" "=w")
1694         (unspec:VDQX [(match_operand:VDQX 1 "s_register_operand" "w")
1695                       (match_operand:VDQX 2 "s_register_operand" "w")
1696                       (match_operand:SI 3 "immediate_operand" "i")]
1697                      UNSPEC_VADD))]
1698   "TARGET_NEON"
1699   "vadd.<V_if_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
1700   [(set (attr "neon_type")
1701       (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
1702                     (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
1703                                   (const_string "neon_fp_vadd_ddd_vabs_dd")
1704                                   (const_string "neon_fp_vadd_qqq_vabs_qq"))
1705                     (const_string "neon_int_1")))]
1706 )
1707
1708 ; operand 3 represents in bits:
1709 ;  bit 0: signed (vs unsigned).
1710 ;  bit 1: rounding (vs none).
1711
1712 (define_insn "neon_vaddl<mode>"
1713   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
1714         (unspec:<V_widen> [(match_operand:VDI 1 "s_register_operand" "w")
1715                            (match_operand:VDI 2 "s_register_operand" "w")
1716                            (match_operand:SI 3 "immediate_operand" "i")]
1717                           UNSPEC_VADDL))]
1718   "TARGET_NEON"
1719   "vaddl.%T3%#<V_sz_elem>\t%q0, %P1, %P2"
1720   [(set_attr "neon_type" "neon_int_3")]
1721 )
1722
1723 (define_insn "neon_vaddw<mode>"
1724   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
1725         (unspec:<V_widen> [(match_operand:<V_widen> 1 "s_register_operand" "w")
1726                            (match_operand:VDI 2 "s_register_operand" "w")
1727                            (match_operand:SI 3 "immediate_operand" "i")]
1728                           UNSPEC_VADDW))]
1729   "TARGET_NEON"
1730   "vaddw.%T3%#<V_sz_elem>\t%q0, %q1, %P2"
1731   [(set_attr "neon_type" "neon_int_2")]
1732 )
1733
1734 ; vhadd and vrhadd.
1735
1736 (define_insn "neon_vhadd<mode>"
1737   [(set (match_operand:VDQIW 0 "s_register_operand" "=w")
1738         (unspec:VDQIW [(match_operand:VDQIW 1 "s_register_operand" "w")
1739                        (match_operand:VDQIW 2 "s_register_operand" "w")
1740                        (match_operand:SI 3 "immediate_operand" "i")]
1741                       UNSPEC_VHADD))]
1742   "TARGET_NEON"
1743   "v%O3hadd.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
1744   [(set_attr "neon_type" "neon_int_4")]
1745 )
1746
1747 (define_insn "neon_vqadd<mode>"
1748   [(set (match_operand:VDQIX 0 "s_register_operand" "=w")
1749         (unspec:VDQIX [(match_operand:VDQIX 1 "s_register_operand" "w")
1750                        (match_operand:VDQIX 2 "s_register_operand" "w")
1751                        (match_operand:SI 3 "immediate_operand" "i")]
1752                      UNSPEC_VQADD))]
1753   "TARGET_NEON"
1754   "vqadd.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
1755   [(set_attr "neon_type" "neon_int_4")]
1756 )
1757
1758 (define_insn "neon_vaddhn<mode>"
1759   [(set (match_operand:<V_narrow> 0 "s_register_operand" "=w")
1760         (unspec:<V_narrow> [(match_operand:VN 1 "s_register_operand" "w")
1761                             (match_operand:VN 2 "s_register_operand" "w")
1762                             (match_operand:SI 3 "immediate_operand" "i")]
1763                            UNSPEC_VADDHN))]
1764   "TARGET_NEON"
1765   "v%O3addhn.<V_if_elem>\t%P0, %q1, %q2"
1766   [(set_attr "neon_type" "neon_int_4")]
1767 )
1768
1769 (define_insn "neon_vmul<mode>"
1770   [(set (match_operand:VDQW 0 "s_register_operand" "=w")
1771         (unspec:VDQW [(match_operand:VDQW 1 "s_register_operand" "w")
1772                       (match_operand:VDQW 2 "s_register_operand" "w")
1773                       (match_operand:SI 3 "immediate_operand" "i")]
1774                      UNSPEC_VMUL))]
1775   "TARGET_NEON"
1776   "vmul.%F3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
1777   [(set (attr "neon_type")
1778       (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
1779                     (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
1780                                   (const_string "neon_fp_vadd_ddd_vabs_dd")
1781                                   (const_string "neon_fp_vadd_qqq_vabs_qq"))
1782                     (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
1783                                   (if_then_else
1784                                     (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
1785                                     (const_string "neon_mul_ddd_8_16_qdd_16_8_long_32_16_long")
1786                                     (const_string "neon_mul_qqq_8_16_32_ddd_32"))
1787                                   (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
1788                                     (const_string "neon_mul_qqq_8_16_32_ddd_32")
1789                                     (const_string "neon_mul_qqq_8_16_32_ddd_32")))))]
1790 )
1791
1792 (define_insn "neon_vmla<mode>"
1793   [(set (match_operand:VDQW 0 "s_register_operand" "=w")
1794         (unspec:VDQW [(match_operand:VDQW 1 "s_register_operand" "0")
1795                       (match_operand:VDQW 2 "s_register_operand" "w")
1796                       (match_operand:VDQW 3 "s_register_operand" "w")
1797                      (match_operand:SI 4 "immediate_operand" "i")]
1798                     UNSPEC_VMLA))]
1799   "TARGET_NEON"
1800   "vmla.<V_if_elem>\t%<V_reg>0, %<V_reg>2, %<V_reg>3"
1801   [(set (attr "neon_type")
1802       (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
1803                     (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
1804                                   (const_string "neon_fp_vmla_ddd")
1805                                   (const_string "neon_fp_vmla_qqq"))
1806                     (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
1807                                   (if_then_else
1808                                     (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
1809                                     (const_string "neon_mla_ddd_8_16_qdd_16_8_long_32_16_long")
1810                                     (const_string "neon_mla_ddd_32_qqd_16_ddd_32_scalar_qdd_64_32_long_scalar_qdd_64_32_long"))
1811                                   (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
1812                                     (const_string "neon_mla_qqq_8_16")
1813                                     (const_string "neon_mla_qqq_32_qqd_32_scalar")))))]
1814 )
1815
1816 (define_insn "neon_vmlal<mode>"
1817   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
1818         (unspec:<V_widen> [(match_operand:<V_widen> 1 "s_register_operand" "0")
1819                            (match_operand:VW 2 "s_register_operand" "w")
1820                            (match_operand:VW 3 "s_register_operand" "w")
1821                            (match_operand:SI 4 "immediate_operand" "i")]
1822                           UNSPEC_VMLAL))]
1823   "TARGET_NEON"
1824   "vmlal.%T4%#<V_sz_elem>\t%q0, %P2, %P3"
1825   [(set (attr "neon_type")
1826      (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
1827                    (const_string "neon_mla_ddd_8_16_qdd_16_8_long_32_16_long")
1828                    (const_string "neon_mla_ddd_32_qqd_16_ddd_32_scalar_qdd_64_32_long_scalar_qdd_64_32_long")))]
1829 )
1830
1831 (define_insn "neon_vmls<mode>"
1832   [(set (match_operand:VDQW 0 "s_register_operand" "=w")
1833         (unspec:VDQW [(match_operand:VDQW 1 "s_register_operand" "0")
1834                       (match_operand:VDQW 2 "s_register_operand" "w")
1835                       (match_operand:VDQW 3 "s_register_operand" "w")
1836                      (match_operand:SI 4 "immediate_operand" "i")]
1837                     UNSPEC_VMLS))]
1838   "TARGET_NEON"
1839   "vmls.<V_if_elem>\t%<V_reg>0, %<V_reg>2, %<V_reg>3"
1840   [(set (attr "neon_type")
1841       (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
1842                     (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
1843                                   (const_string "neon_fp_vmla_ddd")
1844                                   (const_string "neon_fp_vmla_qqq"))
1845                     (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
1846                                   (if_then_else
1847                                     (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
1848                                     (const_string "neon_mla_ddd_8_16_qdd_16_8_long_32_16_long")
1849                                     (const_string "neon_mla_ddd_32_qqd_16_ddd_32_scalar_qdd_64_32_long_scalar_qdd_64_32_long"))
1850                                   (if_then_else
1851                                     (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
1852                                     (const_string "neon_mla_qqq_8_16")
1853                                     (const_string "neon_mla_qqq_32_qqd_32_scalar")))))]
1854 )
1855
1856 (define_insn "neon_vmlsl<mode>"
1857   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
1858         (unspec:<V_widen> [(match_operand:<V_widen> 1 "s_register_operand" "0")
1859                            (match_operand:VW 2 "s_register_operand" "w")
1860                            (match_operand:VW 3 "s_register_operand" "w")
1861                            (match_operand:SI 4 "immediate_operand" "i")]
1862                           UNSPEC_VMLSL))]
1863   "TARGET_NEON"
1864   "vmlsl.%T4%#<V_sz_elem>\t%q0, %P2, %P3"
1865   [(set (attr "neon_type")
1866      (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
1867                    (const_string "neon_mla_ddd_8_16_qdd_16_8_long_32_16_long")
1868                    (const_string "neon_mla_ddd_32_qqd_16_ddd_32_scalar_qdd_64_32_long_scalar_qdd_64_32_long")))]
1869 )
1870
1871 (define_insn "neon_vqdmulh<mode>"
1872   [(set (match_operand:VMDQI 0 "s_register_operand" "=w")
1873         (unspec:VMDQI [(match_operand:VMDQI 1 "s_register_operand" "w")
1874                        (match_operand:VMDQI 2 "s_register_operand" "w")
1875                        (match_operand:SI 3 "immediate_operand" "i")]
1876                       UNSPEC_VQDMULH))]
1877   "TARGET_NEON"
1878   "vq%O3dmulh.<V_s_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
1879   [(set (attr "neon_type")
1880      (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
1881         (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
1882                       (const_string "neon_mul_ddd_8_16_qdd_16_8_long_32_16_long")
1883                       (const_string "neon_mul_qqq_8_16_32_ddd_32"))
1884         (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
1885                       (const_string "neon_mul_qqq_8_16_32_ddd_32")
1886                       (const_string "neon_mul_qqq_8_16_32_ddd_32"))))]
1887 )
1888
1889 (define_insn "neon_vqdmlal<mode>"
1890   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
1891         (unspec:<V_widen> [(match_operand:<V_widen> 1 "s_register_operand" "0")
1892                            (match_operand:VMDI 2 "s_register_operand" "w")
1893                            (match_operand:VMDI 3 "s_register_operand" "w")
1894                            (match_operand:SI 4 "immediate_operand" "i")]
1895                           UNSPEC_VQDMLAL))]
1896   "TARGET_NEON"
1897   "vqdmlal.<V_s_elem>\t%q0, %P2, %P3"
1898   [(set (attr "neon_type")
1899      (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
1900                    (const_string "neon_mla_ddd_8_16_qdd_16_8_long_32_16_long")
1901                    (const_string "neon_mla_ddd_32_qqd_16_ddd_32_scalar_qdd_64_32_long_scalar_qdd_64_32_long")))]
1902 )
1903
1904 (define_insn "neon_vqdmlsl<mode>"
1905   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
1906         (unspec:<V_widen> [(match_operand:<V_widen> 1 "s_register_operand" "0")
1907                            (match_operand:VMDI 2 "s_register_operand" "w")
1908                            (match_operand:VMDI 3 "s_register_operand" "w")
1909                            (match_operand:SI 4 "immediate_operand" "i")]
1910                           UNSPEC_VQDMLSL))]
1911   "TARGET_NEON"
1912   "vqdmlsl.<V_s_elem>\t%q0, %P2, %P3"
1913   [(set (attr "neon_type")
1914      (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
1915                    (const_string "neon_mla_ddd_8_16_qdd_16_8_long_32_16_long")
1916                    (const_string "neon_mla_ddd_32_qqd_16_ddd_32_scalar_qdd_64_32_long_scalar_qdd_64_32_long")))]
1917 )
1918
1919 (define_insn "neon_vmull<mode>"
1920   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
1921         (unspec:<V_widen> [(match_operand:VW 1 "s_register_operand" "w")
1922                            (match_operand:VW 2 "s_register_operand" "w")
1923                            (match_operand:SI 3 "immediate_operand" "i")]
1924                           UNSPEC_VMULL))]
1925   "TARGET_NEON"
1926   "vmull.%T3%#<V_sz_elem>\t%q0, %P1, %P2"
1927   [(set (attr "neon_type")
1928      (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
1929                    (const_string "neon_mul_ddd_8_16_qdd_16_8_long_32_16_long")
1930                    (const_string "neon_mul_qdd_64_32_long_qqd_16_ddd_32_scalar_64_32_long_scalar")))]
1931 )
1932
1933 (define_insn "neon_vqdmull<mode>"
1934   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
1935         (unspec:<V_widen> [(match_operand:VMDI 1 "s_register_operand" "w")
1936                            (match_operand:VMDI 2 "s_register_operand" "w")
1937                            (match_operand:SI 3 "immediate_operand" "i")]
1938                           UNSPEC_VQDMULL))]
1939   "TARGET_NEON"
1940   "vqdmull.<V_s_elem>\t%q0, %P1, %P2"
1941   [(set (attr "neon_type")
1942      (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
1943                    (const_string "neon_mul_ddd_8_16_qdd_16_8_long_32_16_long")
1944                    (const_string "neon_mul_qdd_64_32_long_qqd_16_ddd_32_scalar_64_32_long_scalar")))]
1945 )
1946
1947 (define_insn "neon_vsub<mode>"
1948   [(set (match_operand:VDQX 0 "s_register_operand" "=w")
1949         (unspec:VDQX [(match_operand:VDQX 1 "s_register_operand" "w")
1950                       (match_operand:VDQX 2 "s_register_operand" "w")
1951                       (match_operand:SI 3 "immediate_operand" "i")]
1952                      UNSPEC_VSUB))]
1953   "TARGET_NEON"
1954   "vsub.<V_if_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
1955   [(set (attr "neon_type")
1956       (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
1957                     (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
1958                                   (const_string "neon_fp_vadd_ddd_vabs_dd")
1959                                   (const_string "neon_fp_vadd_qqq_vabs_qq"))
1960                     (const_string "neon_int_2")))]
1961 )
1962
1963 (define_insn "neon_vsubl<mode>"
1964   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
1965         (unspec:<V_widen> [(match_operand:VDI 1 "s_register_operand" "w")
1966                            (match_operand:VDI 2 "s_register_operand" "w")
1967                            (match_operand:SI 3 "immediate_operand" "i")]
1968                           UNSPEC_VSUBL))]
1969   "TARGET_NEON"
1970   "vsubl.%T3%#<V_sz_elem>\t%q0, %P1, %P2"
1971   [(set_attr "neon_type" "neon_int_2")]
1972 )
1973
1974 (define_insn "neon_vsubw<mode>"
1975   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
1976         (unspec:<V_widen> [(match_operand:<V_widen> 1 "s_register_operand" "w")
1977                            (match_operand:VDI 2 "s_register_operand" "w")
1978                            (match_operand:SI 3 "immediate_operand" "i")]
1979                           UNSPEC_VSUBW))]
1980   "TARGET_NEON"
1981   "vsubw.%T3%#<V_sz_elem>\t%q0, %q1, %P2"
1982   [(set_attr "neon_type" "neon_int_2")]
1983 )
1984
1985 (define_insn "neon_vqsub<mode>"
1986   [(set (match_operand:VDQIX 0 "s_register_operand" "=w")
1987         (unspec:VDQIX [(match_operand:VDQIX 1 "s_register_operand" "w")
1988                        (match_operand:VDQIX 2 "s_register_operand" "w")
1989                        (match_operand:SI 3 "immediate_operand" "i")]
1990                       UNSPEC_VQSUB))]
1991   "TARGET_NEON"
1992   "vqsub.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
1993   [(set_attr "neon_type" "neon_int_5")]
1994 )
1995
1996 (define_insn "neon_vhsub<mode>"
1997   [(set (match_operand:VDQIW 0 "s_register_operand" "=w")
1998         (unspec:VDQIW [(match_operand:VDQIW 1 "s_register_operand" "w")
1999                        (match_operand:VDQIW 2 "s_register_operand" "w")
2000                        (match_operand:SI 3 "immediate_operand" "i")]
2001                       UNSPEC_VHSUB))]
2002   "TARGET_NEON"
2003   "vhsub.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
2004   [(set_attr "neon_type" "neon_int_5")]
2005 )
2006
2007 (define_insn "neon_vsubhn<mode>"
2008   [(set (match_operand:<V_narrow> 0 "s_register_operand" "=w")
2009         (unspec:<V_narrow> [(match_operand:VN 1 "s_register_operand" "w")
2010                             (match_operand:VN 2 "s_register_operand" "w")
2011                             (match_operand:SI 3 "immediate_operand" "i")]
2012                            UNSPEC_VSUBHN))]
2013   "TARGET_NEON"
2014   "v%O3subhn.<V_if_elem>\t%P0, %q1, %q2"
2015   [(set_attr "neon_type" "neon_int_4")]
2016 )
2017
2018 (define_insn "neon_vceq<mode>"
2019   [(set (match_operand:<V_cmp_result> 0 "s_register_operand" "=w")
2020         (unspec:<V_cmp_result> [(match_operand:VDQW 1 "s_register_operand" "w")
2021                                 (match_operand:VDQW 2 "s_register_operand" "w")
2022                                 (match_operand:SI 3 "immediate_operand" "i")]
2023                                UNSPEC_VCEQ))]
2024   "TARGET_NEON"
2025   "vceq.<V_if_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
2026   [(set (attr "neon_type")
2027       (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
2028                     (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
2029                                   (const_string "neon_fp_vadd_ddd_vabs_dd")
2030                                   (const_string "neon_fp_vadd_qqq_vabs_qq"))
2031                     (const_string "neon_int_5")))]
2032 )
2033
2034 (define_insn "neon_vcge<mode>"
2035   [(set (match_operand:<V_cmp_result> 0 "s_register_operand" "=w")
2036         (unspec:<V_cmp_result> [(match_operand:VDQW 1 "s_register_operand" "w")
2037                                 (match_operand:VDQW 2 "s_register_operand" "w")
2038                                 (match_operand:SI 3 "immediate_operand" "i")]
2039                                UNSPEC_VCGE))]
2040   "TARGET_NEON"
2041   "vcge.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
2042   [(set (attr "neon_type")
2043      (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
2044                    (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
2045                                  (const_string "neon_fp_vadd_ddd_vabs_dd")
2046                                  (const_string "neon_fp_vadd_qqq_vabs_qq"))
2047                    (const_string "neon_int_5")))]
2048 )
2049
2050 (define_insn "neon_vcgt<mode>"
2051   [(set (match_operand:<V_cmp_result> 0 "s_register_operand" "=w")
2052         (unspec:<V_cmp_result> [(match_operand:VDQW 1 "s_register_operand" "w")
2053                                 (match_operand:VDQW 2 "s_register_operand" "w")
2054                                 (match_operand:SI 3 "immediate_operand" "i")]
2055                                UNSPEC_VCGT))]
2056   "TARGET_NEON"
2057   "vcgt.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
2058   [(set (attr "neon_type")
2059      (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
2060                    (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
2061                                  (const_string "neon_fp_vadd_ddd_vabs_dd")
2062                                  (const_string "neon_fp_vadd_qqq_vabs_qq"))
2063                    (const_string "neon_int_5")))]
2064 )
2065
2066 (define_insn "neon_vcage<mode>"
2067   [(set (match_operand:<V_cmp_result> 0 "s_register_operand" "=w")
2068         (unspec:<V_cmp_result> [(match_operand:VCVTF 1 "s_register_operand" "w")
2069                                 (match_operand:VCVTF 2 "s_register_operand" "w")
2070                                 (match_operand:SI 3 "immediate_operand" "i")]
2071                                UNSPEC_VCAGE))]
2072   "TARGET_NEON"
2073   "vacge.<V_if_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
2074   [(set (attr "neon_type")
2075      (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
2076                    (const_string "neon_fp_vadd_ddd_vabs_dd")
2077                    (const_string "neon_fp_vadd_qqq_vabs_qq")))]
2078 )
2079
2080 (define_insn "neon_vcagt<mode>"
2081   [(set (match_operand:<V_cmp_result> 0 "s_register_operand" "=w")
2082         (unspec:<V_cmp_result> [(match_operand:VCVTF 1 "s_register_operand" "w")
2083                                 (match_operand:VCVTF 2 "s_register_operand" "w")
2084                                 (match_operand:SI 3 "immediate_operand" "i")]
2085                                UNSPEC_VCAGT))]
2086   "TARGET_NEON"
2087   "vacgt.<V_if_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
2088   [(set (attr "neon_type")
2089      (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
2090                    (const_string "neon_fp_vadd_ddd_vabs_dd")
2091                    (const_string "neon_fp_vadd_qqq_vabs_qq")))]
2092 )
2093
2094 (define_insn "neon_vtst<mode>"
2095   [(set (match_operand:VDQIW 0 "s_register_operand" "=w")
2096         (unspec:VDQIW [(match_operand:VDQIW 1 "s_register_operand" "w")
2097                        (match_operand:VDQIW 2 "s_register_operand" "w")
2098                        (match_operand:SI 3 "immediate_operand" "i")]
2099                       UNSPEC_VTST))]
2100   "TARGET_NEON"
2101   "vtst.<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
2102   [(set_attr "neon_type" "neon_int_4")]
2103 )
2104
2105 (define_insn "neon_vabd<mode>"
2106   [(set (match_operand:VDQW 0 "s_register_operand" "=w")
2107         (unspec:VDQW [(match_operand:VDQW 1 "s_register_operand" "w")
2108                       (match_operand:VDQW 2 "s_register_operand" "w")
2109                       (match_operand:SI 3 "immediate_operand" "i")]
2110                      UNSPEC_VABD))]
2111   "TARGET_NEON"
2112   "vabd.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
2113   [(set (attr "neon_type")
2114      (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
2115                    (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
2116                                  (const_string "neon_fp_vadd_ddd_vabs_dd")
2117                                  (const_string "neon_fp_vadd_qqq_vabs_qq"))
2118                    (const_string "neon_int_5")))]
2119 )
2120
2121 (define_insn "neon_vabdl<mode>"
2122   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
2123         (unspec:<V_widen> [(match_operand:VW 1 "s_register_operand" "w")
2124                            (match_operand:VW 2 "s_register_operand" "w")
2125                            (match_operand:SI 3 "immediate_operand" "i")]
2126                           UNSPEC_VABDL))]
2127   "TARGET_NEON"
2128   "vabdl.%T3%#<V_sz_elem>\t%q0, %P1, %P2"
2129   [(set_attr "neon_type" "neon_int_5")]
2130 )
2131
2132 (define_insn "neon_vaba<mode>"
2133   [(set (match_operand:VDQIW 0 "s_register_operand" "=w")
2134         (unspec:VDQIW [(match_operand:VDQIW 1 "s_register_operand" "0")
2135                        (match_operand:VDQIW 2 "s_register_operand" "w")
2136                        (match_operand:VDQIW 3 "s_register_operand" "w")
2137                        (match_operand:SI 4 "immediate_operand" "i")]
2138                       UNSPEC_VABA))]
2139   "TARGET_NEON"
2140   "vaba.%T4%#<V_sz_elem>\t%<V_reg>0, %<V_reg>2, %<V_reg>3"
2141   [(set (attr "neon_type")
2142      (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
2143                    (const_string "neon_vaba") (const_string "neon_vaba_qqq")))]
2144 )
2145
2146 (define_insn "neon_vabal<mode>"
2147   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
2148         (unspec:<V_widen> [(match_operand:<V_widen> 1 "s_register_operand" "0")
2149                            (match_operand:VW 2 "s_register_operand" "w")
2150                            (match_operand:VW 3 "s_register_operand" "w")
2151                            (match_operand:SI 4 "immediate_operand" "i")]
2152                           UNSPEC_VABAL))]
2153   "TARGET_NEON"
2154   "vabal.%T4%#<V_sz_elem>\t%q0, %P2, %P3"
2155   [(set_attr "neon_type" "neon_vaba")]
2156 )
2157
2158 (define_insn "neon_vmax<mode>"
2159   [(set (match_operand:VDQW 0 "s_register_operand" "=w")
2160         (unspec:VDQW [(match_operand:VDQW 1 "s_register_operand" "w")
2161                       (match_operand:VDQW 2 "s_register_operand" "w")
2162                       (match_operand:SI 3 "immediate_operand" "i")]
2163                      UNSPEC_VMAX))]
2164   "TARGET_NEON"
2165   "vmax.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
2166   [(set (attr "neon_type")
2167     (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
2168                   (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
2169                                 (const_string "neon_fp_vadd_ddd_vabs_dd")
2170                                 (const_string "neon_fp_vadd_qqq_vabs_qq"))
2171                   (const_string "neon_int_5")))]
2172 )
2173
2174 (define_insn "neon_vmin<mode>"
2175   [(set (match_operand:VDQW 0 "s_register_operand" "=w")
2176         (unspec:VDQW [(match_operand:VDQW 1 "s_register_operand" "w")
2177                       (match_operand:VDQW 2 "s_register_operand" "w")
2178                       (match_operand:SI 3 "immediate_operand" "i")]
2179                      UNSPEC_VMIN))]
2180   "TARGET_NEON"
2181   "vmin.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
2182   [(set (attr "neon_type")
2183     (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
2184                   (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
2185                                 (const_string "neon_fp_vadd_ddd_vabs_dd")
2186                                 (const_string "neon_fp_vadd_qqq_vabs_qq"))
2187                   (const_string "neon_int_5")))]
2188 )
2189
2190 (define_expand "neon_vpadd<mode>"
2191   [(match_operand:VD 0 "s_register_operand" "=w")
2192    (match_operand:VD 1 "s_register_operand" "w")
2193    (match_operand:VD 2 "s_register_operand" "w")
2194    (match_operand:SI 3 "immediate_operand" "i")]
2195   "TARGET_NEON"
2196 {
2197   emit_insn (gen_neon_vpadd_internal<mode> (operands[0], operands[1],
2198                                             operands[2]));
2199   DONE;
2200 })
2201
2202 (define_insn "neon_vpaddl<mode>"
2203   [(set (match_operand:<V_double_width> 0 "s_register_operand" "=w")
2204         (unspec:<V_double_width> [(match_operand:VDQIW 1 "s_register_operand" "w")
2205                                   (match_operand:SI 2 "immediate_operand" "i")]
2206                                  UNSPEC_VPADDL))]
2207   "TARGET_NEON"
2208   "vpaddl.%T2%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1"
2209   ;; Assume this schedules like vaddl.
2210   [(set_attr "neon_type" "neon_int_3")]
2211 )
2212
2213 (define_insn "neon_vpadal<mode>"
2214   [(set (match_operand:<V_double_width> 0 "s_register_operand" "=w")
2215         (unspec:<V_double_width> [(match_operand:<V_double_width> 1 "s_register_operand" "0")
2216                                   (match_operand:VDQIW 2 "s_register_operand" "w")
2217                                   (match_operand:SI 3 "immediate_operand" "i")]
2218                                  UNSPEC_VPADAL))]
2219   "TARGET_NEON"
2220   "vpadal.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>2"
2221   ;; Assume this schedules like vpadd.
2222   [(set_attr "neon_type" "neon_int_1")]
2223 )
2224
2225 (define_insn "neon_vpmax<mode>"
2226   [(set (match_operand:VD 0 "s_register_operand" "=w")
2227         (unspec:VD [(match_operand:VD 1 "s_register_operand" "w")
2228                     (match_operand:VD 2 "s_register_operand" "w")
2229                     (match_operand:SI 3 "immediate_operand" "i")]
2230                    UNSPEC_VPMAX))]
2231   "TARGET_NEON"
2232   "vpmax.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
2233   ;; Assume this schedules like vmax.
2234   [(set (attr "neon_type")
2235     (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
2236                   (const_string "neon_fp_vadd_ddd_vabs_dd")
2237                   (const_string "neon_int_5")))]
2238 )
2239
2240 (define_insn "neon_vpmin<mode>"
2241   [(set (match_operand:VD 0 "s_register_operand" "=w")
2242         (unspec:VD [(match_operand:VD 1 "s_register_operand" "w")
2243                     (match_operand:VD 2 "s_register_operand" "w")
2244                     (match_operand:SI 3 "immediate_operand" "i")]
2245                    UNSPEC_VPMIN))]
2246   "TARGET_NEON"
2247   "vpmin.%T3%#<V_sz_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
2248   ;; Assume this schedules like vmin.
2249   [(set (attr "neon_type")
2250     (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
2251                   (const_string "neon_fp_vadd_ddd_vabs_dd")
2252                   (const_string "neon_int_5")))]
2253 )
2254
2255 (define_insn "neon_vrecps<mode>"
2256   [(set (match_operand:VCVTF 0 "s_register_operand" "=w")
2257         (unspec:VCVTF [(match_operand:VCVTF 1 "s_register_operand" "w")
2258                        (match_operand:VCVTF 2 "s_register_operand" "w")
2259                        (match_operand:SI 3 "immediate_operand" "i")]
2260                       UNSPEC_VRECPS))]
2261   "TARGET_NEON"
2262   "vrecps.<V_if_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
2263   [(set (attr "neon_type")
2264       (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
2265                     (const_string "neon_fp_vrecps_vrsqrts_ddd")
2266                     (const_string "neon_fp_vrecps_vrsqrts_qqq")))]
2267 )
2268
2269 (define_insn "neon_vrsqrts<mode>"
2270   [(set (match_operand:VCVTF 0 "s_register_operand" "=w")
2271         (unspec:VCVTF [(match_operand:VCVTF 1 "s_register_operand" "w")
2272                        (match_operand:VCVTF 2 "s_register_operand" "w")
2273                        (match_operand:SI 3 "immediate_operand" "i")]
2274                       UNSPEC_VRSQRTS))]
2275   "TARGET_NEON"
2276   "vrsqrts.<V_if_elem>\t%<V_reg>0, %<V_reg>1, %<V_reg>2"
2277   [(set (attr "neon_type")
2278       (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
2279                     (const_string "neon_fp_vrecps_vrsqrts_ddd")
2280                     (const_string "neon_fp_vrecps_vrsqrts_qqq")))]
2281 )
2282
2283 (define_insn "neon_vabs<mode>"
2284   [(set (match_operand:VDQW 0 "s_register_operand" "=w")
2285         (unspec:VDQW [(match_operand:VDQW 1 "s_register_operand" "w")
2286                       (match_operand:SI 2 "immediate_operand" "i")]
2287                      UNSPEC_VABS))]
2288   "TARGET_NEON"
2289   "vabs.<V_s_elem>\t%<V_reg>0, %<V_reg>1"
2290   [(set (attr "neon_type")
2291      (if_then_else (ior (ne (symbol_ref "<Is_float_mode>") (const_int 0))
2292                         (ne (symbol_ref "<Is_float_mode>") (const_int 0)))
2293                    (if_then_else
2294                       (ne (symbol_ref "<Is_d_reg>") (const_int 0))
2295                       (const_string "neon_fp_vadd_ddd_vabs_dd")
2296                       (const_string "neon_fp_vadd_qqq_vabs_qq"))
2297                    (const_string "neon_vqneg_vqabs")))]
2298 )
2299
2300 (define_insn "neon_vqabs<mode>"
2301   [(set (match_operand:VDQIW 0 "s_register_operand" "=w")
2302         (unspec:VDQIW [(match_operand:VDQIW 1 "s_register_operand" "w")
2303                        (match_operand:SI 2 "immediate_operand" "i")]
2304                       UNSPEC_VQABS))]
2305   "TARGET_NEON"
2306   "vqabs.<V_s_elem>\t%<V_reg>0, %<V_reg>1"
2307   [(set_attr "neon_type" "neon_vqneg_vqabs")]
2308 )
2309
2310 (define_expand "neon_vneg<mode>"
2311   [(match_operand:VDQW 0 "s_register_operand" "")
2312    (match_operand:VDQW 1 "s_register_operand" "")
2313    (match_operand:SI 2 "immediate_operand" "")]
2314   "TARGET_NEON"
2315 {
2316   emit_insn (gen_neg<mode>2 (operands[0], operands[1]));
2317   DONE;
2318 })
2319
2320 (define_insn "neon_vqneg<mode>"
2321   [(set (match_operand:VDQIW 0 "s_register_operand" "=w")
2322         (unspec:VDQIW [(match_operand:VDQIW 1 "s_register_operand" "w")
2323                        (match_operand:SI 2 "immediate_operand" "i")]
2324                       UNSPEC_VQNEG))]
2325   "TARGET_NEON"
2326   "vqneg.<V_s_elem>\t%<V_reg>0, %<V_reg>1"
2327   [(set_attr "neon_type" "neon_vqneg_vqabs")]
2328 )
2329
2330 (define_insn "neon_vcls<mode>"
2331   [(set (match_operand:VDQIW 0 "s_register_operand" "=w")
2332         (unspec:VDQIW [(match_operand:VDQIW 1 "s_register_operand" "w")
2333                        (match_operand:SI 2 "immediate_operand" "i")]
2334                       UNSPEC_VCLS))]
2335   "TARGET_NEON"
2336   "vcls.<V_s_elem>\t%<V_reg>0, %<V_reg>1"
2337   [(set_attr "neon_type" "neon_int_1")]
2338 )
2339
2340 (define_insn "neon_vclz<mode>"
2341   [(set (match_operand:VDQIW 0 "s_register_operand" "=w")
2342         (unspec:VDQIW [(match_operand:VDQIW 1 "s_register_operand" "w")
2343                        (match_operand:SI 2 "immediate_operand" "i")]
2344                       UNSPEC_VCLZ))]
2345   "TARGET_NEON"
2346   "vclz.<V_if_elem>\t%<V_reg>0, %<V_reg>1"
2347   [(set_attr "neon_type" "neon_int_1")]
2348 )
2349
2350 (define_insn "neon_vcnt<mode>"
2351   [(set (match_operand:VE 0 "s_register_operand" "=w")
2352         (unspec:VE [(match_operand:VE 1 "s_register_operand" "w")
2353                     (match_operand:SI 2 "immediate_operand" "i")]
2354                    UNSPEC_VCNT))]
2355   "TARGET_NEON"
2356   "vcnt.<V_sz_elem>\t%<V_reg>0, %<V_reg>1"
2357   [(set_attr "neon_type" "neon_int_1")]
2358 )
2359
2360 (define_insn "neon_vrecpe<mode>"
2361   [(set (match_operand:V32 0 "s_register_operand" "=w")
2362         (unspec:V32 [(match_operand:V32 1 "s_register_operand" "w")
2363                      (match_operand:SI 2 "immediate_operand" "i")]
2364                     UNSPEC_VRECPE))]
2365   "TARGET_NEON"
2366   "vrecpe.<V_u_elem>\t%<V_reg>0, %<V_reg>1"
2367   [(set (attr "neon_type")
2368       (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
2369                     (const_string "neon_fp_vadd_ddd_vabs_dd")
2370                     (const_string "neon_fp_vadd_qqq_vabs_qq")))]
2371 )
2372
2373 (define_insn "neon_vrsqrte<mode>"
2374   [(set (match_operand:V32 0 "s_register_operand" "=w")
2375         (unspec:V32 [(match_operand:V32 1 "s_register_operand" "w")
2376                      (match_operand:SI 2 "immediate_operand" "i")]
2377                     UNSPEC_VRSQRTE))]
2378   "TARGET_NEON"
2379   "vrsqrte.<V_u_elem>\t%<V_reg>0, %<V_reg>1"
2380   [(set (attr "neon_type")
2381       (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
2382                     (const_string "neon_fp_vadd_ddd_vabs_dd")
2383                     (const_string "neon_fp_vadd_qqq_vabs_qq")))]
2384 )
2385
2386 (define_expand "neon_vmvn<mode>"
2387   [(match_operand:VDQIW 0 "s_register_operand" "")
2388    (match_operand:VDQIW 1 "s_register_operand" "")
2389    (match_operand:SI 2 "immediate_operand" "")]
2390   "TARGET_NEON"
2391 {
2392   emit_insn (gen_one_cmpl<mode>2 (operands[0], operands[1]));
2393   DONE;
2394 })
2395
2396 (define_insn "neon_vget_lane<mode>_sext_internal"
2397   [(set (match_operand:SI 0 "s_register_operand" "=r")
2398         (sign_extend:SI
2399           (vec_select:<V_elem>
2400             (match_operand:VD 1 "s_register_operand" "w")
2401             (parallel [(match_operand:SI 2 "immediate_operand" "i")]))))]
2402   "TARGET_NEON"
2403   "vmov%?.s<V_sz_elem>\t%0, %P1[%c2]"
2404   [(set_attr "predicable" "yes")
2405    (set_attr "neon_type" "neon_bp_simple")]
2406 )
2407
2408 (define_insn "neon_vget_lane<mode>_zext_internal"
2409   [(set (match_operand:SI 0 "s_register_operand" "=r")
2410         (zero_extend:SI
2411           (vec_select:<V_elem>
2412             (match_operand:VD 1 "s_register_operand" "w")
2413             (parallel [(match_operand:SI 2 "immediate_operand" "i")]))))]
2414   "TARGET_NEON"
2415   "vmov%?.u<V_sz_elem>\t%0, %P1[%c2]"
2416   [(set_attr "predicable" "yes")
2417    (set_attr "neon_type" "neon_bp_simple")]
2418 )
2419
2420 (define_insn "neon_vget_lane<mode>_sext_internal"
2421   [(set (match_operand:SI 0 "s_register_operand" "=r")
2422         (sign_extend:SI
2423           (vec_select:<V_elem>
2424             (match_operand:VQ 1 "s_register_operand" "w")
2425             (parallel [(match_operand:SI 2 "immediate_operand" "i")]))))]
2426   "TARGET_NEON"
2427 {
2428   rtx ops[3];
2429   int regno = REGNO (operands[1]);
2430   unsigned int halfelts = GET_MODE_NUNITS (<MODE>mode) / 2;
2431   unsigned int elt = INTVAL (operands[2]);
2432
2433   ops[0] = operands[0];
2434   ops[1] = gen_rtx_REG (<V_HALF>mode, regno + 2 * (elt / halfelts));
2435   ops[2] = GEN_INT (elt % halfelts);
2436   output_asm_insn ("vmov%?.s<V_sz_elem>\t%0, %P1[%c2]", ops);
2437
2438   return "";
2439 }
2440   [(set_attr "predicable" "yes")
2441    (set_attr "neon_type" "neon_bp_simple")]
2442 )
2443
2444 (define_insn "neon_vget_lane<mode>_zext_internal"
2445   [(set (match_operand:SI 0 "s_register_operand" "=r")
2446         (zero_extend:SI
2447           (vec_select:<V_elem>
2448             (match_operand:VQ 1 "s_register_operand" "w")
2449             (parallel [(match_operand:SI 2 "immediate_operand" "i")]))))]
2450   "TARGET_NEON"
2451 {
2452   rtx ops[3];
2453   int regno = REGNO (operands[1]);
2454   unsigned int halfelts = GET_MODE_NUNITS (<MODE>mode) / 2;
2455   unsigned int elt = INTVAL (operands[2]);
2456
2457   ops[0] = operands[0];
2458   ops[1] = gen_rtx_REG (<V_HALF>mode, regno + 2 * (elt / halfelts));
2459   ops[2] = GEN_INT (elt % halfelts);
2460   output_asm_insn ("vmov%?.u<V_sz_elem>\t%0, %P1[%c2]", ops);
2461
2462   return "";
2463 }
2464   [(set_attr "predicable" "yes")
2465    (set_attr "neon_type" "neon_bp_simple")]
2466 )
2467
2468 (define_expand "neon_vget_lane<mode>"
2469   [(match_operand:<V_ext> 0 "s_register_operand" "")
2470    (match_operand:VDQW 1 "s_register_operand" "")
2471    (match_operand:SI 2 "immediate_operand" "")
2472    (match_operand:SI 3 "immediate_operand" "")]
2473   "TARGET_NEON"
2474 {
2475   HOST_WIDE_INT magic = INTVAL (operands[3]);
2476   rtx insn;
2477
2478   neon_lane_bounds (operands[2], 0, GET_MODE_NUNITS (<MODE>mode));
2479
2480   if ((magic & 3) == 3 || GET_MODE_BITSIZE (GET_MODE_INNER (<MODE>mode)) == 32)
2481     insn = gen_vec_extract<mode> (operands[0], operands[1], operands[2]);
2482   else
2483     {
2484       if ((magic & 1) != 0)
2485         insn = gen_neon_vget_lane<mode>_sext_internal (operands[0], operands[1],
2486                                                        operands[2]);
2487       else
2488         insn = gen_neon_vget_lane<mode>_zext_internal (operands[0], operands[1],
2489                                                        operands[2]);
2490     }
2491   emit_insn (insn);
2492   DONE;
2493 })
2494
2495 ; Operand 3 (info word) is ignored because it does nothing useful with 64-bit
2496 ; elements.
2497
2498 (define_insn "neon_vget_lanedi"
2499   [(set (match_operand:DI 0 "s_register_operand" "=r")
2500        (unspec:DI [(match_operand:DI 1 "s_register_operand" "w")
2501                    (match_operand:SI 2 "immediate_operand" "i")
2502                    (match_operand:SI 3 "immediate_operand" "i")]
2503                   UNSPEC_VGET_LANE))]
2504   "TARGET_NEON"
2505 {
2506   neon_lane_bounds (operands[2], 0, 1);
2507   return "vmov%?\t%Q0, %R0, %P1  @ di";
2508 }
2509   [(set_attr "predicable" "yes")
2510    (set_attr "neon_type" "neon_bp_simple")]
2511 )
2512
2513 (define_insn "neon_vget_lanev2di"
2514   [(set (match_operand:DI 0 "s_register_operand" "=r")
2515        (unspec:DI [(match_operand:V2DI 1 "s_register_operand" "w")
2516                    (match_operand:SI 2 "immediate_operand" "i")
2517                    (match_operand:SI 3 "immediate_operand" "i")]
2518                   UNSPEC_VGET_LANE))]
2519   "TARGET_NEON"
2520 {
2521   rtx ops[2];
2522   unsigned int regno = REGNO (operands[1]);
2523   unsigned int elt = INTVAL (operands[2]);
2524
2525   neon_lane_bounds (operands[2], 0, 2);
2526
2527   ops[0] = operands[0];
2528   ops[1] = gen_rtx_REG (DImode, regno + 2 * elt);
2529   output_asm_insn ("vmov%?\t%Q0, %R0, %P1  @ v2di", ops);
2530
2531   return "";
2532 }
2533   [(set_attr "predicable" "yes")
2534    (set_attr "neon_type" "neon_bp_simple")]
2535 )
2536
2537 (define_insn "neon_vset_lane<mode>"
2538   [(set (match_operand:VD 0 "s_register_operand" "=w")
2539         (unspec:VD [(match_operand:<V_elem> 1 "s_register_operand" "r")
2540                     (match_operand:VD 2 "s_register_operand" "0")
2541                     (match_operand:SI 3 "immediate_operand" "i")]
2542                    UNSPEC_VSET_LANE))]
2543   "TARGET_NEON"
2544 {
2545   neon_lane_bounds (operands[3], 0, GET_MODE_NUNITS (<MODE>mode));
2546   return "vmov%?.<V_sz_elem>\t%P0[%c3], %1";
2547 }
2548   [(set_attr "predicable" "yes")
2549    (set_attr "neon_type" "neon_bp_simple")]
2550 )
2551
2552 ; See neon_vget_lanedi comment for reasons operands 2 & 3 are ignored.
2553
2554 (define_insn "neon_vset_lanedi"
2555   [(set (match_operand:DI 0 "s_register_operand" "=w")
2556         (unspec:DI [(match_operand:DI 1 "s_register_operand" "r")
2557                     (match_operand:DI 2 "s_register_operand" "0")
2558                     (match_operand:SI 3 "immediate_operand" "i")]
2559                    UNSPEC_VSET_LANE))]
2560   "TARGET_NEON"
2561 {
2562   neon_lane_bounds (operands[3], 0, 1);
2563   return "vmov%?\t%P0, %Q1, %R1  @ di";
2564 }
2565   [(set_attr "predicable" "yes")
2566    (set_attr "neon_type" "neon_bp_simple")]
2567 )
2568
2569 (define_insn "neon_vset_lane<mode>"
2570   [(set (match_operand:VQ 0 "s_register_operand" "=w")
2571         (unspec:VQ [(match_operand:<V_elem> 1 "s_register_operand" "r")
2572                     (match_operand:VQ 2 "s_register_operand" "0")
2573                     (match_operand:SI 3 "immediate_operand" "i")]
2574                    UNSPEC_VSET_LANE))]
2575   "TARGET_NEON"
2576 {
2577   rtx ops[4];
2578   unsigned int regno = REGNO (operands[0]);
2579   unsigned int halfelts = GET_MODE_NUNITS (<MODE>mode) / 2;
2580   unsigned int elt = INTVAL (operands[3]);
2581
2582   neon_lane_bounds (operands[3], 0, halfelts * 2);
2583
2584   ops[0] = gen_rtx_REG (<V_HALF>mode, regno + 2 * (elt / halfelts));
2585   ops[1] = operands[1];
2586   ops[2] = GEN_INT (elt % halfelts);
2587   output_asm_insn ("vmov%?.<V_sz_elem>\t%P0[%c2], %1", ops);
2588
2589   return "";
2590 }
2591   [(set_attr "predicable" "yes")
2592    (set_attr "neon_type" "neon_bp_simple")]
2593 )
2594
2595 (define_insn "neon_vset_lanev2di"
2596   [(set (match_operand:V2DI 0 "s_register_operand" "=w")
2597         (unspec:V2DI [(match_operand:DI 1 "s_register_operand" "r")
2598                       (match_operand:V2DI 2 "s_register_operand" "0")
2599                       (match_operand:SI 3 "immediate_operand" "i")]
2600                    UNSPEC_VSET_LANE))]
2601   "TARGET_NEON"
2602 {
2603   rtx ops[2];
2604   unsigned int regno = REGNO (operands[0]);
2605   unsigned int elt = INTVAL (operands[3]);
2606
2607   neon_lane_bounds (operands[3], 0, 2);
2608
2609   ops[0] = gen_rtx_REG (DImode, regno + 2 * elt);
2610   ops[1] = operands[1];
2611   output_asm_insn ("vmov%?\t%P0, %Q1, %R1  @ v2di", ops);
2612
2613   return "";
2614 }
2615   [(set_attr "predicable" "yes")
2616    (set_attr "neon_type" "neon_bp_simple")]
2617 )
2618
2619 (define_expand "neon_vcreate<mode>"
2620   [(match_operand:VDX 0 "s_register_operand" "")
2621    (match_operand:DI 1 "general_operand" "")]
2622   "TARGET_NEON"
2623 {
2624   rtx src = gen_lowpart (<MODE>mode, operands[1]);
2625   emit_move_insn (operands[0], src);
2626   DONE;
2627 })
2628
2629 (define_insn "neon_vdup_n<mode>"
2630   [(set (match_operand:VDQW 0 "s_register_operand" "=w")
2631         (unspec:VDQW [(match_operand:<V_elem> 1 "s_register_operand" "r")]
2632                     UNSPEC_VDUP_N))]
2633   "TARGET_NEON"
2634   "vdup%?.<V_sz_elem>\t%<V_reg>0, %1"
2635   ;; Assume this schedules like vmov.
2636   [(set_attr "predicable" "yes")
2637    (set_attr "neon_type" "neon_bp_simple")]
2638 )
2639
2640 (define_insn "neon_vdup_ndi"
2641   [(set (match_operand:DI 0 "s_register_operand" "=w")
2642         (unspec:DI [(match_operand:DI 1 "s_register_operand" "r")]
2643                    UNSPEC_VDUP_N))]
2644   "TARGET_NEON"
2645   "vmov%?\t%P0, %Q1, %R1"
2646   [(set_attr "predicable" "yes")
2647    (set_attr "neon_type" "neon_bp_simple")]
2648 )
2649
2650 (define_insn "neon_vdup_nv2di"
2651   [(set (match_operand:V2DI 0 "s_register_operand" "=w")
2652         (unspec:V2DI [(match_operand:DI 1 "s_register_operand" "r")]
2653                      UNSPEC_VDUP_N))]
2654   "TARGET_NEON"
2655   "vmov%?\t%e0, %Q1, %R1\;vmov%?\t%f0, %Q1, %R1"
2656   [(set_attr "predicable" "yes")
2657    (set_attr "length" "8")
2658    (set_attr "neon_type" "neon_bp_simple")]
2659 )
2660
2661 (define_insn "neon_vdup_lane<mode>"
2662   [(set (match_operand:VD 0 "s_register_operand" "=w")
2663         (unspec:VD [(match_operand:VD 1 "s_register_operand" "w")
2664                     (match_operand:SI 2 "immediate_operand" "i")]
2665                    UNSPEC_VDUP_LANE))]
2666   "TARGET_NEON"
2667 {
2668   neon_lane_bounds (operands[2], 0, GET_MODE_NUNITS (<MODE>mode));
2669   return "vdup.<V_sz_elem>\t%P0, %P1[%c2]";
2670 }
2671   ;; Assume this schedules like vmov.
2672   [(set_attr "neon_type" "neon_bp_simple")]
2673 )
2674
2675 (define_insn "neon_vdup_lane<mode>"
2676   [(set (match_operand:VQ 0 "s_register_operand" "=w")
2677         (unspec:VQ [(match_operand:<V_HALF> 1 "s_register_operand" "w")
2678                     (match_operand:SI 2 "immediate_operand" "i")]
2679                    UNSPEC_VDUP_LANE))]
2680   "TARGET_NEON"
2681 {
2682   neon_lane_bounds (operands[2], 0, GET_MODE_NUNITS (<V_HALF>mode));
2683   return "vdup.<V_sz_elem>\t%q0, %P1[%c2]";
2684 }
2685   ;; Assume this schedules like vmov.
2686   [(set_attr "neon_type" "neon_bp_simple")]
2687 )
2688
2689 ; Scalar index is ignored, since only zero is valid here.
2690 (define_expand "neon_vdup_lanedi"
2691   [(set (match_operand:DI 0 "s_register_operand" "=w")
2692         (unspec:DI [(match_operand:DI 1 "s_register_operand" "w")
2693                     (match_operand:SI 2 "immediate_operand" "i")]
2694                    UNSPEC_VDUP_LANE))]
2695   "TARGET_NEON"
2696 {
2697   neon_lane_bounds (operands[2], 0, 1);
2698   emit_move_insn (operands[0], operands[1]);
2699   DONE;
2700 })
2701
2702 ; Likewise.
2703 (define_insn "neon_vdup_lanev2di"
2704   [(set (match_operand:V2DI 0 "s_register_operand" "=w")
2705         (unspec:V2DI [(match_operand:DI 1 "s_register_operand" "w")
2706                       (match_operand:SI 2 "immediate_operand" "i")]
2707                      UNSPEC_VDUP_LANE))]
2708   "TARGET_NEON"
2709 {
2710   neon_lane_bounds (operands[2], 0, 1);
2711   return "vmov\t%e0, %P1\;vmov\t%f0, %P1";
2712 }
2713   [(set_attr "length" "8")
2714    (set_attr "neon_type" "neon_bp_simple")]
2715 )
2716
2717 ;; In this insn, operand 1 should be low, and operand 2 the high part of the
2718 ;; dest vector.
2719 ;; FIXME: A different implementation of this builtin could make it much
2720 ;; more likely that we wouldn't actually need to output anything (we could make
2721 ;; it so that the reg allocator puts things in the right places magically
2722 ;; instead). Lack of subregs for vectors makes that tricky though, I think.
2723
2724 (define_insn "neon_vcombine<mode>"
2725   [(set (match_operand:<V_DOUBLE> 0 "s_register_operand" "=w")
2726         (unspec:<V_DOUBLE> [(match_operand:VDX 1 "s_register_operand" "w")
2727                             (match_operand:VDX 2 "s_register_operand" "w")]
2728                            UNSPEC_VCOMBINE))]
2729   "TARGET_NEON"
2730 {
2731   int dest = REGNO (operands[0]);
2732   int src1 = REGNO (operands[1]);
2733   int src2 = REGNO (operands[2]);
2734   rtx destlo;
2735
2736   if (src1 == dest && src2 == dest + 2)
2737     return "";
2738   else if (src2 == dest && src1 == dest + 2)
2739     /* Special case of reversed high/low parts.  */
2740     return "vswp\t%P1, %P2";
2741
2742   destlo = gen_rtx_REG (<MODE>mode, dest);
2743
2744   if (!reg_overlap_mentioned_p (operands[2], destlo))
2745     {
2746       /* Try to avoid unnecessary moves if part of the result is in the right
2747          place already.  */
2748       if (src1 != dest)
2749         output_asm_insn ("vmov\t%e0, %P1", operands);
2750       if (src2 != dest + 2)
2751         output_asm_insn ("vmov\t%f0, %P2", operands);
2752     }
2753   else
2754     {
2755       if (src2 != dest + 2)
2756         output_asm_insn ("vmov\t%f0, %P2", operands);
2757       if (src1 != dest)
2758         output_asm_insn ("vmov\t%e0, %P1", operands);
2759     }
2760
2761   return "";
2762 }
2763   ;; We set the neon_type attribute based on the vmov instructions above.
2764   [(set_attr "length" "8")
2765    (set_attr "neon_type" "neon_bp_simple")]
2766 )
2767
2768 (define_insn "neon_vget_high<mode>"
2769   [(set (match_operand:<V_HALF> 0 "s_register_operand" "=w")
2770         (unspec:<V_HALF> [(match_operand:VQX 1 "s_register_operand" "w")]
2771                          UNSPEC_VGET_HIGH))]
2772   "TARGET_NEON"
2773 {
2774   int dest = REGNO (operands[0]);
2775   int src = REGNO (operands[1]);
2776
2777   if (dest != src + 2)
2778     return "vmov\t%P0, %f1";
2779   else
2780     return "";
2781 }
2782   [(set_attr "neon_type" "neon_bp_simple")]
2783 )
2784
2785 (define_insn "neon_vget_low<mode>"
2786   [(set (match_operand:<V_HALF> 0 "s_register_operand" "=w")
2787         (unspec:<V_HALF> [(match_operand:VQX 1 "s_register_operand" "w")]
2788                          UNSPEC_VGET_LOW))]
2789   "TARGET_NEON"
2790 {
2791   int dest = REGNO (operands[0]);
2792   int src = REGNO (operands[1]);
2793
2794   if (dest != src)
2795     return "vmov\t%P0, %e1";
2796   else
2797     return "";
2798 }
2799   [(set_attr "neon_type" "neon_bp_simple")]
2800 )
2801
2802 (define_insn "neon_vcvt<mode>"
2803   [(set (match_operand:<V_CVTTO> 0 "s_register_operand" "=w")
2804         (unspec:<V_CVTTO> [(match_operand:VCVTF 1 "s_register_operand" "w")
2805                            (match_operand:SI 2 "immediate_operand" "i")]
2806                           UNSPEC_VCVT))]
2807   "TARGET_NEON"
2808   "vcvt.%T2%#32.f32\t%<V_reg>0, %<V_reg>1"
2809   [(set (attr "neon_type")
2810      (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
2811                    (const_string "neon_fp_vadd_ddd_vabs_dd")
2812                    (const_string "neon_fp_vadd_qqq_vabs_qq")))]
2813 )
2814
2815 (define_insn "neon_vcvt<mode>"
2816   [(set (match_operand:<V_CVTTO> 0 "s_register_operand" "=w")
2817         (unspec:<V_CVTTO> [(match_operand:VCVTI 1 "s_register_operand" "w")
2818                            (match_operand:SI 2 "immediate_operand" "i")]
2819                           UNSPEC_VCVT))]
2820   "TARGET_NEON"
2821   "vcvt.f32.%T2%#32\t%<V_reg>0, %<V_reg>1"
2822   [(set (attr "neon_type")
2823      (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
2824                    (const_string "neon_fp_vadd_ddd_vabs_dd")
2825                    (const_string "neon_fp_vadd_qqq_vabs_qq")))]
2826 )
2827
2828 (define_insn "neon_vcvt_n<mode>"
2829   [(set (match_operand:<V_CVTTO> 0 "s_register_operand" "=w")
2830         (unspec:<V_CVTTO> [(match_operand:VCVTF 1 "s_register_operand" "w")
2831                            (match_operand:SI 2 "immediate_operand" "i")
2832                            (match_operand:SI 3 "immediate_operand" "i")]
2833                           UNSPEC_VCVT_N))]
2834   "TARGET_NEON"
2835 {
2836   neon_const_bounds (operands[2], 1, 33);
2837   return "vcvt.%T3%#32.f32\t%<V_reg>0, %<V_reg>1, %2";
2838 }
2839   [(set (attr "neon_type")
2840      (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
2841                    (const_string "neon_fp_vadd_ddd_vabs_dd")
2842                    (const_string "neon_fp_vadd_qqq_vabs_qq")))]
2843 )
2844
2845 (define_insn "neon_vcvt_n<mode>"
2846   [(set (match_operand:<V_CVTTO> 0 "s_register_operand" "=w")
2847         (unspec:<V_CVTTO> [(match_operand:VCVTI 1 "s_register_operand" "w")
2848                            (match_operand:SI 2 "immediate_operand" "i")
2849                            (match_operand:SI 3 "immediate_operand" "i")]
2850                           UNSPEC_VCVT_N))]
2851   "TARGET_NEON"
2852 {
2853   neon_const_bounds (operands[2], 1, 33);
2854   return "vcvt.f32.%T3%#32\t%<V_reg>0, %<V_reg>1, %2";
2855 }
2856   [(set (attr "neon_type")
2857      (if_then_else (ne (symbol_ref "<Is_d_reg>") (const_int 0))
2858                    (const_string "neon_fp_vadd_ddd_vabs_dd")
2859                    (const_string "neon_fp_vadd_qqq_vabs_qq")))]
2860 )
2861
2862 (define_insn "neon_vmovn<mode>"
2863   [(set (match_operand:<V_narrow> 0 "s_register_operand" "=w")
2864         (unspec:<V_narrow> [(match_operand:VN 1 "s_register_operand" "w")
2865                             (match_operand:SI 2 "immediate_operand" "i")]
2866                            UNSPEC_VMOVN))]
2867   "TARGET_NEON"
2868   "vmovn.<V_if_elem>\t%P0, %q1"
2869   [(set_attr "neon_type" "neon_bp_simple")]
2870 )
2871
2872 (define_insn "neon_vqmovn<mode>"
2873   [(set (match_operand:<V_narrow> 0 "s_register_operand" "=w")
2874         (unspec:<V_narrow> [(match_operand:VN 1 "s_register_operand" "w")
2875                             (match_operand:SI 2 "immediate_operand" "i")]
2876                            UNSPEC_VQMOVN))]
2877   "TARGET_NEON"
2878   "vqmovn.%T2%#<V_sz_elem>\t%P0, %q1"
2879   [(set_attr "neon_type" "neon_shift_2")]
2880 )
2881
2882 (define_insn "neon_vqmovun<mode>"
2883   [(set (match_operand:<V_narrow> 0 "s_register_operand" "=w")
2884         (unspec:<V_narrow> [(match_operand:VN 1 "s_register_operand" "w")
2885                             (match_operand:SI 2 "immediate_operand" "i")]
2886                            UNSPEC_VQMOVUN))]
2887   "TARGET_NEON"
2888   "vqmovun.<V_s_elem>\t%P0, %q1"
2889   [(set_attr "neon_type" "neon_shift_2")]
2890 )
2891
2892 (define_insn "neon_vmovl<mode>"
2893   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
2894         (unspec:<V_widen> [(match_operand:VW 1 "s_register_operand" "w")
2895                            (match_operand:SI 2 "immediate_operand" "i")]
2896                           UNSPEC_VMOVL))]
2897   "TARGET_NEON"
2898   "vmovl.%T2%#<V_sz_elem>\t%q0, %P1"
2899   [(set_attr "neon_type" "neon_shift_1")]
2900 )
2901
2902 (define_insn "neon_vmul_lane<mode>"
2903   [(set (match_operand:VMD 0 "s_register_operand" "=w")
2904         (unspec:VMD [(match_operand:VMD 1 "s_register_operand" "w")
2905                      (match_operand:VMD 2 "s_register_operand"
2906                                         "<scalar_mul_constraint>")
2907                      (match_operand:SI 3 "immediate_operand" "i")
2908                      (match_operand:SI 4 "immediate_operand" "i")]
2909                     UNSPEC_VMUL_LANE))]
2910   "TARGET_NEON"
2911 {
2912   neon_lane_bounds (operands[3], 0, GET_MODE_NUNITS (<MODE>mode));
2913   return "vmul.<V_if_elem>\t%P0, %P1, %P2[%c3]";
2914 }
2915   [(set (attr "neon_type")
2916      (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
2917                    (const_string "neon_fp_vmul_ddd")
2918                    (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
2919                                  (const_string "neon_mul_ddd_16_scalar_32_16_long_scalar")
2920                                  (const_string "neon_mul_qdd_64_32_long_qqd_16_ddd_32_scalar_64_32_long_scalar"))))]
2921 )
2922
2923 (define_insn "neon_vmul_lane<mode>"
2924   [(set (match_operand:VMQ 0 "s_register_operand" "=w")
2925         (unspec:VMQ [(match_operand:VMQ 1 "s_register_operand" "w")
2926                      (match_operand:<V_HALF> 2 "s_register_operand"
2927                                              "<scalar_mul_constraint>")
2928                      (match_operand:SI 3 "immediate_operand" "i")
2929                      (match_operand:SI 4 "immediate_operand" "i")]
2930                     UNSPEC_VMUL_LANE))]
2931   "TARGET_NEON"
2932 {
2933   neon_lane_bounds (operands[3], 0, GET_MODE_NUNITS (<V_HALF>mode));
2934   return "vmul.<V_if_elem>\t%q0, %q1, %P2[%c3]";
2935 }
2936   [(set (attr "neon_type")
2937      (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
2938                    (const_string "neon_fp_vmul_qqd")
2939                    (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
2940                                  (const_string "neon_mul_qdd_64_32_long_qqd_16_ddd_32_scalar_64_32_long_scalar")
2941                                  (const_string "neon_mul_qqd_32_scalar"))))]
2942 )
2943
2944 (define_insn "neon_vmull_lane<mode>"
2945   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
2946         (unspec:<V_widen> [(match_operand:VMDI 1 "s_register_operand" "w")
2947                            (match_operand:VMDI 2 "s_register_operand"
2948                                                "<scalar_mul_constraint>")
2949                            (match_operand:SI 3 "immediate_operand" "i")
2950                            (match_operand:SI 4 "immediate_operand" "i")]
2951                           UNSPEC_VMULL_LANE))]
2952   "TARGET_NEON"
2953 {
2954   neon_lane_bounds (operands[3], 0, GET_MODE_NUNITS (<MODE>mode));
2955   return "vmull.%T4%#<V_sz_elem>\t%q0, %P1, %P2[%c3]";
2956 }
2957   [(set (attr "neon_type")
2958      (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
2959                    (const_string "neon_mul_ddd_16_scalar_32_16_long_scalar")
2960                    (const_string "neon_mul_qdd_64_32_long_qqd_16_ddd_32_scalar_64_32_long_scalar")))]
2961 )
2962
2963 (define_insn "neon_vqdmull_lane<mode>"
2964   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
2965         (unspec:<V_widen> [(match_operand:VMDI 1 "s_register_operand" "w")
2966                            (match_operand:VMDI 2 "s_register_operand"
2967                                                "<scalar_mul_constraint>")
2968                            (match_operand:SI 3 "immediate_operand" "i")
2969                            (match_operand:SI 4 "immediate_operand" "i")]
2970                           UNSPEC_VQDMULL_LANE))]
2971   "TARGET_NEON"
2972 {
2973   neon_lane_bounds (operands[3], 0, GET_MODE_NUNITS (<MODE>mode));
2974   return "vqdmull.<V_s_elem>\t%q0, %P1, %P2[%c3]";
2975 }
2976   [(set (attr "neon_type")
2977      (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
2978                    (const_string "neon_mul_ddd_16_scalar_32_16_long_scalar")
2979                    (const_string "neon_mul_qdd_64_32_long_qqd_16_ddd_32_scalar_64_32_long_scalar")))]
2980 )
2981
2982 (define_insn "neon_vqdmulh_lane<mode>"
2983   [(set (match_operand:VMQI 0 "s_register_operand" "=w")
2984         (unspec:VMQI [(match_operand:VMQI 1 "s_register_operand" "w")
2985                       (match_operand:<V_HALF> 2 "s_register_operand"
2986                                               "<scalar_mul_constraint>")
2987                       (match_operand:SI 3 "immediate_operand" "i")
2988                       (match_operand:SI 4 "immediate_operand" "i")]
2989                       UNSPEC_VQDMULH_LANE))]
2990   "TARGET_NEON"
2991 {
2992   neon_lane_bounds (operands[3], 0, GET_MODE_NUNITS (<MODE>mode));
2993   return "vq%O4dmulh.%T4%#<V_sz_elem>\t%q0, %q1, %P2[%c3]";
2994 }
2995   [(set (attr "neon_type")
2996      (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
2997                    (const_string "neon_mul_qdd_64_32_long_qqd_16_ddd_32_scalar_64_32_long_scalar")
2998                    (const_string "neon_mul_qqd_32_scalar")))]
2999 )
3000
3001 (define_insn "neon_vqdmulh_lane<mode>"
3002   [(set (match_operand:VMDI 0 "s_register_operand" "=w")
3003         (unspec:VMDI [(match_operand:VMDI 1 "s_register_operand" "w")
3004                       (match_operand:VMDI 2 "s_register_operand"
3005                                           "<scalar_mul_constraint>")
3006                       (match_operand:SI 3 "immediate_operand" "i")
3007                       (match_operand:SI 4 "immediate_operand" "i")]
3008                       UNSPEC_VQDMULH_LANE))]
3009   "TARGET_NEON"
3010 {
3011   neon_lane_bounds (operands[3], 0, GET_MODE_NUNITS (<MODE>mode));
3012   return "vq%O4dmulh.%T4%#<V_sz_elem>\t%P0, %P1, %P2[%c3]";
3013 }
3014   [(set (attr "neon_type")
3015      (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
3016                    (const_string "neon_mul_ddd_16_scalar_32_16_long_scalar")
3017                    (const_string "neon_mul_qdd_64_32_long_qqd_16_ddd_32_scalar_64_32_long_scalar")))]
3018 )
3019
3020 (define_insn "neon_vmla_lane<mode>"
3021   [(set (match_operand:VMD 0 "s_register_operand" "=w")
3022         (unspec:VMD [(match_operand:VMD 1 "s_register_operand" "0")
3023                      (match_operand:VMD 2 "s_register_operand" "w")
3024                      (match_operand:VMD 3 "s_register_operand"
3025                                         "<scalar_mul_constraint>")
3026                      (match_operand:SI 4 "immediate_operand" "i")
3027                      (match_operand:SI 5 "immediate_operand" "i")]
3028                      UNSPEC_VMLA_LANE))]
3029   "TARGET_NEON"
3030 {
3031   neon_lane_bounds (operands[4], 0, GET_MODE_NUNITS (<MODE>mode));
3032   return "vmla.<V_if_elem>\t%P0, %P2, %P3[%c4]";
3033 }
3034   [(set (attr "neon_type")
3035      (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
3036                    (const_string "neon_fp_vmla_ddd_scalar")
3037                    (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
3038                                  (const_string "neon_mla_ddd_16_scalar_qdd_32_16_long_scalar")
3039                                  (const_string "neon_mla_ddd_32_qqd_16_ddd_32_scalar_qdd_64_32_long_scalar_qdd_64_32_long"))))]
3040 )
3041
3042 (define_insn "neon_vmla_lane<mode>"
3043   [(set (match_operand:VMQ 0 "s_register_operand" "=w")
3044         (unspec:VMQ [(match_operand:VMQ 1 "s_register_operand" "0")
3045                      (match_operand:VMQ 2 "s_register_operand" "w")
3046                      (match_operand:<V_HALF> 3 "s_register_operand"
3047                                              "<scalar_mul_constraint>")
3048                      (match_operand:SI 4 "immediate_operand" "i")
3049                      (match_operand:SI 5 "immediate_operand" "i")]
3050                      UNSPEC_VMLA_LANE))]
3051   "TARGET_NEON"
3052 {
3053   neon_lane_bounds (operands[4], 0, GET_MODE_NUNITS (<MODE>mode));
3054   return "vmla.<V_if_elem>\t%q0, %q2, %P3[%c4]";
3055 }
3056   [(set (attr "neon_type")
3057      (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
3058                    (const_string "neon_fp_vmla_qqq_scalar")
3059                    (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
3060                                  (const_string "neon_mla_ddd_32_qqd_16_ddd_32_scalar_qdd_64_32_long_scalar_qdd_64_32_long")
3061                                  (const_string "neon_mla_qqq_32_qqd_32_scalar"))))]
3062 )
3063
3064 (define_insn "neon_vmlal_lane<mode>"
3065   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
3066         (unspec:<V_widen> [(match_operand:<V_widen> 1 "s_register_operand" "0")
3067                            (match_operand:VMDI 2 "s_register_operand" "w")
3068                            (match_operand:VMDI 3 "s_register_operand"
3069                                                "<scalar_mul_constraint>")
3070                            (match_operand:SI 4 "immediate_operand" "i")
3071                            (match_operand:SI 5 "immediate_operand" "i")]
3072                           UNSPEC_VMLAL_LANE))]
3073   "TARGET_NEON"
3074 {
3075   neon_lane_bounds (operands[4], 0, GET_MODE_NUNITS (<MODE>mode));
3076   return "vmlal.%T5%#<V_sz_elem>\t%q0, %P2, %P3[%c4]";
3077 }
3078   [(set (attr "neon_type")
3079      (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
3080                    (const_string "neon_mla_ddd_16_scalar_qdd_32_16_long_scalar")
3081                    (const_string "neon_mla_ddd_32_qqd_16_ddd_32_scalar_qdd_64_32_long_scalar_qdd_64_32_long")))]
3082 )
3083
3084 (define_insn "neon_vqdmlal_lane<mode>"
3085   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
3086         (unspec:<V_widen> [(match_operand:<V_widen> 1 "s_register_operand" "0")
3087                            (match_operand:VMDI 2 "s_register_operand" "w")
3088                            (match_operand:VMDI 3 "s_register_operand"
3089                                                "<scalar_mul_constraint>")
3090                            (match_operand:SI 4 "immediate_operand" "i")
3091                            (match_operand:SI 5 "immediate_operand" "i")]
3092                           UNSPEC_VQDMLAL_LANE))]
3093   "TARGET_NEON"
3094 {
3095   neon_lane_bounds (operands[4], 0, GET_MODE_NUNITS (<MODE>mode));
3096   return "vqdmlal.<V_s_elem>\t%q0, %P2, %P3[%c4]";
3097 }
3098   [(set (attr "neon_type")
3099      (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
3100                    (const_string "neon_mla_ddd_16_scalar_qdd_32_16_long_scalar")
3101                    (const_string "neon_mla_ddd_32_qqd_16_ddd_32_scalar_qdd_64_32_long_scalar_qdd_64_32_long")))]
3102 )
3103
3104 (define_insn "neon_vmls_lane<mode>"
3105   [(set (match_operand:VMD 0 "s_register_operand" "=w")
3106         (unspec:VMD [(match_operand:VMD 1 "s_register_operand" "0")
3107                      (match_operand:VMD 2 "s_register_operand" "w")
3108                      (match_operand:VMD 3 "s_register_operand"
3109                                         "<scalar_mul_constraint>")
3110                      (match_operand:SI 4 "immediate_operand" "i")
3111                      (match_operand:SI 5 "immediate_operand" "i")]
3112                     UNSPEC_VMLS_LANE))]
3113   "TARGET_NEON"
3114 {
3115   neon_lane_bounds (operands[4], 0, GET_MODE_NUNITS (<MODE>mode));
3116   return "vmls.<V_if_elem>\t%P0, %P2, %P3[%c4]";
3117 }
3118   [(set (attr "neon_type")
3119      (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
3120                    (const_string "neon_fp_vmla_ddd_scalar")
3121                    (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
3122                                  (const_string "neon_mla_ddd_16_scalar_qdd_32_16_long_scalar")
3123                                  (const_string "neon_mla_ddd_32_qqd_16_ddd_32_scalar_qdd_64_32_long_scalar_qdd_64_32_long"))))]
3124 )
3125
3126 (define_insn "neon_vmls_lane<mode>"
3127   [(set (match_operand:VMQ 0 "s_register_operand" "=w")
3128         (unspec:VMQ [(match_operand:VMQ 1 "s_register_operand" "0")
3129                      (match_operand:VMQ 2 "s_register_operand" "w")
3130                      (match_operand:<V_HALF> 3 "s_register_operand"
3131                                              "<scalar_mul_constraint>")
3132                      (match_operand:SI 4 "immediate_operand" "i")
3133                      (match_operand:SI 5 "immediate_operand" "i")]
3134                     UNSPEC_VMLS_LANE))]
3135   "TARGET_NEON"
3136 {
3137   neon_lane_bounds (operands[4], 0, GET_MODE_NUNITS (<MODE>mode));
3138   return "vmls.<V_if_elem>\t%q0, %q2, %P3[%c4]";
3139 }
3140   [(set (attr "neon_type")
3141      (if_then_else (ne (symbol_ref "<Is_float_mode>") (const_int 0))
3142                    (const_string "neon_fp_vmla_qqq_scalar")
3143                    (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
3144                                  (const_string "neon_mla_ddd_32_qqd_16_ddd_32_scalar_qdd_64_32_long_scalar_qdd_64_32_long")
3145                                  (const_string "neon_mla_qqq_32_qqd_32_scalar"))))]
3146 )
3147
3148 (define_insn "neon_vmlsl_lane<mode>"
3149   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
3150         (unspec:<V_widen> [(match_operand:<V_widen> 1 "s_register_operand" "0")
3151                            (match_operand:VMDI 2 "s_register_operand" "w")
3152                            (match_operand:VMDI 3 "s_register_operand"
3153                                                "<scalar_mul_constraint>")
3154                            (match_operand:SI 4 "immediate_operand" "i")
3155                            (match_operand:SI 5 "immediate_operand" "i")]
3156                           UNSPEC_VMLSL_LANE))]
3157   "TARGET_NEON"
3158 {
3159   neon_lane_bounds (operands[4], 0, GET_MODE_NUNITS (<MODE>mode));
3160   return "vmlsl.%T5%#<V_sz_elem>\t%q0, %P2, %P3[%c4]";
3161 }
3162   [(set (attr "neon_type")
3163      (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
3164                    (const_string "neon_mla_ddd_16_scalar_qdd_32_16_long_scalar")
3165                    (const_string "neon_mla_ddd_32_qqd_16_ddd_32_scalar_qdd_64_32_long_scalar_qdd_64_32_long")))]
3166 )
3167
3168 (define_insn "neon_vqdmlsl_lane<mode>"
3169   [(set (match_operand:<V_widen> 0 "s_register_operand" "=w")
3170         (unspec:<V_widen> [(match_operand:<V_widen> 1 "s_register_operand" "0")
3171                            (match_operand:VMDI 2 "s_register_operand" "w")
3172                            (match_operand:VMDI 3 "s_register_operand"
3173                                                "<scalar_mul_constraint>")
3174                            (match_operand:SI 4 "immediate_operand" "i")
3175                            (match_operand:SI 5 "immediate_operand" "i")]
3176                           UNSPEC_VQDMLSL_LANE))]
3177   "TARGET_NEON"
3178 {
3179   neon_lane_bounds (operands[4], 0, GET_MODE_NUNITS (<MODE>mode));
3180   return "vqdmlsl.<V_s_elem>\t%q0, %P2, %P3[%c4]";
3181 }
3182   [(set (attr "neon_type")
3183      (if_then_else (ne (symbol_ref "<Scalar_mul_8_16>") (const_int 0))
3184                    (const_string "neon_mla_ddd_16_scalar_qdd_32_16_long_scalar")
3185                    (const_string "neon_mla_ddd_32_qqd_16_ddd_32_scalar_qdd_64_32_long_scalar_qdd_64_32_long")))]
3186 )
3187
3188 ; FIXME: For the "_n" multiply/multiply-accumulate insns, we copy a value in a
3189 ; core register into a temp register, then use a scalar taken from that. This
3190 ; isn't an optimal solution if e.g. the scalar has just been read from memory
3191 ; or extracted from another vector. The latter case it's currently better to
3192 ; use the "_lane" variant, and the former case can probably be implemented
3193 ; using vld1_lane, but that hasn't been done yet.
3194
3195 (define_expand "neon_vmul_n<mode>"
3196   [(match_operand:VMD 0 "s_register_operand" "")
3197    (match_operand:VMD 1 "s_register_operand" "")
3198    (match_operand:<V_elem> 2 "s_register_operand" "")
3199    (match_operand:SI 3 "immediate_operand" "")]
3200   "TARGET_NEON"
3201 {
3202   rtx tmp = gen_reg_rtx (<MODE>mode);
3203   emit_insn (gen_neon_vset_lane<mode> (tmp, operands[2], tmp, const0_rtx));
3204   emit_insn (gen_neon_vmul_lane<mode> (operands[0], operands[1], tmp,
3205                                        const0_rtx, const0_rtx));
3206   DONE;
3207 })
3208
3209 (define_expand "neon_vmul_n<mode>"
3210   [(match_operand:VMQ 0 "s_register_operand" "")
3211    (match_operand:VMQ 1 "s_register_operand" "")
3212    (match_operand:<V_elem> 2 "s_register_operand" "")
3213    (match_operand:SI 3 "immediate_operand" "")]
3214   "TARGET_NEON"
3215 {
3216   rtx tmp = gen_reg_rtx (<V_HALF>mode);
3217   emit_insn (gen_neon_vset_lane<V_half> (tmp, operands[2], tmp, const0_rtx));
3218   emit_insn (gen_neon_vmul_lane<mode> (operands[0], operands[1], tmp,
3219                                        const0_rtx, const0_rtx));
3220   DONE;
3221 })
3222
3223 (define_expand "neon_vmull_n<mode>"
3224   [(match_operand:<V_widen> 0 "s_register_operand" "")
3225    (match_operand:VMDI 1 "s_register_operand" "")
3226    (match_operand:<V_elem> 2 "s_register_operand" "")
3227    (match_operand:SI 3 "immediate_operand" "")]
3228   "TARGET_NEON"
3229 {
3230   rtx tmp = gen_reg_rtx (<MODE>mode);
3231   emit_insn (gen_neon_vset_lane<mode> (tmp, operands[2], tmp, const0_rtx));
3232   emit_insn (gen_neon_vmull_lane<mode> (operands[0], operands[1], tmp,
3233                                         const0_rtx, operands[3]));
3234   DONE;