avxintrin.h documentation fixes and updates

[dyung]

Summary

This is the result of several patches we made internally to update the documentation that we would like to have reviewed for possible submission.

The changes include:

1. Fix incorrect wording in various intrinsic descriptions. Previously the descriptions used "low-order" and "high-order" when the intended meaning was "even-indexed" and "odd-indexed".
2. Fix a few typos and errors found during review.
3. Restore new line endings and change to use hex suffixes (0h instead of 0x0).

These patches were made by Craig Flores

[lebedev.ri]

lib/Headers/avxintrin.h

1668

While i'm incompetent to actually review this, i have a question.
Why replace code-friendly 0x00 with 00h?
And, why is this hex in the first place? Why not decimals?

[kromanova]

lib/Headers/avxintrin.h

1668

why is this hex in the first place? Why not decimals?

There are a few reasons that I could think of:

(1) for consistency with the defines in the header file describing these values:
#define _CMP_EQ_OQ 0x00 /* Equal (ordered, non-signaling) */
#define _CMP_LT_OS 0x01 /* Less-than (ordered, signaling) */
#define _CMP_LE_OS 0x02 /* Less-than-or-equal (ordered, signaling) */
#define _CMP_UNORD_Q 0x03 /* Unordered (non-signaling) */
#define _CMP_NEQ_UQ 0x04 /* Not-equal (unordered, non-signaling) */

(2) This immediate is 5 bits, so when using hex, it's much easier to tell which bits are set/not set/
(3) For consistency with Intel's and AMD's documentation for intrinsics and corresponding instructions.

I s developers prefer to have it in 0x format, this change it was done for consistency.
AMD and Intel manuals use the 'h' suffix style

1668

Why replace code-friendly 0x00 with 00h?

For consistency with some other intrinsics doxygen documentation using 'h' notation.

I looked little further and noticed that around 60% of the doxygen comments are using '0x' notation, while around 40% are using 'h' notation. It's inconsistent. Now we could pick one or another. If someone has a strong opinion, please speak up. I personally prefer '0x' notation.

Doug, could you please change your code review to introduce '0x' notation back. I will submit a separate code review a little later to change the rest of "h" occurrences to "0x" in the rest of intrinsics documentation.

2378

Please fit tightly into 80 chars.

[dyung]

Updated change to address review feedback.

[RKSimon]

LGTM

[kromanova]

LGTM too.

lib/Headers/avxintrin.h

 /// __m256 _mm256_permute_ps(__m256 A, const int C);
 /// \endcode
 ///
 /// This intrinsic corresponds to the <c> VPERMILPS </c> instruction.
 ///
 /// \param A
 ///    A 256-bit vector of [8 x float].
 /// \param C
-///    An immediate integer operand specifying how the values are to be \n
+///    An immediate integer operand specifying how the values are to be
 ///    copied. \n
 ///    Bits [1:0]: \n
 ///      00: Bits [31:0] of the source are copied to bits [31:0] of the
 ///          returned vector. \n
 ///      01: Bits [63:32] of the source are copied to bits [31:0] of the
 ///          returned vector. \n
 ///      10: Bits [95:64] of the source are copied to bits [31:0] of the
 ///          returned vector. \n

 ///          returned vector. \n
 ///      01: Bits [63:32] of the source are copied to bits [95:64] of the
 ///          returned vector. \n
 ///      10: Bits [95:64] of the source are copied to bits [95:64] of the
 ///          returned vector. \n
 ///      11: Bits [127:96] of the source are copied to bits [95:64] of the
 ///          returned vector. \n
 ///    Bits [7:6]: \n
-///      00: Bits [31:qq0] of the source are copied to bits [127:96] of the
+///      00: Bits [31:0] of the source are copied to bits [127:96] of the
 ///          returned vector. \n
 ///      01: Bits [63:32] of the source are copied to bits [127:96] of the
 ///          returned vector. \n
 ///      10: Bits [95:64] of the source are copied to bits [127:96] of the
 ///          returned vector. \n
 ///      11: Bits [127:96] of the source are copied to bits [127:96] of the
 ///          returned vector. \n
 ///    Bits [1:0]: \n

 ///
 /// \param a
 ///    A 128-bit vector of [2 x double].
 /// \param b
 ///    A 128-bit vector of [2 x double].
 /// \param c
 ///    An immediate integer operand, with bits [4:0] specifying which comparison
 ///    operation to use: \n
