File Coverage

/usr/lib/gcc/x86_64-linux-gnu/5/include/avxintrin.h
Criterion Covered Total %
statement 0 2 0.0
branch n/a
condition n/a
subroutine n/a
pod n/a
total 0 2 0.0


line stmt bran cond sub pod time code
1             /* Copyright (C) 2008-2015 Free Software Foundation, Inc.
2              
3             This file is part of GCC.
4              
5             GCC is free software; you can redistribute it and/or modify
6             it under the terms of the GNU General Public License as published by
7             the Free Software Foundation; either version 3, or (at your option)
8             any later version.
9              
10             GCC is distributed in the hope that it will be useful,
11             but WITHOUT ANY WARRANTY; without even the implied warranty of
12             MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13             GNU General Public License for more details.
14              
15             Under Section 7 of GPL version 3, you are granted additional
16             permissions described in the GCC Runtime Library Exception, version
17             3.1, as published by the Free Software Foundation.
18              
19             You should have received a copy of the GNU General Public License and
20             a copy of the GCC Runtime Library Exception along with this program;
21             see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
22             . */
23              
24             /* Implemented from the specification included in the Intel C++ Compiler
25             User Guide and Reference, version 11.0. */
26              
27             #ifndef _IMMINTRIN_H_INCLUDED
28             # error "Never use directly; include instead."
29             #endif
30              
31             #ifndef _AVXINTRIN_H_INCLUDED
32             #define _AVXINTRIN_H_INCLUDED
33              
34             #ifndef __AVX__
35             #pragma GCC push_options
36             #pragma GCC target("avx")
37             #define __DISABLE_AVX__
38             #endif /* __AVX__ */
39              
40             /* Internal data types for implementing the intrinsics. */
41             typedef double __v4df __attribute__ ((__vector_size__ (32)));
42             typedef float __v8sf __attribute__ ((__vector_size__ (32)));
43             typedef long long __v4di __attribute__ ((__vector_size__ (32)));
44             typedef unsigned long long __v4du __attribute__ ((__vector_size__ (32)));
45             typedef int __v8si __attribute__ ((__vector_size__ (32)));
46             typedef unsigned int __v8su __attribute__ ((__vector_size__ (32)));
47             typedef short __v16hi __attribute__ ((__vector_size__ (32)));
48             typedef unsigned short __v16hu __attribute__ ((__vector_size__ (32)));
49             typedef char __v32qi __attribute__ ((__vector_size__ (32)));
50             typedef unsigned char __v32qu __attribute__ ((__vector_size__ (32)));
51              
52             /* The Intel API is flexible enough that we must allow aliasing with other
53             vector types, and their scalar components. */
54             typedef float __m256 __attribute__ ((__vector_size__ (32),
55             __may_alias__));
56             typedef long long __m256i __attribute__ ((__vector_size__ (32),
57             __may_alias__));
58             typedef double __m256d __attribute__ ((__vector_size__ (32),
59             __may_alias__));
60              
61             /* Compare predicates for scalar and packed compare intrinsics. */
62              
63             /* Equal (ordered, non-signaling) */
64             #define _CMP_EQ_OQ 0x00
65             /* Less-than (ordered, signaling) */
66             #define _CMP_LT_OS 0x01
67             /* Less-than-or-equal (ordered, signaling) */
68             #define _CMP_LE_OS 0x02
69             /* Unordered (non-signaling) */
70             #define _CMP_UNORD_Q 0x03
71             /* Not-equal (unordered, non-signaling) */
72             #define _CMP_NEQ_UQ 0x04
73             /* Not-less-than (unordered, signaling) */
74             #define _CMP_NLT_US 0x05
75             /* Not-less-than-or-equal (unordered, signaling) */
76             #define _CMP_NLE_US 0x06
77             /* Ordered (nonsignaling) */
78             #define _CMP_ORD_Q 0x07
79             /* Equal (unordered, non-signaling) */
80             #define _CMP_EQ_UQ 0x08
81             /* Not-greater-than-or-equal (unordered, signaling) */
82             #define _CMP_NGE_US 0x09
83             /* Not-greater-than (unordered, signaling) */
84             #define _CMP_NGT_US 0x0a
85             /* False (ordered, non-signaling) */
86             #define _CMP_FALSE_OQ 0x0b
87             /* Not-equal (ordered, non-signaling) */
88             #define _CMP_NEQ_OQ 0x0c
89             /* Greater-than-or-equal (ordered, signaling) */
90             #define _CMP_GE_OS 0x0d
91             /* Greater-than (ordered, signaling) */
92             #define _CMP_GT_OS 0x0e
93             /* True (unordered, non-signaling) */
94             #define _CMP_TRUE_UQ 0x0f
95             /* Equal (ordered, signaling) */
96             #define _CMP_EQ_OS 0x10
97             /* Less-than (ordered, non-signaling) */
98             #define _CMP_LT_OQ 0x11
99             /* Less-than-or-equal (ordered, non-signaling) */
100             #define _CMP_LE_OQ 0x12
101             /* Unordered (signaling) */
102             #define _CMP_UNORD_S 0x13
103             /* Not-equal (unordered, signaling) */
104             #define _CMP_NEQ_US 0x14
105             /* Not-less-than (unordered, non-signaling) */
106             #define _CMP_NLT_UQ 0x15
107             /* Not-less-than-or-equal (unordered, non-signaling) */
108             #define _CMP_NLE_UQ 0x16
109             /* Ordered (signaling) */
110             #define _CMP_ORD_S 0x17
111             /* Equal (unordered, signaling) */
112             #define _CMP_EQ_US 0x18
113             /* Not-greater-than-or-equal (unordered, non-signaling) */
114             #define _CMP_NGE_UQ 0x19
115             /* Not-greater-than (unordered, non-signaling) */
116             #define _CMP_NGT_UQ 0x1a
117             /* False (ordered, signaling) */
118             #define _CMP_FALSE_OS 0x1b
119             /* Not-equal (ordered, signaling) */
120             #define _CMP_NEQ_OS 0x1c
121             /* Greater-than-or-equal (ordered, non-signaling) */
122             #define _CMP_GE_OQ 0x1d
123             /* Greater-than (ordered, non-signaling) */
124             #define _CMP_GT_OQ 0x1e
125             /* True (unordered, signaling) */
126             #define _CMP_TRUE_US 0x1f
127              
128             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
129             _mm256_add_pd (__m256d __A, __m256d __B)
130             {
131             return (__m256d) ((__v4df)__A + (__v4df)__B);
132             }
133              
134             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
135             _mm256_add_ps (__m256 __A, __m256 __B)
136             {
137             return (__m256) ((__v8sf)__A + (__v8sf)__B);
138             }
139              
140             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
141             _mm256_addsub_pd (__m256d __A, __m256d __B)
142             {
143             return (__m256d) __builtin_ia32_addsubpd256 ((__v4df)__A, (__v4df)__B);
144             }
145              
146             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
147             _mm256_addsub_ps (__m256 __A, __m256 __B)
148             {
149             return (__m256) __builtin_ia32_addsubps256 ((__v8sf)__A, (__v8sf)__B);
150             }
151              
152              
153             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
154             _mm256_and_pd (__m256d __A, __m256d __B)
155             {
156             return (__m256d) __builtin_ia32_andpd256 ((__v4df)__A, (__v4df)__B);
157             }
158              
159             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
160             _mm256_and_ps (__m256 __A, __m256 __B)
161             {
162             return (__m256) __builtin_ia32_andps256 ((__v8sf)__A, (__v8sf)__B);
163             }
164              
165             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
166             _mm256_andnot_pd (__m256d __A, __m256d __B)
167             {
168             return (__m256d) __builtin_ia32_andnpd256 ((__v4df)__A, (__v4df)__B);
169             }
170              
171             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
172             _mm256_andnot_ps (__m256 __A, __m256 __B)
173             {
174             return (__m256) __builtin_ia32_andnps256 ((__v8sf)__A, (__v8sf)__B);
175             }
176              
177             /* Double/single precision floating point blend instructions - select
178             data from 2 sources using constant/variable mask. */
179              
180             #ifdef __OPTIMIZE__
181             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
182             _mm256_blend_pd (__m256d __X, __m256d __Y, const int __M)
183             {
184             return (__m256d) __builtin_ia32_blendpd256 ((__v4df)__X,
185             (__v4df)__Y,
186             __M);
187             }
188              
189             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
190             _mm256_blend_ps (__m256 __X, __m256 __Y, const int __M)
191             {
192             return (__m256) __builtin_ia32_blendps256 ((__v8sf)__X,
193             (__v8sf)__Y,
194             __M);
195             }
196             #else
197             #define _mm256_blend_pd(X, Y, M) \
198             ((__m256d) __builtin_ia32_blendpd256 ((__v4df)(__m256d)(X), \
199             (__v4df)(__m256d)(Y), (int)(M)))
200              
201             #define _mm256_blend_ps(X, Y, M) \
202             ((__m256) __builtin_ia32_blendps256 ((__v8sf)(__m256)(X), \
203             (__v8sf)(__m256)(Y), (int)(M)))
204             #endif
205              
206             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
207             _mm256_blendv_pd (__m256d __X, __m256d __Y, __m256d __M)
208             {
209             return (__m256d) __builtin_ia32_blendvpd256 ((__v4df)__X,
210             (__v4df)__Y,
211             (__v4df)__M);
212             }
213              
214             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
215             _mm256_blendv_ps (__m256 __X, __m256 __Y, __m256 __M)
216             {
217             return (__m256) __builtin_ia32_blendvps256 ((__v8sf)__X,
218             (__v8sf)__Y,
219             (__v8sf)__M);
220             }
221              
222             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
223             _mm256_div_pd (__m256d __A, __m256d __B)
224             {
225             return (__m256d) ((__v4df)__A / (__v4df)__B);
226             }
227              
228             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
229             _mm256_div_ps (__m256 __A, __m256 __B)
230             {
231             return (__m256) ((__v8sf)__A / (__v8sf)__B);
232             }
233              
234             /* Dot product instructions with mask-defined summing and zeroing parts
235             of result. */
236              
237             #ifdef __OPTIMIZE__
238             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
239             _mm256_dp_ps (__m256 __X, __m256 __Y, const int __M)
240             {
241             return (__m256) __builtin_ia32_dpps256 ((__v8sf)__X,
242             (__v8sf)__Y,
243             __M);
244             }
245             #else
246             #define _mm256_dp_ps(X, Y, M) \
247             ((__m256) __builtin_ia32_dpps256 ((__v8sf)(__m256)(X), \
248             (__v8sf)(__m256)(Y), (int)(M)))
249             #endif
250              
251             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
252             _mm256_hadd_pd (__m256d __X, __m256d __Y)
253             {
254             return (__m256d) __builtin_ia32_haddpd256 ((__v4df)__X, (__v4df)__Y);
255             }
256              
257             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
258             _mm256_hadd_ps (__m256 __X, __m256 __Y)
259             {
260             return (__m256) __builtin_ia32_haddps256 ((__v8sf)__X, (__v8sf)__Y);
261             }
262              
263             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
264             _mm256_hsub_pd (__m256d __X, __m256d __Y)
265             {
266             return (__m256d) __builtin_ia32_hsubpd256 ((__v4df)__X, (__v4df)__Y);
267             }
268              
269             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
270             _mm256_hsub_ps (__m256 __X, __m256 __Y)
271             {
272             return (__m256) __builtin_ia32_hsubps256 ((__v8sf)__X, (__v8sf)__Y);
273             }
274              
275             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
276             _mm256_max_pd (__m256d __A, __m256d __B)
277             {
278             return (__m256d) __builtin_ia32_maxpd256 ((__v4df)__A, (__v4df)__B);
279             }
280              
281             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
282             _mm256_max_ps (__m256 __A, __m256 __B)
283             {
284             return (__m256) __builtin_ia32_maxps256 ((__v8sf)__A, (__v8sf)__B);
285             }
286              
287             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
288             _mm256_min_pd (__m256d __A, __m256d __B)
289             {
290             return (__m256d) __builtin_ia32_minpd256 ((__v4df)__A, (__v4df)__B);
291             }
292              
293             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
294             _mm256_min_ps (__m256 __A, __m256 __B)
295             {
296             return (__m256) __builtin_ia32_minps256 ((__v8sf)__A, (__v8sf)__B);
297             }
298              
299             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
300             _mm256_mul_pd (__m256d __A, __m256d __B)
301             {
302             return (__m256d) ((__v4df)__A * (__v4df)__B);
303             }
304              
305             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
306             _mm256_mul_ps (__m256 __A, __m256 __B)
307             {
308             return (__m256) ((__v8sf)__A * (__v8sf)__B);
309             }
310              
311             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
312             _mm256_or_pd (__m256d __A, __m256d __B)
313             {
314             return (__m256d) __builtin_ia32_orpd256 ((__v4df)__A, (__v4df)__B);
315             }
316              
317             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
318             _mm256_or_ps (__m256 __A, __m256 __B)
319             {
320             return (__m256) __builtin_ia32_orps256 ((__v8sf)__A, (__v8sf)__B);
321             }
322              
323             #ifdef __OPTIMIZE__
324             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
325             _mm256_shuffle_pd (__m256d __A, __m256d __B, const int __mask)
326             {
327             return (__m256d) __builtin_ia32_shufpd256 ((__v4df)__A, (__v4df)__B,
328             __mask);
329             }
330              
331             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
332             _mm256_shuffle_ps (__m256 __A, __m256 __B, const int __mask)
333             {
334             return (__m256) __builtin_ia32_shufps256 ((__v8sf)__A, (__v8sf)__B,
335             __mask);
336             }
337             #else
338             #define _mm256_shuffle_pd(A, B, N) \
339             ((__m256d)__builtin_ia32_shufpd256 ((__v4df)(__m256d)(A), \
340             (__v4df)(__m256d)(B), (int)(N)))
341              
342             #define _mm256_shuffle_ps(A, B, N) \
343             ((__m256) __builtin_ia32_shufps256 ((__v8sf)(__m256)(A), \
344             (__v8sf)(__m256)(B), (int)(N)))
345             #endif
346              
347             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
348             _mm256_sub_pd (__m256d __A, __m256d __B)
349             {
350             return (__m256d) ((__v4df)__A - (__v4df)__B);
351             }
352              
353             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
354             _mm256_sub_ps (__m256 __A, __m256 __B)
355             {
356             return (__m256) ((__v8sf)__A - (__v8sf)__B);
357             }
358              
359             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
360             _mm256_xor_pd (__m256d __A, __m256d __B)
361             {
362             return (__m256d) __builtin_ia32_xorpd256 ((__v4df)__A, (__v4df)__B);
363             }
364              
365             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
366             _mm256_xor_ps (__m256 __A, __m256 __B)
367             {
368             return (__m256) __builtin_ia32_xorps256 ((__v8sf)__A, (__v8sf)__B);
369             }
370              
371             #ifdef __OPTIMIZE__
372             extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
373             _mm_cmp_pd (__m128d __X, __m128d __Y, const int __P)
374             {
375             return (__m128d) __builtin_ia32_cmppd ((__v2df)__X, (__v2df)__Y, __P);
376             }
377              
378             extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
379             _mm_cmp_ps (__m128 __X, __m128 __Y, const int __P)
380             {
381             return (__m128) __builtin_ia32_cmpps ((__v4sf)__X, (__v4sf)__Y, __P);
382             }
383              
384             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
385             _mm256_cmp_pd (__m256d __X, __m256d __Y, const int __P)
386             {
387             return (__m256d) __builtin_ia32_cmppd256 ((__v4df)__X, (__v4df)__Y,
388             __P);
389             }
390              
391             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
392             _mm256_cmp_ps (__m256 __X, __m256 __Y, const int __P)
393             {
394             return (__m256) __builtin_ia32_cmpps256 ((__v8sf)__X, (__v8sf)__Y,
395             __P);
396             }
397              
398             extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
399             _mm_cmp_sd (__m128d __X, __m128d __Y, const int __P)
400             {
401             return (__m128d) __builtin_ia32_cmpsd ((__v2df)__X, (__v2df)__Y, __P);
402             }
403              
404             extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
405             _mm_cmp_ss (__m128 __X, __m128 __Y, const int __P)
406             {
407             return (__m128) __builtin_ia32_cmpss ((__v4sf)__X, (__v4sf)__Y, __P);
408             }
409             #else
410             #define _mm_cmp_pd(X, Y, P) \
411             ((__m128d) __builtin_ia32_cmppd ((__v2df)(__m128d)(X), \
412             (__v2df)(__m128d)(Y), (int)(P)))
413              
414             #define _mm_cmp_ps(X, Y, P) \
415             ((__m128) __builtin_ia32_cmpps ((__v4sf)(__m128)(X), \
416             (__v4sf)(__m128)(Y), (int)(P)))
417              
418             #define _mm256_cmp_pd(X, Y, P) \
419             ((__m256d) __builtin_ia32_cmppd256 ((__v4df)(__m256d)(X), \
420             (__v4df)(__m256d)(Y), (int)(P)))
421              
422             #define _mm256_cmp_ps(X, Y, P) \
423             ((__m256) __builtin_ia32_cmpps256 ((__v8sf)(__m256)(X), \
424             (__v8sf)(__m256)(Y), (int)(P)))
425              
426             #define _mm_cmp_sd(X, Y, P) \
427             ((__m128d) __builtin_ia32_cmpsd ((__v2df)(__m128d)(X), \
428             (__v2df)(__m128d)(Y), (int)(P)))
429              
430             #define _mm_cmp_ss(X, Y, P) \
431             ((__m128) __builtin_ia32_cmpss ((__v4sf)(__m128)(X), \
432             (__v4sf)(__m128)(Y), (int)(P)))
433             #endif
434              
435             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
436             _mm256_cvtepi32_pd (__m128i __A)
437             {
438             return (__m256d)__builtin_ia32_cvtdq2pd256 ((__v4si) __A);
439             }
440              
441             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
442             _mm256_cvtepi32_ps (__m256i __A)
443             {
444             return (__m256)__builtin_ia32_cvtdq2ps256 ((__v8si) __A);
445             }
446              
447             extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
448             _mm256_cvtpd_ps (__m256d __A)
449             {
450             return (__m128)__builtin_ia32_cvtpd2ps256 ((__v4df) __A);
451             }
452              
453             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
454             _mm256_cvtps_epi32 (__m256 __A)
455             {
456             return (__m256i)__builtin_ia32_cvtps2dq256 ((__v8sf) __A);
457             }
458              
459             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
460             _mm256_cvtps_pd (__m128 __A)
461             {
462             return (__m256d)__builtin_ia32_cvtps2pd256 ((__v4sf) __A);
463             }
464              
465             extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
466             _mm256_cvttpd_epi32 (__m256d __A)
467             {
468             return (__m128i)__builtin_ia32_cvttpd2dq256 ((__v4df) __A);
469             }
470              
471             extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
472             _mm256_cvtpd_epi32 (__m256d __A)
473             {
474             return (__m128i)__builtin_ia32_cvtpd2dq256 ((__v4df) __A);
475             }
476              
477             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
478             _mm256_cvttps_epi32 (__m256 __A)
479             {
480             return (__m256i)__builtin_ia32_cvttps2dq256 ((__v8sf) __A);
481             }
482              
483             #ifdef __OPTIMIZE__
484             extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
485             _mm256_extractf128_pd (__m256d __X, const int __N)
486             {
487             return (__m128d) __builtin_ia32_vextractf128_pd256 ((__v4df)__X, __N);
488             }
489              
490             extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
491             _mm256_extractf128_ps (__m256 __X, const int __N)
492             {
493             return (__m128) __builtin_ia32_vextractf128_ps256 ((__v8sf)__X, __N);
494             }
495              
496             extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
497             _mm256_extractf128_si256 (__m256i __X, const int __N)
498             {
499             return (__m128i) __builtin_ia32_vextractf128_si256 ((__v8si)__X, __N);
500             }
501              
502             extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
503             _mm256_extract_epi32 (__m256i __X, int const __N)
504             {
505             __m128i __Y = _mm256_extractf128_si256 (__X, __N >> 2);
506             return _mm_extract_epi32 (__Y, __N % 4);
507             }
508              
509             extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
510             _mm256_extract_epi16 (__m256i __X, int const __N)
511             {
512             __m128i __Y = _mm256_extractf128_si256 (__X, __N >> 3);
513             return _mm_extract_epi16 (__Y, __N % 8);
514             }
515              
516             extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
517             _mm256_extract_epi8 (__m256i __X, int const __N)
518             {
519             __m128i __Y = _mm256_extractf128_si256 (__X, __N >> 4);
520             return _mm_extract_epi8 (__Y, __N % 16);
521             }
522              
523             #ifdef __x86_64__
524             extern __inline long long __attribute__((__gnu_inline__, __always_inline__, __artificial__))
525             _mm256_extract_epi64 (__m256i __X, const int __N)
526             {
527             __m128i __Y = _mm256_extractf128_si256 (__X, __N >> 1);
528             return _mm_extract_epi64 (__Y, __N % 2);
529             }
530             #endif
531             #else
532             #define _mm256_extractf128_pd(X, N) \
533             ((__m128d) __builtin_ia32_vextractf128_pd256 ((__v4df)(__m256d)(X), \
534             (int)(N)))
535              
536             #define _mm256_extractf128_ps(X, N) \
537             ((__m128) __builtin_ia32_vextractf128_ps256 ((__v8sf)(__m256)(X), \
538             (int)(N)))
539              
540             #define _mm256_extractf128_si256(X, N) \
541             ((__m128i) __builtin_ia32_vextractf128_si256 ((__v8si)(__m256i)(X), \
542             (int)(N)))
543              
544             #define _mm256_extract_epi32(X, N) \
545             (__extension__ \
546             ({ \
547             __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 2); \
548             _mm_extract_epi32 (__Y, (N) % 4); \
549             }))
550              
551             #define _mm256_extract_epi16(X, N) \
552             (__extension__ \
553             ({ \
554             __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 3); \
555             _mm_extract_epi16 (__Y, (N) % 8); \
556             }))
557              
558             #define _mm256_extract_epi8(X, N) \
559             (__extension__ \
560             ({ \
561             __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 4); \
562             _mm_extract_epi8 (__Y, (N) % 16); \
563             }))
564              
565             #ifdef __x86_64__
566             #define _mm256_extract_epi64(X, N) \
567             (__extension__ \
568             ({ \
569             __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 1); \
570             _mm_extract_epi64 (__Y, (N) % 2); \
571             }))
572             #endif
573             #endif
574              
575             extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
576             _mm256_zeroall (void)
577             {
578             __builtin_ia32_vzeroall ();
579             }
580              
581             extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
582             _mm256_zeroupper (void)
583             {
584             __builtin_ia32_vzeroupper ();
585             }
586              
587             extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
588             _mm_permutevar_pd (__m128d __A, __m128i __C)
589             {
590             return (__m128d) __builtin_ia32_vpermilvarpd ((__v2df)__A,
591             (__v2di)__C);
592             }
593              
594             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
595             _mm256_permutevar_pd (__m256d __A, __m256i __C)
596             {
597             return (__m256d) __builtin_ia32_vpermilvarpd256 ((__v4df)__A,
598             (__v4di)__C);
599             }
600              
601             extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
602             _mm_permutevar_ps (__m128 __A, __m128i __C)
603             {
604             return (__m128) __builtin_ia32_vpermilvarps ((__v4sf)__A,
605             (__v4si)__C);
606             }
607              
608             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
609             _mm256_permutevar_ps (__m256 __A, __m256i __C)
610             {
611             return (__m256) __builtin_ia32_vpermilvarps256 ((__v8sf)__A,
612             (__v8si)__C);
613             }
614              
615             #ifdef __OPTIMIZE__
616             extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
617             _mm_permute_pd (__m128d __X, const int __C)
618             {
619             return (__m128d) __builtin_ia32_vpermilpd ((__v2df)__X, __C);
620             }
621              
622             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
623             _mm256_permute_pd (__m256d __X, const int __C)
624             {
625             return (__m256d) __builtin_ia32_vpermilpd256 ((__v4df)__X, __C);
626             }
627              
628             extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
629             _mm_permute_ps (__m128 __X, const int __C)
630             {
631             return (__m128) __builtin_ia32_vpermilps ((__v4sf)__X, __C);
632             }
633              
634             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
635             _mm256_permute_ps (__m256 __X, const int __C)
636             {
637             return (__m256) __builtin_ia32_vpermilps256 ((__v8sf)__X, __C);
638             }
639             #else
640             #define _mm_permute_pd(X, C) \
641             ((__m128d) __builtin_ia32_vpermilpd ((__v2df)(__m128d)(X), (int)(C)))
642              
643             #define _mm256_permute_pd(X, C) \
644             ((__m256d) __builtin_ia32_vpermilpd256 ((__v4df)(__m256d)(X), (int)(C)))
645              
646             #define _mm_permute_ps(X, C) \
647             ((__m128) __builtin_ia32_vpermilps ((__v4sf)(__m128)(X), (int)(C)))
648              
649             #define _mm256_permute_ps(X, C) \
650             ((__m256) __builtin_ia32_vpermilps256 ((__v8sf)(__m256)(X), (int)(C)))
651             #endif
652              
653             #ifdef __OPTIMIZE__
654             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
655             _mm256_permute2f128_pd (__m256d __X, __m256d __Y, const int __C)
656             {
657             return (__m256d) __builtin_ia32_vperm2f128_pd256 ((__v4df)__X,
658             (__v4df)__Y,
659             __C);
660             }
661              
662             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
663             _mm256_permute2f128_ps (__m256 __X, __m256 __Y, const int __C)
664             {
665             return (__m256) __builtin_ia32_vperm2f128_ps256 ((__v8sf)__X,
666             (__v8sf)__Y,
667             __C);
668             }
669              
670             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
671             _mm256_permute2f128_si256 (__m256i __X, __m256i __Y, const int __C)
672             {
673             return (__m256i) __builtin_ia32_vperm2f128_si256 ((__v8si)__X,
674             (__v8si)__Y,
675             __C);
676             }
677             #else
678             #define _mm256_permute2f128_pd(X, Y, C) \
679             ((__m256d) __builtin_ia32_vperm2f128_pd256 ((__v4df)(__m256d)(X), \
680             (__v4df)(__m256d)(Y), \
681             (int)(C)))
682              
683             #define _mm256_permute2f128_ps(X, Y, C) \
684             ((__m256) __builtin_ia32_vperm2f128_ps256 ((__v8sf)(__m256)(X), \
685             (__v8sf)(__m256)(Y), \
686             (int)(C)))
687              
688             #define _mm256_permute2f128_si256(X, Y, C) \
689             ((__m256i) __builtin_ia32_vperm2f128_si256 ((__v8si)(__m256i)(X), \
690             (__v8si)(__m256i)(Y), \
691             (int)(C)))
692             #endif
693              
694             extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
695             _mm_broadcast_ss (float const *__X)
696             {
697             return (__m128) __builtin_ia32_vbroadcastss (__X);
698             }
699              
700             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
701             _mm256_broadcast_sd (double const *__X)
702             {
703             return (__m256d) __builtin_ia32_vbroadcastsd256 (__X);
704             }
705              
706             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
707             _mm256_broadcast_ss (float const *__X)
708             {
709             return (__m256) __builtin_ia32_vbroadcastss256 (__X);
710             }
711              
712             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
713             _mm256_broadcast_pd (__m128d const *__X)
714             {
715             return (__m256d) __builtin_ia32_vbroadcastf128_pd256 (__X);
716             }
717              
718             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
719             _mm256_broadcast_ps (__m128 const *__X)
720             {
721             return (__m256) __builtin_ia32_vbroadcastf128_ps256 (__X);
722             }
723              
724             #ifdef __OPTIMIZE__
725             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
726             _mm256_insertf128_pd (__m256d __X, __m128d __Y, const int __O)
727             {
728             return (__m256d) __builtin_ia32_vinsertf128_pd256 ((__v4df)__X,
729             (__v2df)__Y,
730             __O);
731             }
732              
733             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
734             _mm256_insertf128_ps (__m256 __X, __m128 __Y, const int __O)
735             {
736             return (__m256) __builtin_ia32_vinsertf128_ps256 ((__v8sf)__X,
737             (__v4sf)__Y,
738             __O);
739             }
740              
741             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
742             _mm256_insertf128_si256 (__m256i __X, __m128i __Y, const int __O)
743             {
744             return (__m256i) __builtin_ia32_vinsertf128_si256 ((__v8si)__X,
745             (__v4si)__Y,
746             __O);
747             }
748              
749             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
750             _mm256_insert_epi32 (__m256i __X, int __D, int const __N)
751             {
752             __m128i __Y = _mm256_extractf128_si256 (__X, __N >> 2);
753             __Y = _mm_insert_epi32 (__Y, __D, __N % 4);
754             return _mm256_insertf128_si256 (__X, __Y, __N >> 2);
755             }
756              
757             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
758             _mm256_insert_epi16 (__m256i __X, int __D, int const __N)
759             {
760             __m128i __Y = _mm256_extractf128_si256 (__X, __N >> 3);
761             __Y = _mm_insert_epi16 (__Y, __D, __N % 8);
762             return _mm256_insertf128_si256 (__X, __Y, __N >> 3);
763             }
764              
765             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
766             _mm256_insert_epi8 (__m256i __X, int __D, int const __N)
767             {
768             __m128i __Y = _mm256_extractf128_si256 (__X, __N >> 4);
769             __Y = _mm_insert_epi8 (__Y, __D, __N % 16);
770             return _mm256_insertf128_si256 (__X, __Y, __N >> 4);
771             }
772              
773             #ifdef __x86_64__
774             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
775             _mm256_insert_epi64 (__m256i __X, long long __D, int const __N)
776             {
777             __m128i __Y = _mm256_extractf128_si256 (__X, __N >> 1);
778             __Y = _mm_insert_epi64 (__Y, __D, __N % 2);
779             return _mm256_insertf128_si256 (__X, __Y, __N >> 1);
780             }
781             #endif
782             #else
783             #define _mm256_insertf128_pd(X, Y, O) \
784             ((__m256d) __builtin_ia32_vinsertf128_pd256 ((__v4df)(__m256d)(X), \
785             (__v2df)(__m128d)(Y), \
786             (int)(O)))
787              
788             #define _mm256_insertf128_ps(X, Y, O) \
789             ((__m256) __builtin_ia32_vinsertf128_ps256 ((__v8sf)(__m256)(X), \
790             (__v4sf)(__m128)(Y), \
791             (int)(O)))
792              
793             #define _mm256_insertf128_si256(X, Y, O) \
794             ((__m256i) __builtin_ia32_vinsertf128_si256 ((__v8si)(__m256i)(X), \
795             (__v4si)(__m128i)(Y), \
796             (int)(O)))
797              
798             #define _mm256_insert_epi32(X, D, N) \
799             (__extension__ \
800             ({ \
801             __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 2); \
802             __Y = _mm_insert_epi32 (__Y, (D), (N) % 4); \
803             _mm256_insertf128_si256 ((X), __Y, (N) >> 2); \
804             }))
805              
806             #define _mm256_insert_epi16(X, D, N) \
807             (__extension__ \
808             ({ \
809             __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 3); \
810             __Y = _mm_insert_epi16 (__Y, (D), (N) % 8); \
811             _mm256_insertf128_si256 ((X), __Y, (N) >> 3); \
812             }))
813              
814             #define _mm256_insert_epi8(X, D, N) \
815             (__extension__ \
816             ({ \
817             __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 4); \
818             __Y = _mm_insert_epi8 (__Y, (D), (N) % 16); \
819             _mm256_insertf128_si256 ((X), __Y, (N) >> 4); \
820             }))
821              
822             #ifdef __x86_64__
823             #define _mm256_insert_epi64(X, D, N) \
824             (__extension__ \
825             ({ \
826             __m128i __Y = _mm256_extractf128_si256 ((X), (N) >> 1); \
827             __Y = _mm_insert_epi64 (__Y, (D), (N) % 2); \
828             _mm256_insertf128_si256 ((X), __Y, (N) >> 1); \
829             }))
830             #endif
831             #endif
832              
833             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
834             _mm256_load_pd (double const *__P)
835             {
836             return *(__m256d *)__P;
837             }
838              
839             extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
840             _mm256_store_pd (double *__P, __m256d __A)
841             {
842             *(__m256d *)__P = __A;
843             }
844              
845             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
846             _mm256_load_ps (float const *__P)
847             {
848             return *(__m256 *)__P;
849             }
850              
851             extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
852             _mm256_store_ps (float *__P, __m256 __A)
853             {
854             *(__m256 *)__P = __A;
855             }
856              
857             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
858             _mm256_loadu_pd (double const *__P)
859             {
860             return (__m256d) __builtin_ia32_loadupd256 (__P);
861             }
862              
863             extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
864             _mm256_storeu_pd (double *__P, __m256d __A)
865             {
866             __builtin_ia32_storeupd256 (__P, (__v4df)__A);
867             }
868              
869             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
870             _mm256_loadu_ps (float const *__P)
871             {
872             return (__m256) __builtin_ia32_loadups256 (__P);
873             }
874              
875             extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
876             _mm256_storeu_ps (float *__P, __m256 __A)
877             {
878             __builtin_ia32_storeups256 (__P, (__v8sf)__A);
879             }
880              
881             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
882             _mm256_load_si256 (__m256i const *__P)
883             {
884             return *__P;
885             }
886              
887             extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
888             _mm256_store_si256 (__m256i *__P, __m256i __A)
889             {
890             *__P = __A;
891             }
892              
893             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
894             _mm256_loadu_si256 (__m256i const *__P)
895             {
896 0           return (__m256i) __builtin_ia32_loaddqu256 ((char const *)__P);
897             }
898              
899             extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
900             _mm256_storeu_si256 (__m256i *__P, __m256i __A)
901             {
902             __builtin_ia32_storedqu256 ((char *)__P, (__v32qi)__A);
903             }
904              
905             extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
906             _mm_maskload_pd (double const *__P, __m128i __M)
907             {
908             return (__m128d) __builtin_ia32_maskloadpd ((const __v2df *)__P,
909             (__v2di)__M);
910             }
911              
912             extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
913             _mm_maskstore_pd (double *__P, __m128i __M, __m128d __A)
914             {
915             __builtin_ia32_maskstorepd ((__v2df *)__P, (__v2di)__M, (__v2df)__A);
916             }
917              
918             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
919             _mm256_maskload_pd (double const *__P, __m256i __M)
920             {
921             return (__m256d) __builtin_ia32_maskloadpd256 ((const __v4df *)__P,
922             (__v4di)__M);
923             }
924              
925             extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
926             _mm256_maskstore_pd (double *__P, __m256i __M, __m256d __A)
927             {
928             __builtin_ia32_maskstorepd256 ((__v4df *)__P, (__v4di)__M, (__v4df)__A);
929             }
930              
931             extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
932             _mm_maskload_ps (float const *__P, __m128i __M)
933             {
934             return (__m128) __builtin_ia32_maskloadps ((const __v4sf *)__P,
935             (__v4si)__M);
936             }
937              
938             extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
939             _mm_maskstore_ps (float *__P, __m128i __M, __m128 __A)
940             {
941             __builtin_ia32_maskstoreps ((__v4sf *)__P, (__v4si)__M, (__v4sf)__A);
942             }
943              
944             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
945             _mm256_maskload_ps (float const *__P, __m256i __M)
946             {
947             return (__m256) __builtin_ia32_maskloadps256 ((const __v8sf *)__P,
948             (__v8si)__M);
949             }
950              
951             extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
952             _mm256_maskstore_ps (float *__P, __m256i __M, __m256 __A)
953             {
954             __builtin_ia32_maskstoreps256 ((__v8sf *)__P, (__v8si)__M, (__v8sf)__A);
955             }
956              
957             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
958             _mm256_movehdup_ps (__m256 __X)
959             {
960             return (__m256) __builtin_ia32_movshdup256 ((__v8sf)__X);
961             }
962              
963             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
964             _mm256_moveldup_ps (__m256 __X)
965             {
966             return (__m256) __builtin_ia32_movsldup256 ((__v8sf)__X);
967             }
968              
969             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
970             _mm256_movedup_pd (__m256d __X)
971             {
972             return (__m256d) __builtin_ia32_movddup256 ((__v4df)__X);
973             }
974              
975             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
976             _mm256_lddqu_si256 (__m256i const *__P)
977             {
978             return (__m256i) __builtin_ia32_lddqu256 ((char const *)__P);
979             }
980              
981             extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
982             _mm256_stream_si256 (__m256i *__A, __m256i __B)
983             {
984             __builtin_ia32_movntdq256 ((__v4di *)__A, (__v4di)__B);
985             }
986              
987             extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
988             _mm256_stream_pd (double *__A, __m256d __B)
989             {
990             __builtin_ia32_movntpd256 (__A, (__v4df)__B);
991             }
992              
993             extern __inline void __attribute__((__gnu_inline__, __always_inline__, __artificial__))
994             _mm256_stream_ps (float *__P, __m256 __A)
995             {
996             __builtin_ia32_movntps256 (__P, (__v8sf)__A);
997             }
998              
999             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1000             _mm256_rcp_ps (__m256 __A)
1001             {
1002             return (__m256) __builtin_ia32_rcpps256 ((__v8sf)__A);
1003             }
1004              
1005             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1006             _mm256_rsqrt_ps (__m256 __A)
1007             {
1008             return (__m256) __builtin_ia32_rsqrtps256 ((__v8sf)__A);
1009             }
1010              
1011             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1012             _mm256_sqrt_pd (__m256d __A)
1013             {
1014             return (__m256d) __builtin_ia32_sqrtpd256 ((__v4df)__A);
1015             }
1016              
1017             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1018             _mm256_sqrt_ps (__m256 __A)
1019             {
1020             return (__m256) __builtin_ia32_sqrtps256 ((__v8sf)__A);
1021             }
1022              
1023             #ifdef __OPTIMIZE__
1024             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1025             _mm256_round_pd (__m256d __V, const int __M)
1026             {
1027             return (__m256d) __builtin_ia32_roundpd256 ((__v4df)__V, __M);
1028             }
1029              
1030             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1031             _mm256_round_ps (__m256 __V, const int __M)
1032             {
1033             return (__m256) __builtin_ia32_roundps256 ((__v8sf)__V, __M);
1034             }
1035             #else
1036             #define _mm256_round_pd(V, M) \
1037             ((__m256d) __builtin_ia32_roundpd256 ((__v4df)(__m256d)(V), (int)(M)))
1038              
1039             #define _mm256_round_ps(V, M) \
1040             ((__m256) __builtin_ia32_roundps256 ((__v8sf)(__m256)(V), (int)(M)))
1041             #endif
1042              
1043             #define _mm256_ceil_pd(V) _mm256_round_pd ((V), _MM_FROUND_CEIL)
1044             #define _mm256_floor_pd(V) _mm256_round_pd ((V), _MM_FROUND_FLOOR)
1045             #define _mm256_ceil_ps(V) _mm256_round_ps ((V), _MM_FROUND_CEIL)
1046             #define _mm256_floor_ps(V) _mm256_round_ps ((V), _MM_FROUND_FLOOR)
1047              
1048             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1049             _mm256_unpackhi_pd (__m256d __A, __m256d __B)
1050             {
1051             return (__m256d) __builtin_ia32_unpckhpd256 ((__v4df)__A, (__v4df)__B);
1052             }
1053              
1054             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1055             _mm256_unpacklo_pd (__m256d __A, __m256d __B)
1056             {
1057             return (__m256d) __builtin_ia32_unpcklpd256 ((__v4df)__A, (__v4df)__B);
1058             }
1059              
1060             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1061             _mm256_unpackhi_ps (__m256 __A, __m256 __B)
1062             {
1063             return (__m256) __builtin_ia32_unpckhps256 ((__v8sf)__A, (__v8sf)__B);
1064             }
1065              
1066             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1067             _mm256_unpacklo_ps (__m256 __A, __m256 __B)
1068             {
1069             return (__m256) __builtin_ia32_unpcklps256 ((__v8sf)__A, (__v8sf)__B);
1070             }
1071              
1072             extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1073             _mm_testz_pd (__m128d __M, __m128d __V)
1074             {
1075             return __builtin_ia32_vtestzpd ((__v2df)__M, (__v2df)__V);
1076             }
1077              
1078             extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1079             _mm_testc_pd (__m128d __M, __m128d __V)
1080             {
1081             return __builtin_ia32_vtestcpd ((__v2df)__M, (__v2df)__V);
1082             }
1083              
1084             extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1085             _mm_testnzc_pd (__m128d __M, __m128d __V)
1086             {
1087             return __builtin_ia32_vtestnzcpd ((__v2df)__M, (__v2df)__V);
1088             }
1089              
1090             extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1091             _mm_testz_ps (__m128 __M, __m128 __V)
1092             {
1093             return __builtin_ia32_vtestzps ((__v4sf)__M, (__v4sf)__V);
1094             }
1095              
1096             extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1097             _mm_testc_ps (__m128 __M, __m128 __V)
1098             {
1099             return __builtin_ia32_vtestcps ((__v4sf)__M, (__v4sf)__V);
1100             }
1101              
1102             extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1103             _mm_testnzc_ps (__m128 __M, __m128 __V)
1104             {
1105             return __builtin_ia32_vtestnzcps ((__v4sf)__M, (__v4sf)__V);
1106             }
1107              
1108             extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1109             _mm256_testz_pd (__m256d __M, __m256d __V)
1110             {
1111             return __builtin_ia32_vtestzpd256 ((__v4df)__M, (__v4df)__V);
1112             }
1113              
1114             extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1115             _mm256_testc_pd (__m256d __M, __m256d __V)
1116             {
1117             return __builtin_ia32_vtestcpd256 ((__v4df)__M, (__v4df)__V);
1118             }
1119              
1120             extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1121             _mm256_testnzc_pd (__m256d __M, __m256d __V)
1122             {
1123             return __builtin_ia32_vtestnzcpd256 ((__v4df)__M, (__v4df)__V);
1124             }
1125              
1126             extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1127             _mm256_testz_ps (__m256 __M, __m256 __V)
1128             {
1129             return __builtin_ia32_vtestzps256 ((__v8sf)__M, (__v8sf)__V);
1130             }
1131              
1132             extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1133             _mm256_testc_ps (__m256 __M, __m256 __V)
1134             {
1135             return __builtin_ia32_vtestcps256 ((__v8sf)__M, (__v8sf)__V);
1136             }
1137              
1138             extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1139             _mm256_testnzc_ps (__m256 __M, __m256 __V)
1140             {
1141             return __builtin_ia32_vtestnzcps256 ((__v8sf)__M, (__v8sf)__V);
1142             }
1143              
1144             extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1145             _mm256_testz_si256 (__m256i __M, __m256i __V)
1146             {
1147             return __builtin_ia32_ptestz256 ((__v4di)__M, (__v4di)__V);
1148             }
1149              
1150             extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1151             _mm256_testc_si256 (__m256i __M, __m256i __V)
1152             {
1153             return __builtin_ia32_ptestc256 ((__v4di)__M, (__v4di)__V);
1154             }
1155              
1156             extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1157             _mm256_testnzc_si256 (__m256i __M, __m256i __V)
1158             {
1159             return __builtin_ia32_ptestnzc256 ((__v4di)__M, (__v4di)__V);
1160             }
1161              
1162             extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1163             _mm256_movemask_pd (__m256d __A)
1164             {
1165             return __builtin_ia32_movmskpd256 ((__v4df)__A);
1166             }
1167              
1168             extern __inline int __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1169             _mm256_movemask_ps (__m256 __A)
1170             {
1171             return __builtin_ia32_movmskps256 ((__v8sf)__A);
1172             }
1173              
1174             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1175             _mm256_undefined_pd (void)
1176             {
1177             __m256d __Y = __Y;
1178             return __Y;
1179             }
1180              
1181             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1182             _mm256_undefined_ps (void)
1183             {
1184             __m256 __Y = __Y;
1185             return __Y;
1186             }
1187              
1188             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1189             _mm256_undefined_si256 (void)
1190             {
1191             __m256i __Y = __Y;
1192             return __Y;
1193             }
1194              
1195             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1196             _mm256_setzero_pd (void)
1197             {
1198             return __extension__ (__m256d){ 0.0, 0.0, 0.0, 0.0 };
1199             }
1200              
1201             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1202             _mm256_setzero_ps (void)
1203             {
1204             return __extension__ (__m256){ 0.0, 0.0, 0.0, 0.0,
1205             0.0, 0.0, 0.0, 0.0 };
1206             }
1207              
1208             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1209             _mm256_setzero_si256 (void)
1210             {
1211             return __extension__ (__m256i)(__v4di){ 0, 0, 0, 0 };
1212             }
1213              
1214             /* Create the vector [A B C D]. */
1215             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1216             _mm256_set_pd (double __A, double __B, double __C, double __D)
1217             {
1218             return __extension__ (__m256d){ __D, __C, __B, __A };
1219             }
1220              
1221             /* Create the vector [A B C D E F G H]. */
1222             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1223             _mm256_set_ps (float __A, float __B, float __C, float __D,
1224             float __E, float __F, float __G, float __H)
1225             {
1226             return __extension__ (__m256){ __H, __G, __F, __E,
1227             __D, __C, __B, __A };
1228             }
1229              
1230             /* Create the vector [A B C D E F G H]. */
1231             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1232             _mm256_set_epi32 (int __A, int __B, int __C, int __D,
1233             int __E, int __F, int __G, int __H)
1234             {
1235             return __extension__ (__m256i)(__v8si){ __H, __G, __F, __E,
1236             __D, __C, __B, __A };
1237             }
1238              
1239             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1240             _mm256_set_epi16 (short __q15, short __q14, short __q13, short __q12,
1241             short __q11, short __q10, short __q09, short __q08,
1242             short __q07, short __q06, short __q05, short __q04,
1243             short __q03, short __q02, short __q01, short __q00)
1244             {
1245             return __extension__ (__m256i)(__v16hi){
1246             __q00, __q01, __q02, __q03, __q04, __q05, __q06, __q07,
1247             __q08, __q09, __q10, __q11, __q12, __q13, __q14, __q15
1248             };
1249             }
1250              
1251             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1252             _mm256_set_epi8 (char __q31, char __q30, char __q29, char __q28,
1253             char __q27, char __q26, char __q25, char __q24,
1254             char __q23, char __q22, char __q21, char __q20,
1255             char __q19, char __q18, char __q17, char __q16,
1256             char __q15, char __q14, char __q13, char __q12,
1257             char __q11, char __q10, char __q09, char __q08,
1258             char __q07, char __q06, char __q05, char __q04,
1259             char __q03, char __q02, char __q01, char __q00)
1260             {
1261             return __extension__ (__m256i)(__v32qi){
1262             __q00, __q01, __q02, __q03, __q04, __q05, __q06, __q07,
1263             __q08, __q09, __q10, __q11, __q12, __q13, __q14, __q15,
1264             __q16, __q17, __q18, __q19, __q20, __q21, __q22, __q23,
1265             __q24, __q25, __q26, __q27, __q28, __q29, __q30, __q31
1266             };
1267             }
1268              
1269             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1270             _mm256_set_epi64x (long long __A, long long __B, long long __C,
1271             long long __D)
1272             {
1273 0           return __extension__ (__m256i)(__v4di){ __D, __C, __B, __A };
1274             }
1275              
1276             /* Create a vector with all elements equal to A. */
1277             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1278             _mm256_set1_pd (double __A)
1279             {
1280             return __extension__ (__m256d){ __A, __A, __A, __A };
1281             }
1282              
1283             /* Create a vector with all elements equal to A. */
1284             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1285             _mm256_set1_ps (float __A)
1286             {
1287             return __extension__ (__m256){ __A, __A, __A, __A,
1288             __A, __A, __A, __A };
1289             }
1290              
1291             /* Create a vector with all elements equal to A. */
1292             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1293             _mm256_set1_epi32 (int __A)
1294             {
1295             return __extension__ (__m256i)(__v8si){ __A, __A, __A, __A,
1296             __A, __A, __A, __A };
1297             }
1298              
1299             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1300             _mm256_set1_epi16 (short __A)
1301             {
1302             return _mm256_set_epi16 (__A, __A, __A, __A, __A, __A, __A, __A,
1303             __A, __A, __A, __A, __A, __A, __A, __A);
1304             }
1305              
1306             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1307             _mm256_set1_epi8 (char __A)
1308             {
1309             return _mm256_set_epi8 (__A, __A, __A, __A, __A, __A, __A, __A,
1310             __A, __A, __A, __A, __A, __A, __A, __A,
1311             __A, __A, __A, __A, __A, __A, __A, __A,
1312             __A, __A, __A, __A, __A, __A, __A, __A);
1313             }
1314              
1315             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1316             _mm256_set1_epi64x (long long __A)
1317             {
1318             return __extension__ (__m256i)(__v4di){ __A, __A, __A, __A };
1319             }
1320              
1321             /* Create vectors of elements in the reversed order from the
1322             _mm256_set_XXX functions. */
1323              
1324             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1325             _mm256_setr_pd (double __A, double __B, double __C, double __D)
1326             {
1327             return _mm256_set_pd (__D, __C, __B, __A);
1328             }
1329              
1330             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1331             _mm256_setr_ps (float __A, float __B, float __C, float __D,
1332             float __E, float __F, float __G, float __H)
1333             {
1334             return _mm256_set_ps (__H, __G, __F, __E, __D, __C, __B, __A);
1335             }
1336              
1337             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1338             _mm256_setr_epi32 (int __A, int __B, int __C, int __D,
1339             int __E, int __F, int __G, int __H)
1340             {
1341             return _mm256_set_epi32 (__H, __G, __F, __E, __D, __C, __B, __A);
1342             }
1343              
1344             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1345             _mm256_setr_epi16 (short __q15, short __q14, short __q13, short __q12,
1346             short __q11, short __q10, short __q09, short __q08,
1347             short __q07, short __q06, short __q05, short __q04,
1348             short __q03, short __q02, short __q01, short __q00)
1349             {
1350             return _mm256_set_epi16 (__q00, __q01, __q02, __q03,
1351             __q04, __q05, __q06, __q07,
1352             __q08, __q09, __q10, __q11,
1353             __q12, __q13, __q14, __q15);
1354             }
1355              
1356             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1357             _mm256_setr_epi8 (char __q31, char __q30, char __q29, char __q28,
1358             char __q27, char __q26, char __q25, char __q24,
1359             char __q23, char __q22, char __q21, char __q20,
1360             char __q19, char __q18, char __q17, char __q16,
1361             char __q15, char __q14, char __q13, char __q12,
1362             char __q11, char __q10, char __q09, char __q08,
1363             char __q07, char __q06, char __q05, char __q04,
1364             char __q03, char __q02, char __q01, char __q00)
1365             {
1366             return _mm256_set_epi8 (__q00, __q01, __q02, __q03,
1367             __q04, __q05, __q06, __q07,
1368             __q08, __q09, __q10, __q11,
1369             __q12, __q13, __q14, __q15,
1370             __q16, __q17, __q18, __q19,
1371             __q20, __q21, __q22, __q23,
1372             __q24, __q25, __q26, __q27,
1373             __q28, __q29, __q30, __q31);
1374             }
1375              
1376             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1377             _mm256_setr_epi64x (long long __A, long long __B, long long __C,
1378             long long __D)
1379             {
1380             return _mm256_set_epi64x (__D, __C, __B, __A);
1381             }
1382              
1383             /* Casts between various SP, DP, INT vector types. Note that these do no
1384             conversion of values, they just change the type. */
1385             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1386             _mm256_castpd_ps (__m256d __A)
1387             {
1388             return (__m256) __A;
1389             }
1390              
1391             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1392             _mm256_castpd_si256 (__m256d __A)
1393             {
1394             return (__m256i) __A;
1395             }
1396              
1397             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1398             _mm256_castps_pd (__m256 __A)
1399             {
1400             return (__m256d) __A;
1401             }
1402              
1403             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1404             _mm256_castps_si256(__m256 __A)
1405             {
1406             return (__m256i) __A;
1407             }
1408              
1409             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1410             _mm256_castsi256_ps (__m256i __A)
1411             {
1412             return (__m256) __A;
1413             }
1414              
1415             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1416             _mm256_castsi256_pd (__m256i __A)
1417             {
1418             return (__m256d) __A;
1419             }
1420              
1421             extern __inline __m128d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1422             _mm256_castpd256_pd128 (__m256d __A)
1423             {
1424             return (__m128d) __builtin_ia32_pd_pd256 ((__v4df)__A);
1425             }
1426              
1427             extern __inline __m128 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1428             _mm256_castps256_ps128 (__m256 __A)
1429             {
1430             return (__m128) __builtin_ia32_ps_ps256 ((__v8sf)__A);
1431             }
1432              
1433             extern __inline __m128i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1434             _mm256_castsi256_si128 (__m256i __A)
1435             {
1436             return (__m128i) __builtin_ia32_si_si256 ((__v8si)__A);
1437             }
1438              
1439             /* When cast is done from a 128 to 256-bit type, the low 128 bits of
1440             the 256-bit result contain source parameter value and the upper 128
1441             bits of the result are undefined. Those intrinsics shouldn't
1442             generate any extra moves. */
1443              
1444             extern __inline __m256d __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1445             _mm256_castpd128_pd256 (__m128d __A)
1446             {
1447             return (__m256d) __builtin_ia32_pd256_pd ((__v2df)__A);
1448             }
1449              
1450             extern __inline __m256 __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1451             _mm256_castps128_ps256 (__m128 __A)
1452             {
1453             return (__m256) __builtin_ia32_ps256_ps ((__v4sf)__A);
1454             }
1455              
1456             extern __inline __m256i __attribute__((__gnu_inline__, __always_inline__, __artificial__))
1457             _mm256_castsi128_si256 (__m128i __A)
1458             {
1459             return (__m256i) __builtin_ia32_si256_si ((__v4si)__A);
1460             }
1461              
1462             #ifdef __DISABLE_AVX__
1463             #undef __DISABLE_AVX__
1464             #pragma GCC pop_options
1465             #endif /* __DISABLE_AVX__ */
1466              
1467             #endif /* _AVXINTRIN_H_INCLUDED */