1/*! @header
2 * This header defines fixed size vector types with relaxed alignment. For
3 * each vector type defined by <simd/vector_types.h> that is not a 1- or 3-
4 * element vector, there is a corresponding type defined by this header that
5 * requires only the alignment matching that of the underlying scalar type.
6 *
7 * These types should be used to access buffers that may not be sufficiently
8 * aligned to allow them to be accessed using the "normal" simd vector types.
9 * As an example of this usage, suppose that you want to load a vector of
10 * four floats from an array of floats. The type simd_float4 has sixteen byte
11 * alignment, whereas an array of floats has only four byte alignment.
12 * Thus, naively casting a pointer into the array to (simd_float4 *) would
13 * invoke undefined behavior, and likely produce an alignment fault at
14 * runtime. Instead, use the corresponding packed type to load from the array:
15 *
16 * <pre>
17 * @textblock
18 * simd_float4 vector = *(simd_packed_float4 *)&array[i];
19 * // do something with vector ...
20 * @/textblock
21 * </pre>
22 *
23 * It's important to note that the packed_ types are only needed to work with
24 * memory; once the data is loaded, we simply operate on it as usual using
25 * the simd_float4 type, as illustrated above.
26 *
27 * @copyright 2014-2017 Apple, Inc. All rights reserved.
28 * @unsorted */
29
30#ifndef SIMD_PACKED_TYPES
31#define SIMD_PACKED_TYPES
32
33# include <simd/vector_types.h>
34# if SIMD_COMPILER_HAS_REQUIRED_FEATURES
35/*! @abstract A vector of two 8-bit signed (twos-complement) integers with
36 * relaxed alignment.
37 * @description In C++ and Metal, this type is also available as
38 * simd::packed::char2. The alignment of this type is that of the
39 * underlying scalar element type, so you can use it to load or store from
40 * an array of that type. */
41typedef __attribute__((__ext_vector_type__(2),__aligned__(1))) char simd_packed_char2;
42
43/*! @abstract A vector of four 8-bit signed (twos-complement) integers with
44 * relaxed alignment.
45 * @description In C++ and Metal, this type is also available as
46 * simd::packed::char4. The alignment of this type is that of the
47 * underlying scalar element type, so you can use it to load or store from
48 * an array of that type. */
49typedef __attribute__((__ext_vector_type__(4),__aligned__(1))) char simd_packed_char4;
50
51/*! @abstract A vector of eight 8-bit signed (twos-complement) integers with
52 * relaxed alignment.
53 * @description In C++ this type is also available as simd::packed::char8.
54 * This type is not available in Metal. The alignment of this type is only
55 * that of the underlying scalar element type, so you can use it to load or
56 * store from an array of that type. */
57typedef __attribute__((__ext_vector_type__(8),__aligned__(1))) char simd_packed_char8;
58
59/*! @abstract A vector of sixteen 8-bit signed (twos-complement) integers
60 * with relaxed alignment.
61 * @description In C++ this type is also available as simd::packed::char16.
62 * This type is not available in Metal. The alignment of this type is only
63 * that of the underlying scalar element type, so you can use it to load or
64 * store from an array of that type. */
65typedef __attribute__((__ext_vector_type__(16),__aligned__(1))) char simd_packed_char16;
66
67/*! @abstract A vector of thirty-two 8-bit signed (twos-complement) integers
68 * with relaxed alignment.
69 * @description In C++ this type is also available as simd::packed::char32.
70 * This type is not available in Metal. The alignment of this type is only
71 * that of the underlying scalar element type, so you can use it to load or
72 * store from an array of that type. */
73typedef __attribute__((__ext_vector_type__(32),__aligned__(1))) char simd_packed_char32;
74
75/*! @abstract A vector of sixty-four 8-bit signed (twos-complement) integers
76 * with relaxed alignment.
77 * @description In C++ this type is also available as simd::packed::char64.
78 * This type is not available in Metal. The alignment of this type is only
79 * that of the underlying scalar element type, so you can use it to load or
80 * store from an array of that type. */
81typedef __attribute__((__ext_vector_type__(64),__aligned__(1))) char simd_packed_char64;
82
83/*! @abstract A vector of two 8-bit unsigned integers with relaxed
84 * alignment.
85 * @description In C++ and Metal, this type is also available as
86 * simd::packed::uchar2. The alignment of this type is that of the
87 * underlying scalar element type, so you can use it to load or store from
88 * an array of that type. */
89typedef __attribute__((__ext_vector_type__(2),__aligned__(1))) unsigned char simd_packed_uchar2;
90
91/*! @abstract A vector of four 8-bit unsigned integers with relaxed
92 * alignment.
93 * @description In C++ and Metal, this type is also available as
94 * simd::packed::uchar4. The alignment of this type is that of the
95 * underlying scalar element type, so you can use it to load or store from
96 * an array of that type. */
97typedef __attribute__((__ext_vector_type__(4),__aligned__(1))) unsigned char simd_packed_uchar4;
98
99/*! @abstract A vector of eight 8-bit unsigned integers with relaxed
100 * alignment.
101 * @description In C++ this type is also available as simd::packed::uchar8.
102 * This type is not available in Metal. The alignment of this type is only
103 * that of the underlying scalar element type, so you can use it to load or
104 * store from an array of that type. */
105typedef __attribute__((__ext_vector_type__(8),__aligned__(1))) unsigned char simd_packed_uchar8;
106
107/*! @abstract A vector of sixteen 8-bit unsigned integers with relaxed
108 * alignment.
109 * @description In C++ this type is also available as
110 * simd::packed::uchar16. This type is not available in Metal. The
111 * alignment of this type is only that of the underlying scalar element
112 * type, so you can use it to load or store from an array of that type. */
113typedef __attribute__((__ext_vector_type__(16),__aligned__(1))) unsigned char simd_packed_uchar16;
114
115/*! @abstract A vector of thirty-two 8-bit unsigned integers with relaxed
116 * alignment.
117 * @description In C++ this type is also available as
118 * simd::packed::uchar32. This type is not available in Metal. The
119 * alignment of this type is only that of the underlying scalar element
120 * type, so you can use it to load or store from an array of that type. */
121typedef __attribute__((__ext_vector_type__(32),__aligned__(1))) unsigned char simd_packed_uchar32;
122
123/*! @abstract A vector of sixty-four 8-bit unsigned integers with relaxed
124 * alignment.
125 * @description In C++ this type is also available as
126 * simd::packed::uchar64. This type is not available in Metal. The
127 * alignment of this type is only that of the underlying scalar element
128 * type, so you can use it to load or store from an array of that type. */
129typedef __attribute__((__ext_vector_type__(64),__aligned__(1))) unsigned char simd_packed_uchar64;
130
131/*! @abstract A vector of two 16-bit signed (twos-complement) integers with
132 * relaxed alignment.
133 * @description In C++ and Metal, this type is also available as
134 * simd::packed::short2. The alignment of this type is that of the
135 * underlying scalar element type, so you can use it to load or store from
136 * an array of that type. */
137typedef __attribute__((__ext_vector_type__(2),__aligned__(2))) short simd_packed_short2;
138
139/*! @abstract A vector of four 16-bit signed (twos-complement) integers with
140 * relaxed alignment.
141 * @description In C++ and Metal, this type is also available as
142 * simd::packed::short4. The alignment of this type is that of the
143 * underlying scalar element type, so you can use it to load or store from
144 * an array of that type. */
145typedef __attribute__((__ext_vector_type__(4),__aligned__(2))) short simd_packed_short4;
146
147/*! @abstract A vector of eight 16-bit signed (twos-complement) integers
148 * with relaxed alignment.
149 * @description In C++ this type is also available as simd::packed::short8.
150 * This type is not available in Metal. The alignment of this type is only
151 * that of the underlying scalar element type, so you can use it to load or
152 * store from an array of that type. */
153typedef __attribute__((__ext_vector_type__(8),__aligned__(2))) short simd_packed_short8;
154
155/*! @abstract A vector of sixteen 16-bit signed (twos-complement) integers
156 * with relaxed alignment.
157 * @description In C++ this type is also available as
158 * simd::packed::short16. This type is not available in Metal. The
159 * alignment of this type is only that of the underlying scalar element
160 * type, so you can use it to load or store from an array of that type. */
161typedef __attribute__((__ext_vector_type__(16),__aligned__(2))) short simd_packed_short16;
162
163/*! @abstract A vector of thirty-two 16-bit signed (twos-complement)
164 * integers with relaxed alignment.
165 * @description In C++ this type is also available as
166 * simd::packed::short32. This type is not available in Metal. The
167 * alignment of this type is only that of the underlying scalar element
168 * type, so you can use it to load or store from an array of that type. */
169typedef __attribute__((__ext_vector_type__(32),__aligned__(2))) short simd_packed_short32;
170
171/*! @abstract A vector of two 16-bit unsigned integers with relaxed
172 * alignment.
173 * @description In C++ and Metal, this type is also available as
174 * simd::packed::ushort2. The alignment of this type is that of the
175 * underlying scalar element type, so you can use it to load or store from
176 * an array of that type. */
177typedef __attribute__((__ext_vector_type__(2),__aligned__(2))) unsigned short simd_packed_ushort2;
178
179/*! @abstract A vector of four 16-bit unsigned integers with relaxed
180 * alignment.
181 * @description In C++ and Metal, this type is also available as
182 * simd::packed::ushort4. The alignment of this type is that of the
183 * underlying scalar element type, so you can use it to load or store from
184 * an array of that type. */
185typedef __attribute__((__ext_vector_type__(4),__aligned__(2))) unsigned short simd_packed_ushort4;
186
187/*! @abstract A vector of eight 16-bit unsigned integers with relaxed
188 * alignment.
189 * @description In C++ this type is also available as
190 * simd::packed::ushort8. This type is not available in Metal. The
191 * alignment of this type is only that of the underlying scalar element
192 * type, so you can use it to load or store from an array of that type. */
193typedef __attribute__((__ext_vector_type__(8),__aligned__(2))) unsigned short simd_packed_ushort8;
194
195/*! @abstract A vector of sixteen 16-bit unsigned integers with relaxed
196 * alignment.
197 * @description In C++ this type is also available as
198 * simd::packed::ushort16. This type is not available in Metal. The
199 * alignment of this type is only that of the underlying scalar element
200 * type, so you can use it to load or store from an array of that type. */
201typedef __attribute__((__ext_vector_type__(16),__aligned__(2))) unsigned short simd_packed_ushort16;
202
203/*! @abstract A vector of thirty-two 16-bit unsigned integers with relaxed
204 * alignment.
205 * @description In C++ this type is also available as
206 * simd::packed::ushort32. This type is not available in Metal. The
207 * alignment of this type is only that of the underlying scalar element
208 * type, so you can use it to load or store from an array of that type. */
209typedef __attribute__((__ext_vector_type__(32),__aligned__(2))) unsigned short simd_packed_ushort32;
210
211/*! @abstract A vector of two 16-bit floating-point numbers with relaxed
212 * alignment.
213 * @description In C++ and Metal, this type is also available as
214 * simd::packed::half2. The alignment of this type is that of the
215 * underlying scalar element type, so you can use it to load or store from
216 * an array of that type. */
217typedef __attribute__((__ext_vector_type__(2),__aligned__(2))) _Float16 simd_packed_half2;
218
219/*! @abstract A vector of four 16-bit floating-point numbers with relaxed
220 * alignment.
221 * @description In C++ and Metal, this type is also available as
222 * simd::packed::half4. The alignment of this type is that of the
223 * underlying scalar element type, so you can use it to load or store from
224 * an array of that type. */
225typedef __attribute__((__ext_vector_type__(4),__aligned__(2))) _Float16 simd_packed_half4;
226
227/*! @abstract A vector of eight 16-bit floating-point numbers with relaxed
228 * alignment.
229 * @description In C++ this type is also available as simd::packed::half8.
230 * This type is not available in Metal. The alignment of this type is only
231 * that of the underlying scalar element type, so you can use it to load or
232 * store from an array of that type. */
233typedef __attribute__((__ext_vector_type__(8),__aligned__(2))) _Float16 simd_packed_half8;
234
235/*! @abstract A vector of sixteen 16-bit floating-point numbers with relaxed
236 * alignment.
237 * @description In C++ this type is also available as simd::packed::half16.
238 * This type is not available in Metal. The alignment of this type is only
239 * that of the underlying scalar element type, so you can use it to load or
240 * store from an array of that type. */
241typedef __attribute__((__ext_vector_type__(16),__aligned__(2))) _Float16 simd_packed_half16;
242
243/*! @abstract A vector of thirty-two 16-bit floating-point numbers with
244 * relaxed alignment.
245 * @description In C++ this type is also available as simd::packed::half32.
246 * This type is not available in Metal. The alignment of this type is only
247 * that of the underlying scalar element type, so you can use it to load or
248 * store from an array of that type. */
249typedef __attribute__((__ext_vector_type__(32),__aligned__(2))) _Float16 simd_packed_half32;
250
251/*! @abstract A vector of two 32-bit signed (twos-complement) integers with
252 * relaxed alignment.
253 * @description In C++ and Metal, this type is also available as
254 * simd::packed::int2. The alignment of this type is that of the underlying
255 * scalar element type, so you can use it to load or store from an array of
256 * that type. */
257typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) int simd_packed_int2;
258
259/*! @abstract A vector of four 32-bit signed (twos-complement) integers with
260 * relaxed alignment.
261 * @description In C++ and Metal, this type is also available as
262 * simd::packed::int4. The alignment of this type is that of the underlying
263 * scalar element type, so you can use it to load or store from an array of
264 * that type. */
265typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) int simd_packed_int4;
266
267/*! @abstract A vector of eight 32-bit signed (twos-complement) integers
268 * with relaxed alignment.
269 * @description In C++ this type is also available as simd::packed::int8.
270 * This type is not available in Metal. The alignment of this type is only
271 * that of the underlying scalar element type, so you can use it to load or
272 * store from an array of that type. */
273typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) int simd_packed_int8;
274
275/*! @abstract A vector of sixteen 32-bit signed (twos-complement) integers
276 * with relaxed alignment.
277 * @description In C++ this type is also available as simd::packed::int16.
278 * This type is not available in Metal. The alignment of this type is only
279 * that of the underlying scalar element type, so you can use it to load or
280 * store from an array of that type. */
281typedef __attribute__((__ext_vector_type__(16),__aligned__(4))) int simd_packed_int16;
282
283/*! @abstract A vector of two 32-bit unsigned integers with relaxed
284 * alignment.
285 * @description In C++ and Metal, this type is also available as
286 * simd::packed::uint2. The alignment of this type is that of the
287 * underlying scalar element type, so you can use it to load or store from
288 * an array of that type. */
289typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) unsigned int simd_packed_uint2;
290
291/*! @abstract A vector of four 32-bit unsigned integers with relaxed
292 * alignment.
293 * @description In C++ and Metal, this type is also available as
294 * simd::packed::uint4. The alignment of this type is that of the
295 * underlying scalar element type, so you can use it to load or store from
296 * an array of that type. */
297typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) unsigned int simd_packed_uint4;
298
299/*! @abstract A vector of eight 32-bit unsigned integers with relaxed
300 * alignment.
301 * @description In C++ this type is also available as simd::packed::uint8.
302 * This type is not available in Metal. The alignment of this type is only
303 * that of the underlying scalar element type, so you can use it to load or
304 * store from an array of that type. */
305typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) unsigned int simd_packed_uint8;
306
307/*! @abstract A vector of sixteen 32-bit unsigned integers with relaxed
308 * alignment.
309 * @description In C++ this type is also available as simd::packed::uint16.
310 * This type is not available in Metal. The alignment of this type is only
311 * that of the underlying scalar element type, so you can use it to load or
312 * store from an array of that type. */
313typedef __attribute__((__ext_vector_type__(16),__aligned__(4))) unsigned int simd_packed_uint16;
314
315/*! @abstract A vector of two 32-bit floating-point numbers with relaxed
316 * alignment.
317 * @description In C++ and Metal, this type is also available as
318 * simd::packed::float2. The alignment of this type is that of the
319 * underlying scalar element type, so you can use it to load or store from
320 * an array of that type. */
321typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) float simd_packed_float2;
322
323/*! @abstract A vector of four 32-bit floating-point numbers with relaxed
324 * alignment.
325 * @description In C++ and Metal, this type is also available as
326 * simd::packed::float4. The alignment of this type is that of the
327 * underlying scalar element type, so you can use it to load or store from
328 * an array of that type. */
329typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) float simd_packed_float4;
330
331/*! @abstract A vector of eight 32-bit floating-point numbers with relaxed
332 * alignment.
333 * @description In C++ this type is also available as simd::packed::float8.
334 * This type is not available in Metal. The alignment of this type is only
335 * that of the underlying scalar element type, so you can use it to load or
336 * store from an array of that type. */
337typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) float simd_packed_float8;
338
339/*! @abstract A vector of sixteen 32-bit floating-point numbers with relaxed
340 * alignment.
341 * @description In C++ this type is also available as
342 * simd::packed::float16. This type is not available in Metal. The
343 * alignment of this type is only that of the underlying scalar element
344 * type, so you can use it to load or store from an array of that type. */
345typedef __attribute__((__ext_vector_type__(16),__aligned__(4))) float simd_packed_float16;
346
347/*! @abstract A vector of two 64-bit signed (twos-complement) integers with
348 * relaxed alignment.
349 * @description In C++ and Metal, this type is also available as
350 * simd::packed::long2. The alignment of this type is that of the
351 * underlying scalar element type, so you can use it to load or store from
352 * an array of that type. */
353#if defined __LP64__
354typedef __attribute__((__ext_vector_type__(2),__aligned__(8))) simd_long1 simd_packed_long2;
355#else
356typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) simd_long1 simd_packed_long2;
357#endif
358
359/*! @abstract A vector of four 64-bit signed (twos-complement) integers with
360 * relaxed alignment.
361 * @description In C++ and Metal, this type is also available as
362 * simd::packed::long4. The alignment of this type is that of the
363 * underlying scalar element type, so you can use it to load or store from
364 * an array of that type. */
365#if defined __LP64__
366typedef __attribute__((__ext_vector_type__(4),__aligned__(8))) simd_long1 simd_packed_long4;
367#else
368typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) simd_long1 simd_packed_long4;
369#endif
370
371/*! @abstract A vector of eight 64-bit signed (twos-complement) integers
372 * with relaxed alignment.
373 * @description In C++ this type is also available as simd::packed::long8.
374 * This type is not available in Metal. The alignment of this type is only
375 * that of the underlying scalar element type, so you can use it to load or
376 * store from an array of that type. */
377#if defined __LP64__
378typedef __attribute__((__ext_vector_type__(8),__aligned__(8))) simd_long1 simd_packed_long8;
379#else
380typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) simd_long1 simd_packed_long8;
381#endif
382
383/*! @abstract A vector of two 64-bit unsigned integers with relaxed
384 * alignment.
385 * @description In C++ and Metal, this type is also available as
386 * simd::packed::ulong2. The alignment of this type is that of the
387 * underlying scalar element type, so you can use it to load or store from
388 * an array of that type. */
389#if defined __LP64__
390typedef __attribute__((__ext_vector_type__(2),__aligned__(8))) simd_ulong1 simd_packed_ulong2;
391#else
392typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) simd_ulong1 simd_packed_ulong2;
393#endif
394
395/*! @abstract A vector of four 64-bit unsigned integers with relaxed
396 * alignment.
397 * @description In C++ and Metal, this type is also available as
398 * simd::packed::ulong4. The alignment of this type is that of the
399 * underlying scalar element type, so you can use it to load or store from
400 * an array of that type. */
401#if defined __LP64__
402typedef __attribute__((__ext_vector_type__(4),__aligned__(8))) simd_ulong1 simd_packed_ulong4;
403#else
404typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) simd_ulong1 simd_packed_ulong4;
405#endif
406
407/*! @abstract A vector of eight 64-bit unsigned integers with relaxed
408 * alignment.
409 * @description In C++ this type is also available as simd::packed::ulong8.
410 * This type is not available in Metal. The alignment of this type is only
411 * that of the underlying scalar element type, so you can use it to load or
412 * store from an array of that type. */
413#if defined __LP64__
414typedef __attribute__((__ext_vector_type__(8),__aligned__(8))) simd_ulong1 simd_packed_ulong8;
415#else
416typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) simd_ulong1 simd_packed_ulong8;
417#endif
418
419/*! @abstract A vector of two 64-bit floating-point numbers with relaxed
420 * alignment.
421 * @description In C++ and Metal, this type is also available as
422 * simd::packed::double2. The alignment of this type is that of the
423 * underlying scalar element type, so you can use it to load or store from
424 * an array of that type. */
425#if defined __LP64__
426typedef __attribute__((__ext_vector_type__(2),__aligned__(8))) double simd_packed_double2;
427#else
428typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) double simd_packed_double2;
429#endif
430
431/*! @abstract A vector of four 64-bit floating-point numbers with relaxed
432 * alignment.
433 * @description In C++ and Metal, this type is also available as
434 * simd::packed::double4. The alignment of this type is that of the
435 * underlying scalar element type, so you can use it to load or store from
436 * an array of that type. */
437#if defined __LP64__
438typedef __attribute__((__ext_vector_type__(4),__aligned__(8))) double simd_packed_double4;
439#else
440typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) double simd_packed_double4;
441#endif
442
443/*! @abstract A vector of eight 64-bit floating-point numbers with relaxed
444 * alignment.
445 * @description In C++ this type is also available as
446 * simd::packed::double8. This type is not available in Metal. The
447 * alignment of this type is only that of the underlying scalar element
448 * type, so you can use it to load or store from an array of that type. */
449#if defined __LP64__
450typedef __attribute__((__ext_vector_type__(8),__aligned__(8))) double simd_packed_double8;
451#else
452typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) double simd_packed_double8;
453#endif
454
455/* MARK: C++ vector types */
456#if defined __cplusplus
457namespace simd {
458 namespace packed {
459 /*! @abstract A vector of two 8-bit signed (twos-complement) integers
460 * with relaxed alignment.
461 * @description In C or Objective-C, this type is available as
462 * simd_packed_char2. The alignment of this type is only that of the
463 * underlying scalar element type, so you can use it to load or store
464 * from an array of that type. */
465typedef ::simd_packed_char2 char2;
466
467 /*! @abstract A vector of four 8-bit signed (twos-complement) integers
468 * with relaxed alignment.
469 * @description In C or Objective-C, this type is available as
470 * simd_packed_char4. The alignment of this type is only that of the
471 * underlying scalar element type, so you can use it to load or store
472 * from an array of that type. */
473typedef ::simd_packed_char4 char4;
474
475 /*! @abstract A vector of eight 8-bit signed (twos-complement) integers
476 * with relaxed alignment.
477 * @description This type is not available in Metal. In C or
478 * Objective-C, this type is available as simd_packed_char8. The
479 * alignment of this type is only that of the underlying scalar element
480 * type, so you can use it to load or store from an array of that type. */
481typedef ::simd_packed_char8 char8;
482
483 /*! @abstract A vector of sixteen 8-bit signed (twos-complement)
484 * integers with relaxed alignment.
485 * @description This type is not available in Metal. In C or
486 * Objective-C, this type is available as simd_packed_char16. The
487 * alignment of this type is only that of the underlying scalar element
488 * type, so you can use it to load or store from an array of that type. */
489typedef ::simd_packed_char16 char16;
490
491 /*! @abstract A vector of thirty-two 8-bit signed (twos-complement)
492 * integers with relaxed alignment.
493 * @description This type is not available in Metal. In C or
494 * Objective-C, this type is available as simd_packed_char32. The
495 * alignment of this type is only that of the underlying scalar element
496 * type, so you can use it to load or store from an array of that type. */
497typedef ::simd_packed_char32 char32;
498
499 /*! @abstract A vector of sixty-four 8-bit signed (twos-complement)
500 * integers with relaxed alignment.
501 * @description This type is not available in Metal. In C or
502 * Objective-C, this type is available as simd_packed_char64. The
503 * alignment of this type is only that of the underlying scalar element
504 * type, so you can use it to load or store from an array of that type. */
505typedef ::simd_packed_char64 char64;
506
507 /*! @abstract A vector of two 8-bit unsigned integers with relaxed
508 * alignment.
509 * @description In C or Objective-C, this type is available as
510 * simd_packed_uchar2. The alignment of this type is only that of the
511 * underlying scalar element type, so you can use it to load or store
512 * from an array of that type. */
513typedef ::simd_packed_uchar2 uchar2;
514
515 /*! @abstract A vector of four 8-bit unsigned integers with relaxed
516 * alignment.
517 * @description In C or Objective-C, this type is available as
518 * simd_packed_uchar4. The alignment of this type is only that of the
519 * underlying scalar element type, so you can use it to load or store
520 * from an array of that type. */
521typedef ::simd_packed_uchar4 uchar4;
522
523 /*! @abstract A vector of eight 8-bit unsigned integers with relaxed
524 * alignment.
525 * @description This type is not available in Metal. In C or
526 * Objective-C, this type is available as simd_packed_uchar8. The
527 * alignment of this type is only that of the underlying scalar element
528 * type, so you can use it to load or store from an array of that type. */
529typedef ::simd_packed_uchar8 uchar8;
530
531 /*! @abstract A vector of sixteen 8-bit unsigned integers with relaxed
532 * alignment.
533 * @description This type is not available in Metal. In C or
534 * Objective-C, this type is available as simd_packed_uchar16. The
535 * alignment of this type is only that of the underlying scalar element
536 * type, so you can use it to load or store from an array of that type. */
537typedef ::simd_packed_uchar16 uchar16;
538
539 /*! @abstract A vector of thirty-two 8-bit unsigned integers with
540 * relaxed alignment.
541 * @description This type is not available in Metal. In C or
542 * Objective-C, this type is available as simd_packed_uchar32. The
543 * alignment of this type is only that of the underlying scalar element
544 * type, so you can use it to load or store from an array of that type. */
545typedef ::simd_packed_uchar32 uchar32;
546
547 /*! @abstract A vector of sixty-four 8-bit unsigned integers with
548 * relaxed alignment.
549 * @description This type is not available in Metal. In C or
550 * Objective-C, this type is available as simd_packed_uchar64. The
551 * alignment of this type is only that of the underlying scalar element
552 * type, so you can use it to load or store from an array of that type. */
553typedef ::simd_packed_uchar64 uchar64;
554
555 /*! @abstract A vector of two 16-bit signed (twos-complement) integers
556 * with relaxed alignment.
557 * @description In C or Objective-C, this type is available as
558 * simd_packed_short2. The alignment of this type is only that of the
559 * underlying scalar element type, so you can use it to load or store
560 * from an array of that type. */
561typedef ::simd_packed_short2 short2;
562
563 /*! @abstract A vector of four 16-bit signed (twos-complement) integers
564 * with relaxed alignment.
565 * @description In C or Objective-C, this type is available as
566 * simd_packed_short4. The alignment of this type is only that of the
567 * underlying scalar element type, so you can use it to load or store
568 * from an array of that type. */
569typedef ::simd_packed_short4 short4;
570
571 /*! @abstract A vector of eight 16-bit signed (twos-complement) integers
572 * with relaxed alignment.
573 * @description This type is not available in Metal. In C or
574 * Objective-C, this type is available as simd_packed_short8. The
575 * alignment of this type is only that of the underlying scalar element
576 * type, so you can use it to load or store from an array of that type. */
577typedef ::simd_packed_short8 short8;
578
579 /*! @abstract A vector of sixteen 16-bit signed (twos-complement)
580 * integers with relaxed alignment.
581 * @description This type is not available in Metal. In C or
582 * Objective-C, this type is available as simd_packed_short16. The
583 * alignment of this type is only that of the underlying scalar element
584 * type, so you can use it to load or store from an array of that type. */
585typedef ::simd_packed_short16 short16;
586
587 /*! @abstract A vector of thirty-two 16-bit signed (twos-complement)
588 * integers with relaxed alignment.
589 * @description This type is not available in Metal. In C or
590 * Objective-C, this type is available as simd_packed_short32. The
591 * alignment of this type is only that of the underlying scalar element
592 * type, so you can use it to load or store from an array of that type. */
593typedef ::simd_packed_short32 short32;
594
595 /*! @abstract A vector of two 16-bit unsigned integers with relaxed
596 * alignment.
597 * @description In C or Objective-C, this type is available as
598 * simd_packed_ushort2. The alignment of this type is only that of the
599 * underlying scalar element type, so you can use it to load or store
600 * from an array of that type. */
601typedef ::simd_packed_ushort2 ushort2;
602
603 /*! @abstract A vector of four 16-bit unsigned integers with relaxed
604 * alignment.
605 * @description In C or Objective-C, this type is available as
606 * simd_packed_ushort4. The alignment of this type is only that of the
607 * underlying scalar element type, so you can use it to load or store
608 * from an array of that type. */
609typedef ::simd_packed_ushort4 ushort4;
610
611 /*! @abstract A vector of eight 16-bit unsigned integers with relaxed
612 * alignment.
613 * @description This type is not available in Metal. In C or
614 * Objective-C, this type is available as simd_packed_ushort8. The
615 * alignment of this type is only that of the underlying scalar element
616 * type, so you can use it to load or store from an array of that type. */
617typedef ::simd_packed_ushort8 ushort8;
618
619 /*! @abstract A vector of sixteen 16-bit unsigned integers with relaxed
620 * alignment.
621 * @description This type is not available in Metal. In C or
622 * Objective-C, this type is available as simd_packed_ushort16. The
623 * alignment of this type is only that of the underlying scalar element
624 * type, so you can use it to load or store from an array of that type. */
625typedef ::simd_packed_ushort16 ushort16;
626
627 /*! @abstract A vector of thirty-two 16-bit unsigned integers with
628 * relaxed alignment.
629 * @description This type is not available in Metal. In C or
630 * Objective-C, this type is available as simd_packed_ushort32. The
631 * alignment of this type is only that of the underlying scalar element
632 * type, so you can use it to load or store from an array of that type. */
633typedef ::simd_packed_ushort32 ushort32;
634
635 /*! @abstract A vector of two 16-bit floating-point numbers with relaxed
636 * alignment.
637 * @description In C or Objective-C, this type is available as
638 * simd_packed_half2. The alignment of this type is only that of the
639 * underlying scalar element type, so you can use it to load or store
640 * from an array of that type. */
641typedef ::simd_packed_half2 half2;
642
643 /*! @abstract A vector of four 16-bit floating-point numbers with
644 * relaxed alignment.
645 * @description In C or Objective-C, this type is available as
646 * simd_packed_half4. The alignment of this type is only that of the
647 * underlying scalar element type, so you can use it to load or store
648 * from an array of that type. */
649typedef ::simd_packed_half4 half4;
650
651 /*! @abstract A vector of eight 16-bit floating-point numbers with
652 * relaxed alignment.
653 * @description This type is not available in Metal. In C or
654 * Objective-C, this type is available as simd_packed_half8. The
655 * alignment of this type is only that of the underlying scalar element
656 * type, so you can use it to load or store from an array of that type. */
657typedef ::simd_packed_half8 half8;
658
659 /*! @abstract A vector of sixteen 16-bit floating-point numbers with
660 * relaxed alignment.
661 * @description This type is not available in Metal. In C or
662 * Objective-C, this type is available as simd_packed_half16. The
663 * alignment of this type is only that of the underlying scalar element
664 * type, so you can use it to load or store from an array of that type. */
665typedef ::simd_packed_half16 half16;
666
667 /*! @abstract A vector of thirty-two 16-bit floating-point numbers with
668 * relaxed alignment.
669 * @description This type is not available in Metal. In C or
670 * Objective-C, this type is available as simd_packed_half32. The
671 * alignment of this type is only that of the underlying scalar element
672 * type, so you can use it to load or store from an array of that type. */
673typedef ::simd_packed_half32 half32;
674
675 /*! @abstract A vector of two 32-bit signed (twos-complement) integers
676 * with relaxed alignment.
677 * @description In C or Objective-C, this type is available as
678 * simd_packed_int2. The alignment of this type is only that of the
679 * underlying scalar element type, so you can use it to load or store
680 * from an array of that type. */
681typedef ::simd_packed_int2 int2;
682
683 /*! @abstract A vector of four 32-bit signed (twos-complement) integers
684 * with relaxed alignment.
685 * @description In C or Objective-C, this type is available as
686 * simd_packed_int4. The alignment of this type is only that of the
687 * underlying scalar element type, so you can use it to load or store
688 * from an array of that type. */
689typedef ::simd_packed_int4 int4;
690
691 /*! @abstract A vector of eight 32-bit signed (twos-complement) integers
692 * with relaxed alignment.
693 * @description This type is not available in Metal. In C or
694 * Objective-C, this type is available as simd_packed_int8. The
695 * alignment of this type is only that of the underlying scalar element
696 * type, so you can use it to load or store from an array of that type. */
697typedef ::simd_packed_int8 int8;
698
699 /*! @abstract A vector of sixteen 32-bit signed (twos-complement)
700 * integers with relaxed alignment.
701 * @description This type is not available in Metal. In C or
702 * Objective-C, this type is available as simd_packed_int16. The
703 * alignment of this type is only that of the underlying scalar element
704 * type, so you can use it to load or store from an array of that type. */
705typedef ::simd_packed_int16 int16;
706
707 /*! @abstract A vector of two 32-bit unsigned integers with relaxed
708 * alignment.
709 * @description In C or Objective-C, this type is available as
710 * simd_packed_uint2. The alignment of this type is only that of the
711 * underlying scalar element type, so you can use it to load or store
712 * from an array of that type. */
713typedef ::simd_packed_uint2 uint2;
714
715 /*! @abstract A vector of four 32-bit unsigned integers with relaxed
716 * alignment.
717 * @description In C or Objective-C, this type is available as
718 * simd_packed_uint4. The alignment of this type is only that of the
719 * underlying scalar element type, so you can use it to load or store
720 * from an array of that type. */
721typedef ::simd_packed_uint4 uint4;
722
723 /*! @abstract A vector of eight 32-bit unsigned integers with relaxed
724 * alignment.
725 * @description This type is not available in Metal. In C or
726 * Objective-C, this type is available as simd_packed_uint8. The
727 * alignment of this type is only that of the underlying scalar element
728 * type, so you can use it to load or store from an array of that type. */
729typedef ::simd_packed_uint8 uint8;
730
731 /*! @abstract A vector of sixteen 32-bit unsigned integers with relaxed
732 * alignment.
733 * @description This type is not available in Metal. In C or
734 * Objective-C, this type is available as simd_packed_uint16. The
735 * alignment of this type is only that of the underlying scalar element
736 * type, so you can use it to load or store from an array of that type. */
737typedef ::simd_packed_uint16 uint16;
738
739 /*! @abstract A vector of two 32-bit floating-point numbers with relaxed
740 * alignment.
741 * @description In C or Objective-C, this type is available as
742 * simd_packed_float2. The alignment of this type is only that of the
743 * underlying scalar element type, so you can use it to load or store
744 * from an array of that type. */
745typedef ::simd_packed_float2 float2;
746
747 /*! @abstract A vector of four 32-bit floating-point numbers with
748 * relaxed alignment.
749 * @description In C or Objective-C, this type is available as
750 * simd_packed_float4. The alignment of this type is only that of the
751 * underlying scalar element type, so you can use it to load or store
752 * from an array of that type. */
753typedef ::simd_packed_float4 float4;
754
755 /*! @abstract A vector of eight 32-bit floating-point numbers with
756 * relaxed alignment.
757 * @description This type is not available in Metal. In C or
758 * Objective-C, this type is available as simd_packed_float8. The
759 * alignment of this type is only that of the underlying scalar element
760 * type, so you can use it to load or store from an array of that type. */
761typedef ::simd_packed_float8 float8;
762
763 /*! @abstract A vector of sixteen 32-bit floating-point numbers with
764 * relaxed alignment.
765 * @description This type is not available in Metal. In C or
766 * Objective-C, this type is available as simd_packed_float16. The
767 * alignment of this type is only that of the underlying scalar element
768 * type, so you can use it to load or store from an array of that type. */
769typedef ::simd_packed_float16 float16;
770
771 /*! @abstract A vector of two 64-bit signed (twos-complement) integers
772 * with relaxed alignment.
773 * @description In C or Objective-C, this type is available as
774 * simd_packed_long2. The alignment of this type is only that of the
775 * underlying scalar element type, so you can use it to load or store
776 * from an array of that type. */
777typedef ::simd_packed_long2 long2;
778
779 /*! @abstract A vector of four 64-bit signed (twos-complement) integers
780 * with relaxed alignment.
781 * @description In C or Objective-C, this type is available as
782 * simd_packed_long4. The alignment of this type is only that of the
783 * underlying scalar element type, so you can use it to load or store
784 * from an array of that type. */
785typedef ::simd_packed_long4 long4;
786
787 /*! @abstract A vector of eight 64-bit signed (twos-complement) integers
788 * with relaxed alignment.
789 * @description This type is not available in Metal. In C or
790 * Objective-C, this type is available as simd_packed_long8. The
791 * alignment of this type is only that of the underlying scalar element
792 * type, so you can use it to load or store from an array of that type. */
793typedef ::simd_packed_long8 long8;
794
795 /*! @abstract A vector of two 64-bit unsigned integers with relaxed
796 * alignment.
797 * @description In C or Objective-C, this type is available as
798 * simd_packed_ulong2. The alignment of this type is only that of the
799 * underlying scalar element type, so you can use it to load or store
800 * from an array of that type. */
801typedef ::simd_packed_ulong2 ulong2;
802
803 /*! @abstract A vector of four 64-bit unsigned integers with relaxed
804 * alignment.
805 * @description In C or Objective-C, this type is available as
806 * simd_packed_ulong4. The alignment of this type is only that of the
807 * underlying scalar element type, so you can use it to load or store
808 * from an array of that type. */
809typedef ::simd_packed_ulong4 ulong4;
810
811 /*! @abstract A vector of eight 64-bit unsigned integers with relaxed
812 * alignment.
813 * @description This type is not available in Metal. In C or
814 * Objective-C, this type is available as simd_packed_ulong8. The
815 * alignment of this type is only that of the underlying scalar element
816 * type, so you can use it to load or store from an array of that type. */
817typedef ::simd_packed_ulong8 ulong8;
818
819 /*! @abstract A vector of two 64-bit floating-point numbers with relaxed
820 * alignment.
821 * @description In C or Objective-C, this type is available as
822 * simd_packed_double2. The alignment of this type is only that of the
823 * underlying scalar element type, so you can use it to load or store
824 * from an array of that type. */
825typedef ::simd_packed_double2 double2;
826
827 /*! @abstract A vector of four 64-bit floating-point numbers with
828 * relaxed alignment.
829 * @description In C or Objective-C, this type is available as
830 * simd_packed_double4. The alignment of this type is only that of the
831 * underlying scalar element type, so you can use it to load or store
832 * from an array of that type. */
833typedef ::simd_packed_double4 double4;
834
835 /*! @abstract A vector of eight 64-bit floating-point numbers with
836 * relaxed alignment.
837 * @description This type is not available in Metal. In C or
838 * Objective-C, this type is available as simd_packed_double8. The
839 * alignment of this type is only that of the underlying scalar element
840 * type, so you can use it to load or store from an array of that type. */
841typedef ::simd_packed_double8 double8;
842
843 } /* namespace simd::packed:: */
844} /* namespace simd:: */
845#endif /* __cplusplus */
846
847/* MARK: Deprecated vector types */
848/*! @group Deprecated vector types
849 * @discussion These are the original types used by earlier versions of the
850 * simd library; they are provided here for compatability with existing source
851 * files. Use the new ("simd_"-prefixed) types for future development. */
852/*! @abstract A vector of two 8-bit signed (twos-complement) integers with
853 * relaxed alignment.
854 * @description This type is deprecated; you should use simd_packed_char2
855 * or simd::packed::char2 instead. */
856typedef simd_packed_char2 packed_char2;
857
858/*! @abstract A vector of four 8-bit signed (twos-complement) integers with
859 * relaxed alignment.
860 * @description This type is deprecated; you should use simd_packed_char4
861 * or simd::packed::char4 instead. */
862typedef simd_packed_char4 packed_char4;
863
864/*! @abstract A vector of eight 8-bit signed (twos-complement) integers with
865 * relaxed alignment.
866 * @description This type is deprecated; you should use simd_packed_char8
867 * or simd::packed::char8 instead. */
868typedef simd_packed_char8 packed_char8;
869
870/*! @abstract A vector of sixteen 8-bit signed (twos-complement) integers
871 * with relaxed alignment.
872 * @description This type is deprecated; you should use simd_packed_char16
873 * or simd::packed::char16 instead. */
874typedef simd_packed_char16 packed_char16;
875
876/*! @abstract A vector of thirty-two 8-bit signed (twos-complement) integers
877 * with relaxed alignment.
878 * @description This type is deprecated; you should use simd_packed_char32
879 * or simd::packed::char32 instead. */
880typedef simd_packed_char32 packed_char32;
881
882/*! @abstract A vector of sixty-four 8-bit signed (twos-complement) integers
883 * with relaxed alignment.
884 * @description This type is deprecated; you should use simd_packed_char64
885 * or simd::packed::char64 instead. */
886typedef simd_packed_char64 packed_char64;
887
888/*! @abstract A vector of two 8-bit unsigned integers with relaxed
889 * alignment.
890 * @description This type is deprecated; you should use simd_packed_uchar2
891 * or simd::packed::uchar2 instead. */
892typedef simd_packed_uchar2 packed_uchar2;
893
894/*! @abstract A vector of four 8-bit unsigned integers with relaxed
895 * alignment.
896 * @description This type is deprecated; you should use simd_packed_uchar4
897 * or simd::packed::uchar4 instead. */
898typedef simd_packed_uchar4 packed_uchar4;
899
900/*! @abstract A vector of eight 8-bit unsigned integers with relaxed
901 * alignment.
902 * @description This type is deprecated; you should use simd_packed_uchar8
903 * or simd::packed::uchar8 instead. */
904typedef simd_packed_uchar8 packed_uchar8;
905
906/*! @abstract A vector of sixteen 8-bit unsigned integers with relaxed
907 * alignment.
908 * @description This type is deprecated; you should use simd_packed_uchar16
909 * or simd::packed::uchar16 instead. */
910typedef simd_packed_uchar16 packed_uchar16;
911
912/*! @abstract A vector of thirty-two 8-bit unsigned integers with relaxed
913 * alignment.
914 * @description This type is deprecated; you should use simd_packed_uchar32
915 * or simd::packed::uchar32 instead. */
916typedef simd_packed_uchar32 packed_uchar32;
917
918/*! @abstract A vector of sixty-four 8-bit unsigned integers with relaxed
919 * alignment.
920 * @description This type is deprecated; you should use simd_packed_uchar64
921 * or simd::packed::uchar64 instead. */
922typedef simd_packed_uchar64 packed_uchar64;
923
924/*! @abstract A vector of two 16-bit signed (twos-complement) integers with
925 * relaxed alignment.
926 * @description This type is deprecated; you should use simd_packed_short2
927 * or simd::packed::short2 instead. */
928typedef simd_packed_short2 packed_short2;
929
930/*! @abstract A vector of four 16-bit signed (twos-complement) integers with
931 * relaxed alignment.
932 * @description This type is deprecated; you should use simd_packed_short4
933 * or simd::packed::short4 instead. */
934typedef simd_packed_short4 packed_short4;
935
936/*! @abstract A vector of eight 16-bit signed (twos-complement) integers
937 * with relaxed alignment.
938 * @description This type is deprecated; you should use simd_packed_short8
939 * or simd::packed::short8 instead. */
940typedef simd_packed_short8 packed_short8;
941
942/*! @abstract A vector of sixteen 16-bit signed (twos-complement) integers
943 * with relaxed alignment.
944 * @description This type is deprecated; you should use simd_packed_short16
945 * or simd::packed::short16 instead. */
946typedef simd_packed_short16 packed_short16;
947
948/*! @abstract A vector of thirty-two 16-bit signed (twos-complement)
949 * integers with relaxed alignment.
950 * @description This type is deprecated; you should use simd_packed_short32
951 * or simd::packed::short32 instead. */
952typedef simd_packed_short32 packed_short32;
953
954/*! @abstract A vector of two 16-bit unsigned integers with relaxed
955 * alignment.
956 * @description This type is deprecated; you should use simd_packed_ushort2
957 * or simd::packed::ushort2 instead. */
958typedef simd_packed_ushort2 packed_ushort2;
959
960/*! @abstract A vector of four 16-bit unsigned integers with relaxed
961 * alignment.
962 * @description This type is deprecated; you should use simd_packed_ushort4
963 * or simd::packed::ushort4 instead. */
964typedef simd_packed_ushort4 packed_ushort4;
965
966/*! @abstract A vector of eight 16-bit unsigned integers with relaxed
967 * alignment.
968 * @description This type is deprecated; you should use simd_packed_ushort8
969 * or simd::packed::ushort8 instead. */
970typedef simd_packed_ushort8 packed_ushort8;
971
972/*! @abstract A vector of sixteen 16-bit unsigned integers with relaxed
973 * alignment.
974 * @description This type is deprecated; you should use
975 * simd_packed_ushort16 or simd::packed::ushort16 instead. */
976typedef simd_packed_ushort16 packed_ushort16;
977
978/*! @abstract A vector of thirty-two 16-bit unsigned integers with relaxed
979 * alignment.
980 * @description This type is deprecated; you should use
981 * simd_packed_ushort32 or simd::packed::ushort32 instead. */
982typedef simd_packed_ushort32 packed_ushort32;
983
984/*! @abstract A vector of two 32-bit signed (twos-complement) integers with
985 * relaxed alignment.
986 * @description This type is deprecated; you should use simd_packed_int2 or
987 * simd::packed::int2 instead. */
988typedef simd_packed_int2 packed_int2;
989
990/*! @abstract A vector of four 32-bit signed (twos-complement) integers with
991 * relaxed alignment.
992 * @description This type is deprecated; you should use simd_packed_int4 or
993 * simd::packed::int4 instead. */
994typedef simd_packed_int4 packed_int4;
995
996/*! @abstract A vector of eight 32-bit signed (twos-complement) integers
997 * with relaxed alignment.
998 * @description This type is deprecated; you should use simd_packed_int8 or
999 * simd::packed::int8 instead. */
1000typedef simd_packed_int8 packed_int8;
1001
1002/*! @abstract A vector of sixteen 32-bit signed (twos-complement) integers
1003 * with relaxed alignment.
1004 * @description This type is deprecated; you should use simd_packed_int16
1005 * or simd::packed::int16 instead. */
1006typedef simd_packed_int16 packed_int16;
1007
1008/*! @abstract A vector of two 32-bit unsigned integers with relaxed
1009 * alignment.
1010 * @description This type is deprecated; you should use simd_packed_uint2
1011 * or simd::packed::uint2 instead. */
1012typedef simd_packed_uint2 packed_uint2;
1013
1014/*! @abstract A vector of four 32-bit unsigned integers with relaxed
1015 * alignment.
1016 * @description This type is deprecated; you should use simd_packed_uint4
1017 * or simd::packed::uint4 instead. */
1018typedef simd_packed_uint4 packed_uint4;
1019
1020/*! @abstract A vector of eight 32-bit unsigned integers with relaxed
1021 * alignment.
1022 * @description This type is deprecated; you should use simd_packed_uint8
1023 * or simd::packed::uint8 instead. */
1024typedef simd_packed_uint8 packed_uint8;
1025
1026/*! @abstract A vector of sixteen 32-bit unsigned integers with relaxed
1027 * alignment.
1028 * @description This type is deprecated; you should use simd_packed_uint16
1029 * or simd::packed::uint16 instead. */
1030typedef simd_packed_uint16 packed_uint16;
1031
1032/*! @abstract A vector of two 32-bit floating-point numbers with relaxed
1033 * alignment.
1034 * @description This type is deprecated; you should use simd_packed_float2
1035 * or simd::packed::float2 instead. */
1036typedef simd_packed_float2 packed_float2;
1037
1038/*! @abstract A vector of four 32-bit floating-point numbers with relaxed
1039 * alignment.
1040 * @description This type is deprecated; you should use simd_packed_float4
1041 * or simd::packed::float4 instead. */
1042typedef simd_packed_float4 packed_float4;
1043
1044/*! @abstract A vector of eight 32-bit floating-point numbers with relaxed
1045 * alignment.
1046 * @description This type is deprecated; you should use simd_packed_float8
1047 * or simd::packed::float8 instead. */
1048typedef simd_packed_float8 packed_float8;
1049
1050/*! @abstract A vector of sixteen 32-bit floating-point numbers with relaxed
1051 * alignment.
1052 * @description This type is deprecated; you should use simd_packed_float16
1053 * or simd::packed::float16 instead. */
1054typedef simd_packed_float16 packed_float16;
1055
1056/*! @abstract A vector of two 64-bit signed (twos-complement) integers with
1057 * relaxed alignment.
1058 * @description This type is deprecated; you should use simd_packed_long2
1059 * or simd::packed::long2 instead. */
1060typedef simd_packed_long2 packed_long2;
1061
1062/*! @abstract A vector of four 64-bit signed (twos-complement) integers with
1063 * relaxed alignment.
1064 * @description This type is deprecated; you should use simd_packed_long4
1065 * or simd::packed::long4 instead. */
1066typedef simd_packed_long4 packed_long4;
1067
1068/*! @abstract A vector of eight 64-bit signed (twos-complement) integers
1069 * with relaxed alignment.
1070 * @description This type is deprecated; you should use simd_packed_long8
1071 * or simd::packed::long8 instead. */
1072typedef simd_packed_long8 packed_long8;
1073
1074/*! @abstract A vector of two 64-bit unsigned integers with relaxed
1075 * alignment.
1076 * @description This type is deprecated; you should use simd_packed_ulong2
1077 * or simd::packed::ulong2 instead. */
1078typedef simd_packed_ulong2 packed_ulong2;
1079
1080/*! @abstract A vector of four 64-bit unsigned integers with relaxed
1081 * alignment.
1082 * @description This type is deprecated; you should use simd_packed_ulong4
1083 * or simd::packed::ulong4 instead. */
1084typedef simd_packed_ulong4 packed_ulong4;
1085
1086/*! @abstract A vector of eight 64-bit unsigned integers with relaxed
1087 * alignment.
1088 * @description This type is deprecated; you should use simd_packed_ulong8
1089 * or simd::packed::ulong8 instead. */
1090typedef simd_packed_ulong8 packed_ulong8;
1091
1092/*! @abstract A vector of two 64-bit floating-point numbers with relaxed
1093 * alignment.
1094 * @description This type is deprecated; you should use simd_packed_double2
1095 * or simd::packed::double2 instead. */
1096typedef simd_packed_double2 packed_double2;
1097
1098/*! @abstract A vector of four 64-bit floating-point numbers with relaxed
1099 * alignment.
1100 * @description This type is deprecated; you should use simd_packed_double4
1101 * or simd::packed::double4 instead. */
1102typedef simd_packed_double4 packed_double4;
1103
1104/*! @abstract A vector of eight 64-bit floating-point numbers with relaxed
1105 * alignment.
1106 * @description This type is deprecated; you should use simd_packed_double8
1107 * or simd::packed::double8 instead. */
1108typedef simd_packed_double8 packed_double8;
1109
1110# endif /* SIMD_COMPILER_HAS_REQUIRED_FEATURES */
1111#endif