-///    0x00 : Equal (ordered, non-signaling)
-///    0x01 : Less-than (ordered, signaling)
-///    0x02 : Less-than-or-equal (ordered, signaling)
-///    0x03 : Unordered (non-signaling)
-///    0x04 : Not-equal (unordered, non-signaling)
-///    0x05 : Not-less-than (unordered, signaling)
-///    0x06 : Not-less-than-or-equal (unordered, signaling)
-///    0x07 : Ordered (non-signaling)
-///    0x08 : Equal (unordered, non-signaling)
-///    0x09 : Not-greater-than-or-equal (unordered, signaling)
-///    0x0a : Not-greater-than (unordered, signaling)
-///    0x0b : False (ordered, non-signaling)
-///    0x0c : Not-equal (ordered, non-signaling)
-///    0x0d : Greater-than-or-equal (ordered, signaling)
-///    0x0e : Greater-than (ordered, signaling)
-///    0x0f : True (unordered, non-signaling)
-///    0x10 : Equal (ordered, signaling)
-///    0x11 : Less-than (ordered, non-signaling)
-///    0x12 : Less-than-or-equal (ordered, non-signaling)
-///    0x13 : Unordered (signaling)
-///    0x14 : Not-equal (unordered, signaling)
-///    0x15 : Not-less-than (unordered, non-signaling)
-///    0x16 : Not-less-than-or-equal (unordered, non-signaling)
-///    0x17 : Ordered (signaling)
-///    0x18 : Equal (unordered, signaling)
-///    0x19 : Not-greater-than-or-equal (unordered, non-signaling)
-///    0x1a : Not-greater-than (unordered, non-signaling)
-///    0x1b : False (ordered, signaling)
-///    0x1c : Not-equal (ordered, signaling)
-///    0x1d : Greater-than-or-equal (ordered, non-signaling)
-///    0x1e : Greater-than (ordered, non-signaling)
-///    0x1f : True (unordered, signaling)
+///    00h: Equal (ordered, non-signaling) \n
+///    01h: Less-than (ordered, signaling) \n
+///    02h: Less-than-or-equal (ordered, signaling) \n
+///    03h: Unordered (non-signaling) \n
+///    04h: Not-equal (unordered, non-signaling) \n
+///    05h: Not-less-than (unordered, signaling) \n
+///    06h: Not-less-than-or-equal (unordered, signaling) \n
+///    07h: Ordered (non-signaling) \n
+///    08h: Equal (unordered, non-signaling) \n
+///    09h: Not-greater-than-or-equal (unordered, signaling) \n
+///    0Ah: Not-greater-than (unordered, signaling) \n
+///    0Bh: False (ordered, non-signaling) \n
+///    0Ch: Not-equal (ordered, non-signaling) \n
+///    0Dh: Greater-than-or-equal (ordered, signaling) \n
+///    0Eh: Greater-than (ordered, signaling) \n
+///    0Fh: True (unordered, non-signaling) \n
+///    10h: Equal (ordered, signaling) \n
+///    11h: Less-than (ordered, non-signaling) \n
+///    12h: Less-than-or-equal (ordered, non-signaling) \n
+///    13h: Unordered (signaling) \n
+///    14h: Not-equal (unordered, signaling) \n
+///    15h: Not-less-than (unordered, non-signaling) \n
+///    16h: Not-less-than-or-equal (unordered, non-signaling) \n
+///    17h: Ordered (signaling) \n
+///    18h: Equal (unordered, signaling) \n
+///    19h: Not-greater-than-or-equal (unordered, non-signaling) \n
+///    1Ah: Not-greater-than (unordered, non-signaling) \n
+///    1Bh: False (ordered, signaling) \n
+///    1Ch: Not-equal (ordered, signaling) \n
+///    1Dh: Greater-than-or-equal (ordered, non-signaling) \n
+///    1Eh: Greater-than (ordered, non-signaling) \n
+///    1Fh: True (unordered, signaling)
 /// \returns A 128-bit vector of [2 x double] containing the comparison results.
 #define _mm_cmp_pd(a, b, c) __extension__ ({ \
   (__m128d)__builtin_ia32_cmppd((__v2df)(__m128d)(a), \
                                 (__v2df)(__m128d)(b), (c)); })
 
 /// \brief Compares each of the corresponding values of two 128-bit vectors of
 ///    [4 x float], using the operation specified by the immediate integer
 ///    operand.

 ///
 /// \param a
 ///    A 128-bit vector of [4 x float].
 /// \param b
 ///    A 128-bit vector of [4 x float].
 /// \param c
 ///    An immediate integer operand, with bits [4:0] specifying which comparison
 ///    operation to use: \n
