mirror of
https://github.com/ziglang/zig.git
synced 2025-12-10 16:23:07 +00:00
5b813f1a2a
Prior to this change we would assume the ABI for Apple targets to be GNU which could result in subtle errors in LLVM emitting calls to non-existent system libc provided functions such as `_sincosf` which is a GNU extension and as such is not provided by macOS for example. This would result in linker errors where the linker would not be able to find the said symbol in `libSystem.tbd`. With this change, we now correctly identify macOS (and other Apple platforms) as having ABI `unknown` which translates to unspecified in LLVM under-the-hood: ``` // main.ll target triple = "aarch64-unknown-macos-unknown" ``` Note however that we never suffix the target OS with target version such as `macos11` or `macos12` which means we fail to instruct LLVM of potential optimisations provided by the OS such as the availability of function `___sincosf_stret`. I suggest we investigate that in a follow-up commit.
1031 lines
54 KiB
C++
Vendored
1031 lines
54 KiB
C++
Vendored
/*! @header
|
|
* This header defines fixed size vector types with relaxed alignment. For
|
|
* each vector type defined by <simd/vector_types.h> that is not a 1- or 3-
|
|
* element vector, there is a corresponding type defined by this header that
|
|
* requires only the alignment matching that of the underlying scalar type.
|
|
*
|
|
* These types should be used to access buffers that may not be sufficiently
|
|
* aligned to allow them to be accessed using the "normal" simd vector types.
|
|
* As an example of this usage, suppose that you want to load a vector of
|
|
* four floats from an array of floats. The type simd_float4 has sixteen byte
|
|
* alignment, whereas an array of floats has only four byte alignment.
|
|
* Thus, naively casting a pointer into the array to (simd_float4 *) would
|
|
* invoke undefined behavior, and likely produce an alignment fault at
|
|
* runtime. Instead, use the corresponding packed type to load from the array:
|
|
*
|
|
* <pre>
|
|
* @textblock
|
|
* simd_float4 vector = *(packed_simd_float4 *)&array[i];
|
|
* // do something with vector ...
|
|
* @/textblock
|
|
* </pre>
|
|
*
|
|
* It's important to note that the packed_ types are only needed to work with
|
|
* memory; once the data is loaded, we simply operate on it as usual using
|
|
* the simd_float4 type, as illustrated above.
|
|
*
|
|
* @copyright 2014-2017 Apple, Inc. All rights reserved.
|
|
* @unsorted */
|
|
|
|
#ifndef SIMD_PACKED_TYPES
|
|
#define SIMD_PACKED_TYPES
|
|
|
|
# include <simd/vector_types.h>
|
|
# if SIMD_COMPILER_HAS_REQUIRED_FEATURES
|
|
/*! @abstract A vector of two 8-bit signed (twos-complement) integers with
|
|
* relaxed alignment.
|
|
* @description In C++ and Metal, this type is also available as
|
|
* simd::packed_char2. The alignment of this type is that of the underlying
|
|
* scalar element type, so you can use it to load or store from an array of
|
|
* that type. */
|
|
typedef __attribute__((__ext_vector_type__(2),__aligned__(1))) char simd_packed_char2;
|
|
|
|
/*! @abstract A vector of four 8-bit signed (twos-complement) integers with
|
|
* relaxed alignment.
|
|
* @description In C++ and Metal, this type is also available as
|
|
* simd::packed_char4. The alignment of this type is that of the underlying
|
|
* scalar element type, so you can use it to load or store from an array of
|
|
* that type. */
|
|
typedef __attribute__((__ext_vector_type__(4),__aligned__(1))) char simd_packed_char4;
|
|
|
|
/*! @abstract A vector of eight 8-bit signed (twos-complement) integers with
|
|
* relaxed alignment.
|
|
* @description In C++ this type is also available as simd::packed_char8.
|
|
* This type is not available in Metal. The alignment of this type is only
|
|
* that of the underlying scalar element type, so you can use it to load or
|
|
* store from an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(8),__aligned__(1))) char simd_packed_char8;
|
|
|
|
/*! @abstract A vector of sixteen 8-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description In C++ this type is also available as simd::packed_char16.
|
|
* This type is not available in Metal. The alignment of this type is only
|
|
* that of the underlying scalar element type, so you can use it to load or
|
|
* store from an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(16),__aligned__(1))) char simd_packed_char16;
|
|
|
|
/*! @abstract A vector of thirty-two 8-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description In C++ this type is also available as simd::packed_char32.
|
|
* This type is not available in Metal. The alignment of this type is only
|
|
* that of the underlying scalar element type, so you can use it to load or
|
|
* store from an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(32),__aligned__(1))) char simd_packed_char32;
|
|
|
|
/*! @abstract A vector of sixty-four 8-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description In C++ this type is also available as simd::packed_char64.
|
|
* This type is not available in Metal. The alignment of this type is only
|
|
* that of the underlying scalar element type, so you can use it to load or
|
|
* store from an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(64),__aligned__(1))) char simd_packed_char64;
|
|
|
|
/*! @abstract A vector of two 8-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C++ and Metal, this type is also available as
|
|
* simd::packed_uchar2. The alignment of this type is that of the
|
|
* underlying scalar element type, so you can use it to load or store from
|
|
* an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(2),__aligned__(1))) unsigned char simd_packed_uchar2;
|
|
|
|
/*! @abstract A vector of four 8-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C++ and Metal, this type is also available as
|
|
* simd::packed_uchar4. The alignment of this type is that of the
|
|
* underlying scalar element type, so you can use it to load or store from
|
|
* an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(4),__aligned__(1))) unsigned char simd_packed_uchar4;
|
|
|
|
/*! @abstract A vector of eight 8-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C++ this type is also available as simd::packed_uchar8.
|
|
* This type is not available in Metal. The alignment of this type is only
|
|
* that of the underlying scalar element type, so you can use it to load or
|
|
* store from an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(8),__aligned__(1))) unsigned char simd_packed_uchar8;
|
|
|
|
/*! @abstract A vector of sixteen 8-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C++ this type is also available as simd::packed_uchar16.
|
|
* This type is not available in Metal. The alignment of this type is only
|
|
* that of the underlying scalar element type, so you can use it to load or
|
|
* store from an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(16),__aligned__(1))) unsigned char simd_packed_uchar16;
|
|
|
|
/*! @abstract A vector of thirty-two 8-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C++ this type is also available as simd::packed_uchar32.
|
|
* This type is not available in Metal. The alignment of this type is only
|
|
* that of the underlying scalar element type, so you can use it to load or
|
|
* store from an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(32),__aligned__(1))) unsigned char simd_packed_uchar32;
|
|
|
|
/*! @abstract A vector of sixty-four 8-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C++ this type is also available as simd::packed_uchar64.
|
|
* This type is not available in Metal. The alignment of this type is only
|
|
* that of the underlying scalar element type, so you can use it to load or
|
|
* store from an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(64),__aligned__(1))) unsigned char simd_packed_uchar64;
|
|
|
|
/*! @abstract A vector of two 16-bit signed (twos-complement) integers with
|
|
* relaxed alignment.
|
|
* @description In C++ and Metal, this type is also available as
|
|
* simd::packed_short2. The alignment of this type is that of the
|
|
* underlying scalar element type, so you can use it to load or store from
|
|
* an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(2),__aligned__(2))) short simd_packed_short2;
|
|
|
|
/*! @abstract A vector of four 16-bit signed (twos-complement) integers with
|
|
* relaxed alignment.
|
|
* @description In C++ and Metal, this type is also available as
|
|
* simd::packed_short4. The alignment of this type is that of the
|
|
* underlying scalar element type, so you can use it to load or store from
|
|
* an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(4),__aligned__(2))) short simd_packed_short4;
|
|
|
|
/*! @abstract A vector of eight 16-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description In C++ this type is also available as simd::packed_short8.
|
|
* This type is not available in Metal. The alignment of this type is only
|
|
* that of the underlying scalar element type, so you can use it to load or
|
|
* store from an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(8),__aligned__(2))) short simd_packed_short8;
|
|
|
|
/*! @abstract A vector of sixteen 16-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description In C++ this type is also available as simd::packed_short16.
|
|
* This type is not available in Metal. The alignment of this type is only
|
|
* that of the underlying scalar element type, so you can use it to load or
|
|
* store from an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(16),__aligned__(2))) short simd_packed_short16;
|
|
|
|
/*! @abstract A vector of thirty-two 16-bit signed (twos-complement)
|
|
* integers with relaxed alignment.
|
|
* @description In C++ this type is also available as simd::packed_short32.
|
|
* This type is not available in Metal. The alignment of this type is only
|
|
* that of the underlying scalar element type, so you can use it to load or
|
|
* store from an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(32),__aligned__(2))) short simd_packed_short32;
|
|
|
|
/*! @abstract A vector of two 16-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C++ and Metal, this type is also available as
|
|
* simd::packed_ushort2. The alignment of this type is that of the
|
|
* underlying scalar element type, so you can use it to load or store from
|
|
* an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(2),__aligned__(2))) unsigned short simd_packed_ushort2;
|
|
|
|
/*! @abstract A vector of four 16-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C++ and Metal, this type is also available as
|
|
* simd::packed_ushort4. The alignment of this type is that of the
|
|
* underlying scalar element type, so you can use it to load or store from
|
|
* an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(4),__aligned__(2))) unsigned short simd_packed_ushort4;
|
|
|
|
/*! @abstract A vector of eight 16-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C++ this type is also available as simd::packed_ushort8.
|
|
* This type is not available in Metal. The alignment of this type is only
|
|
* that of the underlying scalar element type, so you can use it to load or
|
|
* store from an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(8),__aligned__(2))) unsigned short simd_packed_ushort8;
|
|
|
|
/*! @abstract A vector of sixteen 16-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C++ this type is also available as
|
|
* simd::packed_ushort16. This type is not available in Metal. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(16),__aligned__(2))) unsigned short simd_packed_ushort16;
|
|
|
|
/*! @abstract A vector of thirty-two 16-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C++ this type is also available as
|
|
* simd::packed_ushort32. This type is not available in Metal. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(32),__aligned__(2))) unsigned short simd_packed_ushort32;
|
|
|
|
/*! @abstract A vector of two 32-bit signed (twos-complement) integers with
|
|
* relaxed alignment.
|
|
* @description In C++ and Metal, this type is also available as
|
|
* simd::packed_int2. The alignment of this type is that of the underlying
|
|
* scalar element type, so you can use it to load or store from an array of
|
|
* that type. */
|
|
typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) int simd_packed_int2;
|
|
|
|
/*! @abstract A vector of four 32-bit signed (twos-complement) integers with
|
|
* relaxed alignment.
|
|
* @description In C++ and Metal, this type is also available as
|
|
* simd::packed_int4. The alignment of this type is that of the underlying
|
|
* scalar element type, so you can use it to load or store from an array of
|
|
* that type. */
|
|
typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) int simd_packed_int4;
|
|
|
|
/*! @abstract A vector of eight 32-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description In C++ this type is also available as simd::packed_int8.
|
|
* This type is not available in Metal. The alignment of this type is only
|
|
* that of the underlying scalar element type, so you can use it to load or
|
|
* store from an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) int simd_packed_int8;
|
|
|
|
/*! @abstract A vector of sixteen 32-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description In C++ this type is also available as simd::packed_int16.
|
|
* This type is not available in Metal. The alignment of this type is only
|
|
* that of the underlying scalar element type, so you can use it to load or
|
|
* store from an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(16),__aligned__(4))) int simd_packed_int16;
|
|
|
|
/*! @abstract A vector of two 32-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C++ and Metal, this type is also available as
|
|
* simd::packed_uint2. The alignment of this type is that of the underlying
|
|
* scalar element type, so you can use it to load or store from an array of
|
|
* that type. */
|
|
typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) unsigned int simd_packed_uint2;
|
|
|
|
/*! @abstract A vector of four 32-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C++ and Metal, this type is also available as
|
|
* simd::packed_uint4. The alignment of this type is that of the underlying
|
|
* scalar element type, so you can use it to load or store from an array of
|
|
* that type. */
|
|
typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) unsigned int simd_packed_uint4;
|
|
|
|
/*! @abstract A vector of eight 32-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C++ this type is also available as simd::packed_uint8.
|
|
* This type is not available in Metal. The alignment of this type is only
|
|
* that of the underlying scalar element type, so you can use it to load or
|
|
* store from an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) unsigned int simd_packed_uint8;
|
|
|
|
/*! @abstract A vector of sixteen 32-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C++ this type is also available as simd::packed_uint16.
|
|
* This type is not available in Metal. The alignment of this type is only
|
|
* that of the underlying scalar element type, so you can use it to load or
|
|
* store from an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(16),__aligned__(4))) unsigned int simd_packed_uint16;
|
|
|
|
/*! @abstract A vector of two 32-bit floating-point numbers with relaxed
|
|
* alignment.
|
|
* @description In C++ and Metal, this type is also available as
|
|
* simd::packed_float2. The alignment of this type is that of the
|
|
* underlying scalar element type, so you can use it to load or store from
|
|
* an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) float simd_packed_float2;
|
|
|
|
/*! @abstract A vector of four 32-bit floating-point numbers with relaxed
|
|
* alignment.
|
|
* @description In C++ and Metal, this type is also available as
|
|
* simd::packed_float4. The alignment of this type is that of the
|
|
* underlying scalar element type, so you can use it to load or store from
|
|
* an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) float simd_packed_float4;
|
|
|
|
/*! @abstract A vector of eight 32-bit floating-point numbers with relaxed
|
|
* alignment.
|
|
* @description In C++ this type is also available as simd::packed_float8.
|
|
* This type is not available in Metal. The alignment of this type is only
|
|
* that of the underlying scalar element type, so you can use it to load or
|
|
* store from an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) float simd_packed_float8;
|
|
|
|
/*! @abstract A vector of sixteen 32-bit floating-point numbers with relaxed
|
|
* alignment.
|
|
* @description In C++ this type is also available as simd::packed_float16.
|
|
* This type is not available in Metal. The alignment of this type is only
|
|
* that of the underlying scalar element type, so you can use it to load or
|
|
* store from an array of that type. */
|
|
typedef __attribute__((__ext_vector_type__(16),__aligned__(4))) float simd_packed_float16;
|
|
|
|
/*! @abstract A vector of two 64-bit signed (twos-complement) integers with
|
|
* relaxed alignment.
|
|
* @description In C++ and Metal, this type is also available as
|
|
* simd::packed_long2. The alignment of this type is that of the underlying
|
|
* scalar element type, so you can use it to load or store from an array of
|
|
* that type. */
|
|
#if defined __LP64__
|
|
typedef __attribute__((__ext_vector_type__(2),__aligned__(8))) simd_long1 simd_packed_long2;
|
|
#else
|
|
typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) simd_long1 simd_packed_long2;
|
|
#endif
|
|
|
|
/*! @abstract A vector of four 64-bit signed (twos-complement) integers with
|
|
* relaxed alignment.
|
|
* @description In C++ and Metal, this type is also available as
|
|
* simd::packed_long4. The alignment of this type is that of the underlying
|
|
* scalar element type, so you can use it to load or store from an array of
|
|
* that type. */
|
|
#if defined __LP64__
|
|
typedef __attribute__((__ext_vector_type__(4),__aligned__(8))) simd_long1 simd_packed_long4;
|
|
#else
|
|
typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) simd_long1 simd_packed_long4;
|
|
#endif
|
|
|
|
/*! @abstract A vector of eight 64-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description In C++ this type is also available as simd::packed_long8.
|
|
* This type is not available in Metal. The alignment of this type is only
|
|
* that of the underlying scalar element type, so you can use it to load or
|
|
* store from an array of that type. */
|
|
#if defined __LP64__
|
|
typedef __attribute__((__ext_vector_type__(8),__aligned__(8))) simd_long1 simd_packed_long8;
|
|
#else
|
|
typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) simd_long1 simd_packed_long8;
|
|
#endif
|
|
|
|
/*! @abstract A vector of two 64-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C++ and Metal, this type is also available as
|
|
* simd::packed_ulong2. The alignment of this type is that of the
|
|
* underlying scalar element type, so you can use it to load or store from
|
|
* an array of that type. */
|
|
#if defined __LP64__
|
|
typedef __attribute__((__ext_vector_type__(2),__aligned__(8))) simd_ulong1 simd_packed_ulong2;
|
|
#else
|
|
typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) simd_ulong1 simd_packed_ulong2;
|
|
#endif
|
|
|
|
/*! @abstract A vector of four 64-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C++ and Metal, this type is also available as
|
|
* simd::packed_ulong4. The alignment of this type is that of the
|
|
* underlying scalar element type, so you can use it to load or store from
|
|
* an array of that type. */
|
|
#if defined __LP64__
|
|
typedef __attribute__((__ext_vector_type__(4),__aligned__(8))) simd_ulong1 simd_packed_ulong4;
|
|
#else
|
|
typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) simd_ulong1 simd_packed_ulong4;
|
|
#endif
|
|
|
|
/*! @abstract A vector of eight 64-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C++ this type is also available as simd::packed_ulong8.
|
|
* This type is not available in Metal. The alignment of this type is only
|
|
* that of the underlying scalar element type, so you can use it to load or
|
|
* store from an array of that type. */
|
|
#if defined __LP64__
|
|
typedef __attribute__((__ext_vector_type__(8),__aligned__(8))) simd_ulong1 simd_packed_ulong8;
|
|
#else
|
|
typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) simd_ulong1 simd_packed_ulong8;
|
|
#endif
|
|
|
|
/*! @abstract A vector of two 64-bit floating-point numbers with relaxed
|
|
* alignment.
|
|
* @description In C++ and Metal, this type is also available as
|
|
* simd::packed_double2. The alignment of this type is that of the
|
|
* underlying scalar element type, so you can use it to load or store from
|
|
* an array of that type. */
|
|
#if defined __LP64__
|
|
typedef __attribute__((__ext_vector_type__(2),__aligned__(8))) double simd_packed_double2;
|
|
#else
|
|
typedef __attribute__((__ext_vector_type__(2),__aligned__(4))) double simd_packed_double2;
|
|
#endif
|
|
|
|
/*! @abstract A vector of four 64-bit floating-point numbers with relaxed
|
|
* alignment.
|
|
* @description In C++ and Metal, this type is also available as
|
|
* simd::packed_double4. The alignment of this type is that of the
|
|
* underlying scalar element type, so you can use it to load or store from
|
|
* an array of that type. */
|
|
#if defined __LP64__
|
|
typedef __attribute__((__ext_vector_type__(4),__aligned__(8))) double simd_packed_double4;
|
|
#else
|
|
typedef __attribute__((__ext_vector_type__(4),__aligned__(4))) double simd_packed_double4;
|
|
#endif
|
|
|
|
/*! @abstract A vector of eight 64-bit floating-point numbers with relaxed
|
|
* alignment.
|
|
* @description In C++ this type is also available as simd::packed_double8.
|
|
* This type is not available in Metal. The alignment of this type is only
|
|
* that of the underlying scalar element type, so you can use it to load or
|
|
* store from an array of that type. */
|
|
#if defined __LP64__
|
|
typedef __attribute__((__ext_vector_type__(8),__aligned__(8))) double simd_packed_double8;
|
|
#else
|
|
typedef __attribute__((__ext_vector_type__(8),__aligned__(4))) double simd_packed_double8;
|
|
#endif
|
|
|
|
/* MARK: C++ vector types */
|
|
#if defined __cplusplus
|
|
namespace simd {
|
|
namespace packed {
|
|
/*! @abstract A vector of two 8-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description In C or Objective-C, this type is available as
|
|
* simd_packed_char2. The alignment of this type is only that of the
|
|
* underlying scalar element type, so you can use it to load or store
|
|
* from an array of that type. */
|
|
typedef ::simd_packed_char2 char2;
|
|
|
|
/*! @abstract A vector of four 8-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description In C or Objective-C, this type is available as
|
|
* simd_packed_char4. The alignment of this type is only that of the
|
|
* underlying scalar element type, so you can use it to load or store
|
|
* from an array of that type. */
|
|
typedef ::simd_packed_char4 char4;
|
|
|
|
/*! @abstract A vector of eight 8-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_char8. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_char8 char8;
|
|
|
|
/*! @abstract A vector of sixteen 8-bit signed (twos-complement)
|
|
* integers with relaxed alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_char16. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_char16 char16;
|
|
|
|
/*! @abstract A vector of thirty-two 8-bit signed (twos-complement)
|
|
* integers with relaxed alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_char32. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_char32 char32;
|
|
|
|
/*! @abstract A vector of sixty-four 8-bit signed (twos-complement)
|
|
* integers with relaxed alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_char64. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_char64 char64;
|
|
|
|
/*! @abstract A vector of two 8-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C or Objective-C, this type is available as
|
|
* simd_packed_uchar2. The alignment of this type is only that of the
|
|
* underlying scalar element type, so you can use it to load or store
|
|
* from an array of that type. */
|
|
typedef ::simd_packed_uchar2 uchar2;
|
|
|
|
/*! @abstract A vector of four 8-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C or Objective-C, this type is available as
|
|
* simd_packed_uchar4. The alignment of this type is only that of the
|
|
* underlying scalar element type, so you can use it to load or store
|
|
* from an array of that type. */
|
|
typedef ::simd_packed_uchar4 uchar4;
|
|
|
|
/*! @abstract A vector of eight 8-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_uchar8. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_uchar8 uchar8;
|
|
|
|
/*! @abstract A vector of sixteen 8-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_uchar16. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_uchar16 uchar16;
|
|
|
|
/*! @abstract A vector of thirty-two 8-bit unsigned integers with
|
|
* relaxed alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_uchar32. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_uchar32 uchar32;
|
|
|
|
/*! @abstract A vector of sixty-four 8-bit unsigned integers with
|
|
* relaxed alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_uchar64. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_uchar64 uchar64;
|
|
|
|
/*! @abstract A vector of two 16-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description In C or Objective-C, this type is available as
|
|
* simd_packed_short2. The alignment of this type is only that of the
|
|
* underlying scalar element type, so you can use it to load or store
|
|
* from an array of that type. */
|
|
typedef ::simd_packed_short2 short2;
|
|
|
|
/*! @abstract A vector of four 16-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description In C or Objective-C, this type is available as
|
|
* simd_packed_short4. The alignment of this type is only that of the
|
|
* underlying scalar element type, so you can use it to load or store
|
|
* from an array of that type. */
|
|
typedef ::simd_packed_short4 short4;
|
|
|
|
/*! @abstract A vector of eight 16-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_short8. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_short8 short8;
|
|
|
|
/*! @abstract A vector of sixteen 16-bit signed (twos-complement)
|
|
* integers with relaxed alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_short16. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_short16 short16;
|
|
|
|
/*! @abstract A vector of thirty-two 16-bit signed (twos-complement)
|
|
* integers with relaxed alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_short32. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_short32 short32;
|
|
|
|
/*! @abstract A vector of two 16-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C or Objective-C, this type is available as
|
|
* simd_packed_ushort2. The alignment of this type is only that of the
|
|
* underlying scalar element type, so you can use it to load or store
|
|
* from an array of that type. */
|
|
typedef ::simd_packed_ushort2 ushort2;
|
|
|
|
/*! @abstract A vector of four 16-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C or Objective-C, this type is available as
|
|
* simd_packed_ushort4. The alignment of this type is only that of the
|
|
* underlying scalar element type, so you can use it to load or store
|
|
* from an array of that type. */
|
|
typedef ::simd_packed_ushort4 ushort4;
|
|
|
|
/*! @abstract A vector of eight 16-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_ushort8. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_ushort8 ushort8;
|
|
|
|
/*! @abstract A vector of sixteen 16-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_ushort16. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_ushort16 ushort16;
|
|
|
|
/*! @abstract A vector of thirty-two 16-bit unsigned integers with
|
|
* relaxed alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_ushort32. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_ushort32 ushort32;
|
|
|
|
/*! @abstract A vector of two 32-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description In C or Objective-C, this type is available as
|
|
* simd_packed_int2. The alignment of this type is only that of the
|
|
* underlying scalar element type, so you can use it to load or store
|
|
* from an array of that type. */
|
|
typedef ::simd_packed_int2 int2;
|
|
|
|
/*! @abstract A vector of four 32-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description In C or Objective-C, this type is available as
|
|
* simd_packed_int4. The alignment of this type is only that of the
|
|
* underlying scalar element type, so you can use it to load or store
|
|
* from an array of that type. */
|
|
typedef ::simd_packed_int4 int4;
|
|
|
|
/*! @abstract A vector of eight 32-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_int8. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_int8 int8;
|
|
|
|
/*! @abstract A vector of sixteen 32-bit signed (twos-complement)
|
|
* integers with relaxed alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_int16. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_int16 int16;
|
|
|
|
/*! @abstract A vector of two 32-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C or Objective-C, this type is available as
|
|
* simd_packed_uint2. The alignment of this type is only that of the
|
|
* underlying scalar element type, so you can use it to load or store
|
|
* from an array of that type. */
|
|
typedef ::simd_packed_uint2 uint2;
|
|
|
|
/*! @abstract A vector of four 32-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C or Objective-C, this type is available as
|
|
* simd_packed_uint4. The alignment of this type is only that of the
|
|
* underlying scalar element type, so you can use it to load or store
|
|
* from an array of that type. */
|
|
typedef ::simd_packed_uint4 uint4;
|
|
|
|
/*! @abstract A vector of eight 32-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_uint8. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_uint8 uint8;
|
|
|
|
/*! @abstract A vector of sixteen 32-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_uint16. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_uint16 uint16;
|
|
|
|
/*! @abstract A vector of two 32-bit floating-point numbers with relaxed
|
|
* alignment.
|
|
* @description In C or Objective-C, this type is available as
|
|
* simd_packed_float2. The alignment of this type is only that of the
|
|
* underlying scalar element type, so you can use it to load or store
|
|
* from an array of that type. */
|
|
typedef ::simd_packed_float2 float2;
|
|
|
|
/*! @abstract A vector of four 32-bit floating-point numbers with
|
|
* relaxed alignment.
|
|
* @description In C or Objective-C, this type is available as
|
|
* simd_packed_float4. The alignment of this type is only that of the
|
|
* underlying scalar element type, so you can use it to load or store
|
|
* from an array of that type. */
|
|
typedef ::simd_packed_float4 float4;
|
|
|
|
/*! @abstract A vector of eight 32-bit floating-point numbers with
|
|
* relaxed alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_float8. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_float8 float8;
|
|
|
|
/*! @abstract A vector of sixteen 32-bit floating-point numbers with
|
|
* relaxed alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_float16. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_float16 float16;
|
|
|
|
/*! @abstract A vector of two 64-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description In C or Objective-C, this type is available as
|
|
* simd_packed_long2. The alignment of this type is only that of the
|
|
* underlying scalar element type, so you can use it to load or store
|
|
* from an array of that type. */
|
|
typedef ::simd_packed_long2 long2;
|
|
|
|
/*! @abstract A vector of four 64-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description In C or Objective-C, this type is available as
|
|
* simd_packed_long4. The alignment of this type is only that of the
|
|
* underlying scalar element type, so you can use it to load or store
|
|
* from an array of that type. */
|
|
typedef ::simd_packed_long4 long4;
|
|
|
|
/*! @abstract A vector of eight 64-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_long8. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_long8 long8;
|
|
|
|
/*! @abstract A vector of two 64-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C or Objective-C, this type is available as
|
|
* simd_packed_ulong2. The alignment of this type is only that of the
|
|
* underlying scalar element type, so you can use it to load or store
|
|
* from an array of that type. */
|
|
typedef ::simd_packed_ulong2 ulong2;
|
|
|
|
/*! @abstract A vector of four 64-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description In C or Objective-C, this type is available as
|
|
* simd_packed_ulong4. The alignment of this type is only that of the
|
|
* underlying scalar element type, so you can use it to load or store
|
|
* from an array of that type. */
|
|
typedef ::simd_packed_ulong4 ulong4;
|
|
|
|
/*! @abstract A vector of eight 64-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_ulong8. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_ulong8 ulong8;
|
|
|
|
/*! @abstract A vector of two 64-bit floating-point numbers with relaxed
|
|
* alignment.
|
|
* @description In C or Objective-C, this type is available as
|
|
* simd_packed_double2. The alignment of this type is only that of the
|
|
* underlying scalar element type, so you can use it to load or store
|
|
* from an array of that type. */
|
|
typedef ::simd_packed_double2 double2;
|
|
|
|
/*! @abstract A vector of four 64-bit floating-point numbers with
|
|
* relaxed alignment.
|
|
* @description In C or Objective-C, this type is available as
|
|
* simd_packed_double4. The alignment of this type is only that of the
|
|
* underlying scalar element type, so you can use it to load or store
|
|
* from an array of that type. */
|
|
typedef ::simd_packed_double4 double4;
|
|
|
|
/*! @abstract A vector of eight 64-bit floating-point numbers with
|
|
* relaxed alignment.
|
|
* @description This type is not available in Metal. In C or
|
|
* Objective-C, this type is available as simd_packed_double8. The
|
|
* alignment of this type is only that of the underlying scalar element
|
|
* type, so you can use it to load or store from an array of that type. */
|
|
typedef ::simd_packed_double8 double8;
|
|
|
|
} /* namespace simd::packed:: */
|
|
} /* namespace simd:: */
|
|
#endif /* __cplusplus */
|
|
|
|
/* MARK: Deprecated vector types */
|
|
/*! @group Deprecated vector types
|
|
* @discussion These are the original types used by earlier versions of the
|
|
* simd library; they are provided here for compatability with existing source
|
|
* files. Use the new ("simd_"-prefixed) types for future development. */
|
|
/*! @abstract A vector of two 8-bit signed (twos-complement) integers with
|
|
* relaxed alignment.
|
|
* @description This type is deprecated; you should use simd_packed_char2
|
|
* or simd::packed_char2 instead. */
|
|
typedef simd_packed_char2 packed_char2;
|
|
|
|
/*! @abstract A vector of four 8-bit signed (twos-complement) integers with
|
|
* relaxed alignment.
|
|
* @description This type is deprecated; you should use simd_packed_char4
|
|
* or simd::packed_char4 instead. */
|
|
typedef simd_packed_char4 packed_char4;
|
|
|
|
/*! @abstract A vector of eight 8-bit signed (twos-complement) integers with
|
|
* relaxed alignment.
|
|
* @description This type is deprecated; you should use simd_packed_char8
|
|
* or simd::packed_char8 instead. */
|
|
typedef simd_packed_char8 packed_char8;
|
|
|
|
/*! @abstract A vector of sixteen 8-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description This type is deprecated; you should use simd_packed_char16
|
|
* or simd::packed_char16 instead. */
|
|
typedef simd_packed_char16 packed_char16;
|
|
|
|
/*! @abstract A vector of thirty-two 8-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description This type is deprecated; you should use simd_packed_char32
|
|
* or simd::packed_char32 instead. */
|
|
typedef simd_packed_char32 packed_char32;
|
|
|
|
/*! @abstract A vector of sixty-four 8-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description This type is deprecated; you should use simd_packed_char64
|
|
* or simd::packed_char64 instead. */
|
|
typedef simd_packed_char64 packed_char64;
|
|
|
|
/*! @abstract A vector of two 8-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_uchar2
|
|
* or simd::packed_uchar2 instead. */
|
|
typedef simd_packed_uchar2 packed_uchar2;
|
|
|
|
/*! @abstract A vector of four 8-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_uchar4
|
|
* or simd::packed_uchar4 instead. */
|
|
typedef simd_packed_uchar4 packed_uchar4;
|
|
|
|
/*! @abstract A vector of eight 8-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_uchar8
|
|
* or simd::packed_uchar8 instead. */
|
|
typedef simd_packed_uchar8 packed_uchar8;
|
|
|
|
/*! @abstract A vector of sixteen 8-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_uchar16
|
|
* or simd::packed_uchar16 instead. */
|
|
typedef simd_packed_uchar16 packed_uchar16;
|
|
|
|
/*! @abstract A vector of thirty-two 8-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_uchar32
|
|
* or simd::packed_uchar32 instead. */
|
|
typedef simd_packed_uchar32 packed_uchar32;
|
|
|
|
/*! @abstract A vector of sixty-four 8-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_uchar64
|
|
* or simd::packed_uchar64 instead. */
|
|
typedef simd_packed_uchar64 packed_uchar64;
|
|
|
|
/*! @abstract A vector of two 16-bit signed (twos-complement) integers with
|
|
* relaxed alignment.
|
|
* @description This type is deprecated; you should use simd_packed_short2
|
|
* or simd::packed_short2 instead. */
|
|
typedef simd_packed_short2 packed_short2;
|
|
|
|
/*! @abstract A vector of four 16-bit signed (twos-complement) integers with
|
|
* relaxed alignment.
|
|
* @description This type is deprecated; you should use simd_packed_short4
|
|
* or simd::packed_short4 instead. */
|
|
typedef simd_packed_short4 packed_short4;
|
|
|
|
/*! @abstract A vector of eight 16-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description This type is deprecated; you should use simd_packed_short8
|
|
* or simd::packed_short8 instead. */
|
|
typedef simd_packed_short8 packed_short8;
|
|
|
|
/*! @abstract A vector of sixteen 16-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description This type is deprecated; you should use simd_packed_short16
|
|
* or simd::packed_short16 instead. */
|
|
typedef simd_packed_short16 packed_short16;
|
|
|
|
/*! @abstract A vector of thirty-two 16-bit signed (twos-complement)
|
|
* integers with relaxed alignment.
|
|
* @description This type is deprecated; you should use simd_packed_short32
|
|
* or simd::packed_short32 instead. */
|
|
typedef simd_packed_short32 packed_short32;
|
|
|
|
/*! @abstract A vector of two 16-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_ushort2
|
|
* or simd::packed_ushort2 instead. */
|
|
typedef simd_packed_ushort2 packed_ushort2;
|
|
|
|
/*! @abstract A vector of four 16-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_ushort4
|
|
* or simd::packed_ushort4 instead. */
|
|
typedef simd_packed_ushort4 packed_ushort4;
|
|
|
|
/*! @abstract A vector of eight 16-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_ushort8
|
|
* or simd::packed_ushort8 instead. */
|
|
typedef simd_packed_ushort8 packed_ushort8;
|
|
|
|
/*! @abstract A vector of sixteen 16-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use
|
|
* simd_packed_ushort16 or simd::packed_ushort16 instead. */
|
|
typedef simd_packed_ushort16 packed_ushort16;
|
|
|
|
/*! @abstract A vector of thirty-two 16-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use
|
|
* simd_packed_ushort32 or simd::packed_ushort32 instead. */
|
|
typedef simd_packed_ushort32 packed_ushort32;
|
|
|
|
/*! @abstract A vector of two 32-bit signed (twos-complement) integers with
|
|
* relaxed alignment.
|
|
* @description This type is deprecated; you should use simd_packed_int2 or
|
|
* simd::packed_int2 instead. */
|
|
typedef simd_packed_int2 packed_int2;
|
|
|
|
/*! @abstract A vector of four 32-bit signed (twos-complement) integers with
|
|
* relaxed alignment.
|
|
* @description This type is deprecated; you should use simd_packed_int4 or
|
|
* simd::packed_int4 instead. */
|
|
typedef simd_packed_int4 packed_int4;
|
|
|
|
/*! @abstract A vector of eight 32-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description This type is deprecated; you should use simd_packed_int8 or
|
|
* simd::packed_int8 instead. */
|
|
typedef simd_packed_int8 packed_int8;
|
|
|
|
/*! @abstract A vector of sixteen 32-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description This type is deprecated; you should use simd_packed_int16
|
|
* or simd::packed_int16 instead. */
|
|
typedef simd_packed_int16 packed_int16;
|
|
|
|
/*! @abstract A vector of two 32-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_uint2
|
|
* or simd::packed_uint2 instead. */
|
|
typedef simd_packed_uint2 packed_uint2;
|
|
|
|
/*! @abstract A vector of four 32-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_uint4
|
|
* or simd::packed_uint4 instead. */
|
|
typedef simd_packed_uint4 packed_uint4;
|
|
|
|
/*! @abstract A vector of eight 32-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_uint8
|
|
* or simd::packed_uint8 instead. */
|
|
typedef simd_packed_uint8 packed_uint8;
|
|
|
|
/*! @abstract A vector of sixteen 32-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_uint16
|
|
* or simd::packed_uint16 instead. */
|
|
typedef simd_packed_uint16 packed_uint16;
|
|
|
|
/*! @abstract A vector of two 32-bit floating-point numbers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_float2
|
|
* or simd::packed_float2 instead. */
|
|
typedef simd_packed_float2 packed_float2;
|
|
|
|
/*! @abstract A vector of four 32-bit floating-point numbers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_float4
|
|
* or simd::packed_float4 instead. */
|
|
typedef simd_packed_float4 packed_float4;
|
|
|
|
/*! @abstract A vector of eight 32-bit floating-point numbers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_float8
|
|
* or simd::packed_float8 instead. */
|
|
typedef simd_packed_float8 packed_float8;
|
|
|
|
/*! @abstract A vector of sixteen 32-bit floating-point numbers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_float16
|
|
* or simd::packed_float16 instead. */
|
|
typedef simd_packed_float16 packed_float16;
|
|
|
|
/*! @abstract A vector of two 64-bit signed (twos-complement) integers with
|
|
* relaxed alignment.
|
|
* @description This type is deprecated; you should use simd_packed_long2
|
|
* or simd::packed_long2 instead. */
|
|
typedef simd_packed_long2 packed_long2;
|
|
|
|
/*! @abstract A vector of four 64-bit signed (twos-complement) integers with
|
|
* relaxed alignment.
|
|
* @description This type is deprecated; you should use simd_packed_long4
|
|
* or simd::packed_long4 instead. */
|
|
typedef simd_packed_long4 packed_long4;
|
|
|
|
/*! @abstract A vector of eight 64-bit signed (twos-complement) integers
|
|
* with relaxed alignment.
|
|
* @description This type is deprecated; you should use simd_packed_long8
|
|
* or simd::packed_long8 instead. */
|
|
typedef simd_packed_long8 packed_long8;
|
|
|
|
/*! @abstract A vector of two 64-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_ulong2
|
|
* or simd::packed_ulong2 instead. */
|
|
typedef simd_packed_ulong2 packed_ulong2;
|
|
|
|
/*! @abstract A vector of four 64-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_ulong4
|
|
* or simd::packed_ulong4 instead. */
|
|
typedef simd_packed_ulong4 packed_ulong4;
|
|
|
|
/*! @abstract A vector of eight 64-bit unsigned integers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_ulong8
|
|
* or simd::packed_ulong8 instead. */
|
|
typedef simd_packed_ulong8 packed_ulong8;
|
|
|
|
/*! @abstract A vector of two 64-bit floating-point numbers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_double2
|
|
* or simd::packed_double2 instead. */
|
|
typedef simd_packed_double2 packed_double2;
|
|
|
|
/*! @abstract A vector of four 64-bit floating-point numbers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_double4
|
|
* or simd::packed_double4 instead. */
|
|
typedef simd_packed_double4 packed_double4;
|
|
|
|
/*! @abstract A vector of eight 64-bit floating-point numbers with relaxed
|
|
* alignment.
|
|
* @description This type is deprecated; you should use simd_packed_double8
|
|
* or simd::packed_double8 instead. */
|
|
typedef simd_packed_double8 packed_double8;
|
|
|
|
# endif /* SIMD_COMPILER_HAS_REQUIRED_FEATURES */
|
|
#endif |