[clang] [X86][AVX10.2] Add comments for the avx10_2convertintrin.h file (PR #120766)
Mikołaj Piróg via cfe-commits
cfe-commits at lists.llvm.org
Sat Dec 21 13:33:15 PST 2024
https://github.com/mikolaj-pirog updated https://github.com/llvm/llvm-project/pull/120766
>From 0c107c06255cc2c8c2ae1abd1825d547b70db33a Mon Sep 17 00:00:00 2001
From: "Pirog, Mikolaj Maciej" <mikolaj.maciej.pirog at intel.com>
Date: Fri, 13 Dec 2024 15:40:14 +0100
Subject: [PATCH 1/9] mend
---
clang/lib/Headers/avx10_2convertintrin.h | 304 +++++++++++++++++++++++
1 file changed, 304 insertions(+)
diff --git a/clang/lib/Headers/avx10_2convertintrin.h b/clang/lib/Headers/avx10_2convertintrin.h
index 134adb2850c8de..62b71ce87dd382 100644
--- a/clang/lib/Headers/avx10_2convertintrin.h
+++ b/clang/lib/Headers/avx10_2convertintrin.h
@@ -24,24 +24,146 @@
__attribute__((__always_inline__, __nodebug__, __target__("avx10.2-256"), \
__min_vector_width__(256)))
+/// Convert two 128-bit vectors, \a __A and \a __B, containing packed
+/// single-precision (32-bit) floating-point elements to a 128-bit vector
+/// containing FP16 elements.
+///
+/// \code{.operation]
+/// FOR i := 0 to 7
+/// IF i < 4
+/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
+/// ELSE
+/// dst.fp16[i] := convert_fp32_to_fp16(__A.fp32[i - 4])
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __A
+/// A 128-bit vector of [4 x float].
+/// \param __B
+/// A 128-bit vector of [4 x float].
+/// \returns
+/// A 128-bit vector of [8 x fp16]. Lower 4 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A.
static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtx2ps_ph(__m128 __A,
__m128 __B) {
return (__m128h)__builtin_ia32_vcvt2ps2phx128_mask(
(__v4sf)__A, (__v4sf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)(-1));
}
+/// Convert two 128-bit vectors, \a __A and \a __B, containing packed
+/// single-precision (32-bit) floating-point elements to a 128-bit vector
+/// containing FP16 elements. Merging mask \a __U is used to determine if given
+/// element should be taken from \a __W instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 7
+/// IF mask[i]
+/// dst.fp16[i] := __W[i]
+/// ELSE
+/// IF i < 4
+/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
+/// ELSE
+/// dst.fp16[i] := convert_fp32_to_fp16(__A.fp32[i - 4])
+/// FI
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __W
+/// A 128-bit vector of [8 x fp16].
+/// \param __U
+/// A 8-bit merging mask.
+/// \param __A
+/// A 128-bit vector of [4 x float].
+/// \param __B
+/// A 128-bit vector of [4 x float].
+/// \returns
+/// A 128-bit vector of [8 x fp16]. Lower 4 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// element from \a __W is taken instead.
static __inline__ __m128h __DEFAULT_FN_ATTRS128
_mm_mask_cvtx2ps_ph(__m128h __W, __mmask8 __U, __m128 __A, __m128 __B) {
return (__m128h)__builtin_ia32_vcvt2ps2phx128_mask(
(__v4sf)__A, (__v4sf)__B, (__v8hf)__W, (__mmask8)__U);
}
+/// Convert two 128-bit vectors, \a __A and \a __B, containing packed
+/// single-precision (32-bit) floating-point elements to a 128-bit vector
+/// containing FP16 elements. Zeroing mask \a __U is used to determine if given
+/// element should be zeroed instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 7
+/// IF mask[i]
+/// dst.fp16[i] := 0
+/// ELSE
+/// IF i < 4
+/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
+/// ELSE
+/// dst.fp16[i] := convert_fp32_to_fp16(__A.fp32[i - 4])
+/// FI
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __U
+/// A 8-bit merging mask.
+/// \param __A
+/// A 128-bit vector of [4 x float].
+/// \param __B
+/// A 128-bit vector of [4 x float].
+/// \returns
+/// A 128-bit vector of [8 x fp16]. Lower 4 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// zero is taken instead.
static __inline__ __m128h __DEFAULT_FN_ATTRS128
_mm_maskz_cvtx2ps_ph(__mmask8 __U, __m128 __A, __m128 __B) {
return (__m128h)__builtin_ia32_vcvt2ps2phx128_mask(
(__v4sf)__A, (__v4sf)__B, (__v8hf)_mm_setzero_ph(), (__mmask8)__U);
}
+/// Convert two 256-bit vectors, \a __A and \a __B, containing packed
+/// single-precision (32-bit) floating-point elements to a 256-bit vector
+/// containing FP16 elements.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// IF i < 8
+/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
+/// ELSE
+/// dst.fp16[i] := convert_fp32_to_fp16(__A.fp32[i - 8])
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __A
+/// A 256-bit vector of [8 x float].
+/// \param __B
+/// A 256-bit vector of [8 x float].
+/// \returns
+/// A 256-bit vector of [16 x fp16]. Lower 8 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A.
static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_cvtx2ps_ph(__m256 __A,
__m256 __B) {
return (__m256h)__builtin_ia32_vcvt2ps2phx256_mask(
@@ -49,6 +171,42 @@ static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_cvtx2ps_ph(__m256 __A,
_MM_FROUND_CUR_DIRECTION);
}
+/// Convert two 256-bit vectors, \a __A and \a __B, containing packed
+/// single-precision (32-bit) floating-point elements to a 256-bit vector
+/// containing FP16 elements. Merging mask \a __U is used to determine if given
+/// element should be taken from \a __W instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// IF mask[i]
+/// dst.fp16[i] := __W[i]
+/// ELSE
+/// IF i < 8
+/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
+/// ELSE
+/// dst.fp16[i] := convert_fp32_to_fp16(__A.fp32[i - 8])
+/// FI
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __W
+/// A 256-bit vector of [16 x fp16].
+/// \param __U
+/// A 8-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [8 x float].
+/// \param __B
+/// A 256-bit vector of [8 x float].
+/// \returns
+/// A 256-bit vector of [16 x fp16]. Lower 4 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// element from \a __W is taken instead.
static __inline__ __m256h __DEFAULT_FN_ATTRS256
_mm256_mask_cvtx2ps_ph(__m256h __W, __mmask16 __U, __m256 __A, __m256 __B) {
return (__m256h)__builtin_ia32_vcvt2ps2phx256_mask(
@@ -56,6 +214,40 @@ _mm256_mask_cvtx2ps_ph(__m256h __W, __mmask16 __U, __m256 __A, __m256 __B) {
_MM_FROUND_CUR_DIRECTION);
}
+/// Convert two 256-bit vectors, \a __A and \a __B, containing packed
+/// single-precision (32-bit) floating-point elements to a 256-bit vector
+/// containing FP16 elements. Zeroing mask \a __U is used to determine if given
+/// element should be zeroed instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// IF mask[i]
+/// dst.fp16[i] := 0
+/// ELSE
+/// IF i < 8
+/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
+/// ELSE
+/// dst.fp16[i] := convert_fp32_to_fp16(__A.fp32[i - 8])
+/// FI
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __U
+/// A 8-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [8 x float].
+/// \param __B
+/// A 256-bit vector of [8 x float].
+/// \returns
+/// A 256-bit vector of [16 x fp16]. Lower 4 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// zero is taken instead.
static __inline__ __m256h __DEFAULT_FN_ATTRS256
_mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
return (__m256h)__builtin_ia32_vcvt2ps2phx256_mask(
@@ -63,15 +255,127 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
_MM_FROUND_CUR_DIRECTION);
}
+/// Convert two 256-bit vectors, \a __A and \a __B, containing packed
+/// single-precision (32-bit) floating-point elements to a 256-bit vector
+/// containing FP16 elements. Rounding mode \a __R needs to be provided.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// IF i < 8
+/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
+/// ELSE
+/// dst.fp16[i] := convert_fp32_to_fp16(__A.fp32[i - 8])
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __A
+/// A 256-bit vector of [8 x float].
+/// \param __B
+/// A 256-bit vector of [8 x float].
+/// \param __R
+/// Rounding mode. Valid inputs are: _MM_FROUND_CUR_DIRECTION or
+/// result bitwise or of _MM_FROUND_NO_EXC with at most one of the following:
+/// _MM_FROUND_TO_NEAREST_INT, _MM_FROUND_TO_NEG_INF, _MM_FROUND_TO_POS_INF,
+/// _MM_FROUND_TO_ZERO.
+/// \returns
+/// A 256-bit vector of [16 x fp16]. Lower 8 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A.
#define _mm256_cvtx_round2ps_ph(A, B, R) \
((__m256h)__builtin_ia32_vcvt2ps2phx256_mask( \
(__v8sf)(A), (__v8sf)(B), (__v16hf)_mm256_undefined_ph(), \
(__mmask16)(-1), (const int)(R)))
+/// Convert two 256-bit vectors, \a __A and \a __B, containing packed
+/// single-precision (32-bit) floating-point elements to a 256-bit vector
+/// containing FP16 elements. Merging mask \a __U is used to determine if given
+/// element should be taken from \a __W instead. Rounding mode \a __R needs to
+/// be provided.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// IF mask[i]
+/// dst.fp16[i] := __W[i]
+/// ELSE
+/// IF i < 8
+/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
+/// ELSE
+/// dst.fp16[i] := convert_fp32_to_fp16(__A.fp32[i - 8])
+/// FI
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __W
+/// A 256-bit vector of [16 x fp16].
+/// \param __U
+/// A 8-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [8 x float].
+/// \param __B
+/// A 256-bit vector of [8 x float].
+/// \param __R
+/// Rounding mode. Valid inputs are: _MM_FROUND_CUR_DIRECTION or
+/// result bitwise or of _MM_FROUND_NO_EXC with at most one of the following:
+/// _MM_FROUND_TO_NEAREST_INT, _MM_FROUND_TO_NEG_INF, _MM_FROUND_TO_POS_INF,
+/// _MM_FROUND_TO_ZERO.
+/// \returns
+/// A 256-bit vector of [16 x fp16]. Lower 4 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// element from \a __W is taken instead.
#define _mm256_mask_cvtx_round2ps_ph(W, U, A, B, R) \
((__m256h)__builtin_ia32_vcvt2ps2phx256_mask( \
(__v8sf)(A), (__v8sf)(B), (__v16hf)(W), (__mmask16)(U), (const int)(R)))
+/// Convert two 256-bit vectors, \a __A and \a __B, containing packed
+/// single-precision (32-bit) floating-point elements to a 256-bit vector
+/// containing FP16 elements. Zeroing mask \a __U is used to determine if given
+/// element should be zeroed instead. Rounding mode \a __R needs to be provided.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// IF mask[i]
+/// dst.fp16[i] := 0
+/// ELSE
+/// IF i < 8
+/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
+/// ELSE
+/// dst.fp16[i] := convert_fp32_to_fp16(__A.fp32[i - 8])
+/// FI
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __U
+/// A 8-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [8 x float].
+/// \param __B
+/// A 256-bit vector of [8 x float].
+/// \param __R
+/// Rounding mode. Valid inputs are: _MM_FROUND_CUR_DIRECTION or
+/// result bitwise or of _MM_FROUND_NO_EXC with at most one of the following:
+/// _MM_FROUND_TO_NEAREST_INT, _MM_FROUND_TO_NEG_INF, _MM_FROUND_TO_POS_INF,
+/// _MM_FROUND_TO_ZERO.
+/// \returns
+/// A 256-bit vector of [16 x fp16]. Lower 4 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// zero is taken instead.
#define _mm256_maskz_cvtx_round2ps_ph(U, A, B, R) \
((__m256h)__builtin_ia32_vcvt2ps2phx256_mask( \
(__v8sf)(A), (__v8sf)(B), (__v16hf)(_mm256_setzero_ph()), \
>From 5a7f69432e56429aa325e6e99b6614582a866277 Mon Sep 17 00:00:00 2001
From: "Pirog, Mikolaj Maciej" <mikolaj.maciej.pirog at intel.com>
Date: Tue, 17 Dec 2024 15:52:08 +0100
Subject: [PATCH 2/9] further work
---
clang/lib/Headers/avx10_2convertintrin.h | 226 +++++++++++++++++++++--
1 file changed, 209 insertions(+), 17 deletions(-)
diff --git a/clang/lib/Headers/avx10_2convertintrin.h b/clang/lib/Headers/avx10_2convertintrin.h
index 62b71ce87dd382..28e028e906bb66 100644
--- a/clang/lib/Headers/avx10_2convertintrin.h
+++ b/clang/lib/Headers/avx10_2convertintrin.h
@@ -106,13 +106,13 @@ _mm_mask_cvtx2ps_ph(__m128h __W, __mmask8 __U, __m128 __A, __m128 __B) {
/// \code{.operation]
/// FOR i := 0 to 7
/// IF mask[i]
-/// dst.fp16[i] := 0
-/// ELSE
/// IF i < 4
/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
/// ELSE
/// dst.fp16[i] := convert_fp32_to_fp16(__A.fp32[i - 4])
/// FI
+/// ELSE
+/// dst.fp16[i] := 0
/// FI
/// ENDFOR
/// \endcode
@@ -130,8 +130,8 @@ _mm_mask_cvtx2ps_ph(__m128h __W, __mmask8 __U, __m128 __A, __m128 __B) {
/// \returns
/// A 128-bit vector of [8 x fp16]. Lower 4 elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
-/// (converted) elements from \a __A. If corresponding mask bit is set, then
-/// zero is taken instead.
+/// (converted) elements from \a __A. If corresponding mask bit is not set,
+/// then zero is taken instead.
static __inline__ __m128h __DEFAULT_FN_ATTRS128
_mm_maskz_cvtx2ps_ph(__mmask8 __U, __m128 __A, __m128 __B) {
return (__m128h)__builtin_ia32_vcvt2ps2phx128_mask(
@@ -222,13 +222,13 @@ _mm256_mask_cvtx2ps_ph(__m256h __W, __mmask16 __U, __m256 __A, __m256 __B) {
/// \code{.operation]
/// FOR i := 0 to 15
/// IF mask[i]
-/// dst.fp16[i] := 0
-/// ELSE
/// IF i < 8
/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
/// ELSE
/// dst.fp16[i] := convert_fp32_to_fp16(__A.fp32[i - 8])
/// FI
+/// ELSE
+/// dst.fp16[i] := 0
/// FI
/// ENDFOR
/// \endcode
@@ -238,7 +238,7 @@ _mm256_mask_cvtx2ps_ph(__m256h __W, __mmask16 __U, __m256 __A, __m256 __B) {
/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
///
/// \param __U
-/// A 8-bit merging mask.
+/// A 8-bit zeroing mask.
/// \param __A
/// A 256-bit vector of [8 x float].
/// \param __B
@@ -246,8 +246,8 @@ _mm256_mask_cvtx2ps_ph(__m256h __W, __mmask16 __U, __m256 __A, __m256 __B) {
/// \returns
/// A 256-bit vector of [16 x fp16]. Lower 4 elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
-/// (converted) elements from \a __A. If corresponding mask bit is set, then
-/// zero is taken instead.
+/// (converted) elements from \a __A. If corresponding mask bit is not set,
+/// then zero is taken instead.
static __inline__ __m256h __DEFAULT_FN_ATTRS256
_mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
return (__m256h)__builtin_ia32_vcvt2ps2phx256_mask(
@@ -279,7 +279,7 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
/// A 256-bit vector of [8 x float].
/// \param __R
/// Rounding mode. Valid inputs are: _MM_FROUND_CUR_DIRECTION or
-/// result bitwise or of _MM_FROUND_NO_EXC with at most one of the following:
+/// result of bitwise or of _MM_FROUND_NO_EXC with at most one of the following:
/// _MM_FROUND_TO_NEAREST_INT, _MM_FROUND_TO_NEG_INF, _MM_FROUND_TO_POS_INF,
/// _MM_FROUND_TO_ZERO.
/// \returns
@@ -325,7 +325,7 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
/// A 256-bit vector of [8 x float].
/// \param __R
/// Rounding mode. Valid inputs are: _MM_FROUND_CUR_DIRECTION or
-/// result bitwise or of _MM_FROUND_NO_EXC with at most one of the following:
+/// result of bitwise or of _MM_FROUND_NO_EXC with at most one of the following:
/// _MM_FROUND_TO_NEAREST_INT, _MM_FROUND_TO_NEG_INF, _MM_FROUND_TO_POS_INF,
/// _MM_FROUND_TO_ZERO.
/// \returns
@@ -345,13 +345,13 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
/// \code{.operation]
/// FOR i := 0 to 15
/// IF mask[i]
-/// dst.fp16[i] := 0
-/// ELSE
/// IF i < 8
/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
/// ELSE
/// dst.fp16[i] := convert_fp32_to_fp16(__A.fp32[i - 8])
/// FI
+/// ELSE
+/// dst.fp16[i] := 0
/// FI
/// ENDFOR
/// \endcode
@@ -361,21 +361,21 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
///
/// \param __U
-/// A 8-bit merging mask.
+/// A 8-bit zeroing mask.
/// \param __A
/// A 256-bit vector of [8 x float].
/// \param __B
/// A 256-bit vector of [8 x float].
/// \param __R
/// Rounding mode. Valid inputs are: _MM_FROUND_CUR_DIRECTION or
-/// result bitwise or of _MM_FROUND_NO_EXC with at most one of the following:
+/// result of bitwise or of _MM_FROUND_NO_EXC with at most one of the following:
/// _MM_FROUND_TO_NEAREST_INT, _MM_FROUND_TO_NEG_INF, _MM_FROUND_TO_POS_INF,
/// _MM_FROUND_TO_ZERO.
/// \returns
/// A 256-bit vector of [16 x fp16]. Lower 4 elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
-/// (converted) elements from \a __A. If corresponding mask bit is set, then
-/// zero is taken instead.
+/// (converted) elements from \a __A. If corresponding mask bit is not set,
+/// then zero is taken instead.
#define _mm256_maskz_cvtx_round2ps_ph(U, A, B, R) \
((__m256h)__builtin_ia32_vcvt2ps2phx256_mask( \
(__v8sf)(A), (__v8sf)(B), (__v16hf)(_mm256_setzero_ph()), \
@@ -537,18 +537,114 @@ _mm256_maskz_cvtbiassph_phf8(__mmask16 __U, __m256i __A, __m256h __B) {
(__mmask16)__U);
}
+/// Convert two 128-bit vectors, \a __A and \a __B, containing packed
+/// FP16 floating-point elements to a 128-bit vector
+/// containing E5M2 FP8 elements.
+///
+/// \code{.operation]
+/// FOR i := 0 to 16
+/// IF i < 8
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 8])
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A.
static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_pbf8(__m128h __A,
__m128h __B) {
return (__m128i)__builtin_ia32_vcvtne2ph2bf8_128((__v8hf)(__A),
(__v8hf)(__B));
}
+/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 16
+/// IF __U[i]
+/// dst.fp8[i] := __W[i]
+/// ELSE
+/// IF i < 8
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 8])
+/// FI
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __W
+/// A 128-bit vector of [16 x fp8].
+/// \param __U
+/// A 16-bit merging mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtne2ph_pbf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
return (__m128i)__builtin_ia32_selectb_128(
(__mmask16)__U, (__v16qi)_mm_cvtne2ph_pbf8(__A, __B), (__v16qi)__W);
}
+/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
+/// Zeroing mask \a __U is used to determine if given element should be zeroed
+/// instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 16
+/// IF __U[i]
+/// IF i < 8
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 8])
+/// FI
+/// ELSE
+/// dst.fp8[i] := 0
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __U
+/// A 16-bit zeroing mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
+/// zero is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_maskz_cvtne2ph_pbf8(__mmask16 __U, __m128h __A, __m128h __B) {
return (__m128i)__builtin_ia32_selectb_128(
@@ -556,18 +652,114 @@ _mm_maskz_cvtne2ph_pbf8(__mmask16 __U, __m128h __A, __m128h __B) {
(__v16qi)(__m128i)_mm_setzero_si128());
}
+/// Convert two 256-bit vectors, \a __A and \a __B, containing packed
+/// FP16 floating-point elements to a 256-bit vector
+/// containing E5M2 FP8 elements.
+///
+/// \code{.operation]
+/// FOR i := 0 to 32
+/// IF i < 16
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 16])
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x fp16].
+/// \returns
+/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A.
static __inline__ __m256i __DEFAULT_FN_ATTRS256
_mm256_cvtne2ph_pbf8(__m256h __A, __m256h __B) {
return (__m256i)__builtin_ia32_vcvtne2ph2bf8_256((__v16hf)(__A),
(__v16hf)(__B));
}
+/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 32
+/// IF __U[i]
+/// dst.fp8[i] := __W.fp8[i]
+/// ELSE
+/// IF i < 16
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 16])
+/// FI
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __W
+/// A 256-bit vector of [32 x fp8].
+/// \param __U
+/// A 32-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x fp16].
+/// \returns
+/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// element from \a __W is taken instead.
static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtne2ph_pbf8(
__m256i __W, __mmask32 __U, __m256h __A, __m256h __B) {
return (__m256i)__builtin_ia32_selectb_256(
(__mmask16)__U, (__v32qi)_mm256_cvtne2ph_pbf8(__A, __B), (__v32qi)__W);
}
+/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be zeroed
+/// instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 32
+/// IF __U[i]
+/// dst.fp8[i] := 0
+/// ELSE
+/// IF i < 16
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 16])
+/// FI
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __U
+/// A 32-bit zeroing mask.
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x fp16].
+/// \returns
+/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is not set,
+/// then element from \a __W is taken instead.
static __inline__ __m256i __DEFAULT_FN_ATTRS256
_mm256_maskz_cvtne2ph_pbf8(__mmask32 __U, __m256h __A, __m256h __B) {
return (__m256i)__builtin_ia32_selectb_256(
>From f895546ee95495ae6464582510f1e79b30e60948 Mon Sep 17 00:00:00 2001
From: "Pirog, Mikolaj Maciej" <mikolaj.maciej.pirog at intel.com>
Date: Thu, 19 Dec 2024 20:10:03 +0100
Subject: [PATCH 3/9] further work
---
clang/lib/Headers/avx10_2convertintrin.h | 1586 +++++++++++++++++++++-
1 file changed, 1562 insertions(+), 24 deletions(-)
diff --git a/clang/lib/Headers/avx10_2convertintrin.h b/clang/lib/Headers/avx10_2convertintrin.h
index 28e028e906bb66..15c7d9b66f520f 100644
--- a/clang/lib/Headers/avx10_2convertintrin.h
+++ b/clang/lib/Headers/avx10_2convertintrin.h
@@ -381,6 +381,32 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
(__v8sf)(A), (__v8sf)(B), (__v16hf)(_mm256_setzero_ph()), \
(__mmask16)(U), (const int)(R)))
+/// Add two 128-bit vectors, \a __A and \a __B, containing packed
+/// single-precision (32-bit) floating-point elements and 16-bit integers
+/// respectively.
+
+/// \code{.operation]
+/// FOR i := 0 to 7
+/// IF i < 4
+/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
+/// ELSE
+/// dst.fp16[i] := convert_fp32_to_fp16(__A.fp32[i - 4])
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __A
+/// A 128-bit vector of [4 x float].
+/// \param __B
+/// A 128-bit vector of [4 x float].
+/// \returns
+/// A 128-bit vector of [8 x fp16]. Lower 4 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_cvtbiasph_pbf8(__m128i __A, __m128h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2bf8_128_mask(
@@ -537,9 +563,8 @@ _mm256_maskz_cvtbiassph_phf8(__mmask16 __U, __m256i __A, __m256h __B) {
(__mmask16)__U);
}
-/// Convert two 128-bit vectors, \a __A and \a __B, containing packed
-/// FP16 floating-point elements to a 128-bit vector
-/// containing E5M2 FP8 elements.
+/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
///
/// \code{.operation]
/// FOR i := 0 to 16
@@ -575,7 +600,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_pbf8(__m128h __A,
/// from \a __W instead.
///
/// \code{.operation]
-/// FOR i := 0 to 16
+/// FOR i := 0 to 15
/// IF __U[i]
/// dst.fp8[i] := __W[i]
/// ELSE
@@ -652,9 +677,8 @@ _mm_maskz_cvtne2ph_pbf8(__mmask16 __U, __m128h __A, __m128h __B) {
(__v16qi)(__m128i)_mm_setzero_si128());
}
-/// Convert two 256-bit vectors, \a __A and \a __B, containing packed
-/// FP16 floating-point elements to a 256-bit vector
-/// containing E5M2 FP8 elements.
+/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
///
/// \code{.operation]
/// FOR i := 0 to 32
@@ -759,7 +783,7 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtne2ph_pbf8(
/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set,
-/// then element from \a __W is taken instead.
+/// zero is taken instead.
static __inline__ __m256i __DEFAULT_FN_ATTRS256
_mm256_maskz_cvtne2ph_pbf8(__mmask32 __U, __m256h __A, __m256h __B) {
return (__m256i)__builtin_ia32_selectb_256(
@@ -767,18 +791,114 @@ _mm256_maskz_cvtne2ph_pbf8(__mmask32 __U, __m256h __A, __m256h __B) {
(__v32qi)(__m256i)_mm256_setzero_si256());
}
+/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
+/// Resulting elements are saturated in case of overflow.
+///
+/// \code{.operation]
+/// FOR i := 0 to 16
+/// IF i < 8
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 8])
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
+///
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_cvtnes2ph_pbf8(__m128h __A, __m128h __B) {
return (__m128i)__builtin_ia32_vcvtne2ph2bf8s_128((__v8hf)(__A),
(__v8hf)(__B));
}
+/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead. Resulting elements are saturated in case of overflow.
+///
+/// \code{.operation]
+/// FOR i := 0 to 16
+/// IF __U[i]
+/// dst.fp8[i] := __W[i]
+/// ELSE
+/// IF i < 8
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 8])
+/// FI
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __W
+/// A 128-bit vector of [16 x fp8].
+/// \param __U
+/// A 16-bit merging mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtnes2ph_pbf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
return (__m128i)__builtin_ia32_selectb_128(
(__mmask16)__U, (__v16qi)_mm_cvtnes2ph_pbf8(__A, __B), (__v16qi)__W);
}
+/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
+/// Zeroing mask \a __U is used to determine if given element should be zeroed
+/// instead. Resulting elements are saturated in case of overflow.
+///
+/// \code{.operation]
+/// FOR i := 0 to 16
+/// IF __U[i]
+/// IF i < 8
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 8])
+/// FI
+/// ELSE
+/// dst.fp8[i] := 0
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __U
+/// A 16-bit zeroing mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
+/// zero is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_maskz_cvtnes2ph_pbf8(__mmask16 __U, __m128h __A, __m128h __B) {
return (__m128i)__builtin_ia32_selectb_128(
@@ -786,18 +906,114 @@ _mm_maskz_cvtnes2ph_pbf8(__mmask16 __U, __m128h __A, __m128h __B) {
(__v16qi)(__m128i)_mm_setzero_si128());
}
+/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
+/// Resulting elements are saturated in case of overflow.
+///
+/// \code{.operation]
+/// FOR i := 0 to 32
+/// IF i < 16
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 16])
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x fp16].
+/// \returns
+/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A.
static __inline__ __m256i __DEFAULT_FN_ATTRS256
_mm256_cvtnes2ph_pbf8(__m256h __A, __m256h __B) {
return (__m256i)__builtin_ia32_vcvtne2ph2bf8s_256((__v16hf)(__A),
(__v16hf)(__B));
}
+/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead. Resulting elements are saturated in case of overflow.
+///
+/// \code{.operation]
+/// FOR i := 0 to 32
+/// IF __U[i]
+/// dst.fp8[i] := __W.fp8[i]
+/// ELSE
+/// IF i < 16
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 16])
+/// FI
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __W
+/// A 256-bit vector of [32 x fp8].
+/// \param __U
+/// A 32-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x fp16].
+/// \returns
+/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// element from \a __W is taken instead.
static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtnes2ph_pbf8(
__m256i __W, __mmask32 __U, __m256h __A, __m256h __B) {
return (__m256i)__builtin_ia32_selectb_256(
(__mmask16)__U, (__v32qi)_mm256_cvtnes2ph_pbf8(__A, __B), (__v32qi)__W);
}
+/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be zeroed
+/// instead. Resulting elements are saturated in case of overflow.
+///
+/// \code{.operation]
+/// FOR i := 0 to 32
+/// IF __U[i]
+/// dst.fp8[i] := 0
+/// ELSE
+/// IF i < 16
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 16])
+/// FI
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __U
+/// A 32-bit zeroing mask.
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x fp16].
+/// \returns
+/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is not set,
+/// zero is taken instead.
static __inline__ __m256i __DEFAULT_FN_ATTRS256
_mm256_maskz_cvtnes2ph_pbf8(__mmask32 __U, __m256h __A, __m256h __B) {
return (__m256i)__builtin_ia32_selectb_256(
@@ -805,37 +1021,227 @@ _mm256_maskz_cvtnes2ph_pbf8(__mmask32 __U, __m256h __A, __m256h __B) {
(__v32qi)(__m256i)_mm256_setzero_si256());
}
+/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
+///
+/// \code{.operation]
+/// FOR i := 0 to 16
+/// IF i < 8
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 8])
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2HF8 instruction.
+///
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A.
static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_phf8(__m128h __A,
__m128h __B) {
return (__m128i)__builtin_ia32_vcvtne2ph2hf8_128((__v8hf)(__A),
(__v8hf)(__B));
}
-static __inline__ __m128i __DEFAULT_FN_ATTRS128
-_mm_mask_cvtne2ph_phf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
- return (__m128i)__builtin_ia32_selectb_128(
- (__mmask16)__U, (__v16qi)_mm_cvtne2ph_phf8(__A, __B), (__v16qi)__W);
-}
-
-static __inline__ __m128i __DEFAULT_FN_ATTRS128
-_mm_maskz_cvtne2ph_phf8(__mmask16 __U, __m128h __A, __m128h __B) {
- return (__m128i)__builtin_ia32_selectb_128(
- (__mmask16)__U, (__v16qi)_mm_cvtne2ph_phf8(__A, __B),
- (__v16qi)(__m128i)_mm_setzero_si128());
-}
-
-static __inline__ __m256i __DEFAULT_FN_ATTRS256
-_mm256_cvtne2ph_phf8(__m256h __A, __m256h __B) {
- return (__m256i)__builtin_ia32_vcvtne2ph2hf8_256((__v16hf)(__A),
+/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 16
+/// IF __U[i]
+/// dst.fp8[i] := __W[i]
+/// ELSE
+/// IF i < 8
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 8])
+/// FI
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2HF8 instruction.
+///
+/// \param __W
+/// A 128-bit vector of [16 x fp8].
+/// \param __U
+/// A 16-bit merging mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// element from \a __W is taken instead.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_mask_cvtne2ph_phf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
+ return (__m128i)__builtin_ia32_selectb_128(
+ (__mmask16)__U, (__v16qi)_mm_cvtne2ph_phf8(__A, __B), (__v16qi)__W);
+}
+
+/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
+/// Zeroing mask \a __U is used to determine if given element should be zeroed
+/// instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 16
+/// IF __U[i]
+/// IF i < 8
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 8])
+/// FI
+/// ELSE
+/// dst.fp8[i] := 0
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2HF8 instruction.
+///
+/// \param __U
+/// A 16-bit zeroing mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
+/// zero is taken instead.
+static __inline__ __m128i __DEFAULT_FN_ATTRS128
+_mm_maskz_cvtne2ph_phf8(__mmask16 __U, __m128h __A, __m128h __B) {
+ return (__m128i)__builtin_ia32_selectb_128(
+ (__mmask16)__U, (__v16qi)_mm_cvtne2ph_phf8(__A, __B),
+ (__v16qi)(__m128i)_mm_setzero_si128());
+}
+
+/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
+///
+/// \code{.operation]
+/// FOR i := 0 to 32
+/// IF i < 16
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 16])
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2HF8 instruction.
+///
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x fp16].
+/// \returns
+/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A.
+static __inline__ __m256i __DEFAULT_FN_ATTRS256
+_mm256_cvtne2ph_phf8(__m256h __A, __m256h __B) {
+ return (__m256i)__builtin_ia32_vcvtne2ph2hf8_256((__v16hf)(__A),
(__v16hf)(__B));
}
+/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 32
+/// IF __U[i]
+/// dst.fp8[i] := __W.fp8[i]
+/// ELSE
+/// IF i < 16
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 16])
+/// FI
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2HF8 instruction.
+///
+/// \param __W
+/// A 256-bit vector of [32 x fp8].
+/// \param __U
+/// A 32-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x fp16].
+/// \returns
+/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// element from \a __W is taken instead.
static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtne2ph_phf8(
__m256i __W, __mmask32 __U, __m256h __A, __m256h __B) {
return (__m256i)__builtin_ia32_selectb_256(
(__mmask16)__U, (__v32qi)_mm256_cvtne2ph_phf8(__A, __B), (__v32qi)__W);
}
+/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be zeroed
+/// instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 32
+/// IF __U[i]
+/// dst.fp8[i] := 0
+/// ELSE
+/// IF i < 16
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 16])
+/// FI
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __U
+/// A 32-bit zeroing mask.
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x fp16].
+/// \returns
+/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is not set,
+/// zero is taken instead.
static __inline__ __m256i __DEFAULT_FN_ATTRS256
_mm256_maskz_cvtne2ph_phf8(__mmask32 __U, __m256h __A, __m256h __B) {
return (__m256i)__builtin_ia32_selectb_256(
@@ -843,18 +1249,114 @@ _mm256_maskz_cvtne2ph_phf8(__mmask32 __U, __m256h __A, __m256h __B) {
(__v32qi)(__m256i)_mm256_setzero_si256());
}
+/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
+/// Resulting elements are saturated in case of overflow.
+///
+/// \code{.operation]
+/// FOR i := 0 to 16
+/// IF i < 8
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 8])
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
+///
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_cvtnes2ph_phf8(__m128h __A, __m128h __B) {
return (__m128i)__builtin_ia32_vcvtne2ph2hf8s_128((__v8hf)(__A),
(__v8hf)(__B));
}
+/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead. Resulting elements are saturated in case of overflow.
+///
+/// \code{.operation]
+/// FOR i := 0 to 16
+/// IF __U[i]
+/// dst.fp8[i] := __W[i]
+/// ELSE
+/// IF i < 8
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 8])
+/// FI
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __W
+/// A 128-bit vector of [16 x fp8].
+/// \param __U
+/// A 16-bit merging mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtnes2ph_phf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
return (__m128i)__builtin_ia32_selectb_128(
(__mmask16)__U, (__v16qi)_mm_cvtnes2ph_phf8(__A, __B), (__v16qi)__W);
}
+/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
+/// Zeroing mask \a __U is used to determine if given element should be zeroed
+/// instead. Resulting elements are saturated in case of overflow.
+///
+/// \code{.operation]
+/// FOR i := 0 to 16
+/// IF __U[i]
+/// IF i < 8
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 8])
+/// FI
+/// ELSE
+/// dst.fp8[i] := 0
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __U
+/// A 16-bit zeroing mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
+/// zero is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_maskz_cvtnes2ph_phf8(__mmask16 __U, __m128h __A, __m128h __B) {
return (__m128i)__builtin_ia32_selectb_128(
@@ -862,18 +1364,114 @@ _mm_maskz_cvtnes2ph_phf8(__mmask16 __U, __m128h __A, __m128h __B) {
(__v16qi)(__m128i)_mm_setzero_si128());
}
+/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
+/// Resulting elements are saturated in case of overflow.
+///
+/// \code{.operation]
+/// FOR i := 0 to 32
+/// IF i < 16
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 16])
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x fp16].
+/// \returns
+/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A.
static __inline__ __m256i __DEFAULT_FN_ATTRS256
_mm256_cvtnes2ph_phf8(__m256h __A, __m256h __B) {
return (__m256i)__builtin_ia32_vcvtne2ph2hf8s_256((__v16hf)(__A),
(__v16hf)(__B));
}
+/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead. Resulting elements are saturated in case of overflow.
+///
+/// \code{.operation]
+/// FOR i := 0 to 32
+/// IF __U[i]
+/// dst.fp8[i] := __W.fp8[i]
+/// ELSE
+/// IF i < 16
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 16])
+/// FI
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __W
+/// A 256-bit vector of [32 x fp8].
+/// \param __U
+/// A 32-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x fp16].
+/// \returns
+/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// element from \a __W is taken instead.
static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtnes2ph_phf8(
__m256i __W, __mmask32 __U, __m256h __A, __m256h __B) {
return (__m256i)__builtin_ia32_selectb_256(
(__mmask16)__U, (__v32qi)_mm256_cvtnes2ph_phf8(__A, __B), (__v32qi)__W);
}
+/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be zeroed
+/// instead. Resulting elements are saturated in case of overflow.
+///
+/// \code{.operation]
+/// FOR i := 0 to 32
+/// IF __U[i]
+/// dst.fp8[i] := 0
+/// ELSE
+/// IF i < 16
+/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 16])
+/// FI
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __U
+/// A 32-bit zeroing mask.
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x fp16].
+/// \returns
+/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// (converted) elements from \a __B; higher order elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is not set,
+/// zero is taken instead.
static __inline__ __m256i __DEFAULT_FN_ATTRS256
_mm256_maskz_cvtnes2ph_phf8(__mmask32 __U, __m256h __A, __m256h __B) {
return (__m256i)__builtin_ia32_selectb_256(
@@ -881,206 +1479,1146 @@ _mm256_maskz_cvtnes2ph_phf8(__mmask32 __U, __m256h __A, __m256h __B) {
(__v32qi)(__m256i)_mm256_setzero_si256());
}
+/// Convert 128-bit vector \a __A, containing packed FP8 E4M3 floating-point
+/// elements to a 128-bit vector containing FP16 elements. The conversion is exact.
+///
+/// \code{.operation]
+/// FOR i := 0 to 7
+/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF82PH instruction.
+///
+/// \param __A
+/// A 128-bit vector of [16 x fp8].
+/// \returns
+/// A 128-bit vector of [8 x fp16]. Resulting elements correspond to the
+/// (converted) elements from \a __A.
static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtnehf8_ph(__m128i __A) {
return (__m128h)__builtin_ia32_vcvthf8_2ph128_mask(
(__v16qi)__A, (__v8hf)(__m128h)_mm_undefined_ph(), (__mmask8)-1);
}
+/// Convert 128-bit vector \a __A, containing packed FP8 E4M3 floating-point
+/// elements to a 128-bit vector containing FP16 elements. The conversion is
+/// exact. Merging mask \a __U is used to determine if given element should be
+/// taken from \a __W instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 7
+/// IF __U[i]
+/// dst.fp16[i] := __W[i]
+/// ELSE
+/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF82PH instruction.
+///
+/// \param __W
+/// A 128-bit vector of [8 x fp16].
+/// \param __U
+/// A 8-bit merging mask.
+/// \param __A
+/// A 128-bit vector of [16 x fp8].
+/// \returns
+/// A 128-bit vector of [8 x fp16]. Resulting elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// element from \a __W is taken instead.
static __inline__ __m128h __DEFAULT_FN_ATTRS128
_mm_mask_cvtnehf8_ph(__m128h __W, __mmask8 __U, __m128i __A) {
return (__m128h)__builtin_ia32_vcvthf8_2ph128_mask(
(__v16qi)__A, (__v8hf)(__m128h)__W, (__mmask8)__U);
}
+/// Convert 128-bit vector \a __A, containing packed FP8 E4M3 floating-point
+/// elements to a 128-bit vector containing FP16 elements. The conversion is
+/// exact. Zeroing mask \a __U is used to determine if given element should be
+/// zeroed instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 7
+/// IF __U[i]
+/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
+/// ELSE
+/// dst.fp16[i] := 0
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF82PH instruction.
+///
+/// \param __U
+/// A 8-bit zeroing mask.
+/// \param __A
+/// A 128-bit vector of [16 x fp8].
+/// \returns
+/// A 128-bit vector of [8 x fp16]. Resulting elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
+/// zero is taken instead.
static __inline__ __m128h __DEFAULT_FN_ATTRS128
_mm_maskz_cvtnehf8_ph(__mmask8 __U, __m128i __A) {
return (__m128h)__builtin_ia32_vcvthf8_2ph128_mask(
(__v16qi)__A, (__v8hf)(__m128h)_mm_setzero_ph(), (__mmask8)__U);
}
+/// Convert 256-bit vector \a __A, containing packed FP8 E4M3 floating-point
+/// elements to a 256-bit vector containing FP16 elements. The conversion is exact.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF82PH instruction.
+///
+/// \param __A
+/// A 256-bit vector of [32 x fp8].
+/// \returns
+/// A 256-bit vector of [16 x fp16]. Resulting elements correspond to the
+/// (converted) elements from \a __A.
static __inline__ __m256h __DEFAULT_FN_ATTRS256
_mm256_cvtnehf8_ph(__m128i __A) {
return (__m256h)__builtin_ia32_vcvthf8_2ph256_mask(
(__v16qi)__A, (__v16hf)(__m256h)_mm256_undefined_ph(), (__mmask16)-1);
}
+/// Convert 256-bit vector \a __A, containing packed FP8 E4M3 floating-point
+/// elements to a 256-bit vector containing FP16 elements. The conversion is
+/// exact. Merging mask \a __U is used to determine if given element should be
+/// taken from \a __W instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// IF __U[i]
+/// dst.fp16[i] := __W[i]
+/// ELSE
+/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF82PH instruction.
+///
+/// \param __W
+/// A 256-bit vector of [16 x fp16].
+/// \param __U
+/// A 16-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [32 x fp8].
+/// \returns
+/// A 256-bit vector of [16 x fp16]. Resulting elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// element from \a __W is taken instead.
static __inline__ __m256h __DEFAULT_FN_ATTRS256
_mm256_mask_cvtnehf8_ph(__m256h __W, __mmask16 __U, __m128i __A) {
return (__m256h)__builtin_ia32_vcvthf8_2ph256_mask(
(__v16qi)__A, (__v16hf)(__m256h)__W, (__mmask16)__U);
}
+/// Convert 256-bit vector \a __A, containing packed FP8 E4M3 floating-point
+/// elements to a 256-bit vector containing FP16 elements. The conversion is
+/// exact. Zeroing mask \a __U is used to determine if given element should be
+/// zeroed instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// IF __U[i]
+/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
+/// ELSE
+/// dst.fp16[i] := 0
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF82PH instruction.
+///
+/// \param __U
+/// A 16-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [32 x fp8].
+/// \returns
+/// A 256-bit vector of [16 x fp16]. Resulting elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
+/// zero is taken instead.
static __inline__ __m256h __DEFAULT_FN_ATTRS256
_mm256_maskz_cvtnehf8_ph(__mmask16 __U, __m128i __A) {
return (__m256h)__builtin_ia32_vcvthf8_2ph256_mask(
(__v16qi)__A, (__v16hf)(__m256h)_mm256_setzero_ph(), (__mmask16)__U);
}
+/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
+/// resulting vector are zeroed.
+///
+/// \code{.operation]
+/// FOR i := 0 to 7
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the (converted)
+/// elements from \a __A; upper elements are zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtneph_pbf8(__m128h __A) {
return (__m128i)__builtin_ia32_vcvtneph2bf8_128_mask(
(__v8hf)__A, (__v16qi)(__m128i)_mm_undefined_si128(), (__mmask8)-1);
}
+/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
+/// resulting vector are zeroed. Merging mask \a __U is used to determine if
+/// given element should be taken from \a __W instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 7
+/// IF __U[i]
+/// dst.fp8[i] := __W[i]
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// FI
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __W
+/// A 128-bit vector of [16 x fp8].
+/// \param __U
+/// A 8-bit merging mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+///
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// (converted) elements from \a __A; upper elements are zeroed. If
+/// corresponding mask bit is set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtneph_pbf8(__m128i __W, __mmask8 __U, __m128h __A) {
return (__m128i)__builtin_ia32_vcvtneph2bf8_128_mask(
(__v8hf)__A, (__v16qi)(__m128i)__W, (__mmask8)__U);
}
+/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
+/// resulting vector are zeroed. Zeroing mask \a __U is used to determine if
+/// given element should be zeroed instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 7
+/// IF __U[i]
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ELSE
+/// dst.fp8[i] := 0
+/// FI
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __U
+/// A 8-bit merging mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+///
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// (converted) elements from \a __A; upper elements are zeroed. If
+/// corresponding mask bit is not set, then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_maskz_cvtneph_pbf8(__mmask8 __U, __m128h __A) {
return (__m128i)__builtin_ia32_vcvtneph2bf8_128_mask(
(__v8hf)__A, (__v16qi)(__m128i)_mm_setzero_si128(), (__mmask8)__U);
}
+/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E5M2 FP8 elements.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ENDFOR
+///
+/// dst[255:128] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the (converted)
+/// elements from \a __A.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_cvtneph_pbf8(__m256h __A) {
return (__m128i)__builtin_ia32_vcvtneph2bf8_256_mask(
(__v16hf)__A, (__v16qi)(__m128i)_mm_undefined_si128(), (__mmask16)-1);
}
+/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E5M2 FP8 elements. Merging mask \a __U is
+/// used to determine if given element should be taken from \a __W instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// IF __U[i]
+/// dst.fp8[i] := __W[i]
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// FI
+/// ENDFOR
+///
+/// dst[255:128] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __W
+/// A 128-bit vector of [16 x fp8].
+/// \param __U
+/// A 16-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the
+/// (converted) elements from \a __A. If
+/// corresponding mask bit is set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_mask_cvtneph_pbf8(__m128i __W, __mmask16 __U, __m256h __A) {
return (__m128i)__builtin_ia32_vcvtneph2bf8_256_mask(
(__v16hf)__A, (__v16qi)(__m128i)__W, (__mmask16)__U);
}
+/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E5M2 FP8 elements. Zeroing mask \a __U is
+/// used to determine if given element should be zeroed instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// IF __U[i]
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ELSE
+/// dst.fp8[i] := 0
+/// FI
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __U
+/// A 16-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is not set,
+/// then element is zeroed instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_maskz_cvtneph_pbf8(__mmask16 __U, __m256h __A) {
return (__m128i)__builtin_ia32_vcvtneph2bf8_256_mask(
(__v16hf)__A, (__v16qi)(__m128i)_mm_setzero_si128(), (__mmask16)__U);
}
+/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
+/// resulting vector are zeroed. Results are saturated.
+///
+/// \code{.operation]
+/// FOR i := 0 to 7
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the (converted)
+/// elements from \a __A; upper elements are zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtnesph_pbf8(__m128h __A) {
return (__m128i)__builtin_ia32_vcvtneph2bf8s_128_mask(
(__v8hf)__A, (__v16qi)(__m128i)_mm_undefined_si128(), (__mmask8)-1);
}
+/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
+/// resulting vector are zeroed. Results are saturated. Merging mask \a __U is
+/// used to determine if given element should be taken from \a __W instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 7
+/// IF __U[i]
+/// dst.fp8[i] := __W[i]
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// FI
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __W
+/// A 128-bit vector of [16 x fp8].
+/// \param __U
+/// A 8-bit merging mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// (converted) elements from \a __A; upper elements are zeroed. If
+/// corresponding mask bit is set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtnesph_pbf8(__m128i __W, __mmask8 __U, __m128h __A) {
return (__m128i)__builtin_ia32_vcvtneph2bf8s_128_mask(
(__v8hf)__A, (__v16qi)(__m128i)__W, (__mmask8)__U);
}
+/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
+/// resulting vector are zeroed. Results are saturated. Zeroing mask \a __U is
+/// used to determine if given element should be zeroed instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 7
+/// IF __U[i]
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ELSE
+/// dst.fp8[i] := 0
+/// FI
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __U
+/// A 8-bit merging mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// (converted) elements from \a __A; upper elements are zeroed. If
+/// corresponding mask bit is not set, then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_maskz_cvtnesph_pbf8(__mmask8 __U, __m128h __A) {
return (__m128i)__builtin_ia32_vcvtneph2bf8s_128_mask(
(__v8hf)__A, (__v16qi)(__m128i)_mm_setzero_si128(), (__mmask8)__U);
}
+/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E5M2 FP8 elements. Results are saturated.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ENDFOR
+///
+/// dst[255:128] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the (converted)
+/// elements from \a __A.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_cvtnesph_pbf8(__m256h __A) {
return (__m128i)__builtin_ia32_vcvtneph2bf8s_256_mask(
(__v16hf)__A, (__v16qi)(__m128i)_mm_undefined_si128(), (__mmask16)-1);
}
+/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E5M2 FP8 elements. Results are saturated.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// IF __U[i]
+/// dst.fp8[i] := __W[i]
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// FI
+/// ENDFOR
+///
+/// dst[255:128] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __W
+/// A 128-bit vector of [16 x fp8].
+/// \param __U
+/// A 16-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the
+/// (converted) elements from \a __A. If
+/// corresponding mask bit is set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_mask_cvtnesph_pbf8(__m128i __W, __mmask16 __U, __m256h __A) {
return (__m128i)__builtin_ia32_vcvtneph2bf8s_256_mask(
(__v16hf)__A, (__v16qi)(__m128i)__W, (__mmask16)__U);
}
+/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E5M2 FP8 elements. Results are saturated.
+/// Zeroing mask \a __U is used to determine if given element should be zeroed
+/// instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// IF __U[i]
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ELSE
+/// dst.fp8[i] := 0
+/// FI
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __U
+/// A 16-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is not set,
+/// then element is zeroed instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_maskz_cvtnesph_pbf8(__mmask16 __U, __m256h __A) {
return (__m128i)__builtin_ia32_vcvtneph2bf8s_256_mask(
(__v16hf)__A, (__v16qi)(__m128i)_mm_setzero_si128(), (__mmask16)__U);
}
+/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
+/// resulting vector are zeroed.
+///
+/// \code{.operation]
+/// FOR i := 0 to 7
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the (converted)
+/// elements from \a __A; upper elements are zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtneph_phf8(__m128h __A) {
return (__m128i)__builtin_ia32_vcvtneph2hf8_128_mask(
(__v8hf)__A, (__v16qi)(__m128i)_mm_undefined_si128(), (__mmask8)-1);
}
+/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E4M3 FP8 elements. Upper elements of
+/// resulting vector are zeroed. Merging mask \a __U is used to determine if
+/// given element should be taken from \a __W instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 7
+/// IF __U[i]
+/// dst.fp8[i] := __W[i]
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// FI
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __W
+/// A 128-bit vector of [16 x fp8].
+/// \param __U
+/// A 8-bit merging mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+///
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// (converted) elements from \a __A; upper elements are zeroed. If
+/// corresponding mask bit is set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtneph_phf8(__m128i __W, __mmask8 __U, __m128h __A) {
return (__m128i)__builtin_ia32_vcvtneph2hf8_128_mask(
(__v8hf)__A, (__v16qi)(__m128i)__W, (__mmask8)__U);
}
+/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E4M3 FP8 elements. Upper elements of
+/// resulting vector are zeroed. Zeroing mask \a __U is used to determine if
+/// given element should be zeroed instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 7
+/// IF __U[i]
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ELSE
+/// dst.fp8[i] := 0
+/// FI
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __U
+/// A 8-bit merging mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+///
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// (converted) elements from \a __A; upper elements are zeroed. If
+/// corresponding mask bit is not set, then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_maskz_cvtneph_phf8(__mmask8 __U, __m128h __A) {
return (__m128i)__builtin_ia32_vcvtneph2hf8_128_mask(
(__v8hf)__A, (__v16qi)(__m128i)_mm_setzero_si128(), (__mmask8)__U);
}
+/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E4M3 FP8 elements.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ENDFOR
+///
+/// dst[255:128] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the (converted)
+/// elements from \a __A.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_cvtneph_phf8(__m256h __A) {
return (__m128i)__builtin_ia32_vcvtneph2hf8_256_mask(
(__v16hf)__A, (__v16qi)(__m128i)_mm_undefined_si128(), (__mmask16)-1);
}
+/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E4M3 FP8 elements. Merging mask \a __U is
+/// used to determine if given element should be taken from \a __W instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// IF __U[i]
+/// dst.fp8[i] := __W[i]
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// FI
+/// ENDFOR
+///
+/// dst[255:128] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __W
+/// A 128-bit vector of [16 x fp8].
+/// \param __U
+/// A 16-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the
+/// (converted) elements from \a __A. If
+/// corresponding mask bit is set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_mask_cvtneph_phf8(__m128i __W, __mmask16 __U, __m256h __A) {
return (__m128i)__builtin_ia32_vcvtneph2hf8_256_mask(
(__v16hf)__A, (__v16qi)(__m128i)__W, (__mmask16)__U);
}
+/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E4M3 FP8 elements. Zeroing mask \a __U is
+/// used to determine if given element should be zeroed instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// IF __U[i]
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ELSE
+/// dst.fp8[i] := 0
+/// FI
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __U
+/// A 16-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is not set,
+/// then element is zeroed instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_maskz_cvtneph_phf8(__mmask16 __U, __m256h __A) {
return (__m128i)__builtin_ia32_vcvtneph2hf8_256_mask(
(__v16hf)__A, (__v16qi)(__m128i)_mm_setzero_si128(), (__mmask16)__U);
}
+/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E4M3 FP8 elements. Upper elements of
+/// resulting vector are zeroed. Results are saturated.
+///
+/// \code{.operation]
+/// FOR i := 0 to 7
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the (converted)
+/// elements from \a __A; upper elements are zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtnesph_phf8(__m128h __A) {
return (__m128i)__builtin_ia32_vcvtneph2hf8s_128_mask(
(__v8hf)__A, (__v16qi)(__m128i)_mm_undefined_si128(), (__mmask8)-1);
}
+/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E4M3 FP8 elements. Upper elements of
+/// resulting vector are zeroed. Results are saturated. Merging mask \a __U is
+/// used to determine if given element should be taken from \a __W instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 7
+/// IF __U[i]
+/// dst.fp8[i] := __W[i]
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// FI
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __W
+/// A 128-bit vector of [16 x fp8].
+/// \param __U
+/// A 8-bit merging mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// (converted) elements from \a __A; upper elements are zeroed. If
+/// corresponding mask bit is set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtnesph_phf8(__m128i __W, __mmask8 __U, __m128h __A) {
return (__m128i)__builtin_ia32_vcvtneph2hf8s_128_mask(
(__v8hf)__A, (__v16qi)(__m128i)__W, (__mmask8)__U);
}
+/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E4M3 FP8 elements. Upper elements of
+/// resulting vector are zeroed. Results are saturated. Zeroing mask \a __U is
+/// used to determine if given element should be zeroed instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 7
+/// IF __U[i]
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ELSE
+/// dst.fp8[i] := 0
+/// FI
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __U
+/// A 8-bit merging mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// (converted) elements from \a __A; upper elements are zeroed. If
+/// corresponding mask bit is not set, then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_maskz_cvtnesph_phf8(__mmask8 __U, __m128h __A) {
return (__m128i)__builtin_ia32_vcvtneph2hf8s_128_mask(
(__v8hf)__A, (__v16qi)(__m128i)_mm_setzero_si128(), (__mmask8)__U);
}
+/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E4M3 FP8 elements. Results are saturated.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ENDFOR
+///
+/// dst[255:128] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the (converted)
+/// elements from \a __A.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_cvtnesph_phf8(__m256h __A) {
return (__m128i)__builtin_ia32_vcvtneph2hf8s_256_mask(
(__v16hf)__A, (__v16qi)(__m128i)_mm_undefined_si128(), (__mmask16)-1);
}
+/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E4M3 FP8 elements. Results are saturated.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// IF __U[i]
+/// dst.fp8[i] := __W[i]
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// FI
+/// ENDFOR
+///
+/// dst[255:128] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __W
+/// A 128-bit vector of [16 x fp8].
+/// \param __U
+/// A 16-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [8 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the
+/// (converted) elements from \a __A. If
+/// corresponding mask bit is set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_mask_cvtnesph_phf8(__m128i __W, __mmask16 __U, __m256h __A) {
return (__m128i)__builtin_ia32_vcvtneph2hf8s_256_mask(
(__v16hf)__A, (__v16qi)(__m128i)__W, (__mmask16)__U);
}
+/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
+/// to a 128-bit vector containing E4M3 FP8 elements. Results are saturated.
+/// Zeroing mask \a __U is used to determine if given element should be zeroed
+/// instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// IF __U[i]
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ELSE
+/// dst.fp8[i] := 0
+/// FI
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+///
+/// \param __U
+/// A 16-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is not set,
+/// then element is zeroed instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_maskz_cvtnesph_phf8(__mmask16 __U, __m256h __A) {
return (__m128i)__builtin_ia32_vcvtneph2hf8s_256_mask(
(__v16hf)__A, (__v16qi)(__m128i)_mm_setzero_si128(), (__mmask16)__U);
}
+/// Convert 128-bit vector \a __A, containing packed FP8 E5M2 floating-point
+/// elements to a 128-bit vector containing FP16 elements. The conversion is exact.
+///
+/// \code{.operation]
+/// FOR i := 0 to 7
+/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF82PH instruction.
+///
+/// \param __A
+/// A 128-bit vector of [16 x fp8].
+/// \returns
+/// A 128-bit vector of [8 x fp16]. Resulting elements correspond to the
+/// (converted) elements from \a __A.
static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtpbf8_ph(__m128i __A) {
return _mm_castsi128_ph(_mm_slli_epi16(_mm_cvtepi8_epi16(__A), 8));
}
+/// Convert 128-bit vector \a __A, containing packed FP8 E5M2 floating-point
+/// elements to a 128-bit vector containing FP16 elements. The conversion is
+/// exact. Merging mask \a __U is used to determine if given element should be
+/// taken from \a __W instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 7
+/// IF __U[i]
+/// dst.fp16[i] := __W[i]
+/// ELSE
+/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF82PH instruction.
+///
+/// \param __W
+/// A 128-bit vector of [8 x fp16].
+/// \param __U
+/// A 8-bit merging mask.
+/// \param __A
+/// A 128-bit vector of [16 x fp8].
+/// \returns
+/// A 128-bit vector of [8 x fp16]. Resulting elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// element from \a __W is taken instead.
static __inline__ __m128h __DEFAULT_FN_ATTRS128
_mm_mask_cvtpbf8_ph(__m128h __S, __mmask8 __U, __m128i __A) {
return _mm_castsi128_ph(
_mm_mask_slli_epi16((__m128i)__S, __U, _mm_cvtepi8_epi16(__A), 8));
}
+/// Convert 128-bit vector \a __A, containing packed FP8 E5M2 floating-point
+/// elements to a 128-bit vector containing FP16 elements. The conversion is
+/// exact. Zeroing mask \a __U is used to determine if given element should be
+/// zeroed instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 7
+/// IF __U[i]
+/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
+/// ELSE
+/// dst.fp16[i] := 0
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF82PH instruction.
+///
+/// \param __U
+/// A 8-bit zeroing mask.
+/// \param __A
+/// A 128-bit vector of [16 x fp8].
+/// \returns
+/// A 128-bit vector of [8 x fp16]. Resulting elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
+/// zero is taken instead.
static __inline__ __m128h __DEFAULT_FN_ATTRS128
_mm_maskz_cvtpbf8_ph(__mmask8 __U, __m128i __A) {
return _mm_castsi128_ph(_mm_slli_epi16(_mm_maskz_cvtepi8_epi16(__U, __A), 8));
}
+/// Convert 256-bit vector \a __A, containing packed FP8 E4M3 floating-point
+/// elements to a 256-bit vector containing FP16 elements. The conversion is exact.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF82PH instruction.
+///
+/// \param __A
+/// A 256-bit vector of [32 x fp8].
+/// \returns
+/// A 256-bit vector of [16 x fp16]. Resulting elements correspond to the
+/// (converted) elements from \a __A.
static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_cvtpbf8_ph(__m128i __A) {
return _mm256_castsi256_ph(_mm256_slli_epi16(_mm256_cvtepi8_epi16(__A), 8));
}
+/// Convert 256-bit vector \a __A, containing packed FP8 E5M2 floating-point
+/// elements to a 256-bit vector containing FP16 elements. The conversion is
+/// exact. Merging mask \a __U is used to determine if given element should be
+/// taken from \a __W instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// IF __U[i]
+/// dst.fp16[i] := __W[i]
+/// ELSE
+/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF82PH instruction.
+///
+/// \param __W
+/// A 256-bit vector of [16 x fp16].
+/// \param __U
+/// A 16-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [32 x fp8].
+/// \returns
+/// A 256-bit vector of [16 x fp16]. Resulting elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// element from \a __W is taken instead.
static __inline__ __m256h __DEFAULT_FN_ATTRS256
_mm256_mask_cvtpbf8_ph(__m256h __S, __mmask8 __U, __m128i __A) {
return _mm256_castsi256_ph(
_mm256_mask_slli_epi16((__m256i)__S, __U, _mm256_cvtepi8_epi16(__A), 8));
}
+/// Convert 256-bit vector \a __A, containing packed FP8 E5M2 floating-point
+/// elements to a 256-bit vector containing FP16 elements. The conversion is
+/// exact. Zeroing mask \a __U is used to determine if given element should be
+/// zeroed instead.
+///
+/// \code{.operation]
+/// FOR i := 0 to 15
+/// IF __U[i]
+/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
+/// ELSE
+/// dst.fp16[i] := 0
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVTHF82PH instruction.
+///
+/// \param __U
+/// A 16-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [32 x fp8].
+/// \returns
+/// A 256-bit vector of [16 x fp16]. Resulting elements correspond to the
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
+/// zero is taken instead.
static __inline__ __m256h __DEFAULT_FN_ATTRS256
_mm256_maskz_cvtpbf8_ph(__mmask8 __U, __m128i __A) {
return _mm256_castsi256_ph(
>From 99ff5fe6607836cc0b39d4794fd7d932398e7bd6 Mon Sep 17 00:00:00 2001
From: "Pirog, Mikolaj Maciej" <mikolaj.maciej.pirog at intel.com>
Date: Fri, 20 Dec 2024 14:44:14 +0100
Subject: [PATCH 4/9] further work
---
clang/lib/Headers/avx10_2convertintrin.h | 837 ++++++++++++++++++++---
1 file changed, 751 insertions(+), 86 deletions(-)
diff --git a/clang/lib/Headers/avx10_2convertintrin.h b/clang/lib/Headers/avx10_2convertintrin.h
index 15c7d9b66f520f..341dc9cfd6aae3 100644
--- a/clang/lib/Headers/avx10_2convertintrin.h
+++ b/clang/lib/Headers/avx10_2convertintrin.h
@@ -28,7 +28,7 @@
/// single-precision (32-bit) floating-point elements to a 128-bit vector
/// containing FP16 elements.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 7
/// IF i < 4
/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
@@ -61,7 +61,7 @@ static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtx2ps_ph(__m128 __A,
/// containing FP16 elements. Merging mask \a __U is used to determine if given
/// element should be taken from \a __W instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 7
/// IF mask[i]
/// dst.fp16[i] := __W[i]
@@ -103,7 +103,7 @@ _mm_mask_cvtx2ps_ph(__m128h __W, __mmask8 __U, __m128 __A, __m128 __B) {
/// containing FP16 elements. Zeroing mask \a __U is used to determine if given
/// element should be zeroed instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 7
/// IF mask[i]
/// IF i < 4
@@ -142,7 +142,7 @@ _mm_maskz_cvtx2ps_ph(__mmask8 __U, __m128 __A, __m128 __B) {
/// single-precision (32-bit) floating-point elements to a 256-bit vector
/// containing FP16 elements.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// IF i < 8
/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
@@ -176,7 +176,7 @@ static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_cvtx2ps_ph(__m256 __A,
/// containing FP16 elements. Merging mask \a __U is used to determine if given
/// element should be taken from \a __W instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// IF mask[i]
/// dst.fp16[i] := __W[i]
@@ -219,7 +219,7 @@ _mm256_mask_cvtx2ps_ph(__m256h __W, __mmask16 __U, __m256 __A, __m256 __B) {
/// containing FP16 elements. Zeroing mask \a __U is used to determine if given
/// element should be zeroed instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// IF mask[i]
/// IF i < 8
@@ -259,7 +259,7 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
/// single-precision (32-bit) floating-point elements to a 256-bit vector
/// containing FP16 elements. Rounding mode \a __R needs to be provided.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// IF i < 8
/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
@@ -297,7 +297,7 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
/// element should be taken from \a __W instead. Rounding mode \a __R needs to
/// be provided.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// IF mask[i]
/// dst.fp16[i] := __W[i]
@@ -342,7 +342,7 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
/// containing FP16 elements. Zeroing mask \a __U is used to determine if given
/// element should be zeroed instead. Rounding mode \a __R needs to be provided.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// IF mask[i]
/// IF i < 8
@@ -381,18 +381,16 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
(__v8sf)(A), (__v8sf)(B), (__v16hf)(_mm256_setzero_ph()), \
(__mmask16)(U), (const int)(R)))
-/// Add two 128-bit vectors, \a __A and \a __B, containing packed
-/// single-precision (32-bit) floating-point elements and 16-bit integers
-/// respectively.
-
-/// \code{.operation]
+/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+///
+/// \code{.operation}
/// FOR i := 0 to 7
-/// IF i < 4
-/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
-/// ELSE
-/// dst.fp16[i] := convert_fp32_to_fp16(__A.fp32[i - 4])
-/// FI
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
/// ENDFOR
+///
+/// dst[127:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -400,25 +398,90 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
///
/// \param __A
-/// A 128-bit vector of [4 x float].
+/// A 128-bit vector of [8 x fp16].
/// \param __B
-/// A 128-bit vector of [4 x float].
+/// A 128-bit vector of [8 x int16].
/// \returns
-/// A 128-bit vector of [8 x fp16]. Lower 4 elements correspond to the
-/// (converted) elements from \a __B; higher order elements correspond to the
-/// (converted) elements from \a __A.
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// sum of elements from \a __A and \a __B; higher order elements are zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_cvtbiasph_pbf8(__m128i __A, __m128h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2bf8_128_mask(
(__v16qi)__A, (__v8hf)__B, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
}
+/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
+///
+/// \code{.operation}
+/// FOR i := 0 to 7
+/// IF __U[i]
+/// dst.fp8[i] := _W[i]
+/// ELSE
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// FI
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __W
+/// A 128-bit vector of [16 x fp8].
+/// \param __U
+/// A 8-bit merging mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the sum of
+/// elements from \a __A and \a __B; higher order elements are zeroed. If
+/// corresponding mask bit is set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtbiasph_pbf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2bf8_128_mask(
(__v16qi)__A, (__v8hf)__B, (__v16qi)(__m128i)__W, (__mmask8)__U);
}
+/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+/// Zeroing mask \a __U is used to determine if given element should be zeroed
+/// instead.
+///
+/// \code{.operation}
+/// FOR i := 0 to 7
+/// IF __U[i]
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ELSE
+/// dst.fp8[i] := 0
+/// FI
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __U
+/// A 8-bit zeroing mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the sum of
+/// elements from \a __A and \a __B; higher order elements are zeroed. If
+/// corresponding mask bit is not set, then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_maskz_cvtbiasph_pbf8(__mmask8 __U, __m128i __A, __m128h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2bf8_128_mask(
@@ -426,6 +489,27 @@ _mm_maskz_cvtbiasph_pbf8(__mmask8 __U, __m128i __A, __m128h __B) {
(__mmask8)__U);
}
+/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+///
+/// \code{.operation}
+/// FOR i := 0 to 15
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Elements correspond to the
+/// sum of elements from \a __A and \a __B.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_cvtbiasph_pbf8(__m256i __A, __m256h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2bf8_256_mask(
@@ -433,12 +517,74 @@ _mm256_cvtbiasph_pbf8(__m256i __A, __m256h __B) {
(__mmask16)-1);
}
+/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
+///
+/// \code{.operation}
+/// FOR i := 0 to 15
+/// IF __U[i]
+/// dst.fp8[i] := _W[i]
+/// ELSE
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __W
+/// A 128-bit vector of [16 x fp8].
+/// \param __U
+/// A 16-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Elements correspond to the sum of
+/// elements from \a __A and \a __B. If corresponding mask bit is set, then
+/// element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiasph_pbf8(
__m128i __W, __mmask16 __U, __m256i __A, __m256h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2bf8_256_mask(
(__v32qi)__A, (__v16hf)__B, (__v16qi)(__m128i)__W, (__mmask16)__U);
}
+/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
+///
+/// \code{.operation}
+/// FOR i := 0 to 15
+/// IF __U[i]
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ELSE
+/// dst.fp8[i] := 0
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __U
+/// A 16-bit zeroing mask.
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Elements correspond to the sum of
+/// elements from \a __A and \a __B. If corresponding mask bit is not set,
+/// then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_maskz_cvtbiasph_pbf8(__mmask16 __U, __m256i __A, __m256h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2bf8_256_mask(
@@ -446,18 +592,108 @@ _mm256_maskz_cvtbiasph_pbf8(__mmask16 __U, __m256i __A, __m256h __B) {
(__mmask16)__U);
}
+/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+/// Results are saturated.
+///
+/// \code{.operation}
+/// FOR i := 0 to 7
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// sum of elements from \a __A and \a __B; higher order elements are zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_cvtbiassph_pbf8(__m128i __A, __m128h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2bf8s_128_mask(
(__v16qi)__A, (__v8hf)__B, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
}
+/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+/// Results are saturated. Merging mask \a __U is used to determine if given
+/// element should be taken from \a __W instead.
+///
+/// \code{.operation}
+/// FOR i := 0 to 7
+/// IF __U[i]
+/// dst.fp8[i] := _W[i]
+/// ELSE
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// FI
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __W
+/// A 128-bit vector of [16 x fp8].
+/// \param __U
+/// A 8-bit merging mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the sum of
+/// elements from \a __A and \a __B; higher order elements are zeroed. If
+/// corresponding mask bit is set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtbiassph_pbf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2bf8s_128_mask(
(__v16qi)__A, (__v8hf)__B, (__v16qi)(__m128i)__W, (__mmask8)__U);
}
+/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+/// Results are saturated. Zeroing mask \a __U is used to determine if given
+/// element should be zeroed instead.
+///
+/// \code{.operation}
+/// FOR i := 0 to 7
+/// IF __U[i]
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ELSE
+/// dst.fp8[i] := 0
+/// FI
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __U
+/// A 8-bit zeroing mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the sum of
+/// elements from \a __A and \a __B; higher order elements are zeroed. If
+/// corresponding mask bit is not set, then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_maskz_cvtbiassph_pbf8(__mmask8 __U, __m128i __A, __m128h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2bf8s_128_mask(
@@ -465,6 +701,28 @@ _mm_maskz_cvtbiassph_pbf8(__mmask8 __U, __m128i __A, __m128h __B) {
(__mmask8)__U);
}
+/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+/// Results are saturated.
+///
+/// \code{.operation}
+/// FOR i := 0 to 15
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Elements correspond to the
+/// sum of elements from \a __A and \a __B.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_cvtbiassph_pbf8(__m256i __A, __m256h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2bf8s_256_mask(
@@ -472,12 +730,74 @@ _mm256_cvtbiassph_pbf8(__m256i __A, __m256h __B) {
(__mmask16)-1);
}
+/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+/// Results are saturated. Merging mask \a __U is used to determine if given
+/// element should be taken from \a __W instead.
+///
+/// \code{.operation}
+/// FOR i := 0 to 15
+/// IF __U[i]
+/// dst.fp8[i] := _W[i]
+/// ELSE
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __W
+/// A 128-bit vector of [16 x fp8].
+/// \param __U
+/// A 16-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Elements correspond to the sum of
+/// elements from \a __A and \a __B. If corresponding mask bit is set, then
+/// element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiassph_pbf8(
__m128i __W, __mmask16 __U, __m256i __A, __m256h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2bf8s_256_mask(
(__v32qi)__A, (__v16hf)__B, (__v16qi)(__m128i)__W, (__mmask16)__U);
}
+/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+/// Results are saturated. Merging mask \a __U is used to determine if given
+/// element should be taken from \a __W instead.
+///
+/// \code{.operation}
+/// FOR i := 0 to 15
+/// IF __U[i]
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ELSE
+/// dst.fp8[i] := 0
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __U
+/// A 16-bit zeroing mask.
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Elements correspond to the sum of
+/// elements from \a __A and \a __B. If corresponding mask bit is not set,
+/// then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_maskz_cvtbiassph_pbf8(__mmask16 __U, __m256i __A, __m256h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2bf8s_256_mask(
@@ -485,18 +805,107 @@ _mm256_maskz_cvtbiassph_pbf8(__mmask16 __U, __m256i __A, __m256h __B) {
(__mmask16)__U);
}
+/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
+///
+/// \code{.operation}
+/// FOR i := 0 to 7
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// sum of elements from \a __A and \a __B; higher order elements are zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_cvtbiasph_phf8(__m128i __A, __m128h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2hf8_128_mask(
(__v16qi)__A, (__v8hf)__B, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
}
+/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
+///
+/// \code{.operation}
+/// FOR i := 0 to 7
+/// IF __U[i]
+/// dst.fp8[i] := _W[i]
+/// ELSE
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// FI
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __W
+/// A 128-bit vector of [16 x fp8].
+/// \param __U
+/// A 8-bit merging mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the sum of
+/// elements from \a __A and \a __B; higher order elements are zeroed. If
+/// corresponding mask bit is set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtbiasph_phf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2hf8_128_mask(
(__v16qi)__A, (__v8hf)__B, (__v16qi)(__m128i)__W, (__mmask8)__U);
}
+/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
+/// Zeroing mask \a __U is used to determine if given element should be zeroed
+/// instead.
+///
+/// \code{.operation}
+/// FOR i := 0 to 7
+/// IF __U[i]
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ELSE
+/// dst.fp8[i] := 0
+/// FI
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __U
+/// A 8-bit zeroing mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the sum of
+/// elements from \a __A and \a __B; higher order elements are zeroed. If
+/// corresponding mask bit is not set, then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_maskz_cvtbiasph_phf8(__mmask8 __U, __m128i __A, __m128h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2hf8_128_mask(
@@ -504,6 +913,27 @@ _mm_maskz_cvtbiasph_phf8(__mmask8 __U, __m128i __A, __m128h __B) {
(__mmask8)__U);
}
+/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
+///
+/// \code{.operation}
+/// FOR i := 0 to 15
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Elements correspond to the
+/// sum of elements from \a __A and \a __B.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_cvtbiasph_phf8(__m256i __A, __m256h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2hf8_256_mask(
@@ -511,12 +941,74 @@ _mm256_cvtbiasph_phf8(__m256i __A, __m256h __B) {
(__mmask16)-1);
}
+/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
+///
+/// \code{.operation}
+/// FOR i := 0 to 15
+/// IF __U[i]
+/// dst.fp8[i] := _W[i]
+/// ELSE
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __W
+/// A 128-bit vector of [16 x fp8].
+/// \param __U
+/// A 16-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Elements correspond to the sum of
+/// elements from \a __A and \a __B. If corresponding mask bit is set, then
+/// element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiasph_phf8(
__m128i __W, __mmask16 __U, __m256i __A, __m256h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2hf8_256_mask(
(__v32qi)__A, (__v16hf)__B, (__v16qi)(__m128i)__W, (__mmask16)__U);
}
+/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
+///
+/// \code{.operation}
+/// FOR i := 0 to 15
+/// IF __U[i]
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ELSE
+/// dst.fp8[i] := 0
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __U
+/// A 16-bit zeroing mask.
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Elements correspond to the sum of
+/// elements from \a __A and \a __B. If corresponding mask bit is not set,
+/// then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_maskz_cvtbiasph_phf8(__mmask16 __U, __m256i __A, __m256h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2hf8_256_mask(
@@ -524,18 +1016,108 @@ _mm256_maskz_cvtbiasph_phf8(__mmask16 __U, __m256i __A, __m256h __B) {
(__mmask16)__U);
}
+/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
+/// Results are saturated.
+///
+/// \code{.operation}
+/// FOR i := 0 to 7
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// sum of elements from \a __A and \a __B; higher order elements are zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_cvtbiassph_phf8(__m128i __A, __m128h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2hf8s_128_mask(
(__v16qi)__A, (__v8hf)__B, (__v16qi)_mm_undefined_si128(), (__mmask8)-1);
}
+/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
+/// Results are saturated. Merging mask \a __U is used to determine if given
+/// element should be taken from \a __W instead.
+///
+/// \code{.operation}
+/// FOR i := 0 to 7
+/// IF __U[i]
+/// dst.fp8[i] := _W[i]
+/// ELSE
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// FI
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __W
+/// A 128-bit vector of [16 x fp8].
+/// \param __U
+/// A 8-bit merging mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the sum of
+/// elements from \a __A and \a __B; higher order elements are zeroed. If
+/// corresponding mask bit is set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtbiassph_phf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2hf8s_128_mask(
(__v16qi)__A, (__v8hf)__B, (__v16qi)(__m128i)__W, (__mmask8)__U);
}
+/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
+/// Results are saturated. Zeroing mask \a __U is used to determine if given
+/// element should be zeroed instead.
+///
+/// \code{.operation}
+/// FOR i := 0 to 7
+/// IF __U[i]
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ELSE
+/// dst.fp8[i] := 0
+/// FI
+/// ENDFOR
+///
+/// dst[127:64] := 0
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __U
+/// A 8-bit zeroing mask.
+/// \param __A
+/// A 128-bit vector of [8 x fp16].
+/// \param __B
+/// A 128-bit vector of [8 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the sum of
+/// elements from \a __A and \a __B; higher order elements are zeroed. If
+/// corresponding mask bit is not set, then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_maskz_cvtbiassph_phf8(__mmask8 __U, __m128i __A, __m128h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2hf8s_128_mask(
@@ -543,6 +1125,28 @@ _mm_maskz_cvtbiassph_phf8(__mmask8 __U, __m128i __A, __m128h __B) {
(__mmask8)__U);
}
+/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
+/// Results are saturated.
+///
+/// \code{.operation}
+/// FOR i := 0 to 15
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Elements correspond to the
+/// sum of elements from \a __A and \a __B.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_cvtbiassph_phf8(__m256i __A, __m256h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2hf8s_256_mask(
@@ -550,12 +1154,74 @@ _mm256_cvtbiassph_phf8(__m256i __A, __m256h __B) {
(__mmask16)-1);
}
+/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
+/// Results are saturated. Merging mask \a __U is used to determine if given
+/// element should be taken from \a __W instead.
+///
+/// \code{.operation}
+/// FOR i := 0 to 15
+/// IF __U[i]
+/// dst.fp8[i] := _W[i]
+/// ELSE
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __W
+/// A 128-bit vector of [16 x fp8].
+/// \param __U
+/// A 16-bit merging mask.
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Elements correspond to the sum of
+/// elements from \a __A and \a __B. If corresponding mask bit is set, then
+/// element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiassph_phf8(
__m128i __W, __mmask16 __U, __m256i __A, __m256h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2hf8s_256_mask(
(__v32qi)__A, (__v16hf)__B, (__v16qi)(__m128i)__W, (__mmask16)__U);
}
+/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
+/// Results are saturated. Merging mask \a __U is used to determine if given
+/// element should be taken from \a __W instead.
+///
+/// \code{.operation}
+/// FOR i := 0 to 15
+/// IF __U[i]
+/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ELSE
+/// dst.fp8[i] := 0
+/// FI
+/// ENDFOR
+/// \endcode
+///
+/// \headerfile <immintrin.h>
+///
+/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+///
+/// \param __U
+/// A 16-bit zeroing mask.
+/// \param __A
+/// A 256-bit vector of [16 x fp16].
+/// \param __B
+/// A 256-bit vector of [16 x int16].
+/// \returns
+/// A 128-bit vector of [16 x fp8]. Elements correspond to the sum of
+/// elements from \a __A and \a __B. If corresponding mask bit is not set,
+/// then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_maskz_cvtbiassph_phf8(__mmask16 __U, __m256i __A, __m256h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2hf8s_256_mask(
@@ -566,7 +1232,7 @@ _mm256_maskz_cvtbiassph_phf8(__mmask16 __U, __m256i __A, __m256h __B) {
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 16
/// IF i < 8
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
@@ -599,7 +1265,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_pbf8(__m128h __A,
/// Merging mask \a __U is used to determine if given element should be taken
/// from \a __W instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
/// dst.fp8[i] := __W[i]
@@ -641,7 +1307,7 @@ _mm_mask_cvtne2ph_pbf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
/// Zeroing mask \a __U is used to determine if given element should be zeroed
/// instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 16
/// IF __U[i]
/// IF i < 8
@@ -680,7 +1346,7 @@ _mm_maskz_cvtne2ph_pbf8(__mmask16 __U, __m128h __A, __m128h __B) {
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 32
/// IF i < 16
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
@@ -713,7 +1379,7 @@ _mm256_cvtne2ph_pbf8(__m256h __A, __m256h __B) {
/// Merging mask \a __U is used to determine if given element should be taken
/// from \a __W instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 32
/// IF __U[i]
/// dst.fp8[i] := __W.fp8[i]
@@ -755,7 +1421,7 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtne2ph_pbf8(
/// Merging mask \a __U is used to determine if given element should be zeroed
/// instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 32
/// IF __U[i]
/// dst.fp8[i] := 0
@@ -795,7 +1461,7 @@ _mm256_maskz_cvtne2ph_pbf8(__mmask32 __U, __m256h __A, __m256h __B) {
/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
/// Resulting elements are saturated in case of overflow.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 16
/// IF i < 8
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
@@ -828,7 +1494,7 @@ _mm_cvtnes2ph_pbf8(__m128h __A, __m128h __B) {
/// Merging mask \a __U is used to determine if given element should be taken
/// from \a __W instead. Resulting elements are saturated in case of overflow.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 16
/// IF __U[i]
/// dst.fp8[i] := __W[i]
@@ -870,7 +1536,7 @@ _mm_mask_cvtnes2ph_pbf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
/// Zeroing mask \a __U is used to determine if given element should be zeroed
/// instead. Resulting elements are saturated in case of overflow.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 16
/// IF __U[i]
/// IF i < 8
@@ -910,7 +1576,7 @@ _mm_maskz_cvtnes2ph_pbf8(__mmask16 __U, __m128h __A, __m128h __B) {
/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
/// Resulting elements are saturated in case of overflow.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 32
/// IF i < 16
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
@@ -943,7 +1609,7 @@ _mm256_cvtnes2ph_pbf8(__m256h __A, __m256h __B) {
/// Merging mask \a __U is used to determine if given element should be taken
/// from \a __W instead. Resulting elements are saturated in case of overflow.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 32
/// IF __U[i]
/// dst.fp8[i] := __W.fp8[i]
@@ -985,7 +1651,7 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtnes2ph_pbf8(
/// Merging mask \a __U is used to determine if given element should be zeroed
/// instead. Resulting elements are saturated in case of overflow.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 32
/// IF __U[i]
/// dst.fp8[i] := 0
@@ -1024,7 +1690,7 @@ _mm256_maskz_cvtnes2ph_pbf8(__mmask32 __U, __m256h __A, __m256h __B) {
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 16
/// IF i < 8
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
@@ -1057,7 +1723,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_phf8(__m128h __A,
/// Merging mask \a __U is used to determine if given element should be taken
/// from \a __W instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 16
/// IF __U[i]
/// dst.fp8[i] := __W[i]
@@ -1099,7 +1765,7 @@ _mm_mask_cvtne2ph_phf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
/// Zeroing mask \a __U is used to determine if given element should be zeroed
/// instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 16
/// IF __U[i]
/// IF i < 8
@@ -1138,7 +1804,7 @@ _mm_maskz_cvtne2ph_phf8(__mmask16 __U, __m128h __A, __m128h __B) {
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 32
/// IF i < 16
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
@@ -1171,7 +1837,7 @@ _mm256_cvtne2ph_phf8(__m256h __A, __m256h __B) {
/// Merging mask \a __U is used to determine if given element should be taken
/// from \a __W instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 32
/// IF __U[i]
/// dst.fp8[i] := __W.fp8[i]
@@ -1213,7 +1879,7 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtne2ph_phf8(
/// Merging mask \a __U is used to determine if given element should be zeroed
/// instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 32
/// IF __U[i]
/// dst.fp8[i] := 0
@@ -1253,7 +1919,7 @@ _mm256_maskz_cvtne2ph_phf8(__mmask32 __U, __m256h __A, __m256h __B) {
/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
/// Resulting elements are saturated in case of overflow.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 16
/// IF i < 8
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
@@ -1286,7 +1952,7 @@ _mm_cvtnes2ph_phf8(__m128h __A, __m128h __B) {
/// Merging mask \a __U is used to determine if given element should be taken
/// from \a __W instead. Resulting elements are saturated in case of overflow.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 16
/// IF __U[i]
/// dst.fp8[i] := __W[i]
@@ -1328,7 +1994,7 @@ _mm_mask_cvtnes2ph_phf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
/// Zeroing mask \a __U is used to determine if given element should be zeroed
/// instead. Resulting elements are saturated in case of overflow.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 16
/// IF __U[i]
/// IF i < 8
@@ -1368,7 +2034,7 @@ _mm_maskz_cvtnes2ph_phf8(__mmask16 __U, __m128h __A, __m128h __B) {
/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
/// Resulting elements are saturated in case of overflow.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 32
/// IF i < 16
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
@@ -1401,7 +2067,7 @@ _mm256_cvtnes2ph_phf8(__m256h __A, __m256h __B) {
/// Merging mask \a __U is used to determine if given element should be taken
/// from \a __W instead. Resulting elements are saturated in case of overflow.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 32
/// IF __U[i]
/// dst.fp8[i] := __W.fp8[i]
@@ -1443,7 +2109,7 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtnes2ph_phf8(
/// Merging mask \a __U is used to determine if given element should be zeroed
/// instead. Resulting elements are saturated in case of overflow.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 32
/// IF __U[i]
/// dst.fp8[i] := 0
@@ -1482,7 +2148,7 @@ _mm256_maskz_cvtnes2ph_phf8(__mmask32 __U, __m256h __A, __m256h __B) {
/// Convert 128-bit vector \a __A, containing packed FP8 E4M3 floating-point
/// elements to a 128-bit vector containing FP16 elements. The conversion is exact.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 7
/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
/// ENDFOR
@@ -1507,7 +2173,7 @@ static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtnehf8_ph(__m128i __A) {
/// exact. Merging mask \a __U is used to determine if given element should be
/// taken from \a __W instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
/// dst.fp16[i] := __W[i]
@@ -1542,7 +2208,7 @@ _mm_mask_cvtnehf8_ph(__m128h __W, __mmask8 __U, __m128i __A) {
/// exact. Zeroing mask \a __U is used to determine if given element should be
/// zeroed instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
@@ -1573,7 +2239,7 @@ _mm_maskz_cvtnehf8_ph(__mmask8 __U, __m128i __A) {
/// Convert 256-bit vector \a __A, containing packed FP8 E4M3 floating-point
/// elements to a 256-bit vector containing FP16 elements. The conversion is exact.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
/// ENDFOR
@@ -1599,7 +2265,7 @@ _mm256_cvtnehf8_ph(__m128i __A) {
/// exact. Merging mask \a __U is used to determine if given element should be
/// taken from \a __W instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
/// dst.fp16[i] := __W[i]
@@ -1634,7 +2300,7 @@ _mm256_mask_cvtnehf8_ph(__m256h __W, __mmask16 __U, __m128i __A) {
/// exact. Zeroing mask \a __U is used to determine if given element should be
/// zeroed instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
@@ -1666,7 +2332,7 @@ _mm256_maskz_cvtnehf8_ph(__mmask16 __U, __m128i __A) {
/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
/// resulting vector are zeroed.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 7
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
/// ENDFOR
@@ -1693,7 +2359,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtneph_pbf8(__m128h __A) {
/// resulting vector are zeroed. Merging mask \a __U is used to determine if
/// given element should be taken from \a __W instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
/// dst.fp8[i] := __W[i]
@@ -1731,7 +2397,7 @@ _mm_mask_cvtneph_pbf8(__m128i __W, __mmask8 __U, __m128h __A) {
/// resulting vector are zeroed. Zeroing mask \a __U is used to determine if
/// given element should be zeroed instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
@@ -1752,7 +2418,6 @@ _mm_mask_cvtneph_pbf8(__m128i __W, __mmask8 __U, __m128h __A) {
/// \param __A
/// A 128-bit vector of [8 x fp16].
/// \returns
-///
/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __A; upper elements are zeroed. If
/// corresponding mask bit is not set, then element is zeroed.
@@ -1765,7 +2430,7 @@ _mm_maskz_cvtneph_pbf8(__mmask8 __U, __m128h __A) {
/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
/// to a 128-bit vector containing E5M2 FP8 elements.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
/// ENDFOR
@@ -1792,7 +2457,7 @@ _mm256_cvtneph_pbf8(__m256h __A) {
/// to a 128-bit vector containing E5M2 FP8 elements. Merging mask \a __U is
/// used to determine if given element should be taken from \a __W instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
/// dst.fp8[i] := __W[i]
@@ -1828,7 +2493,7 @@ _mm256_mask_cvtneph_pbf8(__m128i __W, __mmask16 __U, __m256h __A) {
/// to a 128-bit vector containing E5M2 FP8 elements. Zeroing mask \a __U is
/// used to determine if given element should be zeroed instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
@@ -1862,7 +2527,7 @@ _mm256_maskz_cvtneph_pbf8(__mmask16 __U, __m256h __A) {
/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
/// resulting vector are zeroed. Results are saturated.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 7
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
/// ENDFOR
@@ -1889,7 +2554,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtnesph_pbf8(__m128h __A) {
/// resulting vector are zeroed. Results are saturated. Merging mask \a __U is
/// used to determine if given element should be taken from \a __W instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
/// dst.fp8[i] := __W[i]
@@ -1926,7 +2591,7 @@ _mm_mask_cvtnesph_pbf8(__m128i __W, __mmask8 __U, __m128h __A) {
/// resulting vector are zeroed. Results are saturated. Zeroing mask \a __U is
/// used to determine if given element should be zeroed instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
@@ -1943,7 +2608,7 @@ _mm_mask_cvtnesph_pbf8(__m128i __W, __mmask8 __U, __m128h __A) {
/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
///
/// \param __U
-/// A 8-bit merging mask.
+/// A 8-bit zeroing mask.
/// \param __A
/// A 128-bit vector of [8 x fp16].
/// \returns
@@ -1959,7 +2624,7 @@ _mm_maskz_cvtnesph_pbf8(__mmask8 __U, __m128h __A) {
/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
/// to a 128-bit vector containing E5M2 FP8 elements. Results are saturated.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
/// ENDFOR
@@ -1987,7 +2652,7 @@ _mm256_cvtnesph_pbf8(__m256h __A) {
/// Merging mask \a __U is used to determine if given element should be taken
/// from \a __W instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
/// dst.fp8[i] := __W[i]
@@ -2024,7 +2689,7 @@ _mm256_mask_cvtnesph_pbf8(__m128i __W, __mmask16 __U, __m256h __A) {
/// Zeroing mask \a __U is used to determine if given element should be zeroed
/// instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
@@ -2058,7 +2723,7 @@ _mm256_maskz_cvtnesph_pbf8(__mmask16 __U, __m256h __A) {
/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
/// resulting vector are zeroed.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 7
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
/// ENDFOR
@@ -2085,7 +2750,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtneph_phf8(__m128h __A) {
/// resulting vector are zeroed. Merging mask \a __U is used to determine if
/// given element should be taken from \a __W instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
/// dst.fp8[i] := __W[i]
@@ -2123,7 +2788,7 @@ _mm_mask_cvtneph_phf8(__m128i __W, __mmask8 __U, __m128h __A) {
/// resulting vector are zeroed. Zeroing mask \a __U is used to determine if
/// given element should be zeroed instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
@@ -2157,7 +2822,7 @@ _mm_maskz_cvtneph_phf8(__mmask8 __U, __m128h __A) {
/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
/// to a 128-bit vector containing E4M3 FP8 elements.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
/// ENDFOR
@@ -2184,7 +2849,7 @@ _mm256_cvtneph_phf8(__m256h __A) {
/// to a 128-bit vector containing E4M3 FP8 elements. Merging mask \a __U is
/// used to determine if given element should be taken from \a __W instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
/// dst.fp8[i] := __W[i]
@@ -2220,7 +2885,7 @@ _mm256_mask_cvtneph_phf8(__m128i __W, __mmask16 __U, __m256h __A) {
/// to a 128-bit vector containing E4M3 FP8 elements. Zeroing mask \a __U is
/// used to determine if given element should be zeroed instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
@@ -2254,7 +2919,7 @@ _mm256_maskz_cvtneph_phf8(__mmask16 __U, __m256h __A) {
/// to a 128-bit vector containing E4M3 FP8 elements. Upper elements of
/// resulting vector are zeroed. Results are saturated.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 7
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
/// ENDFOR
@@ -2281,7 +2946,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtnesph_phf8(__m128h __A) {
/// resulting vector are zeroed. Results are saturated. Merging mask \a __U is
/// used to determine if given element should be taken from \a __W instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
/// dst.fp8[i] := __W[i]
@@ -2318,7 +2983,7 @@ _mm_mask_cvtnesph_phf8(__m128i __W, __mmask8 __U, __m128h __A) {
/// resulting vector are zeroed. Results are saturated. Zeroing mask \a __U is
/// used to determine if given element should be zeroed instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
@@ -2351,7 +3016,7 @@ _mm_maskz_cvtnesph_phf8(__mmask8 __U, __m128h __A) {
/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
/// to a 128-bit vector containing E4M3 FP8 elements. Results are saturated.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
/// ENDFOR
@@ -2379,7 +3044,7 @@ _mm256_cvtnesph_phf8(__m256h __A) {
/// Merging mask \a __U is used to determine if given element should be taken
/// from \a __W instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
/// dst.fp8[i] := __W[i]
@@ -2416,7 +3081,7 @@ _mm256_mask_cvtnesph_phf8(__m128i __W, __mmask16 __U, __m256h __A) {
/// Zeroing mask \a __U is used to determine if given element should be zeroed
/// instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
@@ -2449,7 +3114,7 @@ _mm256_maskz_cvtnesph_phf8(__mmask16 __U, __m256h __A) {
/// Convert 128-bit vector \a __A, containing packed FP8 E5M2 floating-point
/// elements to a 128-bit vector containing FP16 elements. The conversion is exact.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 7
/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
/// ENDFOR
@@ -2473,7 +3138,7 @@ static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtpbf8_ph(__m128i __A) {
/// exact. Merging mask \a __U is used to determine if given element should be
/// taken from \a __W instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
/// dst.fp16[i] := __W[i]
@@ -2508,7 +3173,7 @@ _mm_mask_cvtpbf8_ph(__m128h __S, __mmask8 __U, __m128i __A) {
/// exact. Zeroing mask \a __U is used to determine if given element should be
/// zeroed instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
@@ -2538,7 +3203,7 @@ _mm_maskz_cvtpbf8_ph(__mmask8 __U, __m128i __A) {
/// Convert 256-bit vector \a __A, containing packed FP8 E4M3 floating-point
/// elements to a 256-bit vector containing FP16 elements. The conversion is exact.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
/// ENDFOR
@@ -2562,7 +3227,7 @@ static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_cvtpbf8_ph(__m128i __A) {
/// exact. Merging mask \a __U is used to determine if given element should be
/// taken from \a __W instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
/// dst.fp16[i] := __W[i]
@@ -2597,7 +3262,7 @@ _mm256_mask_cvtpbf8_ph(__m256h __S, __mmask8 __U, __m128i __A) {
/// exact. Zeroing mask \a __U is used to determine if given element should be
/// zeroed instead.
///
-/// \code{.operation]
+/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
>From b069337d461da42883093aedeb00c019131d3559 Mon Sep 17 00:00:00 2001
From: "Pirog, Mikolaj Maciej" <mikolaj.maciej.pirog at intel.com>
Date: Fri, 20 Dec 2024 17:17:17 +0100
Subject: [PATCH 5/9] Add all comments
---
clang/lib/Headers/avx10_2convertintrin.h | 281 +++++++++++------------
1 file changed, 139 insertions(+), 142 deletions(-)
diff --git a/clang/lib/Headers/avx10_2convertintrin.h b/clang/lib/Headers/avx10_2convertintrin.h
index 341dc9cfd6aae3..52a64a5309763d 100644
--- a/clang/lib/Headers/avx10_2convertintrin.h
+++ b/clang/lib/Headers/avx10_2convertintrin.h
@@ -47,7 +47,7 @@
/// \param __B
/// A 128-bit vector of [4 x float].
/// \returns
-/// A 128-bit vector of [8 x fp16]. Lower 4 elements correspond to the
+/// A 128-bit vector of [8 x fp16]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A.
static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtx2ps_ph(__m128 __A,
@@ -88,7 +88,7 @@ static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtx2ps_ph(__m128 __A,
/// \param __B
/// A 128-bit vector of [4 x float].
/// \returns
-/// A 128-bit vector of [8 x fp16]. Lower 4 elements correspond to the
+/// A 128-bit vector of [8 x fp16]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is set, then
/// element from \a __W is taken instead.
@@ -122,13 +122,13 @@ _mm_mask_cvtx2ps_ph(__m128h __W, __mmask8 __U, __m128 __A, __m128 __B) {
/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
///
/// \param __U
-/// A 8-bit merging mask.
+/// A 8-bit zeroing mask.
/// \param __A
/// A 128-bit vector of [4 x float].
/// \param __B
/// A 128-bit vector of [4 x float].
/// \returns
-/// A 128-bit vector of [8 x fp16]. Lower 4 elements correspond to the
+/// A 128-bit vector of [8 x fp16]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set,
/// then zero is taken instead.
@@ -161,7 +161,7 @@ _mm_maskz_cvtx2ps_ph(__mmask8 __U, __m128 __A, __m128 __B) {
/// \param __B
/// A 256-bit vector of [8 x float].
/// \returns
-/// A 256-bit vector of [16 x fp16]. Lower 8 elements correspond to the
+/// A 256-bit vector of [16 x fp16]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A.
static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_cvtx2ps_ph(__m256 __A,
@@ -197,13 +197,13 @@ static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_cvtx2ps_ph(__m256 __A,
/// \param __W
/// A 256-bit vector of [16 x fp16].
/// \param __U
-/// A 8-bit merging mask.
+/// A 16-bit merging mask.
/// \param __A
/// A 256-bit vector of [8 x float].
/// \param __B
/// A 256-bit vector of [8 x float].
/// \returns
-/// A 256-bit vector of [16 x fp16]. Lower 4 elements correspond to the
+/// A 256-bit vector of [16 x fp16]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is set, then
/// element from \a __W is taken instead.
@@ -238,13 +238,13 @@ _mm256_mask_cvtx2ps_ph(__m256h __W, __mmask16 __U, __m256 __A, __m256 __B) {
/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
///
/// \param __U
-/// A 8-bit zeroing mask.
+/// A 16-bit zeroing mask.
/// \param __A
/// A 256-bit vector of [8 x float].
/// \param __B
/// A 256-bit vector of [8 x float].
/// \returns
-/// A 256-bit vector of [16 x fp16]. Lower 4 elements correspond to the
+/// A 256-bit vector of [16 x fp16]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set,
/// then zero is taken instead.
@@ -283,7 +283,7 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
/// _MM_FROUND_TO_NEAREST_INT, _MM_FROUND_TO_NEG_INF, _MM_FROUND_TO_POS_INF,
/// _MM_FROUND_TO_ZERO.
/// \returns
-/// A 256-bit vector of [16 x fp16]. Lower 8 elements correspond to the
+/// A 256-bit vector of [16 x fp16]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A.
#define _mm256_cvtx_round2ps_ph(A, B, R) \
@@ -318,7 +318,7 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
/// \param __W
/// A 256-bit vector of [16 x fp16].
/// \param __U
-/// A 8-bit merging mask.
+/// A 16-bit merging mask.
/// \param __A
/// A 256-bit vector of [8 x float].
/// \param __B
@@ -329,7 +329,7 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
/// _MM_FROUND_TO_NEAREST_INT, _MM_FROUND_TO_NEG_INF, _MM_FROUND_TO_POS_INF,
/// _MM_FROUND_TO_ZERO.
/// \returns
-/// A 256-bit vector of [16 x fp16]. Lower 4 elements correspond to the
+/// A 256-bit vector of [16 x fp16]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is set, then
/// element from \a __W is taken instead.
@@ -361,7 +361,7 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
///
/// \param __U
-/// A 8-bit zeroing mask.
+/// A 16-bit zeroing mask.
/// \param __A
/// A 256-bit vector of [8 x float].
/// \param __B
@@ -372,7 +372,7 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
/// _MM_FROUND_TO_NEAREST_INT, _MM_FROUND_TO_NEG_INF, _MM_FROUND_TO_POS_INF,
/// _MM_FROUND_TO_ZERO.
/// \returns
-/// A 256-bit vector of [16 x fp16]. Lower 4 elements correspond to the
+/// A 256-bit vector of [16 x fp16]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set,
/// then zero is taken instead.
@@ -395,7 +395,7 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2BF8 instruction.
///
/// \param __A
/// A 128-bit vector of [8 x fp16].
@@ -430,7 +430,7 @@ _mm_cvtbiasph_pbf8(__m128i __A, __m128h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2BF8 instruction.
///
/// \param __W
/// A 128-bit vector of [16 x fp8].
@@ -470,7 +470,7 @@ _mm_mask_cvtbiasph_pbf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2BF8 instruction.
///
/// \param __U
/// A 8-bit zeroing mask.
@@ -501,7 +501,7 @@ _mm_maskz_cvtbiasph_pbf8(__mmask8 __U, __m128i __A, __m128h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2BF8 instruction.
///
/// \param __A
/// A 256-bit vector of [16 x fp16].
@@ -535,7 +535,7 @@ _mm256_cvtbiasph_pbf8(__m256i __A, __m256h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2BF8 instruction.
///
/// \param __W
/// A 128-bit vector of [16 x fp8].
@@ -573,7 +573,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiasph_pbf8(
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2BF8 instruction.
///
/// \param __U
/// A 16-bit zeroing mask.
@@ -607,7 +607,7 @@ _mm256_maskz_cvtbiasph_pbf8(__mmask16 __U, __m256i __A, __m256h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2BF8 instruction.
///
/// \param __A
/// A 128-bit vector of [8 x fp16].
@@ -642,7 +642,7 @@ _mm_cvtbiassph_pbf8(__m128i __A, __m128h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2BF8S instruction.
///
/// \param __W
/// A 128-bit vector of [16 x fp8].
@@ -682,7 +682,7 @@ _mm_mask_cvtbiassph_pbf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2BF8S instruction.
///
/// \param __U
/// A 8-bit zeroing mask.
@@ -714,7 +714,7 @@ _mm_maskz_cvtbiassph_pbf8(__mmask8 __U, __m128i __A, __m128h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2BF8S instruction.
///
/// \param __A
/// A 256-bit vector of [16 x fp16].
@@ -748,7 +748,7 @@ _mm256_cvtbiassph_pbf8(__m256i __A, __m256h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2BF8S instruction.
///
/// \param __W
/// A 128-bit vector of [16 x fp8].
@@ -786,7 +786,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiassph_pbf8(
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2BF8S instruction.
///
/// \param __U
/// A 16-bit zeroing mask.
@@ -819,7 +819,7 @@ _mm256_maskz_cvtbiassph_pbf8(__mmask16 __U, __m256i __A, __m256h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2HF8 instruction.
///
/// \param __A
/// A 128-bit vector of [8 x fp16].
@@ -854,7 +854,7 @@ _mm_cvtbiasph_phf8(__m128i __A, __m128h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2HF8 instruction.
///
/// \param __W
/// A 128-bit vector of [16 x fp8].
@@ -894,7 +894,7 @@ _mm_mask_cvtbiasph_phf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2HF8 instruction.
///
/// \param __U
/// A 8-bit zeroing mask.
@@ -925,7 +925,7 @@ _mm_maskz_cvtbiasph_phf8(__mmask8 __U, __m128i __A, __m128h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2HF8 instruction.
///
/// \param __A
/// A 256-bit vector of [16 x fp16].
@@ -959,7 +959,7 @@ _mm256_cvtbiasph_phf8(__m256i __A, __m256h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2HF8 instruction.
///
/// \param __W
/// A 128-bit vector of [16 x fp8].
@@ -997,7 +997,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiasph_phf8(
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2HF8 instruction.
///
/// \param __U
/// A 16-bit zeroing mask.
@@ -1031,7 +1031,7 @@ _mm256_maskz_cvtbiasph_phf8(__mmask16 __U, __m256i __A, __m256h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2HF8S`instruction.
///
/// \param __A
/// A 128-bit vector of [8 x fp16].
@@ -1066,7 +1066,7 @@ _mm_cvtbiassph_phf8(__m128i __A, __m128h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2HF8S instruction.
///
/// \param __W
/// A 128-bit vector of [16 x fp8].
@@ -1106,7 +1106,7 @@ _mm_mask_cvtbiassph_phf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2HF8S instruction.
///
/// \param __U
/// A 8-bit zeroing mask.
@@ -1138,7 +1138,7 @@ _mm_maskz_cvtbiassph_phf8(__mmask8 __U, __m128i __A, __m128h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2HF8S instruction.
///
/// \param __A
/// A 256-bit vector of [16 x fp16].
@@ -1172,7 +1172,7 @@ _mm256_cvtbiassph_phf8(__m256i __A, __m256h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2HF8S instruction.
///
/// \param __W
/// A 128-bit vector of [16 x fp8].
@@ -1210,7 +1210,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiassph_phf8(
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVT2PS2PHX instruction.
+/// This intrinsic corresponds to the \c VCVTBIASPH2HF8S instruction.
///
/// \param __U
/// A 16-bit zeroing mask.
@@ -1251,7 +1251,7 @@ _mm256_maskz_cvtbiassph_phf8(__mmask16 __U, __m256i __A, __m256h __B) {
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A.
static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_pbf8(__m128h __A,
@@ -1292,7 +1292,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_pbf8(__m128h __A,
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is set, then
/// element from \a __W is taken instead.
@@ -1332,7 +1332,7 @@ _mm_mask_cvtne2ph_pbf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// zero is taken instead.
@@ -1347,7 +1347,7 @@ _mm_maskz_cvtne2ph_pbf8(__mmask16 __U, __m128h __A, __m128h __B) {
/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
///
/// \code{.operation}
-/// FOR i := 0 to 32
+/// FOR i := 0 to 31
/// IF i < 16
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
/// ELSE
@@ -1365,7 +1365,7 @@ _mm_maskz_cvtne2ph_pbf8(__mmask16 __U, __m128h __A, __m128h __B) {
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A.
static __inline__ __m256i __DEFAULT_FN_ATTRS256
@@ -1380,7 +1380,7 @@ _mm256_cvtne2ph_pbf8(__m256h __A, __m256h __B) {
/// from \a __W instead.
///
/// \code{.operation}
-/// FOR i := 0 to 32
+/// FOR i := 0 to 31
/// IF __U[i]
/// dst.fp8[i] := __W.fp8[i]
/// ELSE
@@ -1406,7 +1406,7 @@ _mm256_cvtne2ph_pbf8(__m256h __A, __m256h __B) {
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is set, then
/// element from \a __W is taken instead.
@@ -1422,7 +1422,7 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtne2ph_pbf8(
/// instead.
///
/// \code{.operation}
-/// FOR i := 0 to 32
+/// FOR i := 0 to 31
/// IF __U[i]
/// dst.fp8[i] := 0
/// ELSE
@@ -1446,7 +1446,7 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtne2ph_pbf8(
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set,
/// zero is taken instead.
@@ -1459,7 +1459,7 @@ _mm256_maskz_cvtne2ph_pbf8(__mmask32 __U, __m256h __A, __m256h __B) {
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
-/// Resulting elements are saturated in case of overflow.
+/// Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
/// FOR i := 0 to 16
@@ -1480,7 +1480,7 @@ _mm256_maskz_cvtne2ph_pbf8(__mmask32 __U, __m256h __A, __m256h __B) {
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
@@ -1492,7 +1492,7 @@ _mm_cvtnes2ph_pbf8(__m128h __A, __m128h __B) {
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
/// Merging mask \a __U is used to determine if given element should be taken
-/// from \a __W instead. Resulting elements are saturated in case of overflow.
+/// from \a __W instead. Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
/// FOR i := 0 to 16
@@ -1510,7 +1510,7 @@ _mm_cvtnes2ph_pbf8(__m128h __A, __m128h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __W
/// A 128-bit vector of [16 x fp8].
@@ -1534,10 +1534,10 @@ _mm_mask_cvtnes2ph_pbf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
/// Zeroing mask \a __U is used to determine if given element should be zeroed
-/// instead. Resulting elements are saturated in case of overflow.
+/// instead. Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
-/// FOR i := 0 to 16
+/// FOR i := 0 to 15
/// IF __U[i]
/// IF i < 8
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
@@ -1552,7 +1552,7 @@ _mm_mask_cvtnes2ph_pbf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __U
/// A 16-bit zeroing mask.
@@ -1561,7 +1561,7 @@ _mm_mask_cvtnes2ph_pbf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// zero is taken instead.
@@ -1574,10 +1574,10 @@ _mm_maskz_cvtnes2ph_pbf8(__mmask16 __U, __m128h __A, __m128h __B) {
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
-/// Resulting elements are saturated in case of overflow.
+/// Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
-/// FOR i := 0 to 32
+/// FOR i := 0 to 31
/// IF i < 16
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
/// ELSE
@@ -1588,14 +1588,14 @@ _mm_maskz_cvtnes2ph_pbf8(__mmask16 __U, __m128h __A, __m128h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __A
/// A 256-bit vector of [16 x fp16].
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A.
static __inline__ __m256i __DEFAULT_FN_ATTRS256
@@ -1607,10 +1607,10 @@ _mm256_cvtnes2ph_pbf8(__m256h __A, __m256h __B) {
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
/// Merging mask \a __U is used to determine if given element should be taken
-/// from \a __W instead. Resulting elements are saturated in case of overflow.
+/// from \a __W instead. Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
-/// FOR i := 0 to 32
+/// FOR i := 0 to 31
/// IF __U[i]
/// dst.fp8[i] := __W.fp8[i]
/// ELSE
@@ -1625,7 +1625,7 @@ _mm256_cvtnes2ph_pbf8(__m256h __A, __m256h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __W
/// A 256-bit vector of [32 x fp8].
@@ -1636,7 +1636,7 @@ _mm256_cvtnes2ph_pbf8(__m256h __A, __m256h __B) {
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is set, then
/// element from \a __W is taken instead.
@@ -1649,10 +1649,10 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtnes2ph_pbf8(
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
/// Merging mask \a __U is used to determine if given element should be zeroed
-/// instead. Resulting elements are saturated in case of overflow.
+/// instead. Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
-/// FOR i := 0 to 32
+/// FOR i := 0 to 31
/// IF __U[i]
/// dst.fp8[i] := 0
/// ELSE
@@ -1667,7 +1667,7 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtnes2ph_pbf8(
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __U
/// A 32-bit zeroing mask.
@@ -1676,7 +1676,7 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtnes2ph_pbf8(
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set,
/// zero is taken instead.
@@ -1691,7 +1691,7 @@ _mm256_maskz_cvtnes2ph_pbf8(__mmask32 __U, __m256h __A, __m256h __B) {
/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
///
/// \code{.operation}
-/// FOR i := 0 to 16
+/// FOR i := 0 to 15
/// IF i < 8
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
/// ELSE
@@ -1709,7 +1709,7 @@ _mm256_maskz_cvtnes2ph_pbf8(__mmask32 __U, __m256h __A, __m256h __B) {
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A.
static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_phf8(__m128h __A,
@@ -1724,7 +1724,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_phf8(__m128h __A,
/// from \a __W instead.
///
/// \code{.operation}
-/// FOR i := 0 to 16
+/// FOR i := 0 to 15
/// IF __U[i]
/// dst.fp8[i] := __W[i]
/// ELSE
@@ -1750,7 +1750,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_phf8(__m128h __A,
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is set, then
/// element from \a __W is taken instead.
@@ -1766,7 +1766,7 @@ _mm_mask_cvtne2ph_phf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
/// instead.
///
/// \code{.operation}
-/// FOR i := 0 to 16
+/// FOR i := 0 to 15
/// IF __U[i]
/// IF i < 8
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
@@ -1790,7 +1790,7 @@ _mm_mask_cvtne2ph_phf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// zero is taken instead.
@@ -1805,7 +1805,7 @@ _mm_maskz_cvtne2ph_phf8(__mmask16 __U, __m128h __A, __m128h __B) {
/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
///
/// \code{.operation}
-/// FOR i := 0 to 32
+/// FOR i := 0 to 31
/// IF i < 16
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
/// ELSE
@@ -1823,7 +1823,7 @@ _mm_maskz_cvtne2ph_phf8(__mmask16 __U, __m128h __A, __m128h __B) {
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A.
static __inline__ __m256i __DEFAULT_FN_ATTRS256
@@ -1838,7 +1838,7 @@ _mm256_cvtne2ph_phf8(__m256h __A, __m256h __B) {
/// from \a __W instead.
///
/// \code{.operation}
-/// FOR i := 0 to 32
+/// FOR i := 0 to 31
/// IF __U[i]
/// dst.fp8[i] := __W.fp8[i]
/// ELSE
@@ -1864,7 +1864,7 @@ _mm256_cvtne2ph_phf8(__m256h __A, __m256h __B) {
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is set, then
/// element from \a __W is taken instead.
@@ -1880,7 +1880,7 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtne2ph_phf8(
/// instead.
///
/// \code{.operation}
-/// FOR i := 0 to 32
+/// FOR i := 0 to 31
/// IF __U[i]
/// dst.fp8[i] := 0
/// ELSE
@@ -1904,7 +1904,7 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtne2ph_phf8(
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set,
/// zero is taken instead.
@@ -1917,10 +1917,10 @@ _mm256_maskz_cvtne2ph_phf8(__mmask32 __U, __m256h __A, __m256h __B) {
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
-/// Resulting elements are saturated in case of overflow.
+/// Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
-/// FOR i := 0 to 16
+/// FOR i := 0 to 15
/// IF i < 8
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
/// ELSE
@@ -1931,14 +1931,14 @@ _mm256_maskz_cvtne2ph_phf8(__mmask32 __U, __m256h __A, __m256h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
+/// This intrinsic corresponds to the \c VCVTNE2PH2HF8S instruction.
///
/// \param __A
/// A 128-bit vector of [8 x fp16].
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
@@ -1950,10 +1950,10 @@ _mm_cvtnes2ph_phf8(__m128h __A, __m128h __B) {
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
/// Merging mask \a __U is used to determine if given element should be taken
-/// from \a __W instead. Resulting elements are saturated in case of overflow.
+/// from \a __W instead. Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
-/// FOR i := 0 to 16
+/// FOR i := 0 to 15
/// IF __U[i]
/// dst.fp8[i] := __W[i]
/// ELSE
@@ -1968,7 +1968,7 @@ _mm_cvtnes2ph_phf8(__m128h __A, __m128h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNE2PH2HF8S instruction.
///
/// \param __W
/// A 128-bit vector of [16 x fp8].
@@ -1979,7 +1979,7 @@ _mm_cvtnes2ph_phf8(__m128h __A, __m128h __B) {
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is set, then
/// element from \a __W is taken instead.
@@ -1992,10 +1992,10 @@ _mm_mask_cvtnes2ph_phf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
/// Zeroing mask \a __U is used to determine if given element should be zeroed
-/// instead. Resulting elements are saturated in case of overflow.
+/// instead. Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
-/// FOR i := 0 to 16
+/// FOR i := 0 to 15
/// IF __U[i]
/// IF i < 8
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
@@ -2010,7 +2010,7 @@ _mm_mask_cvtnes2ph_phf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNE2PH2HF8S instruction.
///
/// \param __U
/// A 16-bit zeroing mask.
@@ -2019,7 +2019,7 @@ _mm_mask_cvtnes2ph_phf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// zero is taken instead.
@@ -2032,11 +2032,11 @@ _mm_maskz_cvtnes2ph_phf8(__mmask16 __U, __m128h __A, __m128h __B) {
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
-/// Resulting elements are saturated in case of overflow.
+/// Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
-/// FOR i := 0 to 32
-/// IF i < 16
+/// FOR i := 0 to 15
+/// IF i < 16
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
/// ELSE
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 16])
@@ -2046,14 +2046,14 @@ _mm_maskz_cvtnes2ph_phf8(__mmask16 __U, __m128h __A, __m128h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNE2PH2HF8S instruction.
///
/// \param __A
/// A 256-bit vector of [16 x fp16].
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A.
static __inline__ __m256i __DEFAULT_FN_ATTRS256
@@ -2065,10 +2065,10 @@ _mm256_cvtnes2ph_phf8(__m256h __A, __m256h __B) {
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
/// Merging mask \a __U is used to determine if given element should be taken
-/// from \a __W instead. Resulting elements are saturated in case of overflow.
+/// from \a __W instead. Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
-/// FOR i := 0 to 32
+/// FOR i := 0 to 31
/// IF __U[i]
/// dst.fp8[i] := __W.fp8[i]
/// ELSE
@@ -2083,7 +2083,7 @@ _mm256_cvtnes2ph_phf8(__m256h __A, __m256h __B) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNE2PH2HF8S instruction.
///
/// \param __W
/// A 256-bit vector of [32 x fp8].
@@ -2094,7 +2094,7 @@ _mm256_cvtnes2ph_phf8(__m256h __A, __m256h __B) {
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is set, then
/// element from \a __W is taken instead.
@@ -2107,10 +2107,10 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtnes2ph_phf8(
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
/// Merging mask \a __U is used to determine if given element should be zeroed
-/// instead. Resulting elements are saturated in case of overflow.
+/// instead. Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
-/// FOR i := 0 to 32
+/// FOR i := 0 to 31
/// IF __U[i]
/// dst.fp8[i] := 0
/// ELSE
@@ -2125,7 +2125,7 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtnes2ph_phf8(
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __U
/// A 32-bit zeroing mask.
@@ -2134,7 +2134,7 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtnes2ph_phf8(
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower 16 elements correspond to the
+/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set,
/// zero is taken instead.
@@ -2150,7 +2150,7 @@ _mm256_maskz_cvtnes2ph_phf8(__mmask32 __U, __m256h __A, __m256h __B) {
///
/// \code{.operation}
/// FOR i := 0 to 7
-/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
+/// dst.fp16[i] := convert_fp8_to_fp16(__A.fp8[i])
/// ENDFOR
/// \endcode
///
@@ -2178,7 +2178,7 @@ static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtnehf8_ph(__m128i __A) {
/// IF __U[i]
/// dst.fp16[i] := __W[i]
/// ELSE
-/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
+/// dst.fp16[i] := convert_fp8_to_fp16(__A.fp8[i])
/// FI
/// ENDFOR
/// \endcode
@@ -2211,7 +2211,7 @@ _mm_mask_cvtnehf8_ph(__m128h __W, __mmask8 __U, __m128i __A) {
/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
-/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
+/// dst.fp16[i] := convert_fp8_to_fp16(__A.fp8[i])
/// ELSE
/// dst.fp16[i] := 0
/// FI
@@ -2241,7 +2241,7 @@ _mm_maskz_cvtnehf8_ph(__mmask8 __U, __m128i __A) {
///
/// \code{.operation}
/// FOR i := 0 to 15
-/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
+/// dst.fp16[i] := convert_fp8_to_fp16(__A.fp8[i])
/// ENDFOR
/// \endcode
///
@@ -2270,7 +2270,7 @@ _mm256_cvtnehf8_ph(__m128i __A) {
/// IF __U[i]
/// dst.fp16[i] := __W[i]
/// ELSE
-/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
+/// dst.fp16[i] := convert_fp8_to_fp16(__A.fp8[i])
/// FI
/// ENDFOR
/// \endcode
@@ -2315,7 +2315,7 @@ _mm256_mask_cvtnehf8_ph(__m256h __W, __mmask16 __U, __m128i __A) {
/// This intrinsic corresponds to the \c VCVTHF82PH instruction.
///
/// \param __U
-/// A 16-bit merging mask.
+/// A 16-bit zeroing mask.
/// \param __A
/// A 256-bit vector of [32 x fp8].
/// \returns
@@ -2342,7 +2342,7 @@ _mm256_maskz_cvtnehf8_ph(__mmask16 __U, __m128i __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNEPH2BF8 instruction.
///
/// \param __A
/// A 128-bit vector of [8 x fp16].
@@ -2373,7 +2373,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtneph_pbf8(__m128h __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNEPH2BF8 instruction.
///
/// \param __W
/// A 128-bit vector of [16 x fp8].
@@ -2382,7 +2382,6 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtneph_pbf8(__m128h __A) {
/// \param __A
/// A 128-bit vector of [8 x fp16].
/// \returns
-///
/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __A; upper elements are zeroed. If
/// corresponding mask bit is set, then element from \a __W is taken instead.
@@ -2411,7 +2410,7 @@ _mm_mask_cvtneph_pbf8(__m128i __W, __mmask8 __U, __m128h __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNEPH2BF8 instruction.
///
/// \param __U
/// A 8-bit merging mask.
@@ -2510,7 +2509,7 @@ _mm256_mask_cvtneph_pbf8(__m128i __W, __mmask16 __U, __m256h __A) {
/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
///
/// \param __U
-/// A 16-bit merging mask.
+/// A 16-bit zeroing mask.
/// \param __A
/// A 256-bit vector of [16 x fp16].
/// \returns
@@ -2537,7 +2536,7 @@ _mm256_maskz_cvtneph_pbf8(__mmask16 __U, __m256h __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __A
/// A 128-bit vector of [8 x fp16].
@@ -2568,7 +2567,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtnesph_pbf8(__m128h __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __W
/// A 128-bit vector of [16 x fp8].
@@ -2605,7 +2604,7 @@ _mm_mask_cvtnesph_pbf8(__m128i __W, __mmask8 __U, __m128h __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __U
/// A 8-bit zeroing mask.
@@ -2634,7 +2633,7 @@ _mm_maskz_cvtnesph_pbf8(__mmask8 __U, __m128h __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __A
/// A 256-bit vector of [16 x fp16].
@@ -2666,7 +2665,7 @@ _mm256_cvtnesph_pbf8(__m256h __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __W
/// A 128-bit vector of [16 x fp8].
@@ -2703,10 +2702,10 @@ _mm256_mask_cvtnesph_pbf8(__m128i __W, __mmask16 __U, __m256h __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __U
-/// A 16-bit merging mask.
+/// A 16-bit zeroing mask.
/// \param __A
/// A 256-bit vector of [16 x fp16].
/// \returns
@@ -2733,7 +2732,7 @@ _mm256_maskz_cvtnesph_pbf8(__mmask16 __U, __m256h __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNEPH2HF8 instruction.
///
/// \param __A
/// A 128-bit vector of [8 x fp16].
@@ -2773,7 +2772,6 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtneph_phf8(__m128h __A) {
/// \param __A
/// A 128-bit vector of [8 x fp16].
/// \returns
-///
/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __A; upper elements are zeroed. If
/// corresponding mask bit is set, then element from \a __W is taken instead.
@@ -2805,11 +2803,10 @@ _mm_mask_cvtneph_phf8(__m128i __W, __mmask8 __U, __m128h __A) {
/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
///
/// \param __U
-/// A 8-bit merging mask.
+/// A 8-bit zeroing mask.
/// \param __A
/// A 128-bit vector of [8 x fp16].
/// \returns
-///
/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __A; upper elements are zeroed. If
/// corresponding mask bit is not set, then element is zeroed.
@@ -2902,7 +2899,7 @@ _mm256_mask_cvtneph_phf8(__m128i __W, __mmask16 __U, __m256h __A) {
/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
///
/// \param __U
-/// A 16-bit merging mask.
+/// A 16-bit zeroing mask.
/// \param __A
/// A 256-bit vector of [16 x fp16].
/// \returns
@@ -2929,7 +2926,7 @@ _mm256_maskz_cvtneph_phf8(__mmask16 __U, __m256h __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNEPH2HF8S instruction.
///
/// \param __A
/// A 128-bit vector of [8 x fp16].
@@ -2960,7 +2957,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtnesph_phf8(__m128h __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __W
/// A 128-bit vector of [16 x fp8].
@@ -2997,10 +2994,10 @@ _mm_mask_cvtnesph_phf8(__m128i __W, __mmask8 __U, __m128h __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __U
-/// A 8-bit merging mask.
+/// A 8-bit zeroing mask.
/// \param __A
/// A 128-bit vector of [8 x fp16].
/// \returns
@@ -3026,7 +3023,7 @@ _mm_maskz_cvtnesph_phf8(__mmask8 __U, __m128h __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __A
/// A 256-bit vector of [16 x fp16].
@@ -3058,7 +3055,7 @@ _mm256_cvtnesph_phf8(__m256h __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __W
/// A 128-bit vector of [16 x fp8].
@@ -3095,10 +3092,10 @@ _mm256_mask_cvtnesph_phf8(__m128i __W, __mmask16 __U, __m256h __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
+/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __U
-/// A 16-bit merging mask.
+/// A 16-bit zeroing mask.
/// \param __A
/// A 256-bit vector of [16 x fp16].
/// \returns
@@ -3122,7 +3119,7 @@ _mm256_maskz_cvtnesph_phf8(__mmask16 __U, __m256h __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTHF82PH instruction.
+/// This intrinsic does not corresponds to a single instruction.
///
/// \param __A
/// A 128-bit vector of [16 x fp8].
@@ -3150,7 +3147,7 @@ static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtpbf8_ph(__m128i __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTHF82PH instruction.
+/// This intrinsic does not corresponds to a single instruction.
///
/// \param __W
/// A 128-bit vector of [8 x fp16].
@@ -3185,7 +3182,7 @@ _mm_mask_cvtpbf8_ph(__m128h __S, __mmask8 __U, __m128i __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTHF82PH instruction.
+/// This intrinsic does not corresponds to a single instruction.
///
/// \param __U
/// A 8-bit zeroing mask.
@@ -3211,7 +3208,7 @@ _mm_maskz_cvtpbf8_ph(__mmask8 __U, __m128i __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTHF82PH instruction.
+/// This intrinsic does not corresponds to a single instruction.
///
/// \param __A
/// A 256-bit vector of [32 x fp8].
@@ -3239,7 +3236,7 @@ static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_cvtpbf8_ph(__m128i __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTHF82PH instruction.
+/// This intrinsic does not corresponds to a single instruction.
///
/// \param __W
/// A 256-bit vector of [16 x fp16].
@@ -3274,10 +3271,10 @@ _mm256_mask_cvtpbf8_ph(__m256h __S, __mmask8 __U, __m128i __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic corresponds to the \c VCVTHF82PH instruction.
+/// This intrinsic does not corresponds to a single instruction.
///
/// \param __U
-/// A 16-bit merging mask.
+/// A 16-bit zeroing mask.
/// \param __A
/// A 256-bit vector of [32 x fp8].
/// \returns
>From b1e7a88dfccdd28df46cbd5ee5da3060cbc602f7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Miko=C5=82aj=20Pir=C3=B3g?= <mikolajpirog at gmail.com>
Date: Sat, 21 Dec 2024 19:50:29 +0100
Subject: [PATCH 6/9] Revierwer suggestions: correct merging masking order,
typos
---
clang/lib/Headers/avx10_2convertintrin.h | 202 +++++++++++------------
1 file changed, 101 insertions(+), 101 deletions(-)
diff --git a/clang/lib/Headers/avx10_2convertintrin.h b/clang/lib/Headers/avx10_2convertintrin.h
index 52a64a5309763d..a4faf359e82c26 100644
--- a/clang/lib/Headers/avx10_2convertintrin.h
+++ b/clang/lib/Headers/avx10_2convertintrin.h
@@ -63,14 +63,14 @@ static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtx2ps_ph(__m128 __A,
///
/// \code{.operation}
/// FOR i := 0 to 7
-/// IF mask[i]
-/// dst.fp16[i] := __W[i]
-/// ELSE
+/// IF __U[i]
/// IF i < 4
/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
/// ELSE
/// dst.fp16[i] := convert_fp32_to_fp16(__A.fp32[i - 4])
/// FI
+/// ELSE
+/// dst.fp16[i] := __W.fp16[i]
/// FI
/// ENDFOR
/// \endcode
@@ -90,7 +90,7 @@ static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtx2ps_ph(__m128 __A,
/// \returns
/// A 128-bit vector of [8 x fp16]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
-/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m128h __DEFAULT_FN_ATTRS128
_mm_mask_cvtx2ps_ph(__m128h __W, __mmask8 __U, __m128 __A, __m128 __B) {
@@ -105,7 +105,7 @@ _mm_mask_cvtx2ps_ph(__m128h __W, __mmask8 __U, __m128 __A, __m128 __B) {
///
/// \code{.operation}
/// FOR i := 0 to 7
-/// IF mask[i]
+/// IF __U[i]
/// IF i < 4
/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
/// ELSE
@@ -178,14 +178,14 @@ static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_cvtx2ps_ph(__m256 __A,
///
/// \code{.operation}
/// FOR i := 0 to 15
-/// IF mask[i]
-/// dst.fp16[i] := __W[i]
-/// ELSE
+/// IF __U[i]
/// IF i < 8
/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
/// ELSE
/// dst.fp16[i] := convert_fp32_to_fp16(__A.fp32[i - 8])
/// FI
+/// ELSE
+/// dst.fp16[i] := __W.fp16[i]
/// FI
/// ENDFOR
/// \endcode
@@ -205,7 +205,7 @@ static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_cvtx2ps_ph(__m256 __A,
/// \returns
/// A 256-bit vector of [16 x fp16]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
-/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m256h __DEFAULT_FN_ATTRS256
_mm256_mask_cvtx2ps_ph(__m256h __W, __mmask16 __U, __m256 __A, __m256 __B) {
@@ -221,7 +221,7 @@ _mm256_mask_cvtx2ps_ph(__m256h __W, __mmask16 __U, __m256 __A, __m256 __B) {
///
/// \code{.operation}
/// FOR i := 0 to 15
-/// IF mask[i]
+/// IF __U[i]
/// IF i < 8
/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
/// ELSE
@@ -299,14 +299,14 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
///
/// \code{.operation}
/// FOR i := 0 to 15
-/// IF mask[i]
-/// dst.fp16[i] := __W[i]
-/// ELSE
+/// IF __U[i]
/// IF i < 8
/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
/// ELSE
/// dst.fp16[i] := convert_fp32_to_fp16(__A.fp32[i - 8])
/// FI
+/// ELSE
+/// dst.fp16[i] := __W.fp16[i]
/// FI
/// ENDFOR
/// \endcode
@@ -331,7 +331,7 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
/// \returns
/// A 256-bit vector of [16 x fp16]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
-/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
#define _mm256_mask_cvtx_round2ps_ph(W, U, A, B, R) \
((__m256h)__builtin_ia32_vcvt2ps2phx256_mask( \
@@ -344,7 +344,7 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
///
/// \code{.operation}
/// FOR i := 0 to 15
-/// IF mask[i]
+/// IF __U[i]
/// IF i < 8
/// dst.fp16[i] := convert_fp32_to_fp16(__B.fp32[i])
/// ELSE
@@ -419,9 +419,9 @@ _mm_cvtbiasph_pbf8(__m128i __A, __m128h __B) {
/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
-/// dst.fp8[i] := _W[i]
-/// ELSE
/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ELSE
+/// dst.fp8[i] := _W[i]
/// FI
/// ENDFOR
///
@@ -443,7 +443,7 @@ _mm_cvtbiasph_pbf8(__m128i __A, __m128h __B) {
/// \returns
/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the sum of
/// elements from \a __A and \a __B; higher order elements are zeroed. If
-/// corresponding mask bit is set, then element from \a __W is taken instead.
+/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtbiasph_pbf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2bf8_128_mask(
@@ -526,9 +526,9 @@ _mm256_cvtbiasph_pbf8(__m256i __A, __m256h __B) {
/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
-/// dst.fp8[i] := _W[i]
-/// ELSE
/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ELSE
+/// dst.fp8[i] := _W[i]
/// FI
/// ENDFOR
/// \endcode
@@ -547,7 +547,7 @@ _mm256_cvtbiasph_pbf8(__m256i __A, __m256h __B) {
/// A 256-bit vector of [16 x int16].
/// \returns
/// A 128-bit vector of [16 x fp8]. Elements correspond to the sum of
-/// elements from \a __A and \a __B. If corresponding mask bit is set, then
+/// elements from \a __A and \a __B. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiasph_pbf8(
__m128i __W, __mmask16 __U, __m256i __A, __m256h __B) {
@@ -631,9 +631,9 @@ _mm_cvtbiassph_pbf8(__m128i __A, __m128h __B) {
/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
-/// dst.fp8[i] := _W[i]
-/// ELSE
/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ELSE
+/// dst.fp8[i] := _W[i]
/// FI
/// ENDFOR
///
@@ -655,7 +655,7 @@ _mm_cvtbiassph_pbf8(__m128i __A, __m128h __B) {
/// \returns
/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the sum of
/// elements from \a __A and \a __B; higher order elements are zeroed. If
-/// corresponding mask bit is set, then element from \a __W is taken instead.
+/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtbiassph_pbf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2bf8s_128_mask(
@@ -739,9 +739,9 @@ _mm256_cvtbiassph_pbf8(__m256i __A, __m256h __B) {
/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
-/// dst.fp8[i] := _W[i]
-/// ELSE
/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ELSE
+/// dst.fp8[i] := _W[i]
/// FI
/// ENDFOR
/// \endcode
@@ -760,7 +760,7 @@ _mm256_cvtbiassph_pbf8(__m256i __A, __m256h __B) {
/// A 256-bit vector of [16 x int16].
/// \returns
/// A 128-bit vector of [16 x fp8]. Elements correspond to the sum of
-/// elements from \a __A and \a __B. If corresponding mask bit is set, then
+/// elements from \a __A and \a __B. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiassph_pbf8(
__m128i __W, __mmask16 __U, __m256i __A, __m256h __B) {
@@ -843,9 +843,9 @@ _mm_cvtbiasph_phf8(__m128i __A, __m128h __B) {
/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
-/// dst.fp8[i] := _W[i]
-/// ELSE
/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ELSE
+/// dst.fp8[i] := _W[i]
/// FI
/// ENDFOR
///
@@ -867,7 +867,7 @@ _mm_cvtbiasph_phf8(__m128i __A, __m128h __B) {
/// \returns
/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the sum of
/// elements from \a __A and \a __B; higher order elements are zeroed. If
-/// corresponding mask bit is set, then element from \a __W is taken instead.
+/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtbiasph_phf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2hf8_128_mask(
@@ -950,9 +950,9 @@ _mm256_cvtbiasph_phf8(__m256i __A, __m256h __B) {
/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
-/// dst.fp8[i] := _W[i]
-/// ELSE
/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ELSE
+/// dst.fp8[i] := _W[i]
/// FI
/// ENDFOR
/// \endcode
@@ -971,7 +971,7 @@ _mm256_cvtbiasph_phf8(__m256i __A, __m256h __B) {
/// A 256-bit vector of [16 x int16].
/// \returns
/// A 128-bit vector of [16 x fp8]. Elements correspond to the sum of
-/// elements from \a __A and \a __B. If corresponding mask bit is set, then
+/// elements from \a __A and \a __B. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiasph_phf8(
__m128i __W, __mmask16 __U, __m256i __A, __m256h __B) {
@@ -1055,9 +1055,9 @@ _mm_cvtbiassph_phf8(__m128i __A, __m128h __B) {
/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
-/// dst.fp8[i] := _W[i]
-/// ELSE
/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ELSE
+/// dst.fp8[i] := _W[i]
/// FI
/// ENDFOR
///
@@ -1079,7 +1079,7 @@ _mm_cvtbiassph_phf8(__m128i __A, __m128h __B) {
/// \returns
/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the sum of
/// elements from \a __A and \a __B; higher order elements are zeroed. If
-/// corresponding mask bit is set, then element from \a __W is taken instead.
+/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtbiassph_phf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
return (__m128i)__builtin_ia32_vcvtbiasph2hf8s_128_mask(
@@ -1163,9 +1163,9 @@ _mm256_cvtbiassph_phf8(__m256i __A, __m256h __B) {
/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
-/// dst.fp8[i] := _W[i]
-/// ELSE
/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
+/// ELSE
+/// dst.fp8[i] := _W[i]
/// FI
/// ENDFOR
/// \endcode
@@ -1184,7 +1184,7 @@ _mm256_cvtbiassph_phf8(__m256i __A, __m256h __B) {
/// A 256-bit vector of [16 x int16].
/// \returns
/// A 128-bit vector of [16 x fp8]. Elements correspond to the sum of
-/// elements from \a __A and \a __B. If corresponding mask bit is set, then
+/// elements from \a __A and \a __B. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiassph_phf8(
__m128i __W, __mmask16 __U, __m256i __A, __m256h __B) {
@@ -1268,13 +1268,13 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_pbf8(__m128h __A,
/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
-/// dst.fp8[i] := __W[i]
-/// ELSE
/// IF i < 8
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
/// ELSE
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 8])
/// FI
+/// ELSE
+/// dst.fp8 := __W.fp8[i]
/// FI
/// ENDFOR
/// \endcode
@@ -1294,7 +1294,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_pbf8(__m128h __A,
/// \returns
/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
-/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtne2ph_pbf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
@@ -1382,13 +1382,13 @@ _mm256_cvtne2ph_pbf8(__m256h __A, __m256h __B) {
/// \code{.operation}
/// FOR i := 0 to 31
/// IF __U[i]
-/// dst.fp8[i] := __W.fp8[i]
-/// ELSE
/// IF i < 16
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
/// ELSE
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 16])
/// FI
+/// ELSE
+/// dst.fp8[i] := __W.fp8[i]
/// FI
/// ENDFOR
/// \endcode
@@ -1408,7 +1408,7 @@ _mm256_cvtne2ph_pbf8(__m256h __A, __m256h __B) {
/// \returns
/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
-/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtne2ph_pbf8(
__m256i __W, __mmask32 __U, __m256h __A, __m256h __B) {
@@ -1497,13 +1497,13 @@ _mm_cvtnes2ph_pbf8(__m128h __A, __m128h __B) {
/// \code{.operation}
/// FOR i := 0 to 16
/// IF __U[i]
-/// dst.fp8[i] := __W[i]
-/// ELSE
/// IF i < 8
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
/// ELSE
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 8])
/// FI
+/// ELSE
+/// dst.fp8 := __W.fp8[i]
/// FI
/// ENDFOR
/// \endcode
@@ -1523,7 +1523,7 @@ _mm_cvtnes2ph_pbf8(__m128h __A, __m128h __B) {
/// \returns
/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
-/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtnes2ph_pbf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
@@ -1612,13 +1612,13 @@ _mm256_cvtnes2ph_pbf8(__m256h __A, __m256h __B) {
/// \code{.operation}
/// FOR i := 0 to 31
/// IF __U[i]
-/// dst.fp8[i] := __W.fp8[i]
-/// ELSE
/// IF i < 16
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
/// ELSE
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 16])
/// FI
+/// ELSE
+/// dst.fp8[i] := __W.fp8[i]
/// FI
/// ENDFOR
/// \endcode
@@ -1638,7 +1638,7 @@ _mm256_cvtnes2ph_pbf8(__m256h __A, __m256h __B) {
/// \returns
/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
-/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtnes2ph_pbf8(
__m256i __W, __mmask32 __U, __m256h __A, __m256h __B) {
@@ -1726,13 +1726,13 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_phf8(__m128h __A,
/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
-/// dst.fp8[i] := __W[i]
-/// ELSE
/// IF i < 8
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
/// ELSE
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 8])
/// FI
+/// ELSE
+/// dst.fp8 := __W.fp8[i]
/// FI
/// ENDFOR
/// \endcode
@@ -1752,7 +1752,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_phf8(__m128h __A,
/// \returns
/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
-/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtne2ph_phf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
@@ -1840,13 +1840,13 @@ _mm256_cvtne2ph_phf8(__m256h __A, __m256h __B) {
/// \code{.operation}
/// FOR i := 0 to 31
/// IF __U[i]
-/// dst.fp8[i] := __W.fp8[i]
-/// ELSE
/// IF i < 16
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
/// ELSE
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 16])
/// FI
+/// ELSE
+/// dst.fp8[i] := __W.fp8[i]
/// FI
/// ENDFOR
/// \endcode
@@ -1866,7 +1866,7 @@ _mm256_cvtne2ph_phf8(__m256h __A, __m256h __B) {
/// \returns
/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
-/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtne2ph_phf8(
__m256i __W, __mmask32 __U, __m256h __A, __m256h __B) {
@@ -1955,13 +1955,13 @@ _mm_cvtnes2ph_phf8(__m128h __A, __m128h __B) {
/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
-/// dst.fp8[i] := __W[i]
-/// ELSE
/// IF i < 8
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
/// ELSE
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 8])
/// FI
+/// ELSE
+/// dst.fp8 := __W.fp8[i]
/// FI
/// ENDFOR
/// \endcode
@@ -1981,7 +1981,7 @@ _mm_cvtnes2ph_phf8(__m128h __A, __m128h __B) {
/// \returns
/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
-/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtnes2ph_phf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
@@ -2070,13 +2070,13 @@ _mm256_cvtnes2ph_phf8(__m256h __A, __m256h __B) {
/// \code{.operation}
/// FOR i := 0 to 31
/// IF __U[i]
-/// dst.fp8[i] := __W.fp8[i]
-/// ELSE
/// IF i < 16
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
/// ELSE
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 16])
/// FI
+/// ELSE
+/// dst.fp8[i] := __W.fp8[i]
/// FI
/// ENDFOR
/// \endcode
@@ -2096,7 +2096,7 @@ _mm256_cvtnes2ph_phf8(__m256h __A, __m256h __B) {
/// \returns
/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
-/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtnes2ph_phf8(
__m256i __W, __mmask32 __U, __m256h __A, __m256h __B) {
@@ -2176,9 +2176,9 @@ static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtnehf8_ph(__m128i __A) {
/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
-/// dst.fp16[i] := __W[i]
-/// ELSE
/// dst.fp16[i] := convert_fp8_to_fp16(__A.fp8[i])
+/// ELSE
+/// dst.fp16[i] := __W.fp16[i]
/// FI
/// ENDFOR
/// \endcode
@@ -2195,7 +2195,7 @@ static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtnehf8_ph(__m128i __A) {
/// A 128-bit vector of [16 x fp8].
/// \returns
/// A 128-bit vector of [8 x fp16]. Resulting elements correspond to the
-/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m128h __DEFAULT_FN_ATTRS128
_mm_mask_cvtnehf8_ph(__m128h __W, __mmask8 __U, __m128i __A) {
@@ -2268,9 +2268,9 @@ _mm256_cvtnehf8_ph(__m128i __A) {
/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
-/// dst.fp16[i] := __W[i]
-/// ELSE
/// dst.fp16[i] := convert_fp8_to_fp16(__A.fp8[i])
+/// ELSE
+/// dst.fp16[i] := __W.fp16[i]
/// FI
/// ENDFOR
/// \endcode
@@ -2287,7 +2287,7 @@ _mm256_cvtnehf8_ph(__m128i __A) {
/// A 256-bit vector of [32 x fp8].
/// \returns
/// A 256-bit vector of [16 x fp16]. Resulting elements correspond to the
-/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m256h __DEFAULT_FN_ATTRS256
_mm256_mask_cvtnehf8_ph(__m256h __W, __mmask16 __U, __m128i __A) {
@@ -2362,9 +2362,9 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtneph_pbf8(__m128h __A) {
/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
-/// dst.fp8[i] := __W[i]
-/// ELSE
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ELSE
+/// dst.fp8 := __W.fp8[i]
/// FI
/// ENDFOR
///
@@ -2384,7 +2384,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtneph_pbf8(__m128h __A) {
/// \returns
/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __A; upper elements are zeroed. If
-/// corresponding mask bit is set, then element from \a __W is taken instead.
+/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtneph_pbf8(__m128i __W, __mmask8 __U, __m128h __A) {
return (__m128i)__builtin_ia32_vcvtneph2bf8_128_mask(
@@ -2399,9 +2399,9 @@ _mm_mask_cvtneph_pbf8(__m128i __W, __mmask8 __U, __m128h __A) {
/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
-/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
-/// ELSE
/// dst.fp8[i] := 0
+/// ELSE
+/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
/// FI
/// ENDFOR
///
@@ -2459,9 +2459,9 @@ _mm256_cvtneph_pbf8(__m256h __A) {
/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
-/// dst.fp8[i] := __W[i]
-/// ELSE
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ELSE
+/// dst.fp8 := __W.fp8[i]
/// FI
/// ENDFOR
///
@@ -2481,7 +2481,7 @@ _mm256_cvtneph_pbf8(__m256h __A) {
/// \returns
/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the
/// (converted) elements from \a __A. If
-/// corresponding mask bit is set, then element from \a __W is taken instead.
+/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_mask_cvtneph_pbf8(__m128i __W, __mmask16 __U, __m256h __A) {
return (__m128i)__builtin_ia32_vcvtneph2bf8_256_mask(
@@ -2556,9 +2556,9 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtnesph_pbf8(__m128h __A) {
/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
-/// dst.fp8[i] := __W[i]
-/// ELSE
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ELSE
+/// dst.fp8 := __W.fp8[i]
/// FI
/// ENDFOR
///
@@ -2578,7 +2578,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtnesph_pbf8(__m128h __A) {
/// \returns
/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __A; upper elements are zeroed. If
-/// corresponding mask bit is set, then element from \a __W is taken instead.
+/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtnesph_pbf8(__m128i __W, __mmask8 __U, __m128h __A) {
return (__m128i)__builtin_ia32_vcvtneph2bf8s_128_mask(
@@ -2654,9 +2654,9 @@ _mm256_cvtnesph_pbf8(__m256h __A) {
/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
-/// dst.fp8[i] := __W[i]
-/// ELSE
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ELSE
+/// dst.fp8 := __W.fp8[i]
/// FI
/// ENDFOR
///
@@ -2676,7 +2676,7 @@ _mm256_cvtnesph_pbf8(__m256h __A) {
/// \returns
/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the
/// (converted) elements from \a __A. If
-/// corresponding mask bit is set, then element from \a __W is taken instead.
+/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_mask_cvtnesph_pbf8(__m128i __W, __mmask16 __U, __m256h __A) {
return (__m128i)__builtin_ia32_vcvtneph2bf8s_256_mask(
@@ -2752,9 +2752,9 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtneph_phf8(__m128h __A) {
/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
-/// dst.fp8[i] := __W[i]
-/// ELSE
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ELSE
+/// dst.fp8 := __W.fp8[i]
/// FI
/// ENDFOR
///
@@ -2774,7 +2774,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtneph_phf8(__m128h __A) {
/// \returns
/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __A; upper elements are zeroed. If
-/// corresponding mask bit is set, then element from \a __W is taken instead.
+/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtneph_phf8(__m128i __W, __mmask8 __U, __m128h __A) {
return (__m128i)__builtin_ia32_vcvtneph2hf8_128_mask(
@@ -2849,9 +2849,9 @@ _mm256_cvtneph_phf8(__m256h __A) {
/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
-/// dst.fp8[i] := __W[i]
-/// ELSE
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ELSE
+/// dst.fp8 := __W.fp8[i]
/// FI
/// ENDFOR
///
@@ -2871,7 +2871,7 @@ _mm256_cvtneph_phf8(__m256h __A) {
/// \returns
/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the
/// (converted) elements from \a __A. If
-/// corresponding mask bit is set, then element from \a __W is taken instead.
+/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_mask_cvtneph_phf8(__m128i __W, __mmask16 __U, __m256h __A) {
return (__m128i)__builtin_ia32_vcvtneph2hf8_256_mask(
@@ -2946,9 +2946,9 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtnesph_phf8(__m128h __A) {
/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
-/// dst.fp8[i] := __W[i]
-/// ELSE
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ELSE
+/// dst.fp8 := __W.fp8[i]
/// FI
/// ENDFOR
///
@@ -2968,7 +2968,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtnesph_phf8(__m128h __A) {
/// \returns
/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
/// (converted) elements from \a __A; upper elements are zeroed. If
-/// corresponding mask bit is set, then element from \a __W is taken instead.
+/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_mask_cvtnesph_phf8(__m128i __W, __mmask8 __U, __m128h __A) {
return (__m128i)__builtin_ia32_vcvtneph2hf8s_128_mask(
@@ -3044,9 +3044,9 @@ _mm256_cvtnesph_phf8(__m256h __A) {
/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
-/// dst.fp8[i] := __W[i]
-/// ELSE
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
+/// ELSE
+/// dst.fp8 := __W.fp8[i]
/// FI
/// ENDFOR
///
@@ -3066,7 +3066,7 @@ _mm256_cvtnesph_phf8(__m256h __A) {
/// \returns
/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the
/// (converted) elements from \a __A. If
-/// corresponding mask bit is set, then element from \a __W is taken instead.
+/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_mask_cvtnesph_phf8(__m128i __W, __mmask16 __U, __m256h __A) {
return (__m128i)__builtin_ia32_vcvtneph2hf8s_256_mask(
@@ -3138,9 +3138,9 @@ static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtpbf8_ph(__m128i __A) {
/// \code{.operation}
/// FOR i := 0 to 7
/// IF __U[i]
-/// dst.fp16[i] := __W[i]
-/// ELSE
/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
+/// ELSE
+/// dst.fp16[i] := __W.fp16[i]
/// FI
/// ENDFOR
/// \endcode
@@ -3157,7 +3157,7 @@ static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtpbf8_ph(__m128i __A) {
/// A 128-bit vector of [16 x fp8].
/// \returns
/// A 128-bit vector of [8 x fp16]. Resulting elements correspond to the
-/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m128h __DEFAULT_FN_ATTRS128
_mm_mask_cvtpbf8_ph(__m128h __S, __mmask8 __U, __m128i __A) {
@@ -3227,9 +3227,9 @@ static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_cvtpbf8_ph(__m128i __A) {
/// \code{.operation}
/// FOR i := 0 to 15
/// IF __U[i]
-/// dst.fp16[i] := __W[i]
-/// ELSE
/// dst.fp16[i] := convert_fp8_to_fp16(__B.fp8[i])
+/// ELSE
+/// dst.fp16[i] := __W.fp16[i]
/// FI
/// ENDFOR
/// \endcode
@@ -3246,7 +3246,7 @@ static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_cvtpbf8_ph(__m128i __A) {
/// A 256-bit vector of [32 x fp8].
/// \returns
/// A 256-bit vector of [16 x fp16]. Resulting elements correspond to the
-/// (converted) elements from \a __A. If corresponding mask bit is set, then
+/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m256h __DEFAULT_FN_ATTRS256
_mm256_mask_cvtpbf8_ph(__m256h __S, __mmask8 __U, __m128i __A) {
>From 1c76481f397260d5b3a226b3c93aa514c1e413e1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Miko=C5=82aj=20Pir=C3=B3g?= <mikolajpirog at gmail.com>
Date: Sat, 21 Dec 2024 21:18:34 +0100
Subject: [PATCH 7/9] Reviewer suggestions: add bf8, hf8
---
clang/lib/Headers/avx10_2convertintrin.h | 722 +++++++++++------------
1 file changed, 361 insertions(+), 361 deletions(-)
diff --git a/clang/lib/Headers/avx10_2convertintrin.h b/clang/lib/Headers/avx10_2convertintrin.h
index a4faf359e82c26..077d8c95b2f38b 100644
--- a/clang/lib/Headers/avx10_2convertintrin.h
+++ b/clang/lib/Headers/avx10_2convertintrin.h
@@ -25,8 +25,8 @@
__min_vector_width__(256)))
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed
-/// single-precision (32-bit) floating-point elements to a 128-bit vector
-/// containing FP16 elements.
+/// single-precision (32-bit) floating-point elements to a 128-bit vector
+/// containing FP16 elements.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -57,9 +57,9 @@ static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtx2ps_ph(__m128 __A,
}
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed
-/// single-precision (32-bit) floating-point elements to a 128-bit vector
-/// containing FP16 elements. Merging mask \a __U is used to determine if given
-/// element should be taken from \a __W instead.
+/// single-precision (32-bit) floating-point elements to a 128-bit vector
+/// containing FP16 elements. Merging mask \a __U is used to determine if given
+/// element should be taken from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -99,9 +99,9 @@ _mm_mask_cvtx2ps_ph(__m128h __W, __mmask8 __U, __m128 __A, __m128 __B) {
}
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed
-/// single-precision (32-bit) floating-point elements to a 128-bit vector
-/// containing FP16 elements. Zeroing mask \a __U is used to determine if given
-/// element should be zeroed instead.
+/// single-precision (32-bit) floating-point elements to a 128-bit vector
+/// containing FP16 elements. Zeroing mask \a __U is used to determine if given
+/// element should be zeroed instead.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -139,8 +139,8 @@ _mm_maskz_cvtx2ps_ph(__mmask8 __U, __m128 __A, __m128 __B) {
}
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed
-/// single-precision (32-bit) floating-point elements to a 256-bit vector
-/// containing FP16 elements.
+/// single-precision (32-bit) floating-point elements to a 256-bit vector
+/// containing FP16 elements.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -172,9 +172,9 @@ static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_cvtx2ps_ph(__m256 __A,
}
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed
-/// single-precision (32-bit) floating-point elements to a 256-bit vector
-/// containing FP16 elements. Merging mask \a __U is used to determine if given
-/// element should be taken from \a __W instead.
+/// single-precision (32-bit) floating-point elements to a 256-bit vector
+/// containing FP16 elements. Merging mask \a __U is used to determine if given
+/// element should be taken from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -215,9 +215,9 @@ _mm256_mask_cvtx2ps_ph(__m256h __W, __mmask16 __U, __m256 __A, __m256 __B) {
}
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed
-/// single-precision (32-bit) floating-point elements to a 256-bit vector
-/// containing FP16 elements. Zeroing mask \a __U is used to determine if given
-/// element should be zeroed instead.
+/// single-precision (32-bit) floating-point elements to a 256-bit vector
+/// containing FP16 elements. Zeroing mask \a __U is used to determine if given
+/// element should be zeroed instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -256,8 +256,8 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
}
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed
-/// single-precision (32-bit) floating-point elements to a 256-bit vector
-/// containing FP16 elements. Rounding mode \a __R needs to be provided.
+/// single-precision (32-bit) floating-point elements to a 256-bit vector
+/// containing FP16 elements. Rounding mode \a __R needs to be provided.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -292,10 +292,10 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
(__mmask16)(-1), (const int)(R)))
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed
-/// single-precision (32-bit) floating-point elements to a 256-bit vector
-/// containing FP16 elements. Merging mask \a __U is used to determine if given
-/// element should be taken from \a __W instead. Rounding mode \a __R needs to
-/// be provided.
+/// single-precision (32-bit) floating-point elements to a 256-bit vector
+/// containing FP16 elements. Merging mask \a __U is used to determine if given
+/// element should be taken from \a __W instead. Rounding mode \a __R needs to
+/// be provided.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -338,9 +338,9 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
(__v8sf)(A), (__v8sf)(B), (__v16hf)(W), (__mmask16)(U), (const int)(R)))
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed
-/// single-precision (32-bit) floating-point elements to a 256-bit vector
-/// containing FP16 elements. Zeroing mask \a __U is used to determine if given
-/// element should be zeroed instead. Rounding mode \a __R needs to be provided.
+/// single-precision (32-bit) floating-point elements to a 256-bit vector
+/// containing FP16 elements. Zeroing mask \a __U is used to determine if given
+/// element should be zeroed instead. Rounding mode \a __R needs to be provided.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -382,8 +382,8 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
(__mmask16)(U), (const int)(R)))
/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -402,7 +402,7 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
/// \param __B
/// A 128-bit vector of [8 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x bf8]. Lower elements correspond to the
/// sum of elements from \a __A and \a __B; higher order elements are zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_cvtbiasph_pbf8(__m128i __A, __m128h __B) {
@@ -411,10 +411,10 @@ _mm_cvtbiasph_pbf8(__m128i __A, __m128h __B) {
}
/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
-/// Merging mask \a __U is used to determine if given element should be taken
-/// from \a __W instead.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -433,7 +433,7 @@ _mm_cvtbiasph_pbf8(__m128i __A, __m128h __B) {
/// This intrinsic corresponds to the \c VCVTBIASPH2BF8 instruction.
///
/// \param __W
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x bf8].
/// \param __U
/// A 8-bit merging mask.
/// \param __A
@@ -441,7 +441,7 @@ _mm_cvtbiasph_pbf8(__m128i __A, __m128h __B) {
/// \param __B
/// A 128-bit vector of [8 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the sum of
+/// A 128-bit vector of [16 x bf8]. Lower elements correspond to the sum of
/// elements from \a __A and \a __B; higher order elements are zeroed. If
/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
@@ -451,10 +451,10 @@ _mm_mask_cvtbiasph_pbf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
}
/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
-/// Zeroing mask \a __U is used to determine if given element should be zeroed
-/// instead.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+/// Zeroing mask \a __U is used to determine if given element should be zeroed
+/// instead.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -479,7 +479,7 @@ _mm_mask_cvtbiasph_pbf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
/// \param __B
/// A 128-bit vector of [8 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the sum of
+/// A 128-bit vector of [16 x bf8]. Lower elements correspond to the sum of
/// elements from \a __A and \a __B; higher order elements are zeroed. If
/// corresponding mask bit is not set, then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
@@ -490,8 +490,8 @@ _mm_maskz_cvtbiasph_pbf8(__mmask8 __U, __m128i __A, __m128h __B) {
}
/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -508,7 +508,7 @@ _mm_maskz_cvtbiasph_pbf8(__mmask8 __U, __m128i __A, __m128h __B) {
/// \param __B
/// A 256-bit vector of [16 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Elements correspond to the
+/// A 128-bit vector of [16 x bf8]. Elements correspond to the
/// sum of elements from \a __A and \a __B.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_cvtbiasph_pbf8(__m256i __A, __m256h __B) {
@@ -518,10 +518,10 @@ _mm256_cvtbiasph_pbf8(__m256i __A, __m256h __B) {
}
/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
-/// Merging mask \a __U is used to determine if given element should be taken
-/// from \a __W instead.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -538,7 +538,7 @@ _mm256_cvtbiasph_pbf8(__m256i __A, __m256h __B) {
/// This intrinsic corresponds to the \c VCVTBIASPH2BF8 instruction.
///
/// \param __W
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x bf8].
/// \param __U
/// A 16-bit merging mask.
/// \param __A
@@ -546,7 +546,7 @@ _mm256_cvtbiasph_pbf8(__m256i __A, __m256h __B) {
/// \param __B
/// A 256-bit vector of [16 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Elements correspond to the sum of
+/// A 128-bit vector of [16 x bf8]. Elements correspond to the sum of
/// elements from \a __A and \a __B. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiasph_pbf8(
@@ -556,10 +556,10 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiasph_pbf8(
}
/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
-/// Merging mask \a __U is used to determine if given element should be taken
-/// from \a __W instead.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -582,7 +582,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiasph_pbf8(
/// \param __B
/// A 256-bit vector of [16 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Elements correspond to the sum of
+/// A 128-bit vector of [16 x bf8]. Elements correspond to the sum of
/// elements from \a __A and \a __B. If corresponding mask bit is not set,
/// then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
@@ -593,9 +593,9 @@ _mm256_maskz_cvtbiasph_pbf8(__mmask16 __U, __m256i __A, __m256h __B) {
}
/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
-/// Results are saturated.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+/// Results are saturated.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -614,7 +614,7 @@ _mm256_maskz_cvtbiasph_pbf8(__mmask16 __U, __m256i __A, __m256h __B) {
/// \param __B
/// A 128-bit vector of [8 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x bf8]. Lower elements correspond to the
/// sum of elements from \a __A and \a __B; higher order elements are zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_cvtbiassph_pbf8(__m128i __A, __m128h __B) {
@@ -623,10 +623,10 @@ _mm_cvtbiassph_pbf8(__m128i __A, __m128h __B) {
}
/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
-/// Results are saturated. Merging mask \a __U is used to determine if given
-/// element should be taken from \a __W instead.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+/// Results are saturated. Merging mask \a __U is used to determine if given
+/// element should be taken from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -645,7 +645,7 @@ _mm_cvtbiassph_pbf8(__m128i __A, __m128h __B) {
/// This intrinsic corresponds to the \c VCVTBIASPH2BF8S instruction.
///
/// \param __W
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x bf8].
/// \param __U
/// A 8-bit merging mask.
/// \param __A
@@ -653,7 +653,7 @@ _mm_cvtbiassph_pbf8(__m128i __A, __m128h __B) {
/// \param __B
/// A 128-bit vector of [8 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the sum of
+/// A 128-bit vector of [16 x bf8]. Lower elements correspond to the sum of
/// elements from \a __A and \a __B; higher order elements are zeroed. If
/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
@@ -663,10 +663,10 @@ _mm_mask_cvtbiassph_pbf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
}
/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
-/// Results are saturated. Zeroing mask \a __U is used to determine if given
-/// element should be zeroed instead.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+/// Results are saturated. Zeroing mask \a __U is used to determine if given
+/// element should be zeroed instead.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -691,7 +691,7 @@ _mm_mask_cvtbiassph_pbf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
/// \param __B
/// A 128-bit vector of [8 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the sum of
+/// A 128-bit vector of [16 x bf8]. Lower elements correspond to the sum of
/// elements from \a __A and \a __B; higher order elements are zeroed. If
/// corresponding mask bit is not set, then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
@@ -702,9 +702,9 @@ _mm_maskz_cvtbiassph_pbf8(__mmask8 __U, __m128i __A, __m128h __B) {
}
/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
-/// Results are saturated.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+/// Results are saturated.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -721,7 +721,7 @@ _mm_maskz_cvtbiassph_pbf8(__mmask8 __U, __m128i __A, __m128h __B) {
/// \param __B
/// A 256-bit vector of [16 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Elements correspond to the
+/// A 128-bit vector of [16 x bf8]. Elements correspond to the
/// sum of elements from \a __A and \a __B.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_cvtbiassph_pbf8(__m256i __A, __m256h __B) {
@@ -731,10 +731,10 @@ _mm256_cvtbiassph_pbf8(__m256i __A, __m256h __B) {
}
/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
-/// Results are saturated. Merging mask \a __U is used to determine if given
-/// element should be taken from \a __W instead.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+/// Results are saturated. Merging mask \a __U is used to determine if given
+/// element should be taken from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -751,7 +751,7 @@ _mm256_cvtbiassph_pbf8(__m256i __A, __m256h __B) {
/// This intrinsic corresponds to the \c VCVTBIASPH2BF8S instruction.
///
/// \param __W
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x bf8].
/// \param __U
/// A 16-bit merging mask.
/// \param __A
@@ -759,7 +759,7 @@ _mm256_cvtbiassph_pbf8(__m256i __A, __m256h __B) {
/// \param __B
/// A 256-bit vector of [16 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Elements correspond to the sum of
+/// A 128-bit vector of [16 x bf8]. Elements correspond to the sum of
/// elements from \a __A and \a __B. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiassph_pbf8(
@@ -769,10 +769,10 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiassph_pbf8(
}
/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
-/// Results are saturated. Merging mask \a __U is used to determine if given
-/// element should be taken from \a __W instead.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E5M2.
+/// Results are saturated. Merging mask \a __U is used to determine if given
+/// element should be taken from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -795,7 +795,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiassph_pbf8(
/// \param __B
/// A 256-bit vector of [16 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Elements correspond to the sum of
+/// A 128-bit vector of [16 x bf8]. Elements correspond to the sum of
/// elements from \a __A and \a __B. If corresponding mask bit is not set,
/// then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
@@ -806,8 +806,8 @@ _mm256_maskz_cvtbiassph_pbf8(__mmask16 __U, __m256i __A, __m256h __B) {
}
/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -826,7 +826,7 @@ _mm256_maskz_cvtbiassph_pbf8(__mmask16 __U, __m256i __A, __m256h __B) {
/// \param __B
/// A 128-bit vector of [8 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x hf8]. Lower elements correspond to the
/// sum of elements from \a __A and \a __B; higher order elements are zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_cvtbiasph_phf8(__m128i __A, __m128h __B) {
@@ -835,10 +835,10 @@ _mm_cvtbiasph_phf8(__m128i __A, __m128h __B) {
}
/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
-/// Merging mask \a __U is used to determine if given element should be taken
-/// from \a __W instead.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -857,7 +857,7 @@ _mm_cvtbiasph_phf8(__m128i __A, __m128h __B) {
/// This intrinsic corresponds to the \c VCVTBIASPH2HF8 instruction.
///
/// \param __W
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x hf8].
/// \param __U
/// A 8-bit merging mask.
/// \param __A
@@ -865,7 +865,7 @@ _mm_cvtbiasph_phf8(__m128i __A, __m128h __B) {
/// \param __B
/// A 128-bit vector of [8 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the sum of
+/// A 128-bit vector of [16 x hf8]. Lower elements correspond to the sum of
/// elements from \a __A and \a __B; higher order elements are zeroed. If
/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
@@ -875,10 +875,10 @@ _mm_mask_cvtbiasph_phf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
}
/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
-/// Zeroing mask \a __U is used to determine if given element should be zeroed
-/// instead.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
+/// Zeroing mask \a __U is used to determine if given element should be zeroed
+/// instead.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -903,7 +903,7 @@ _mm_mask_cvtbiasph_phf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
/// \param __B
/// A 128-bit vector of [8 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the sum of
+/// A 128-bit vector of [16 x hf8]. Lower elements correspond to the sum of
/// elements from \a __A and \a __B; higher order elements are zeroed. If
/// corresponding mask bit is not set, then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
@@ -914,8 +914,8 @@ _mm_maskz_cvtbiasph_phf8(__mmask8 __U, __m128i __A, __m128h __B) {
}
/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -932,7 +932,7 @@ _mm_maskz_cvtbiasph_phf8(__mmask8 __U, __m128i __A, __m128h __B) {
/// \param __B
/// A 256-bit vector of [16 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Elements correspond to the
+/// A 128-bit vector of [16 x hf8]. Elements correspond to the
/// sum of elements from \a __A and \a __B.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_cvtbiasph_phf8(__m256i __A, __m256h __B) {
@@ -942,10 +942,10 @@ _mm256_cvtbiasph_phf8(__m256i __A, __m256h __B) {
}
/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
-/// Merging mask \a __U is used to determine if given element should be taken
-/// from \a __W instead.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -962,7 +962,7 @@ _mm256_cvtbiasph_phf8(__m256i __A, __m256h __B) {
/// This intrinsic corresponds to the \c VCVTBIASPH2HF8 instruction.
///
/// \param __W
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x hf8].
/// \param __U
/// A 16-bit merging mask.
/// \param __A
@@ -970,7 +970,7 @@ _mm256_cvtbiasph_phf8(__m256i __A, __m256h __B) {
/// \param __B
/// A 256-bit vector of [16 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Elements correspond to the sum of
+/// A 128-bit vector of [16 x hf8]. Elements correspond to the sum of
/// elements from \a __A and \a __B. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiasph_phf8(
@@ -980,10 +980,10 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiasph_phf8(
}
/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3
-/// Merging mask \a __U is used to determine if given element should be taken
-/// from \a __W instead.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -1006,7 +1006,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiasph_phf8(
/// \param __B
/// A 256-bit vector of [16 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Elements correspond to the sum of
+/// A 128-bit vector of [16 x hf8]. Elements correspond to the sum of
/// elements from \a __A and \a __B. If corresponding mask bit is not set,
/// then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
@@ -1017,9 +1017,9 @@ _mm256_maskz_cvtbiasph_phf8(__mmask16 __U, __m256i __A, __m256h __B) {
}
/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
-/// Results are saturated.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
+/// Results are saturated.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -1038,7 +1038,7 @@ _mm256_maskz_cvtbiasph_phf8(__mmask16 __U, __m256i __A, __m256h __B) {
/// \param __B
/// A 128-bit vector of [8 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x hf8]. Lower elements correspond to the
/// sum of elements from \a __A and \a __B; higher order elements are zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
_mm_cvtbiassph_phf8(__m128i __A, __m128h __B) {
@@ -1047,10 +1047,10 @@ _mm_cvtbiassph_phf8(__m128i __A, __m128h __B) {
}
/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
-/// Results are saturated. Merging mask \a __U is used to determine if given
-/// element should be taken from \a __W instead.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
+/// Results are saturated. Merging mask \a __U is used to determine if given
+/// element should be taken from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -1069,7 +1069,7 @@ _mm_cvtbiassph_phf8(__m128i __A, __m128h __B) {
/// This intrinsic corresponds to the \c VCVTBIASPH2HF8S instruction.
///
/// \param __W
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x hf8].
/// \param __U
/// A 8-bit merging mask.
/// \param __A
@@ -1077,7 +1077,7 @@ _mm_cvtbiassph_phf8(__m128i __A, __m128h __B) {
/// \param __B
/// A 128-bit vector of [8 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the sum of
+/// A 128-bit vector of [16 x hf8]. Lower elements correspond to the sum of
/// elements from \a __A and \a __B; higher order elements are zeroed. If
/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
@@ -1087,10 +1087,10 @@ _mm_mask_cvtbiassph_phf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
}
/// Add two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
-/// Results are saturated. Zeroing mask \a __U is used to determine if given
-/// element should be zeroed instead.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
+/// Results are saturated. Zeroing mask \a __U is used to determine if given
+/// element should be zeroed instead.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -1115,7 +1115,7 @@ _mm_mask_cvtbiassph_phf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
/// \param __B
/// A 128-bit vector of [8 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the sum of
+/// A 128-bit vector of [16 x hf8]. Lower elements correspond to the sum of
/// elements from \a __A and \a __B; higher order elements are zeroed. If
/// corresponding mask bit is not set, then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
@@ -1126,9 +1126,9 @@ _mm_maskz_cvtbiassph_phf8(__mmask8 __U, __m128i __A, __m128h __B) {
}
/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
-/// Results are saturated.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
+/// Results are saturated.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -1145,7 +1145,7 @@ _mm_maskz_cvtbiassph_phf8(__mmask8 __U, __m128i __A, __m128h __B) {
/// \param __B
/// A 256-bit vector of [16 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Elements correspond to the
+/// A 128-bit vector of [16 x hf8]. Elements correspond to the
/// sum of elements from \a __A and \a __B.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_cvtbiassph_phf8(__m256i __A, __m256h __B) {
@@ -1155,10 +1155,10 @@ _mm256_cvtbiassph_phf8(__m256i __A, __m256h __B) {
}
/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
-/// Results are saturated. Merging mask \a __U is used to determine if given
-/// element should be taken from \a __W instead.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
+/// Results are saturated. Merging mask \a __U is used to determine if given
+/// element should be taken from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -1175,7 +1175,7 @@ _mm256_cvtbiassph_phf8(__m256i __A, __m256h __B) {
/// This intrinsic corresponds to the \c VCVTBIASPH2HF8S instruction.
///
/// \param __W
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x hf8].
/// \param __U
/// A 16-bit merging mask.
/// \param __A
@@ -1183,7 +1183,7 @@ _mm256_cvtbiassph_phf8(__m256i __A, __m256h __B) {
/// \param __B
/// A 256-bit vector of [16 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Elements correspond to the sum of
+/// A 128-bit vector of [16 x hf8]. Elements correspond to the sum of
/// elements from \a __A and \a __B. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiassph_phf8(
@@ -1193,10 +1193,10 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiassph_phf8(
}
/// Add two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements and 8-bit integers stored in the lower half of
-/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
-/// Results are saturated. Merging mask \a __U is used to determine if given
-/// element should be taken from \a __W instead.
+/// floating-point elements and 8-bit integers stored in the lower half of
+/// packed 16-bit integers, respectively. Results are converted to FP8 E4M3.
+/// Results are saturated. Merging mask \a __U is used to determine if given
+/// element should be taken from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -1219,7 +1219,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiassph_phf8(
/// \param __B
/// A 256-bit vector of [16 x int16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Elements correspond to the sum of
+/// A 128-bit vector of [16 x hf8]. Elements correspond to the sum of
/// elements from \a __A and \a __B. If corresponding mask bit is not set,
/// then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
@@ -1230,7 +1230,7 @@ _mm256_maskz_cvtbiassph_phf8(__mmask16 __U, __m256i __A, __m256h __B) {
}
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
+/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
///
/// \code{.operation}
/// FOR i := 0 to 16
@@ -1251,7 +1251,7 @@ _mm256_maskz_cvtbiassph_phf8(__mmask16 __U, __m256i __A, __m256h __B) {
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x bf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A.
static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_pbf8(__m128h __A,
@@ -1261,9 +1261,9 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_pbf8(__m128h __A,
}
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
-/// Merging mask \a __U is used to determine if given element should be taken
-/// from \a __W instead.
+/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -1284,7 +1284,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_pbf8(__m128h __A,
/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
///
/// \param __W
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x bf8].
/// \param __U
/// A 16-bit merging mask.
/// \param __A
@@ -1292,7 +1292,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_pbf8(__m128h __A,
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x bf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
@@ -1303,9 +1303,9 @@ _mm_mask_cvtne2ph_pbf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
}
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
-/// Zeroing mask \a __U is used to determine if given element should be zeroed
-/// instead.
+/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
+/// Zeroing mask \a __U is used to determine if given element should be zeroed
+/// instead.
///
/// \code{.operation}
/// FOR i := 0 to 16
@@ -1332,7 +1332,7 @@ _mm_mask_cvtne2ph_pbf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x bf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// zero is taken instead.
@@ -1344,7 +1344,7 @@ _mm_maskz_cvtne2ph_pbf8(__mmask16 __U, __m128h __A, __m128h __B) {
}
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
+/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
///
/// \code{.operation}
/// FOR i := 0 to 31
@@ -1365,7 +1365,7 @@ _mm_maskz_cvtne2ph_pbf8(__mmask16 __U, __m128h __A, __m128h __B) {
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
+/// A 256-bit vector of [32 x bf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A.
static __inline__ __m256i __DEFAULT_FN_ATTRS256
@@ -1375,9 +1375,9 @@ _mm256_cvtne2ph_pbf8(__m256h __A, __m256h __B) {
}
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
-/// Merging mask \a __U is used to determine if given element should be taken
-/// from \a __W instead.
+/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 31
@@ -1398,7 +1398,7 @@ _mm256_cvtne2ph_pbf8(__m256h __A, __m256h __B) {
/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
///
/// \param __W
-/// A 256-bit vector of [32 x fp8].
+/// A 256-bit vector of [32 x bf8].
/// \param __U
/// A 32-bit merging mask.
/// \param __A
@@ -1406,7 +1406,7 @@ _mm256_cvtne2ph_pbf8(__m256h __A, __m256h __B) {
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
+/// A 256-bit vector of [32 x bf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
@@ -1417,9 +1417,9 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtne2ph_pbf8(
}
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
-/// Merging mask \a __U is used to determine if given element should be zeroed
-/// instead.
+/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be zeroed
+/// instead.
///
/// \code{.operation}
/// FOR i := 0 to 31
@@ -1446,7 +1446,7 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtne2ph_pbf8(
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
+/// A 256-bit vector of [32 x bf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set,
/// zero is taken instead.
@@ -1458,8 +1458,8 @@ _mm256_maskz_cvtne2ph_pbf8(__mmask32 __U, __m256h __A, __m256h __B) {
}
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
-/// Resulting elements are saturated in case of an overflow.
+/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
+/// Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
/// FOR i := 0 to 16
@@ -1480,7 +1480,7 @@ _mm256_maskz_cvtne2ph_pbf8(__mmask32 __U, __m256h __A, __m256h __B) {
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x bf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
@@ -1490,9 +1490,9 @@ _mm_cvtnes2ph_pbf8(__m128h __A, __m128h __B) {
}
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
-/// Merging mask \a __U is used to determine if given element should be taken
-/// from \a __W instead. Resulting elements are saturated in case of an overflow.
+/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead. Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
/// FOR i := 0 to 16
@@ -1513,7 +1513,7 @@ _mm_cvtnes2ph_pbf8(__m128h __A, __m128h __B) {
/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __W
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x bf8].
/// \param __U
/// A 16-bit merging mask.
/// \param __A
@@ -1521,7 +1521,7 @@ _mm_cvtnes2ph_pbf8(__m128h __A, __m128h __B) {
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower 8 elements correspond to the
+/// A 128-bit vector of [16 x bf8]. Lower 8 elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
@@ -1532,9 +1532,9 @@ _mm_mask_cvtnes2ph_pbf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
}
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
-/// Zeroing mask \a __U is used to determine if given element should be zeroed
-/// instead. Resulting elements are saturated in case of an overflow.
+/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
+/// Zeroing mask \a __U is used to determine if given element should be zeroed
+/// instead. Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -1561,7 +1561,7 @@ _mm_mask_cvtnes2ph_pbf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x bf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// zero is taken instead.
@@ -1573,8 +1573,8 @@ _mm_maskz_cvtnes2ph_pbf8(__mmask16 __U, __m128h __A, __m128h __B) {
}
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
-/// Resulting elements are saturated in case of an overflow.
+/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
+/// Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
/// FOR i := 0 to 31
@@ -1595,7 +1595,7 @@ _mm_maskz_cvtnes2ph_pbf8(__mmask16 __U, __m128h __A, __m128h __B) {
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
+/// A 256-bit vector of [32 x bf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A.
static __inline__ __m256i __DEFAULT_FN_ATTRS256
@@ -1605,9 +1605,9 @@ _mm256_cvtnes2ph_pbf8(__m256h __A, __m256h __B) {
}
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
-/// Merging mask \a __U is used to determine if given element should be taken
-/// from \a __W instead. Resulting elements are saturated in case of an overflow.
+/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead. Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
/// FOR i := 0 to 31
@@ -1628,7 +1628,7 @@ _mm256_cvtnes2ph_pbf8(__m256h __A, __m256h __B) {
/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __W
-/// A 256-bit vector of [32 x fp8].
+/// A 256-bit vector of [32 x bf8].
/// \param __U
/// A 32-bit merging mask.
/// \param __A
@@ -1636,7 +1636,7 @@ _mm256_cvtnes2ph_pbf8(__m256h __A, __m256h __B) {
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
+/// A 256-bit vector of [32 x bf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
@@ -1647,9 +1647,9 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtnes2ph_pbf8(
}
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
-/// Merging mask \a __U is used to determine if given element should be zeroed
-/// instead. Resulting elements are saturated in case of an overflow.
+/// floating-point elements to a 256-bit vector containing E5M2 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be zeroed
+/// instead. Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
/// FOR i := 0 to 31
@@ -1676,7 +1676,7 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtnes2ph_pbf8(
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
+/// A 256-bit vector of [32 x bf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set,
/// zero is taken instead.
@@ -1688,7 +1688,7 @@ _mm256_maskz_cvtnes2ph_pbf8(__mmask32 __U, __m256h __A, __m256h __B) {
}
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
+/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -1709,7 +1709,7 @@ _mm256_maskz_cvtnes2ph_pbf8(__mmask32 __U, __m256h __A, __m256h __B) {
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x hf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A.
static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_phf8(__m128h __A,
@@ -1719,9 +1719,9 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_phf8(__m128h __A,
}
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
-/// Merging mask \a __U is used to determine if given element should be taken
-/// from \a __W instead.
+/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -1742,7 +1742,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_phf8(__m128h __A,
/// This intrinsic corresponds to the \c VCVTNE2PH2HF8 instruction.
///
/// \param __W
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x hf8].
/// \param __U
/// A 16-bit merging mask.
/// \param __A
@@ -1750,7 +1750,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_phf8(__m128h __A,
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x hf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
@@ -1761,9 +1761,9 @@ _mm_mask_cvtne2ph_phf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
}
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
-/// Zeroing mask \a __U is used to determine if given element should be zeroed
-/// instead.
+/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
+/// Zeroing mask \a __U is used to determine if given element should be zeroed
+/// instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -1790,7 +1790,7 @@ _mm_mask_cvtne2ph_phf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x hf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// zero is taken instead.
@@ -1802,7 +1802,7 @@ _mm_maskz_cvtne2ph_phf8(__mmask16 __U, __m128h __A, __m128h __B) {
}
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
+/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
///
/// \code{.operation}
/// FOR i := 0 to 31
@@ -1823,7 +1823,7 @@ _mm_maskz_cvtne2ph_phf8(__mmask16 __U, __m128h __A, __m128h __B) {
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
+/// A 256-bit vector of [32 x hf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A.
static __inline__ __m256i __DEFAULT_FN_ATTRS256
@@ -1833,9 +1833,9 @@ _mm256_cvtne2ph_phf8(__m256h __A, __m256h __B) {
}
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
-/// Merging mask \a __U is used to determine if given element should be taken
-/// from \a __W instead.
+/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 31
@@ -1856,7 +1856,7 @@ _mm256_cvtne2ph_phf8(__m256h __A, __m256h __B) {
/// This intrinsic corresponds to the \c VCVTNE2PH2HF8 instruction.
///
/// \param __W
-/// A 256-bit vector of [32 x fp8].
+/// A 256-bit vector of [32 x hf8].
/// \param __U
/// A 32-bit merging mask.
/// \param __A
@@ -1864,7 +1864,7 @@ _mm256_cvtne2ph_phf8(__m256h __A, __m256h __B) {
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
+/// A 256-bit vector of [32 x hf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
@@ -1875,9 +1875,9 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtne2ph_phf8(
}
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
-/// Merging mask \a __U is used to determine if given element should be zeroed
-/// instead.
+/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be zeroed
+/// instead.
///
/// \code{.operation}
/// FOR i := 0 to 31
@@ -1904,7 +1904,7 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtne2ph_phf8(
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
+/// A 256-bit vector of [32 x hf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set,
/// zero is taken instead.
@@ -1916,8 +1916,8 @@ _mm256_maskz_cvtne2ph_phf8(__mmask32 __U, __m256h __A, __m256h __B) {
}
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
-/// Resulting elements are saturated in case of an overflow.
+/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
+/// Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -1938,7 +1938,7 @@ _mm256_maskz_cvtne2ph_phf8(__mmask32 __U, __m256h __A, __m256h __B) {
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x hf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
@@ -1948,9 +1948,9 @@ _mm_cvtnes2ph_phf8(__m128h __A, __m128h __B) {
}
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
-/// Merging mask \a __U is used to determine if given element should be taken
-/// from \a __W instead. Resulting elements are saturated in case of an overflow.
+/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead. Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -1971,7 +1971,7 @@ _mm_cvtnes2ph_phf8(__m128h __A, __m128h __B) {
/// This intrinsic corresponds to the \c VCVTNE2PH2HF8S instruction.
///
/// \param __W
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x hf8].
/// \param __U
/// A 16-bit merging mask.
/// \param __A
@@ -1979,7 +1979,7 @@ _mm_cvtnes2ph_phf8(__m128h __A, __m128h __B) {
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x hf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
@@ -1990,9 +1990,9 @@ _mm_mask_cvtnes2ph_phf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
}
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
-/// Zeroing mask \a __U is used to determine if given element should be zeroed
-/// instead. Resulting elements are saturated in case of an overflow.
+/// floating-point elements to a 128-bit vector containing E4M3 FP8 elements.
+/// Zeroing mask \a __U is used to determine if given element should be zeroed
+/// instead. Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -2019,7 +2019,7 @@ _mm_mask_cvtnes2ph_phf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
/// \param __B
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x hf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// zero is taken instead.
@@ -2031,8 +2031,8 @@ _mm_maskz_cvtnes2ph_phf8(__mmask16 __U, __m128h __A, __m128h __B) {
}
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
-/// Resulting elements are saturated in case of an overflow.
+/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
+/// Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -2053,7 +2053,7 @@ _mm_maskz_cvtnes2ph_phf8(__mmask16 __U, __m128h __A, __m128h __B) {
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
+/// A 256-bit vector of [32 x hf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A.
static __inline__ __m256i __DEFAULT_FN_ATTRS256
@@ -2063,9 +2063,9 @@ _mm256_cvtnes2ph_phf8(__m256h __A, __m256h __B) {
}
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
-/// Merging mask \a __U is used to determine if given element should be taken
-/// from \a __W instead. Resulting elements are saturated in case of an overflow.
+/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead. Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
/// FOR i := 0 to 31
@@ -2086,7 +2086,7 @@ _mm256_cvtnes2ph_phf8(__m256h __A, __m256h __B) {
/// This intrinsic corresponds to the \c VCVTNE2PH2HF8S instruction.
///
/// \param __W
-/// A 256-bit vector of [32 x fp8].
+/// A 256-bit vector of [32 x hf8].
/// \param __U
/// A 32-bit merging mask.
/// \param __A
@@ -2094,7 +2094,7 @@ _mm256_cvtnes2ph_phf8(__m256h __A, __m256h __B) {
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
+/// A 256-bit vector of [32 x hf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
@@ -2105,9 +2105,9 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtnes2ph_phf8(
}
/// Convert two 256-bit vectors, \a __A and \a __B, containing packed FP16
-/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
-/// Merging mask \a __U is used to determine if given element should be zeroed
-/// instead. Resulting elements are saturated in case of an overflow.
+/// floating-point elements to a 256-bit vector containing E4M3 FP8 elements.
+/// Merging mask \a __U is used to determine if given element should be zeroed
+/// instead. Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
/// FOR i := 0 to 31
@@ -2134,7 +2134,7 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtnes2ph_phf8(
/// \param __B
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 256-bit vector of [32 x fp8]. Lower elements correspond to the
+/// A 256-bit vector of [32 x hf8]. Lower elements correspond to the
/// (converted) elements from \a __B; higher order elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set,
/// zero is taken instead.
@@ -2146,7 +2146,7 @@ _mm256_maskz_cvtnes2ph_phf8(__mmask32 __U, __m256h __A, __m256h __B) {
}
/// Convert 128-bit vector \a __A, containing packed FP8 E4M3 floating-point
-/// elements to a 128-bit vector containing FP16 elements. The conversion is exact.
+/// elements to a 128-bit vector containing FP16 elements. The conversion is exact.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -2159,7 +2159,7 @@ _mm256_maskz_cvtnes2ph_phf8(__mmask32 __U, __m256h __A, __m256h __B) {
/// This intrinsic corresponds to the \c VCVTHF82PH instruction.
///
/// \param __A
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x hf8].
/// \returns
/// A 128-bit vector of [8 x fp16]. Resulting elements correspond to the
/// (converted) elements from \a __A.
@@ -2169,9 +2169,9 @@ static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtnehf8_ph(__m128i __A) {
}
/// Convert 128-bit vector \a __A, containing packed FP8 E4M3 floating-point
-/// elements to a 128-bit vector containing FP16 elements. The conversion is
-/// exact. Merging mask \a __U is used to determine if given element should be
-/// taken from \a __W instead.
+/// elements to a 128-bit vector containing FP16 elements. The conversion is
+/// exact. Merging mask \a __U is used to determine if given element should be
+/// taken from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -2192,7 +2192,7 @@ static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtnehf8_ph(__m128i __A) {
/// \param __U
/// A 8-bit merging mask.
/// \param __A
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x hf8].
/// \returns
/// A 128-bit vector of [8 x fp16]. Resulting elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
@@ -2204,9 +2204,9 @@ _mm_mask_cvtnehf8_ph(__m128h __W, __mmask8 __U, __m128i __A) {
}
/// Convert 128-bit vector \a __A, containing packed FP8 E4M3 floating-point
-/// elements to a 128-bit vector containing FP16 elements. The conversion is
-/// exact. Zeroing mask \a __U is used to determine if given element should be
-/// zeroed instead.
+/// elements to a 128-bit vector containing FP16 elements. The conversion is
+/// exact. Zeroing mask \a __U is used to determine if given element should be
+/// zeroed instead.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -2225,7 +2225,7 @@ _mm_mask_cvtnehf8_ph(__m128h __W, __mmask8 __U, __m128i __A) {
/// \param __U
/// A 8-bit zeroing mask.
/// \param __A
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x hf8].
/// \returns
/// A 128-bit vector of [8 x fp16]. Resulting elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
@@ -2237,7 +2237,7 @@ _mm_maskz_cvtnehf8_ph(__mmask8 __U, __m128i __A) {
}
/// Convert 256-bit vector \a __A, containing packed FP8 E4M3 floating-point
-/// elements to a 256-bit vector containing FP16 elements. The conversion is exact.
+/// elements to a 256-bit vector containing FP16 elements. The conversion is exact.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -2250,7 +2250,7 @@ _mm_maskz_cvtnehf8_ph(__mmask8 __U, __m128i __A) {
/// This intrinsic corresponds to the \c VCVTHF82PH instruction.
///
/// \param __A
-/// A 256-bit vector of [32 x fp8].
+/// A 256-bit vector of [32 x hf8].
/// \returns
/// A 256-bit vector of [16 x fp16]. Resulting elements correspond to the
/// (converted) elements from \a __A.
@@ -2261,9 +2261,9 @@ _mm256_cvtnehf8_ph(__m128i __A) {
}
/// Convert 256-bit vector \a __A, containing packed FP8 E4M3 floating-point
-/// elements to a 256-bit vector containing FP16 elements. The conversion is
-/// exact. Merging mask \a __U is used to determine if given element should be
-/// taken from \a __W instead.
+/// elements to a 256-bit vector containing FP16 elements. The conversion is
+/// exact. Merging mask \a __U is used to determine if given element should be
+/// taken from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -2284,7 +2284,7 @@ _mm256_cvtnehf8_ph(__m128i __A) {
/// \param __U
/// A 16-bit merging mask.
/// \param __A
-/// A 256-bit vector of [32 x fp8].
+/// A 256-bit vector of [32 x hf8].
/// \returns
/// A 256-bit vector of [16 x fp16]. Resulting elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
@@ -2296,9 +2296,9 @@ _mm256_mask_cvtnehf8_ph(__m256h __W, __mmask16 __U, __m128i __A) {
}
/// Convert 256-bit vector \a __A, containing packed FP8 E4M3 floating-point
-/// elements to a 256-bit vector containing FP16 elements. The conversion is
-/// exact. Zeroing mask \a __U is used to determine if given element should be
-/// zeroed instead.
+/// elements to a 256-bit vector containing FP16 elements. The conversion is
+/// exact. Zeroing mask \a __U is used to determine if given element should be
+/// zeroed instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -2317,7 +2317,7 @@ _mm256_mask_cvtnehf8_ph(__m256h __W, __mmask16 __U, __m128i __A) {
/// \param __U
/// A 16-bit zeroing mask.
/// \param __A
-/// A 256-bit vector of [32 x fp8].
+/// A 256-bit vector of [32 x hf8].
/// \returns
/// A 256-bit vector of [16 x fp16]. Resulting elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
@@ -2329,8 +2329,8 @@ _mm256_maskz_cvtnehf8_ph(__mmask16 __U, __m128i __A) {
}
/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
-/// resulting vector are zeroed.
+/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
+/// resulting vector are zeroed.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -2347,7 +2347,7 @@ _mm256_maskz_cvtnehf8_ph(__mmask16 __U, __m128i __A) {
/// \param __A
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the (converted)
+/// A 128-bit vector of [16 x bf8]. Lower elements correspond to the (converted)
/// elements from \a __A; upper elements are zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtneph_pbf8(__m128h __A) {
return (__m128i)__builtin_ia32_vcvtneph2bf8_128_mask(
@@ -2355,9 +2355,9 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtneph_pbf8(__m128h __A) {
}
/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
-/// resulting vector are zeroed. Merging mask \a __U is used to determine if
-/// given element should be taken from \a __W instead.
+/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
+/// resulting vector are zeroed. Merging mask \a __U is used to determine if
+/// given element should be taken from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -2376,13 +2376,13 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtneph_pbf8(__m128h __A) {
/// This intrinsic corresponds to the \c VCVTNEPH2BF8 instruction.
///
/// \param __W
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x bf8].
/// \param __U
/// A 8-bit merging mask.
/// \param __A
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x bf8]. Lower elements correspond to the
/// (converted) elements from \a __A; upper elements are zeroed. If
/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
@@ -2392,9 +2392,9 @@ _mm_mask_cvtneph_pbf8(__m128i __W, __mmask8 __U, __m128h __A) {
}
/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
-/// resulting vector are zeroed. Zeroing mask \a __U is used to determine if
-/// given element should be zeroed instead.
+/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
+/// resulting vector are zeroed. Zeroing mask \a __U is used to determine if
+/// given element should be zeroed instead.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -2417,7 +2417,7 @@ _mm_mask_cvtneph_pbf8(__m128i __W, __mmask8 __U, __m128h __A) {
/// \param __A
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x bf8]. Lower elements correspond to the
/// (converted) elements from \a __A; upper elements are zeroed. If
/// corresponding mask bit is not set, then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
@@ -2427,7 +2427,7 @@ _mm_maskz_cvtneph_pbf8(__mmask8 __U, __m128h __A) {
}
/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E5M2 FP8 elements.
+/// to a 128-bit vector containing E5M2 FP8 elements.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -2444,7 +2444,7 @@ _mm_maskz_cvtneph_pbf8(__mmask8 __U, __m128h __A) {
/// \param __A
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the (converted)
+/// A 128-bit vector of [16 x bf8]. Resulting elements correspond to the (converted)
/// elements from \a __A.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_cvtneph_pbf8(__m256h __A) {
@@ -2453,8 +2453,8 @@ _mm256_cvtneph_pbf8(__m256h __A) {
}
/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E5M2 FP8 elements. Merging mask \a __U is
-/// used to determine if given element should be taken from \a __W instead.
+/// to a 128-bit vector containing E5M2 FP8 elements. Merging mask \a __U is
+/// used to determine if given element should be taken from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -2473,13 +2473,13 @@ _mm256_cvtneph_pbf8(__m256h __A) {
/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
///
/// \param __W
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x bf8].
/// \param __U
/// A 16-bit merging mask.
/// \param __A
/// A 256-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the
+/// A 128-bit vector of [16 x bf8]. Resulting elements correspond to the
/// (converted) elements from \a __A. If
/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
@@ -2489,8 +2489,8 @@ _mm256_mask_cvtneph_pbf8(__m128i __W, __mmask16 __U, __m256h __A) {
}
/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E5M2 FP8 elements. Zeroing mask \a __U is
-/// used to determine if given element should be zeroed instead.
+/// to a 128-bit vector containing E5M2 FP8 elements. Zeroing mask \a __U is
+/// used to determine if given element should be zeroed instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -2513,7 +2513,7 @@ _mm256_mask_cvtneph_pbf8(__m128i __W, __mmask16 __U, __m256h __A) {
/// \param __A
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the
+/// A 128-bit vector of [16 x bf8]. Resulting elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set,
/// then element is zeroed instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
@@ -2523,8 +2523,8 @@ _mm256_maskz_cvtneph_pbf8(__mmask16 __U, __m256h __A) {
}
/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
-/// resulting vector are zeroed. Results are saturated.
+/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
+/// resulting vector are zeroed. Results are saturated.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -2541,7 +2541,7 @@ _mm256_maskz_cvtneph_pbf8(__mmask16 __U, __m256h __A) {
/// \param __A
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the (converted)
+/// A 128-bit vector of [16 x bf8]. Lower elements correspond to the (converted)
/// elements from \a __A; upper elements are zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtnesph_pbf8(__m128h __A) {
return (__m128i)__builtin_ia32_vcvtneph2bf8s_128_mask(
@@ -2549,9 +2549,9 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtnesph_pbf8(__m128h __A) {
}
/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
-/// resulting vector are zeroed. Results are saturated. Merging mask \a __U is
-/// used to determine if given element should be taken from \a __W instead.
+/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
+/// resulting vector are zeroed. Results are saturated. Merging mask \a __U is
+/// used to determine if given element should be taken from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -2570,13 +2570,13 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtnesph_pbf8(__m128h __A) {
/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __W
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x bf8].
/// \param __U
/// A 8-bit merging mask.
/// \param __A
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x bf8]. Lower elements correspond to the
/// (converted) elements from \a __A; upper elements are zeroed. If
/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
@@ -2586,9 +2586,9 @@ _mm_mask_cvtnesph_pbf8(__m128i __W, __mmask8 __U, __m128h __A) {
}
/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
-/// resulting vector are zeroed. Results are saturated. Zeroing mask \a __U is
-/// used to determine if given element should be zeroed instead.
+/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
+/// resulting vector are zeroed. Results are saturated. Zeroing mask \a __U is
+/// used to determine if given element should be zeroed instead.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -2611,7 +2611,7 @@ _mm_mask_cvtnesph_pbf8(__m128i __W, __mmask8 __U, __m128h __A) {
/// \param __A
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x bf8]. Lower elements correspond to the
/// (converted) elements from \a __A; upper elements are zeroed. If
/// corresponding mask bit is not set, then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
@@ -2621,7 +2621,7 @@ _mm_maskz_cvtnesph_pbf8(__mmask8 __U, __m128h __A) {
}
/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E5M2 FP8 elements. Results are saturated.
+/// to a 128-bit vector containing E5M2 FP8 elements. Results are saturated.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -2638,7 +2638,7 @@ _mm_maskz_cvtnesph_pbf8(__mmask8 __U, __m128h __A) {
/// \param __A
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the (converted)
+/// A 128-bit vector of [16 x bf8]. Resulting elements correspond to the (converted)
/// elements from \a __A.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_cvtnesph_pbf8(__m256h __A) {
@@ -2647,9 +2647,9 @@ _mm256_cvtnesph_pbf8(__m256h __A) {
}
/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E5M2 FP8 elements. Results are saturated.
-/// Merging mask \a __U is used to determine if given element should be taken
-/// from \a __W instead.
+/// to a 128-bit vector containing E5M2 FP8 elements. Results are saturated.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -2668,13 +2668,13 @@ _mm256_cvtnesph_pbf8(__m256h __A) {
/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __W
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x bf8].
/// \param __U
/// A 16-bit merging mask.
/// \param __A
/// A 256-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the
+/// A 128-bit vector of [16 x bf8]. Resulting elements correspond to the
/// (converted) elements from \a __A. If
/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
@@ -2684,9 +2684,9 @@ _mm256_mask_cvtnesph_pbf8(__m128i __W, __mmask16 __U, __m256h __A) {
}
/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E5M2 FP8 elements. Results are saturated.
-/// Zeroing mask \a __U is used to determine if given element should be zeroed
-/// instead.
+/// to a 128-bit vector containing E5M2 FP8 elements. Results are saturated.
+/// Zeroing mask \a __U is used to determine if given element should be zeroed
+/// instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -2709,7 +2709,7 @@ _mm256_mask_cvtnesph_pbf8(__m128i __W, __mmask16 __U, __m256h __A) {
/// \param __A
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the
+/// A 128-bit vector of [16 x bf8]. Resulting elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set,
/// then element is zeroed instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
@@ -2719,8 +2719,8 @@ _mm256_maskz_cvtnesph_pbf8(__mmask16 __U, __m256h __A) {
}
/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
-/// resulting vector are zeroed.
+/// to a 128-bit vector containing E5M2 FP8 elements. Upper elements of
+/// resulting vector are zeroed.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -2737,7 +2737,7 @@ _mm256_maskz_cvtnesph_pbf8(__mmask16 __U, __m256h __A) {
/// \param __A
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the (converted)
+/// A 128-bit vector of [16 x hf8]. Lower elements correspond to the (converted)
/// elements from \a __A; upper elements are zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtneph_phf8(__m128h __A) {
return (__m128i)__builtin_ia32_vcvtneph2hf8_128_mask(
@@ -2745,9 +2745,9 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtneph_phf8(__m128h __A) {
}
/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E4M3 FP8 elements. Upper elements of
-/// resulting vector are zeroed. Merging mask \a __U is used to determine if
-/// given element should be taken from \a __W instead.
+/// to a 128-bit vector containing E4M3 FP8 elements. Upper elements of
+/// resulting vector are zeroed. Merging mask \a __U is used to determine if
+/// given element should be taken from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -2766,13 +2766,13 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtneph_phf8(__m128h __A) {
/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
///
/// \param __W
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x hf8].
/// \param __U
/// A 8-bit merging mask.
/// \param __A
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x hf8]. Lower elements correspond to the
/// (converted) elements from \a __A; upper elements are zeroed. If
/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
@@ -2782,9 +2782,9 @@ _mm_mask_cvtneph_phf8(__m128i __W, __mmask8 __U, __m128h __A) {
}
/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E4M3 FP8 elements. Upper elements of
-/// resulting vector are zeroed. Zeroing mask \a __U is used to determine if
-/// given element should be zeroed instead.
+/// to a 128-bit vector containing E4M3 FP8 elements. Upper elements of
+/// resulting vector are zeroed. Zeroing mask \a __U is used to determine if
+/// given element should be zeroed instead.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -2807,7 +2807,7 @@ _mm_mask_cvtneph_phf8(__m128i __W, __mmask8 __U, __m128h __A) {
/// \param __A
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x hf8]. Lower elements correspond to the
/// (converted) elements from \a __A; upper elements are zeroed. If
/// corresponding mask bit is not set, then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
@@ -2817,7 +2817,7 @@ _mm_maskz_cvtneph_phf8(__mmask8 __U, __m128h __A) {
}
/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E4M3 FP8 elements.
+/// to a 128-bit vector containing E4M3 FP8 elements.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -2834,7 +2834,7 @@ _mm_maskz_cvtneph_phf8(__mmask8 __U, __m128h __A) {
/// \param __A
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the (converted)
+/// A 128-bit vector of [16 x hf8]. Resulting elements correspond to the (converted)
/// elements from \a __A.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_cvtneph_phf8(__m256h __A) {
@@ -2843,8 +2843,8 @@ _mm256_cvtneph_phf8(__m256h __A) {
}
/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E4M3 FP8 elements. Merging mask \a __U is
-/// used to determine if given element should be taken from \a __W instead.
+/// to a 128-bit vector containing E4M3 FP8 elements. Merging mask \a __U is
+/// used to determine if given element should be taken from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -2863,13 +2863,13 @@ _mm256_cvtneph_phf8(__m256h __A) {
/// This intrinsic corresponds to the \c VCVTNE2PH2BF8 instruction.
///
/// \param __W
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x hf8].
/// \param __U
/// A 16-bit merging mask.
/// \param __A
/// A 256-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the
+/// A 128-bit vector of [16 x hf8]. Resulting elements correspond to the
/// (converted) elements from \a __A. If
/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
@@ -2879,8 +2879,8 @@ _mm256_mask_cvtneph_phf8(__m128i __W, __mmask16 __U, __m256h __A) {
}
/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E4M3 FP8 elements. Zeroing mask \a __U is
-/// used to determine if given element should be zeroed instead.
+/// to a 128-bit vector containing E4M3 FP8 elements. Zeroing mask \a __U is
+/// used to determine if given element should be zeroed instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -2903,7 +2903,7 @@ _mm256_mask_cvtneph_phf8(__m128i __W, __mmask16 __U, __m256h __A) {
/// \param __A
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the
+/// A 128-bit vector of [16 x hf8]. Resulting elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set,
/// then element is zeroed instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
@@ -2913,8 +2913,8 @@ _mm256_maskz_cvtneph_phf8(__mmask16 __U, __m256h __A) {
}
/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E4M3 FP8 elements. Upper elements of
-/// resulting vector are zeroed. Results are saturated.
+/// to a 128-bit vector containing E4M3 FP8 elements. Upper elements of
+/// resulting vector are zeroed. Results are saturated.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -2931,7 +2931,7 @@ _mm256_maskz_cvtneph_phf8(__mmask16 __U, __m256h __A) {
/// \param __A
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the (converted)
+/// A 128-bit vector of [16 x hf8]. Lower elements correspond to the (converted)
/// elements from \a __A; upper elements are zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtnesph_phf8(__m128h __A) {
return (__m128i)__builtin_ia32_vcvtneph2hf8s_128_mask(
@@ -2939,9 +2939,9 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtnesph_phf8(__m128h __A) {
}
/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E4M3 FP8 elements. Upper elements of
-/// resulting vector are zeroed. Results are saturated. Merging mask \a __U is
-/// used to determine if given element should be taken from \a __W instead.
+/// to a 128-bit vector containing E4M3 FP8 elements. Upper elements of
+/// resulting vector are zeroed. Results are saturated. Merging mask \a __U is
+/// used to determine if given element should be taken from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -2960,13 +2960,13 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtnesph_phf8(__m128h __A) {
/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __W
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x hf8].
/// \param __U
/// A 8-bit merging mask.
/// \param __A
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x hf8]. Lower elements correspond to the
/// (converted) elements from \a __A; upper elements are zeroed. If
/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
@@ -2976,9 +2976,9 @@ _mm_mask_cvtnesph_phf8(__m128i __W, __mmask8 __U, __m128h __A) {
}
/// Convert 128-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E4M3 FP8 elements. Upper elements of
-/// resulting vector are zeroed. Results are saturated. Zeroing mask \a __U is
-/// used to determine if given element should be zeroed instead.
+/// to a 128-bit vector containing E4M3 FP8 elements. Upper elements of
+/// resulting vector are zeroed. Results are saturated. Zeroing mask \a __U is
+/// used to determine if given element should be zeroed instead.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -3001,7 +3001,7 @@ _mm_mask_cvtnesph_phf8(__m128i __W, __mmask8 __U, __m128h __A) {
/// \param __A
/// A 128-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Lower elements correspond to the
+/// A 128-bit vector of [16 x hf8]. Lower elements correspond to the
/// (converted) elements from \a __A; upper elements are zeroed. If
/// corresponding mask bit is not set, then element is zeroed.
static __inline__ __m128i __DEFAULT_FN_ATTRS128
@@ -3011,7 +3011,7 @@ _mm_maskz_cvtnesph_phf8(__mmask8 __U, __m128h __A) {
}
/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E4M3 FP8 elements. Results are saturated.
+/// to a 128-bit vector containing E4M3 FP8 elements. Results are saturated.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -3028,7 +3028,7 @@ _mm_maskz_cvtnesph_phf8(__mmask8 __U, __m128h __A) {
/// \param __A
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the (converted)
+/// A 128-bit vector of [16 x hf8]. Resulting elements correspond to the (converted)
/// elements from \a __A.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
_mm256_cvtnesph_phf8(__m256h __A) {
@@ -3037,9 +3037,9 @@ _mm256_cvtnesph_phf8(__m256h __A) {
}
/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E4M3 FP8 elements. Results are saturated.
-/// Merging mask \a __U is used to determine if given element should be taken
-/// from \a __W instead.
+/// to a 128-bit vector containing E4M3 FP8 elements. Results are saturated.
+/// Merging mask \a __U is used to determine if given element should be taken
+/// from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -3058,13 +3058,13 @@ _mm256_cvtnesph_phf8(__m256h __A) {
/// This intrinsic corresponds to the \c VCVTNE2PH2BF8S instruction.
///
/// \param __W
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x hf8].
/// \param __U
/// A 16-bit merging mask.
/// \param __A
/// A 256-bit vector of [8 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the
+/// A 128-bit vector of [16 x hf8]. Resulting elements correspond to the
/// (converted) elements from \a __A. If
/// corresponding mask bit is not set, then element from \a __W is taken instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
@@ -3074,9 +3074,9 @@ _mm256_mask_cvtnesph_phf8(__m128i __W, __mmask16 __U, __m256h __A) {
}
/// Convert 256-bit vector \a __A containing packed FP16 floating-point elements
-/// to a 128-bit vector containing E4M3 FP8 elements. Results are saturated.
-/// Zeroing mask \a __U is used to determine if given element should be zeroed
-/// instead.
+/// to a 128-bit vector containing E4M3 FP8 elements. Results are saturated.
+/// Zeroing mask \a __U is used to determine if given element should be zeroed
+/// instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -3099,7 +3099,7 @@ _mm256_mask_cvtnesph_phf8(__m128i __W, __mmask16 __U, __m256h __A) {
/// \param __A
/// A 256-bit vector of [16 x fp16].
/// \returns
-/// A 128-bit vector of [16 x fp8]. Resulting elements correspond to the
+/// A 128-bit vector of [16 x hf8]. Resulting elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set,
/// then element is zeroed instead.
static __inline__ __m128i __DEFAULT_FN_ATTRS256
@@ -3109,7 +3109,7 @@ _mm256_maskz_cvtnesph_phf8(__mmask16 __U, __m256h __A) {
}
/// Convert 128-bit vector \a __A, containing packed FP8 E5M2 floating-point
-/// elements to a 128-bit vector containing FP16 elements. The conversion is exact.
+/// elements to a 128-bit vector containing FP16 elements. The conversion is exact.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -3122,7 +3122,7 @@ _mm256_maskz_cvtnesph_phf8(__mmask16 __U, __m256h __A) {
/// This intrinsic does not corresponds to a single instruction.
///
/// \param __A
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x hf8].
/// \returns
/// A 128-bit vector of [8 x fp16]. Resulting elements correspond to the
/// (converted) elements from \a __A.
@@ -3131,9 +3131,9 @@ static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtpbf8_ph(__m128i __A) {
}
/// Convert 128-bit vector \a __A, containing packed FP8 E5M2 floating-point
-/// elements to a 128-bit vector containing FP16 elements. The conversion is
-/// exact. Merging mask \a __U is used to determine if given element should be
-/// taken from \a __W instead.
+/// elements to a 128-bit vector containing FP16 elements. The conversion is
+/// exact. Merging mask \a __U is used to determine if given element should be
+/// taken from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -3154,7 +3154,7 @@ static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtpbf8_ph(__m128i __A) {
/// \param __U
/// A 8-bit merging mask.
/// \param __A
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x hf8].
/// \returns
/// A 128-bit vector of [8 x fp16]. Resulting elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
@@ -3166,9 +3166,9 @@ _mm_mask_cvtpbf8_ph(__m128h __S, __mmask8 __U, __m128i __A) {
}
/// Convert 128-bit vector \a __A, containing packed FP8 E5M2 floating-point
-/// elements to a 128-bit vector containing FP16 elements. The conversion is
-/// exact. Zeroing mask \a __U is used to determine if given element should be
-/// zeroed instead.
+/// elements to a 128-bit vector containing FP16 elements. The conversion is
+/// exact. Zeroing mask \a __U is used to determine if given element should be
+/// zeroed instead.
///
/// \code{.operation}
/// FOR i := 0 to 7
@@ -3187,7 +3187,7 @@ _mm_mask_cvtpbf8_ph(__m128h __S, __mmask8 __U, __m128i __A) {
/// \param __U
/// A 8-bit zeroing mask.
/// \param __A
-/// A 128-bit vector of [16 x fp8].
+/// A 128-bit vector of [16 x hf8].
/// \returns
/// A 128-bit vector of [8 x fp16]. Resulting elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
@@ -3198,7 +3198,7 @@ _mm_maskz_cvtpbf8_ph(__mmask8 __U, __m128i __A) {
}
/// Convert 256-bit vector \a __A, containing packed FP8 E4M3 floating-point
-/// elements to a 256-bit vector containing FP16 elements. The conversion is exact.
+/// elements to a 256-bit vector containing FP16 elements. The conversion is exact.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -3211,7 +3211,7 @@ _mm_maskz_cvtpbf8_ph(__mmask8 __U, __m128i __A) {
/// This intrinsic does not corresponds to a single instruction.
///
/// \param __A
-/// A 256-bit vector of [32 x fp8].
+/// A 256-bit vector of [32 x hf8].
/// \returns
/// A 256-bit vector of [16 x fp16]. Resulting elements correspond to the
/// (converted) elements from \a __A.
@@ -3220,9 +3220,9 @@ static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_cvtpbf8_ph(__m128i __A) {
}
/// Convert 256-bit vector \a __A, containing packed FP8 E5M2 floating-point
-/// elements to a 256-bit vector containing FP16 elements. The conversion is
-/// exact. Merging mask \a __U is used to determine if given element should be
-/// taken from \a __W instead.
+/// elements to a 256-bit vector containing FP16 elements. The conversion is
+/// exact. Merging mask \a __U is used to determine if given element should be
+/// taken from \a __W instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -3243,7 +3243,7 @@ static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_cvtpbf8_ph(__m128i __A) {
/// \param __U
/// A 16-bit merging mask.
/// \param __A
-/// A 256-bit vector of [32 x fp8].
+/// A 256-bit vector of [32 x hf8].
/// \returns
/// A 256-bit vector of [16 x fp16]. Resulting elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
@@ -3255,9 +3255,9 @@ _mm256_mask_cvtpbf8_ph(__m256h __S, __mmask8 __U, __m128i __A) {
}
/// Convert 256-bit vector \a __A, containing packed FP8 E5M2 floating-point
-/// elements to a 256-bit vector containing FP16 elements. The conversion is
-/// exact. Zeroing mask \a __U is used to determine if given element should be
-/// zeroed instead.
+/// elements to a 256-bit vector containing FP16 elements. The conversion is
+/// exact. Zeroing mask \a __U is used to determine if given element should be
+/// zeroed instead.
///
/// \code{.operation}
/// FOR i := 0 to 15
@@ -3276,7 +3276,7 @@ _mm256_mask_cvtpbf8_ph(__m256h __S, __mmask8 __U, __m128i __A) {
/// \param __U
/// A 16-bit zeroing mask.
/// \param __A
-/// A 256-bit vector of [32 x fp8].
+/// A 256-bit vector of [32 x hf8].
/// \returns
/// A 256-bit vector of [16 x fp16]. Resulting elements correspond to the
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
>From 6a6a0c563f2f885c517f1f0076502617e30e3fcc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Miko=C5=82aj=20Pir=C3=B3g?= <mikolajpirog at gmail.com>
Date: Sat, 21 Dec 2024 22:31:32 +0100
Subject: [PATCH 8/9] Further reviewer suggestions: add missing dst[max:]
---
clang/lib/Headers/avx10_2convertintrin.h | 196 +++++++++++++++++------
1 file changed, 146 insertions(+), 50 deletions(-)
diff --git a/clang/lib/Headers/avx10_2convertintrin.h b/clang/lib/Headers/avx10_2convertintrin.h
index 077d8c95b2f38b..aa6a502de47dbb 100644
--- a/clang/lib/Headers/avx10_2convertintrin.h
+++ b/clang/lib/Headers/avx10_2convertintrin.h
@@ -35,6 +35,8 @@
/// ELSE
/// dst.fp16[i] := convert_fp32_to_fp16(__A.fp32[i - 4])
/// FI
+///
+/// dst[MAX:127] := 0
/// ENDFOR
/// \endcode
///
@@ -72,6 +74,8 @@ static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtx2ps_ph(__m128 __A,
/// ELSE
/// dst.fp16[i] := __W.fp16[i]
/// FI
+///
+/// dst[MAX:127] := 0
/// ENDFOR
/// \endcode
///
@@ -115,6 +119,8 @@ _mm_mask_cvtx2ps_ph(__m128h __W, __mmask8 __U, __m128 __A, __m128 __B) {
/// dst.fp16[i] := 0
/// FI
/// ENDFOR
+///
+/// dst[MAX:127] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -150,6 +156,8 @@ _mm_maskz_cvtx2ps_ph(__mmask8 __U, __m128 __A, __m128 __B) {
/// dst.fp16[i] := convert_fp32_to_fp16(__A.fp32[i - 8])
/// FI
/// ENDFOR
+///
+/// dst[MAX:256] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -188,6 +196,8 @@ static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_cvtx2ps_ph(__m256 __A,
/// dst.fp16[i] := __W.fp16[i]
/// FI
/// ENDFOR
+///
+/// dst[MAX:256] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -231,6 +241,8 @@ _mm256_mask_cvtx2ps_ph(__m256h __W, __mmask16 __U, __m256 __A, __m256 __B) {
/// dst.fp16[i] := 0
/// FI
/// ENDFOR
+///
+/// dst[MAX:256] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -267,6 +279,8 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
/// dst.fp16[i] := convert_fp32_to_fp16(__A.fp32[i - 8])
/// FI
/// ENDFOR
+///
+/// dst[MAX:256] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -309,6 +323,8 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
/// dst.fp16[i] := __W.fp16[i]
/// FI
/// ENDFOR
+///
+/// dst[MAX:256] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -354,6 +370,8 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
/// dst.fp16[i] := 0
/// FI
/// ENDFOR
+///
+/// dst[MAX:256] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -390,7 +408,7 @@ _mm256_maskz_cvtx2ps_ph(__mmask16 __U, __m256 __A, __m256 __B) {
/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -425,7 +443,7 @@ _mm_cvtbiasph_pbf8(__m128i __A, __m128h __B) {
/// FI
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -465,7 +483,7 @@ _mm_mask_cvtbiasph_pbf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
/// FI
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -497,6 +515,8 @@ _mm_maskz_cvtbiasph_pbf8(__mmask8 __U, __m128i __A, __m128h __B) {
/// FOR i := 0 to 15
/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -531,6 +551,8 @@ _mm256_cvtbiasph_pbf8(__m256i __A, __m256h __B) {
/// dst.fp8[i] := _W[i]
/// FI
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -569,6 +591,8 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiasph_pbf8(
/// dst.fp8[i] := 0
/// FI
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -602,7 +626,7 @@ _mm256_maskz_cvtbiasph_pbf8(__mmask16 __U, __m256i __A, __m256h __B) {
/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -637,7 +661,7 @@ _mm_cvtbiassph_pbf8(__m128i __A, __m128h __B) {
/// FI
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -677,7 +701,7 @@ _mm_mask_cvtbiassph_pbf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
/// FI
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -710,6 +734,8 @@ _mm_maskz_cvtbiassph_pbf8(__mmask8 __U, __m128i __A, __m128h __B) {
/// FOR i := 0 to 15
/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -744,6 +770,8 @@ _mm256_cvtbiassph_pbf8(__m256i __A, __m256h __B) {
/// dst.fp8[i] := _W[i]
/// FI
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -782,6 +810,8 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiassph_pbf8(
/// dst.fp8[i] := 0
/// FI
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -814,7 +844,7 @@ _mm256_maskz_cvtbiassph_pbf8(__mmask16 __U, __m256i __A, __m256h __B) {
/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -849,7 +879,7 @@ _mm_cvtbiasph_phf8(__m128i __A, __m128h __B) {
/// FI
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -889,7 +919,7 @@ _mm_mask_cvtbiasph_phf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
/// FI
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1026,7 +1056,7 @@ _mm256_maskz_cvtbiasph_phf8(__mmask16 __U, __m256i __A, __m256h __B) {
/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1061,7 +1091,7 @@ _mm_cvtbiassph_phf8(__m128i __A, __m128h __B) {
/// FI
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1101,7 +1131,7 @@ _mm_mask_cvtbiassph_phf8(__m128i __W, __mmask8 __U, __m128i __A, __m128h __B) {
/// FI
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1134,6 +1164,8 @@ _mm_maskz_cvtbiassph_phf8(__mmask8 __U, __m128i __A, __m128h __B) {
/// FOR i := 0 to 15
/// dst.fp8[i] := add_convert_fp16_to_fp8_bias(__A.fp16[i], __B.int8[2i])
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1168,6 +1200,8 @@ _mm256_cvtbiassph_phf8(__m256i __A, __m256h __B) {
/// dst.fp8[i] := _W[i]
/// FI
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1206,6 +1240,8 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtbiassph_phf8(
/// dst.fp8[i] := 0
/// FI
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1233,13 +1269,15 @@ _mm256_maskz_cvtbiassph_phf8(__mmask16 __U, __m256i __A, __m256h __B) {
/// floating-point elements to a 128-bit vector containing E5M2 FP8 elements.
///
/// \code{.operation}
-/// FOR i := 0 to 16
+/// FOR i := 0 to 15
/// IF i < 8
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
/// ELSE
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 8])
/// FI
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1277,6 +1315,8 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_pbf8(__m128h __A,
/// dst.fp8 := __W.fp8[i]
/// FI
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1308,7 +1348,7 @@ _mm_mask_cvtne2ph_pbf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
/// instead.
///
/// \code{.operation}
-/// FOR i := 0 to 16
+/// FOR i := 0 to 15
/// IF __U[i]
/// IF i < 8
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
@@ -1319,6 +1359,8 @@ _mm_mask_cvtne2ph_pbf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
/// dst.fp8[i] := 0
/// FI
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1354,6 +1396,8 @@ _mm_maskz_cvtne2ph_pbf8(__mmask16 __U, __m128h __A, __m128h __B) {
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 16])
/// FI
/// ENDFOR
+///
+/// dst[MAX:256] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1391,6 +1435,8 @@ _mm256_cvtne2ph_pbf8(__m256h __A, __m256h __B) {
/// dst.fp8[i] := __W.fp8[i]
/// FI
/// ENDFOR
+///
+/// dst[MAX:256] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1433,6 +1479,8 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtne2ph_pbf8(
/// FI
/// FI
/// ENDFOR
+///
+/// dst[MAX:256] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1462,13 +1510,15 @@ _mm256_maskz_cvtne2ph_pbf8(__mmask32 __U, __m256h __A, __m256h __B) {
/// Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
-/// FOR i := 0 to 16
+/// FOR i := 0 to 15
/// IF i < 8
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
/// ELSE
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 8])
/// FI
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1495,7 +1545,7 @@ _mm_cvtnes2ph_pbf8(__m128h __A, __m128h __B) {
/// from \a __W instead. Resulting elements are saturated in case of an overflow.
///
/// \code{.operation}
-/// FOR i := 0 to 16
+/// FOR i := 0 to 15
/// IF __U[i]
/// IF i < 8
/// dst.fp8[i] := convert_fp16_to_fp8(__B.fp16[i])
@@ -1506,6 +1556,8 @@ _mm_cvtnes2ph_pbf8(__m128h __A, __m128h __B) {
/// dst.fp8 := __W.fp8[i]
/// FI
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1548,6 +1600,8 @@ _mm_mask_cvtnes2ph_pbf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
/// dst.fp8[i] := 0
/// FI
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1584,6 +1638,8 @@ _mm_maskz_cvtnes2ph_pbf8(__mmask16 __U, __m128h __A, __m128h __B) {
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 16])
/// FI
/// ENDFOR
+///
+/// dst[MAX:256] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1621,6 +1677,8 @@ _mm256_cvtnes2ph_pbf8(__m256h __A, __m256h __B) {
/// dst.fp8[i] := __W.fp8[i]
/// FI
/// ENDFOR
+///
+/// dst[MAX:256] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1663,6 +1721,8 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtnes2ph_pbf8(
/// FI
/// FI
/// ENDFOR
+///
+/// dst[MAX:256] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1698,6 +1758,8 @@ _mm256_maskz_cvtnes2ph_pbf8(__mmask32 __U, __m256h __A, __m256h __B) {
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 8])
/// FI
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1735,6 +1797,8 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtne2ph_phf8(__m128h __A,
/// dst.fp8 := __W.fp8[i]
/// FI
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1777,6 +1841,8 @@ _mm_mask_cvtne2ph_phf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
/// dst.fp8[i] := 0
/// FI
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1812,6 +1878,8 @@ _mm_maskz_cvtne2ph_phf8(__mmask16 __U, __m128h __A, __m128h __B) {
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 16])
/// FI
/// ENDFOR
+///
+/// dst[MAX:256] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1849,6 +1917,8 @@ _mm256_cvtne2ph_phf8(__m256h __A, __m256h __B) {
/// dst.fp8[i] := __W.fp8[i]
/// FI
/// ENDFOR
+///
+/// dst[MAX:256] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1891,6 +1961,8 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtne2ph_phf8(
/// FI
/// FI
/// ENDFOR
+///
+/// dst[MAX:256] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1927,6 +1999,8 @@ _mm256_maskz_cvtne2ph_phf8(__mmask32 __U, __m256h __A, __m256h __B) {
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 8])
/// FI
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -1964,6 +2038,8 @@ _mm_cvtnes2ph_phf8(__m128h __A, __m128h __B) {
/// dst.fp8 := __W.fp8[i]
/// FI
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2006,6 +2082,8 @@ _mm_mask_cvtnes2ph_phf8(__m128i __W, __mmask16 __U, __m128h __A, __m128h __B) {
/// dst.fp8[i] := 0
/// FI
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2042,6 +2120,8 @@ _mm_maskz_cvtnes2ph_phf8(__mmask16 __U, __m128h __A, __m128h __B) {
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i - 16])
/// FI
/// ENDFOR
+///
+/// dst[MAX:256] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2079,6 +2159,8 @@ _mm256_cvtnes2ph_phf8(__m256h __A, __m256h __B) {
/// dst.fp8[i] := __W.fp8[i]
/// FI
/// ENDFOR
+///
+/// dst[MAX:256] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2121,6 +2203,8 @@ static __inline__ __m256i __DEFAULT_FN_ATTRS256 _mm256_mask_cvtnes2ph_phf8(
/// FI
/// FI
/// ENDFOR
+///
+/// dst[MAX:256] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2152,6 +2236,8 @@ _mm256_maskz_cvtnes2ph_phf8(__mmask32 __U, __m256h __A, __m256h __B) {
/// FOR i := 0 to 7
/// dst.fp16[i] := convert_fp8_to_fp16(__A.fp8[i])
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2181,6 +2267,8 @@ static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtnehf8_ph(__m128i __A) {
/// dst.fp16[i] := __W.fp16[i]
/// FI
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2216,6 +2304,8 @@ _mm_mask_cvtnehf8_ph(__m128h __W, __mmask8 __U, __m128i __A) {
/// dst.fp16[i] := 0
/// FI
/// ENDFOR
+///
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2243,6 +2333,8 @@ _mm_maskz_cvtnehf8_ph(__mmask8 __U, __m128i __A) {
/// FOR i := 0 to 15
/// dst.fp16[i] := convert_fp8_to_fp16(__A.fp8[i])
/// ENDFOR
+///
+/// dst[MAX:256] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2273,6 +2365,8 @@ _mm256_cvtnehf8_ph(__m128i __A) {
/// dst.fp16[i] := __W.fp16[i]
/// FI
/// ENDFOR
+///
+/// dst[MAX:256] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2308,6 +2402,8 @@ _mm256_mask_cvtnehf8_ph(__m256h __W, __mmask16 __U, __m128i __A) {
/// dst.fp16[i] := 0
/// FI
/// ENDFOR
+///
+/// dst[MAX:256] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2337,7 +2433,7 @@ _mm256_maskz_cvtnehf8_ph(__mmask16 __U, __m128i __A) {
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2368,7 +2464,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtneph_pbf8(__m128h __A) {
/// FI
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2405,7 +2501,7 @@ _mm_mask_cvtneph_pbf8(__m128i __W, __mmask8 __U, __m128h __A) {
/// FI
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2434,7 +2530,7 @@ _mm_maskz_cvtneph_pbf8(__mmask8 __U, __m128h __A) {
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
/// ENDFOR
///
-/// dst[255:128] := 0
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2465,7 +2561,7 @@ _mm256_cvtneph_pbf8(__m256h __A) {
/// FI
/// ENDFOR
///
-/// dst[255:128] := 0
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2501,7 +2597,7 @@ _mm256_mask_cvtneph_pbf8(__m128i __W, __mmask16 __U, __m256h __A) {
/// FI
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2531,7 +2627,7 @@ _mm256_maskz_cvtneph_pbf8(__mmask16 __U, __m256h __A) {
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2562,7 +2658,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtnesph_pbf8(__m128h __A) {
/// FI
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2599,7 +2695,7 @@ _mm_mask_cvtnesph_pbf8(__m128i __W, __mmask8 __U, __m128h __A) {
/// FI
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2628,7 +2724,7 @@ _mm_maskz_cvtnesph_pbf8(__mmask8 __U, __m128h __A) {
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
/// ENDFOR
///
-/// dst[255:128] := 0
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2660,7 +2756,7 @@ _mm256_cvtnesph_pbf8(__m256h __A) {
/// FI
/// ENDFOR
///
-/// dst[255:128] := 0
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2697,7 +2793,7 @@ _mm256_mask_cvtnesph_pbf8(__m128i __W, __mmask16 __U, __m256h __A) {
/// FI
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2727,7 +2823,7 @@ _mm256_maskz_cvtnesph_pbf8(__mmask16 __U, __m256h __A) {
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2758,7 +2854,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtneph_phf8(__m128h __A) {
/// FI
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2795,7 +2891,7 @@ _mm_mask_cvtneph_phf8(__m128i __W, __mmask8 __U, __m128h __A) {
/// FI
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2824,7 +2920,7 @@ _mm_maskz_cvtneph_phf8(__mmask8 __U, __m128h __A) {
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
/// ENDFOR
///
-/// dst[255:128] := 0
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2855,7 +2951,7 @@ _mm256_cvtneph_phf8(__m256h __A) {
/// FI
/// ENDFOR
///
-/// dst[255:128] := 0
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2891,7 +2987,7 @@ _mm256_mask_cvtneph_phf8(__m128i __W, __mmask16 __U, __m256h __A) {
/// FI
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2921,7 +3017,7 @@ _mm256_maskz_cvtneph_phf8(__mmask16 __U, __m256h __A) {
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2952,7 +3048,7 @@ static __inline__ __m128i __DEFAULT_FN_ATTRS128 _mm_cvtnesph_phf8(__m128h __A) {
/// FI
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -2989,7 +3085,7 @@ _mm_mask_cvtnesph_phf8(__m128i __W, __mmask8 __U, __m128h __A) {
/// FI
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -3018,7 +3114,7 @@ _mm_maskz_cvtnesph_phf8(__mmask8 __U, __m128h __A) {
/// dst.fp8[i] := convert_fp16_to_fp8(__A.fp16[i])
/// ENDFOR
///
-/// dst[255:128] := 0
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -3050,7 +3146,7 @@ _mm256_cvtnesph_phf8(__m256h __A) {
/// FI
/// ENDFOR
///
-/// dst[255:128] := 0
+/// dst[MAX:128] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -3087,7 +3183,7 @@ _mm256_mask_cvtnesph_phf8(__m128i __W, __mmask16 __U, __m256h __A) {
/// FI
/// ENDFOR
///
-/// dst[127:64] := 0
+/// dst[MAX:64] := 0
/// \endcode
///
/// \headerfile <immintrin.h>
@@ -3119,7 +3215,7 @@ _mm256_maskz_cvtnesph_phf8(__mmask16 __U, __m256h __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic does not corresponds to a single instruction.
+/// This intrinsic does not correspond to a single instruction.
///
/// \param __A
/// A 128-bit vector of [16 x hf8].
@@ -3147,7 +3243,7 @@ static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtpbf8_ph(__m128i __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic does not corresponds to a single instruction.
+/// This intrinsic does not correspond to a single instruction.
///
/// \param __W
/// A 128-bit vector of [8 x fp16].
@@ -3160,9 +3256,9 @@ static __inline__ __m128h __DEFAULT_FN_ATTRS128 _mm_cvtpbf8_ph(__m128i __A) {
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m128h __DEFAULT_FN_ATTRS128
-_mm_mask_cvtpbf8_ph(__m128h __S, __mmask8 __U, __m128i __A) {
+_mm_mask_cvtpbf8_ph(__m128h __W, __mmask8 __U, __m128i __A) {
return _mm_castsi128_ph(
- _mm_mask_slli_epi16((__m128i)__S, __U, _mm_cvtepi8_epi16(__A), 8));
+ _mm_mask_slli_epi16((__m128i)__W, __U, _mm_cvtepi8_epi16(__A), 8));
}
/// Convert 128-bit vector \a __A, containing packed FP8 E5M2 floating-point
@@ -3182,7 +3278,7 @@ _mm_mask_cvtpbf8_ph(__m128h __S, __mmask8 __U, __m128i __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic does not corresponds to a single instruction.
+/// This intrinsic does not correspond to a single instruction.
///
/// \param __U
/// A 8-bit zeroing mask.
@@ -3208,7 +3304,7 @@ _mm_maskz_cvtpbf8_ph(__mmask8 __U, __m128i __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic does not corresponds to a single instruction.
+/// This intrinsic does not correspond to a single instruction.
///
/// \param __A
/// A 256-bit vector of [32 x hf8].
@@ -3236,7 +3332,7 @@ static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_cvtpbf8_ph(__m128i __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic does not corresponds to a single instruction.
+/// This intrinsic does not correspond to a single instruction.
///
/// \param __W
/// A 256-bit vector of [16 x fp16].
@@ -3249,9 +3345,9 @@ static __inline__ __m256h __DEFAULT_FN_ATTRS256 _mm256_cvtpbf8_ph(__m128i __A) {
/// (converted) elements from \a __A. If corresponding mask bit is not set, then
/// element from \a __W is taken instead.
static __inline__ __m256h __DEFAULT_FN_ATTRS256
-_mm256_mask_cvtpbf8_ph(__m256h __S, __mmask8 __U, __m128i __A) {
+_mm256_mask_cvtpbf8_ph(__m256h __W, __mmask8 __U, __m128i __A) {
return _mm256_castsi256_ph(
- _mm256_mask_slli_epi16((__m256i)__S, __U, _mm256_cvtepi8_epi16(__A), 8));
+ _mm256_mask_slli_epi16((__m256i)__W, __U, _mm256_cvtepi8_epi16(__A), 8));
}
/// Convert 256-bit vector \a __A, containing packed FP8 E5M2 floating-point
@@ -3271,7 +3367,7 @@ _mm256_mask_cvtpbf8_ph(__m256h __S, __mmask8 __U, __m128i __A) {
///
/// \headerfile <immintrin.h>
///
-/// This intrinsic does not corresponds to a single instruction.
+/// This intrinsic does not correspond to a single instruction.
///
/// \param __U
/// A 16-bit zeroing mask.
>From 647d10e45fc8bf8127b9877ff07b7723f5e5b827 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Miko=C5=82aj=20Pir=C3=B3g?= <mikolajpirog at gmail.com>
Date: Sat, 21 Dec 2024 22:32:55 +0100
Subject: [PATCH 9/9] Disable clang-format
---
clang/lib/Headers/avx10_2convertintrin.h | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/clang/lib/Headers/avx10_2convertintrin.h b/clang/lib/Headers/avx10_2convertintrin.h
index aa6a502de47dbb..622be0ac0b1113 100644
--- a/clang/lib/Headers/avx10_2convertintrin.h
+++ b/clang/lib/Headers/avx10_2convertintrin.h
@@ -24,6 +24,8 @@
__attribute__((__always_inline__, __nodebug__, __target__("avx10.2-256"), \
__min_vector_width__(256)))
+//clang-format off
+
/// Convert two 128-bit vectors, \a __A and \a __B, containing packed
/// single-precision (32-bit) floating-point elements to a 128-bit vector
/// containing FP16 elements.
@@ -3383,6 +3385,8 @@ _mm256_maskz_cvtpbf8_ph(__mmask8 __U, __m128i __A) {
_mm256_slli_epi16(_mm256_maskz_cvtepi8_epi16(__U, __A), 8));
}
+// clang-format on
+
#undef __DEFAULT_FN_ATTRS128
#undef __DEFAULT_FN_ATTRS256
More information about the cfe-commits
mailing list