-///    0x00 : Equal (ordered, non-signaling)
-///    0x01 : Less-than (ordered, signaling)
-///    0x02 : Less-than-or-equal (ordered, signaling)
-///    0x03 : Unordered (non-signaling)
-///    0x04 : Not-equal (unordered, non-signaling)
-///    0x05 : Not-less-than (unordered, signaling)
-///    0x06 : Not-less-than-or-equal (unordered, signaling)
-///    0x07 : Ordered (non-signaling)
-///    0x08 : Equal (unordered, non-signaling)
-///    0x09 : Not-greater-than-or-equal (unordered, signaling)
-///    0x0a : Not-greater-than (unordered, signaling)
-///    0x0b : False (ordered, non-signaling)
-///    0x0c : Not-equal (ordered, non-signaling)
-///    0x0d : Greater-than-or-equal (ordered, signaling)
-///    0x0e : Greater-than (ordered, signaling)
-///    0x0f : True (unordered, non-signaling)
-///    0x10 : Equal (ordered, signaling)
-///    0x11 : Less-than (ordered, non-signaling)
-///    0x12 : Less-than-or-equal (ordered, non-signaling)
-///    0x13 : Unordered (signaling)
-///    0x14 : Not-equal (unordered, signaling)
-///    0x15 : Not-less-than (unordered, non-signaling)
-///    0x16 : Not-less-than-or-equal (unordered, non-signaling)
-///    0x17 : Ordered (signaling)
-///    0x18 : Equal (unordered, signaling)
-///    0x19 : Not-greater-than-or-equal (unordered, non-signaling)
-///    0x1a : Not-greater-than (unordered, non-signaling)
-///    0x1b : False (ordered, signaling)
-///    0x1c : Not-equal (ordered, signaling)
-///    0x1d : Greater-than-or-equal (ordered, non-signaling)
-///    0x1e : Greater-than (ordered, non-signaling)
-///    0x1f : True (unordered, signaling)
+///    00h: Equal (ordered, non-signaling) \n
+///    01h: Less-than (ordered, signaling) \n
+///    02h: Less-than-or-equal (ordered, signaling) \n
+///    03h: Unordered (non-signaling) \n
+///    04h: Not-equal (unordered, non-signaling) \n
+///    05h: Not-less-than (unordered, signaling) \n
+///    06h: Not-less-than-or-equal (unordered, signaling) \n
+///    07h: Ordered (non-signaling) \n
+///    08h: Equal (unordered, non-signaling) \n
+///    09h: Not-greater-than-or-equal (unordered, signaling) \n
+///    0Ah: Not-greater-than (unordered, signaling) \n
+///    0Bh: False (ordered, non-signaling) \n
+///    0Ch: Not-equal (ordered, non-signaling) \n
+///    0Dh: Greater-than-or-equal (ordered, signaling) \n
+///    0Eh: Greater-than (ordered, signaling) \n
+///    0Fh: True (unordered, non-signaling) \n
+///    10h: Equal (ordered, signaling) \n
+///    11h: Less-than (ordered, non-signaling) \n
+///    12h: Less-than-or-equal (ordered, non-signaling) \n
+///    13h: Unordered (signaling) \n
+///    14h: Not-equal (unordered, signaling) \n
+///    15h: Not-less-than (unordered, non-signaling) \n
+///    16h: Not-less-than-or-equal (unordered, non-signaling) \n
+///    17h: Ordered (signaling) \n
+///    18h: Equal (unordered, signaling) \n
+///    19h: Not-greater-than-or-equal (unordered, non-signaling) \n
+///    1Ah: Not-greater-than (unordered, non-signaling) \n
+///    1Bh: False (ordered, signaling) \n
+///    1Ch: Not-equal (ordered, signaling) \n
+///    1Dh: Greater-than-or-equal (ordered, non-signaling) \n
+///    1Eh: Greater-than (ordered, non-signaling) \n
+///    1Fh: True (unordered, signaling)
 /// \returns A 128-bit vector of [4 x float] containing the comparison results.
 #define _mm_cmp_ps(a, b, c) __extension__ ({ \
   (__m128)__builtin_ia32_cmpps((__v4sf)(__m128)(a), \
                                (__v4sf)(__m128)(b), (c)); })
 
 /// \brief Compares each of the corresponding double-precision values of two
 ///    256-bit vectors of [4 x double], using the operation specified by the
 ///    immediate integer operand.

 ///
 /// \param a
 ///    A 256-bit vector of [4 x double].
 /// \param b
 ///    A 256-bit vector of [4 x double].
 /// \param c
 ///    An immediate integer operand, with bits [4:0] specifying which comparison
 ///    operation to use: \n
