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