-///    0x00 : Equal (ordered, non-signaling)
-///    0x01 : Less-than (ordered, signaling)
-///    0x02 : Less-than-or-equal (ordered, signaling)
-///    0x03 : Unordered (non-signaling)
-///    0x04 : Not-equal (unordered, non-signaling)
-///    0x05 : Not-less-than (unordered, signaling)
-///    0x06 : Not-less-than-or-equal (unordered, signaling)
-///    0x07 : Ordered (non-signaling)
-///    0x08 : Equal (unordered, non-signaling)
-///    0x09 : Not-greater-than-or-equal (unordered, signaling)
-///    0x0a : Not-greater-than (unordered, signaling)
-///    0x0b : False (ordered, non-signaling)
-///    0x0c : Not-equal (ordered, non-signaling)
-///    0x0d : Greater-than-or-equal (ordered, signaling)
-///    0x0e : Greater-than (ordered, signaling)
-///    0x0f : True (unordered, non-signaling)
-///    0x10 : Equal (ordered, signaling)
-///    0x11 : Less-than (ordered, non-signaling)
-///    0x12 : Less-than-or-equal (ordered, non-signaling)
-///    0x13 : Unordered (signaling)
-///    0x14 : Not-equal (unordered, signaling)
-///    0x15 : Not-less-than (unordered, non-signaling)
-///    0x16 : Not-less-than-or-equal (unordered, non-signaling)
-///    0x17 : Ordered (signaling)
-///    0x18 : Equal (unordered, signaling)
-///    0x19 : Not-greater-than-or-equal (unordered, non-signaling)
-///    0x1a : Not-greater-than (unordered, non-signaling)
-///    0x1b : False (ordered, signaling)
-///    0x1c : Not-equal (ordered, signaling)
-///    0x1d : Greater-than-or-equal (ordered, non-signaling)
-///    0x1e : Greater-than (ordered, non-signaling)
-///    0x1f : True (unordered, signaling)
+///    00h: Equal (ordered, non-signaling) \n
+///    01h: Less-than (ordered, signaling) \n
+///    02h: Less-than-or-equal (ordered, signaling) \n
+///    03h: Unordered (non-signaling) \n
+///    04h: Not-equal (unordered, non-signaling) \n
+///    05h: Not-less-than (unordered, signaling) \n
+///    06h: Not-less-than-or-equal (unordered, signaling) \n
+///    07h: Ordered (non-signaling) \n
+///    08h: Equal (unordered, non-signaling) \n
+///    09h: Not-greater-than-or-equal (unordered, signaling) \n
+///    0Ah: Not-greater-than (unordered, signaling) \n
+///    0Bh: False (ordered, non-signaling) \n
+///    0Ch: Not-equal (ordered, non-signaling) \n
+///    0Dh: Greater-than-or-equal (ordered, signaling) \n
+///    0Eh: Greater-than (ordered, signaling) \n
+///    0Fh: True (unordered, non-signaling) \n
+///    10h: Equal (ordered, signaling) \n
+///    11h: Less-than (ordered, non-signaling) \n
+///    12h: Less-than-or-equal (ordered, non-signaling) \n
+///    13h: Unordered (signaling) \n
+///    14h: Not-equal (unordered, signaling) \n
+///    15h: Not-less-than (unordered, non-signaling) \n
+///    16h: Not-less-than-or-equal (unordered, non-signaling) \n
+///    17h: Ordered (signaling) \n
+///    18h: Equal (unordered, signaling) \n
+///    19h: Not-greater-than-or-equal (unordered, non-signaling) \n
+///    1Ah: Not-greater-than (unordered, non-signaling) \n
+///    1Bh: False (ordered, signaling) \n
+///    1Ch: Not-equal (ordered, signaling) \n
+///    1Dh: Greater-than-or-equal (ordered, non-signaling) \n
+///    1Eh: Greater-than (ordered, non-signaling) \n
+///    1Fh: True (unordered, signaling)
 /// \returns A 256-bit vector of [4 x double] containing the comparison results.
 #define _mm256_cmp_pd(a, b, c) __extension__ ({ \
   (__m256d)__builtin_ia32_cmppd256((__v4df)(__m256d)(a), \
                                    (__v4df)(__m256d)(b), (c)); })
 
 /// \brief Compares each of the corresponding values of two 256-bit vectors of
 ///    [8 x float], using the operation specified by the immediate integer
 ///    operand.

 ///
 /// \param a
 ///    A 256-bit vector of [8 x float].
 /// \param b
 ///    A 256-bit vector of [8 x float].
 /// \param c
 ///    An immediate integer operand, with bits [4:0] specifying which comparison
 ///    operation to use: \n
-///    0x00 : Equal (ordered, non-signaling)
-///    0x01 : Less-than (ordered, signaling)
-///    0x02 : Less-than-or-equal (ordered, signaling)
-///    0x03 : Unordered (non-signaling)
-///    0x04 : Not-equal (unordered, non-signaling)
-///    0x05 : Not-less-than (unordered, signaling)
-///    0x06 : Not-less-than-or-equal (unordered, signaling)
-///    0x07 : Ordered (non-signaling)
-///    0x08 : Equal (unordered, non-signaling)
-///    0x09 : Not-greater-than-or-equal (unordered, signaling)
-///    0x0a : Not-greater-than (unordered, signaling)
-///    0x0b : False (ordered, non-signaling)
-///    0x0c : Not-equal (ordered, non-signaling)
-///    0x0d : Greater-than-or-equal (ordered, signaling)
-///    0x0e : Greater-than (ordered, signaling)
-///    0x0f : True (unordered, non-signaling)
-///    0x10 : Equal (ordered, signaling)
-///    0x11 : Less-than (ordered, non-signaling)
-///    0x12 : Less-than-or-equal (ordered, non-signaling)
-///    0x13 : Unordered (signaling)
-///    0x14 : Not-equal (unordered, signaling)
-///    0x15 : Not-less-than (unordered, non-signaling)
-///    0x16 : Not-less-than-or-equal (unordered, non-signaling)
-///    0x17 : Ordered (signaling)
-///    0x18 : Equal (unordered, signaling)
-///    0x19 : Not-greater-than-or-equal (unordered, non-signaling)
-///    0x1a : Not-greater-than (unordered, non-signaling)
-///    0x1b : False (ordered, signaling)
-///    0x1c : Not-equal (ordered, signaling)
-///    0x1d : Greater-than-or-equal (ordered, non-signaling)
-///    0x1e : Greater-than (ordered, non-signaling)
-///    0x1f : True (unordered, signaling)
+///    00h: Equal (ordered, non-signaling) \n
+///    01h: Less-than (ordered, signaling) \n
+///    02h: Less-than-or-equal (ordered, signaling) \n
+///    03h: Unordered (non-signaling) \n
+///    04h: Not-equal (unordered, non-signaling) \n
+///    05h: Not-less-than (unordered, signaling) \n
+///    06h: Not-less-than-or-equal (unordered, signaling) \n
+///    07h: Ordered (non-signaling) \n
+///    08h: Equal (unordered, non-signaling) \n
+///    09h: Not-greater-than-or-equal (unordered, signaling) \n
+///    0Ah: Not-greater-than (unordered, signaling) \n
+///    0Bh: False (ordered, non-signaling) \n
+///    0Ch: Not-equal (ordered, non-signaling) \n
+///    0Dh: Greater-than-or-equal (ordered, signaling) \n
+///    0Eh: Greater-than (ordered, signaling) \n
+///    0Fh: True (unordered, non-signaling) \n
+///    10h: Equal (ordered, signaling) \n
+///    11h: Less-than (ordered, non-signaling) \n
+///    12h: Less-than-or-equal (ordered, non-signaling) \n
+///    13h: Unordered (signaling) \n
+///    14h: Not-equal (unordered, signaling) \n
+///    15h: Not-less-than (unordered, non-signaling) \n
+///    16h: Not-less-than-or-equal (unordered, non-signaling) \n
+///    17h: Ordered (signaling) \n
+///    18h: Equal (unordered, signaling) \n
+///    19h: Not-greater-than-or-equal (unordered, non-signaling) \n
+///    1Ah: Not-greater-than (unordered, non-signaling) \n
+///    1Bh: False (ordered, signaling) \n
+///    1Ch: Not-equal (ordered, signaling) \n
+///    1Dh: Greater-than-or-equal (ordered, non-signaling) \n
+///    1Eh: Greater-than (ordered, non-signaling) \n
+///    1Fh: True (unordered, signaling)
 /// \returns A 256-bit vector of [8 x float] containing the comparison results.
 #define _mm256_cmp_ps(a, b, c) __extension__ ({ \
   (__m256)__builtin_ia32_cmpps256((__v8sf)(__m256)(a), \
                                   (__v8sf)(__m256)(b), (c)); })
 
 /// \brief Compares each of the corresponding scalar double-precision values of
 ///    two 128-bit vectors of [2 x double], using the operation specified by the
 ///    immediate integer operand.

 ///
 /// \param a
 ///    A 128-bit vector of [2 x double].
 /// \param b
 ///    A 128-bit vector of [2 x double].
 /// \param c
 ///    An immediate integer operand, with bits [4:0] specifying which comparison
 ///    operation to use: \n
-///    0x00 : Equal (ordered, non-signaling)
-///    0x01 : Less-than (ordered, signaling)
-///    0x02 : Less-than-or-equal (ordered, signaling)
-///    0x03 : Unordered (non-signaling)
-///    0x04 : Not-equal (unordered, non-signaling)
-///    0x05 : Not-less-than (unordered, signaling)
-///    0x06 : Not-less-than-or-equal (unordered, signaling)
-///    0x07 : Ordered (non-signaling)
-///    0x08 : Equal (unordered, non-signaling)
-///    0x09 : Not-greater-than-or-equal (unordered, signaling)
-///    0x0a : Not-greater-than (unordered, signaling)
-///    0x0b : False (ordered, non-signaling)
-///    0x0c : Not-equal (ordered, non-signaling)
-///    0x0d : Greater-than-or-equal (ordered, signaling)
-///    0x0e : Greater-than (ordered, signaling)
-///    0x0f : True (unordered, non-signaling)
-///    0x10 : Equal (ordered, signaling)
-///    0x11 : Less-than (ordered, non-signaling)
-///    0x12 : Less-than-or-equal (ordered, non-signaling)
-///    0x13 : Unordered (signaling)
-///    0x14 : Not-equal (unordered, signaling)
-///    0x15 : Not-less-than (unordered, non-signaling)
-///    0x16 : Not-less-than-or-equal (unordered, non-signaling)
-///    0x17 : Ordered (signaling)
-///    0x18 : Equal (unordered, signaling)
-///    0x19 : Not-greater-than-or-equal (unordered, non-signaling)
-///    0x1a : Not-greater-than (unordered, non-signaling)
-///    0x1b : False (ordered, signaling)
-///    0x1c : Not-equal (ordered, signaling)
-///    0x1d : Greater-than-or-equal (ordered, non-signaling)
-///    0x1e : Greater-than (ordered, non-signaling)
-///    0x1f : True (unordered, signaling)
+///    00h: Equal (ordered, non-signaling) \n
+///    01h: Less-than (ordered, signaling) \n
+///    02h: Less-than-or-equal (ordered, signaling) \n
+///    03h: Unordered (non-signaling) \n
+///    04h: Not-equal (unordered, non-signaling) \n
+///    05h: Not-less-than (unordered, signaling) \n
+///    06h: Not-less-than-or-equal (unordered, signaling) \n
+///    07h: Ordered (non-signaling) \n
+///    08h: Equal (unordered, non-signaling) \n
+///    09h: Not-greater-than-or-equal (unordered, signaling) \n
+///    0Ah: Not-greater-than (unordered, signaling) \n
+///    0Bh: False (ordered, non-signaling) \n
+///    0Ch: Not-equal (ordered, non-signaling) \n
+///    0Dh: Greater-than-or-equal (ordered, signaling) \n
+///    0Eh: Greater-than (ordered, signaling) \n
+///    0Fh: True (unordered, non-signaling) \n
+///    10h: Equal (ordered, signaling) \n
+///    11h: Less-than (ordered, non-signaling) \n
+///    12h: Less-than-or-equal (ordered, non-signaling) \n
+///    13h: Unordered (signaling) \n
+///    14h: Not-equal (unordered, signaling) \n
+///    15h: Not-less-than (unordered, non-signaling) \n
+///    16h: Not-less-than-or-equal (unordered, non-signaling) \n
+///    17h: Ordered (signaling) \n
+///    18h: Equal (unordered, signaling) \n
+///    19h: Not-greater-than-or-equal (unordered, non-signaling) \n
+///    1Ah: Not-greater-than (unordered, non-signaling) \n
+///    1Bh: False (ordered, signaling) \n
+///    1Ch: Not-equal (ordered, signaling) \n
+///    1Dh: Greater-than-or-equal (ordered, non-signaling) \n
+///    1Eh: Greater-than (ordered, non-signaling) \n
+///    1Fh: True (unordered, signaling)
 /// \returns A 128-bit vector of [2 x double] containing the comparison results.
 #define _mm_cmp_sd(a, b, c) __extension__ ({ \
   (__m128d)__builtin_ia32_cmpsd((__v2df)(__m128d)(a), \
                                 (__v2df)(__m128d)(b), (c)); })
 
 /// \brief Compares each of the corresponding scalar values of two 128-bit
 ///    vectors of [4 x float], using the operation specified by the immediate
 ///    integer operand.

 ///
 /// \param a
 ///    A 128-bit vector of [4 x float].
 /// \param b
 ///    A 128-bit vector of [4 x float].
 /// \param c
 ///    An immediate integer operand, with bits [4:0] specifying which comparison
 ///    operation to use: \n
-///    0x00 : Equal (ordered, non-signaling)
-///    0x01 : Less-than (ordered, signaling)
-///    0x02 : Less-than-or-equal (ordered, signaling)
-///    0x03 : Unordered (non-signaling)
-///    0x04 : Not-equal (unordered, non-signaling)
-///    0x05 : Not-less-than (unordered, signaling)
-///    0x06 : Not-less-than-or-equal (unordered, signaling)
-///    0x07 : Ordered (non-signaling)
-///    0x08 : Equal (unordered, non-signaling)
-///    0x09 : Not-greater-than-or-equal (unordered, signaling)
-///    0x0a : Not-greater-than (unordered, signaling)
-///    0x0b : False (ordered, non-signaling)
-///    0x0c : Not-equal (ordered, non-signaling)
-///    0x0d : Greater-than-or-equal (ordered, signaling)
-///    0x0e : Greater-than (ordered, signaling)
-///    0x0f : True (unordered, non-signaling)
-///    0x10 : Equal (ordered, signaling)
-///    0x11 : Less-than (ordered, non-signaling)
-///    0x12 : Less-than-or-equal (ordered, non-signaling)
-///    0x13 : Unordered (signaling)
-///    0x14 : Not-equal (unordered, signaling)
-///    0x15 : Not-less-than (unordered, non-signaling)
-///    0x16 : Not-less-than-or-equal (unordered, non-signaling)
-///    0x17 : Ordered (signaling)
-///    0x18 : Equal (unordered, signaling)
-///    0x19 : Not-greater-than-or-equal (unordered, non-signaling)
-///    0x1a : Not-greater-than (unordered, non-signaling)
-///    0x1b : False (ordered, signaling)
-///    0x1c : Not-equal (ordered, signaling)
-///    0x1d : Greater-than-or-equal (ordered, non-signaling)
-///    0x1e : Greater-than (ordered, non-signaling)
-///    0x1f : True (unordered, signaling)
+///    00h: Equal (ordered, non-signaling) \n
+///    01h: Less-than (ordered, signaling) \n
+///    02h: Less-than-or-equal (ordered, signaling) \n
+///    03h: Unordered (non-signaling) \n
+///    04h: Not-equal (unordered, non-signaling) \n
+///    05h: Not-less-than (unordered, signaling) \n
+///    06h: Not-less-than-or-equal (unordered, signaling) \n
+///    07h: Ordered (non-signaling) \n
+///    08h: Equal (unordered, non-signaling) \n
+///    09h: Not-greater-than-or-equal (unordered, signaling) \n
+///    0Ah: Not-greater-than (unordered, signaling) \n
+///    0Bh: False (ordered, non-signaling) \n
+///    0Ch: Not-equal (ordered, non-signaling) \n
+///    0Dh: Greater-than-or-equal (ordered, signaling) \n
+///    0Eh: Greater-than (ordered, signaling) \n
+///    0Fh: True (unordered, non-signaling) \n
+///    10h: Equal (ordered, signaling) \n
+///    11h: Less-than (ordered, non-signaling) \n
+///    12h: Less-than-or-equal (ordered, non-signaling) \n
+///    13h: Unordered (signaling) \n
+///    14h: Not-equal (unordered, signaling) \n
+///    15h: Not-less-than (unordered, non-signaling) \n
+///    16h: Not-less-than-or-equal (unordered, non-signaling) \n
+///    17h: Ordered (signaling) \n
+///    18h: Equal (unordered, signaling) \n
+///    19h: Not-greater-than-or-equal (unordered, non-signaling) \n
+///    1Ah: Not-greater-than (unordered, non-signaling) \n
+///    1Bh: False (ordered, signaling) \n
+///    1Ch: Not-equal (ordered, signaling) \n
+///    1Dh: Greater-than-or-equal (ordered, non-signaling) \n
+///    1Eh: Greater-than (ordered, non-signaling) \n
+///    1Fh: True (unordered, signaling)
 /// \returns A 128-bit vector of [4 x float] containing the comparison results.
 #define _mm_cmp_ss(a, b, c) __extension__ ({ \
   (__m128)__builtin_ia32_cmpss((__v4sf)(__m128)(a), \
                                (__v4sf)(__m128)(b), (c)); })
 
 /// \brief Takes a [8 x i32] vector and returns the vector element value
 ///    indexed by the immediate constant operand.
 ///

 /// \returns A 32 bit float containing the first element of the input vector.
 static __inline float __DEFAULT_FN_ATTRS
 _mm256_cvtss_f32(__m256 __a)
 {
  return __a[0];
 }
 
 /* Vector replicate */
-/// \brief Moves and duplicates high-order (odd-indexed) values from a 256-bit
+/// \brief Moves and duplicates odd-indexed values from a 256-bit
 ///    vector of [8 x float] to float values in a 256-bit vector of
 ///    [8 x float].
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the <c> VMOVSHDUP </c> instruction.
 ///
 /// \param __a

 /// \returns A 256-bit vector of [8 x float] containing the moved and duplicated
 ///    values.
 static __inline __m256 __DEFAULT_FN_ATTRS
 _mm256_movehdup_ps(__m256 __a)
 {
   return __builtin_shufflevector((__v8sf)__a, (__v8sf)__a, 1, 1, 3, 3, 5, 5, 7, 7);
 }
 
-/// \brief Moves and duplicates low-order (even-indexed) values from a 256-bit
-///    vector of [8 x float] to float values in a 256-bit vector of [8 x float].
+/// \brief Moves and duplicates even-indexed values from a 256-bit vector of
+///    [8 x float] to float values in a 256-bit vector of [8 x float].
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the <c> VMOVSLDUP </c> instruction.
 ///
 /// \param __a
 ///    A 256-bit vector of [8 x float]. \n
 ///    Bits [223:192] of \a __a are written to bits [255:224] and [223:192] of

 ///    floating point values with sign bits to be extracted.
 /// \returns The sign bits from the operand, written to bits [3:0].
 static __inline int __DEFAULT_FN_ATTRS
 _mm256_movemask_pd(__m256d __a)
 {
   return __builtin_ia32_movmskpd256((__v4df)__a);
 }
 
-/// \brief Extracts the sign bits of double-precision floating point elements
+/// \brief Extracts the sign bits of single-precision floating point elements
 ///    in a 256-bit vector of [8 x float] and writes them to the lower order
 ///    bits of the return value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the <c> VMOVMSKPS </c> instruction.
 ///
 /// \param __a
-///    A 256-bit vector of [8 x float] containing the double-precision floating
+///    A 256-bit vector of [8 x float] containing the single-precision floating
 ///    point values with sign bits to be extracted.
 /// \returns The sign bits from the operand, written to bits [7:0].
 static __inline int __DEFAULT_FN_ATTRS
 _mm256_movemask_ps(__m256 __a)
 {
   return __builtin_ia32_movmskps256((__v8sf)__a);
 }