[X86][SSE] Enable constexpr on some basic SSE intrinsics (RFC)

[RKSimon]

Summary

This is an initial exploratory patch towards making some (basic initialization and arithmetic) SSE/AVX intrinsics usable in constant expressions.

I've only touched the SSE1 intrinsics that we can do so far - if people are happy with the approach I'll extend the patch to cover the equivalent SSE2->AVX512 intrinsics/types.

My main concern is how best to test these - all we're doing so far is checking that they will compile, which might be enough for now?

A later patch will have to address how to support builtin_shufflevector/builtin_convertvector and element accessors.

[RKSimon]

missing newline

[tschuett]

libcxx uses a function test and calls test() and static_assert(test()), see below
https://github.com/llvm/llvm-project/blob/d86a00d8febd0138a21f92d1420c4b62d7acb0ca/libcxx/test/std/utilities/memory/pointer.conversion/to_address.pass.cpp#L102-126

[RKSimon]

In D93597#2464870, @tschuett wrote:

libcxx uses a function test and calls test() and static_assert(test()), see below
https://github.com/llvm/llvm-project/blob/d86a00d8febd0138a21f92d1420c4b62d7acb0ca/libcxx/test/std/utilities/memory/pointer.conversion/to_address.pass.cpp#L102-126

@tschuett could you explain a little more about how you see this working for vectors? Are you suggesting we embed the vector ops into static_assert ? The problem we have is how to extract a result from a comparison. I did wonder about bitcasting to a struct of some thing, but __builtin_bit_cast doesn't work for vectors, and I'm not sure what would be best.

[tschuett]

constexpr bool test() {
float A = 1,0;
float B = 2,0;
float C = 3.0;
float D = 4,0;
__m128 AV;
__m128 BV;
__m128 result =  _mm_setr_ps(A, B, C, D);
result =  _mm_setzero_ps();
result = _mm_xor_ps(AV, BV);
return true;
}

int main() {
test();
static_assert(test());
return 0;
}

It should help you to test, whether you can call all functions in constant evaluation contexts and normal evaluations. I don't know whether you want to sprinkle some asserts into the test function.

[RKSimon]

I've added the static_assert constexpr methods - this requires C++14 so I've left the existing constexpr wrapper tests with C++11 coverage as well.

[RKSimon]

Does anyone have any feedback before I expand this to cover all the SSE2/AVX equivalents?

[pengfei]

clang/test/CodeGen/X86/sse-builtins.c

815

What are these tests testing for?

[RKSimon]

clang/test/CodeGen/X86/sse-builtins.c

815

These are the more basic c++11 tests to ensure that the intrinsics can be used in a constexpr - without c++14 we can't actually create a __m128 type, so everything is on-the-fly.

[tschuett]

But LLVM is C++14:
https://github.com/llvm/llvm-project/blob/main/llvm/docs/CodingStandards.rst#id13

[erichkeane]

In D93597#2477890, @tschuett wrote:

But LLVM is C++14:
https://github.com/llvm/llvm-project/blob/main/llvm/docs/CodingStandards.rst#id13

The compiler _IS_ compiled with C++14, but the tests are not necessarily compiled as such. The Clang compiler still supports compiling all the way down to C++98.

clang/lib/Headers/xmmintrin.h

 #if __STDC_HOSTED__
 #include <mm_malloc.h>
 #endif
 
 /* Define the default attributes for the functions in this file. */
 #define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("sse"), __min_vector_width__(128)))
 #define __DEFAULT_FN_ATTRS_MMX __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse"), __min_vector_width__(64)))
 
+#if defined(__cplusplus) && (__cplusplus >= 201103L)
+#define __DEFAULT_FN_ATTRS_CONSTEXPR __DEFAULT_FN_ATTRS constexpr
+#else
+#define __DEFAULT_FN_ATTRS_CONSTEXPR __DEFAULT_FN_ATTRS
+#endif
+
 /// Adds the 32-bit float values in the low-order bits of the operands.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the <c> VADDSS / ADDSS </c> instructions.
 ///
 /// \param __a
 ///    A 128-bit vector of [4 x float] containing one of the source operands.

 /// This intrinsic corresponds to the <c> VADDPS / ADDPS </c> instructions.
 ///
 /// \param __a
 ///    A 128-bit vector of [4 x float] containing one of the source operands.
 /// \param __b
 ///    A 128-bit vector of [4 x float] containing one of the source operands.
 /// \returns A 128-bit vector of [4 x float] containing the sums of both
 ///    operands.
-static __inline__ __m128 __DEFAULT_FN_ATTRS
+static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR
 _mm_add_ps(__m128 __a, __m128 __b)
 {
   return (__m128)((__v4sf)__a + (__v4sf)__b);
 }
 
 /// Subtracts the 32-bit float value in the low-order bits of the second
 ///    operand from the corresponding value in the first operand.
 ///
 /// \headerfile <x86intrin.h>

 /// This intrinsic corresponds to the <c> VSUBPS / SUBPS </c> instructions.
 ///
 /// \param __a
 ///    A 128-bit vector of [4 x float] containing the minuend.
 /// \param __b
 ///    A 128-bit vector of [4 x float] containing the subtrahend.
 /// \returns A 128-bit vector of [4 x float] containing the differences between
 ///    both operands.
-static __inline__ __m128 __DEFAULT_FN_ATTRS
+static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR
 _mm_sub_ps(__m128 __a, __m128 __b)
 {
   return (__m128)((__v4sf)__a - (__v4sf)__b);
 }
 
 /// Multiplies two 32-bit float values in the low-order bits of the
 ///    operands.
 ///
 /// \headerfile <x86intrin.h>

 /// This intrinsic corresponds to the <c> VMULPS / MULPS </c> instructions.
 ///
 /// \param __a
 ///    A 128-bit vector of [4 x float] containing one of the source operands.
 /// \param __b
 ///    A 128-bit vector of [4 x float] containing one of the source operands.
 /// \returns A 128-bit vector of [4 x float] containing the products of both
 ///    operands.
-static __inline__ __m128 __DEFAULT_FN_ATTRS
+static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR
 _mm_mul_ps(__m128 __a, __m128 __b)
 {
   return (__m128)((__v4sf)__a * (__v4sf)__b);
 }
 
 /// Divides the value in the low-order 32 bits of the first operand by
 ///    the corresponding value in the second operand.
 ///
 /// \headerfile <x86intrin.h>

 /// This intrinsic corresponds to the <c> VDIVPS / DIVPS </c> instructions.
 ///
 /// \param __a
 ///    A 128-bit vector of [4 x float] containing the dividend.
 /// \param __b
 ///    A 128-bit vector of [4 x float] containing the divisor.
 /// \returns A 128-bit vector of [4 x float] containing the quotients of both
 ///    operands.
-static __inline__ __m128 __DEFAULT_FN_ATTRS
+static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR
 _mm_div_ps(__m128 __a, __m128 __b)
 {
   return (__m128)((__v4sf)__a / (__v4sf)__b);
 }
 
 /// Calculates the square root of the value stored in the low-order bits
 ///    of a 128-bit vector of [4 x float].
 ///
 /// \headerfile <x86intrin.h>

 /// This intrinsic corresponds to the <c> VANDPS / ANDPS </c> instructions.
 ///
 /// \param __a
 ///    A 128-bit vector containing one of the source operands.
 /// \param __b
 ///    A 128-bit vector containing one of the source operands.
 /// \returns A 128-bit vector of [4 x float] containing the bitwise AND of the
 ///    values between both operands.
-static __inline__ __m128 __DEFAULT_FN_ATTRS
+static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR
 _mm_and_ps(__m128 __a, __m128 __b)
 {
   return (__m128)((__v4su)__a & (__v4su)__b);
 }
 
 /// Performs a bitwise AND of two 128-bit vectors of [4 x float], using
 ///    the one's complement of the values contained in the first source
 ///    operand.
 ///

 /// This intrinsic corresponds to the <c> VORPS / ORPS </c> instructions.
 ///
 /// \param __a
 ///    A 128-bit vector of [4 x float] containing one of the source operands.
 /// \param __b
 ///    A 128-bit vector of [4 x float] containing one of the source operands.
 /// \returns A 128-bit vector of [4 x float] containing the bitwise OR of the
 ///    values between both operands.
-static __inline__ __m128 __DEFAULT_FN_ATTRS
+static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR
 _mm_or_ps(__m128 __a, __m128 __b)
 {
   return (__m128)((__v4su)__a | (__v4su)__b);
 }
 
 /// Performs a bitwise exclusive OR of two 128-bit vectors of
 ///    [4 x float].
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the <c> VXORPS / XORPS </c> instructions.
 ///
 /// \param __a
 ///    A 128-bit vector of [4 x float] containing one of the source operands.
 /// \param __b
 ///    A 128-bit vector of [4 x float] containing one of the source operands.
 /// \returns A 128-bit vector of [4 x float] containing the bitwise exclusive OR
 ///    of the values between both operands.
-static __inline__ __m128 __DEFAULT_FN_ATTRS
+static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR
 _mm_xor_ps(__m128 __a, __m128 __b)
 {
   return (__m128)((__v4su)__a ^ (__v4su)__b);
 }
 
 /// Compares two 32-bit float values in the low-order bits of both
 ///    operands for equality and returns the result of the comparison in the
 ///    low-order bits of a vector [4 x float].
 ///

 /// This intrinsic corresponds to the <c> VMOVSS / MOVSS </c> instruction.
 ///
 /// \param __w
 ///    A single-precision floating-point value used to initialize the lower 32
 ///    bits of the result.
 /// \returns An initialized 128-bit floating-point vector of [4 x float]. The
 ///    lower 32 bits contain the value provided in the source operand. The
 ///    upper 96 bits are set to zero.
-static __inline__ __m128 __DEFAULT_FN_ATTRS
+static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR
 _mm_set_ss(float __w)
 {
   return __extension__ (__m128){ __w, 0, 0, 0 };
 }
 
 /// Constructs a 128-bit floating-point vector of [4 x float], with each
 ///    of the four single-precision floating-point vector elements set to the
 ///    specified single-precision floating-point value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the <c> VPERMILPS / PERMILPS </c> instruction.
 ///
 /// \param __w
 ///    A single-precision floating-point value used to initialize each vector
 ///    element of the result.
 /// \returns An initialized 128-bit floating-point vector of [4 x float].
-static __inline__ __m128 __DEFAULT_FN_ATTRS
+static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR
 _mm_set1_ps(float __w)
 {
   return __extension__ (__m128){ __w, __w, __w, __w };
 }
 
 /* Microsoft specific. */
 /// Constructs a 128-bit floating-point vector of [4 x float], with each
 ///    of the four single-precision floating-point vector elements set to the
 ///    specified single-precision floating-point value.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the <c> VPERMILPS / PERMILPS </c> instruction.
 ///
 /// \param __w
 ///    A single-precision floating-point value used to initialize each vector
 ///    element of the result.
 /// \returns An initialized 128-bit floating-point vector of [4 x float].
-static __inline__ __m128 __DEFAULT_FN_ATTRS
+static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR
 _mm_set_ps1(float __w)
 {
     return _mm_set1_ps(__w);
 }
 
 /// Constructs a 128-bit floating-point vector of [4 x float]
 ///    initialized with the specified single-precision floating-point values.
 ///

 ///    of the result.
 /// \param __x
 ///    A single-precision floating-point value used to initialize bits [63:32]
 ///    of the result.
 /// \param __w
 ///    A single-precision floating-point value used to initialize bits [31:0]
 ///    of the result.
 /// \returns An initialized 128-bit floating-point vector of [4 x float].
-static __inline__ __m128 __DEFAULT_FN_ATTRS
+static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR
 _mm_set_ps(float __z, float __y, float __x, float __w)
 {
   return __extension__ (__m128){ __w, __x, __y, __z };
 }
 
 /// Constructs a 128-bit floating-point vector of [4 x float],
 ///    initialized in reverse order with the specified 32-bit single-precision
 ///    float-point values.

 ///    of the result.
 /// \param __x
 ///    A single-precision floating-point value used to initialize bits [95:64]
 ///    of the result.
 /// \param __w
 ///    A single-precision floating-point value used to initialize bits [127:96]
 ///    of the result.
 /// \returns An initialized 128-bit floating-point vector of [4 x float].
-static __inline__ __m128 __DEFAULT_FN_ATTRS
+static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR
 _mm_setr_ps(float __z, float __y, float __x, float __w)
 {
   return __extension__ (__m128){ __z, __y, __x, __w };
 }
 
 /// Constructs a 128-bit floating-point vector of [4 x float] initialized
 ///    to zero.
 ///
 /// \headerfile <x86intrin.h>
 ///
 /// This intrinsic corresponds to the <c> VXORPS / XORPS </c> instruction.
 ///
 /// \returns An initialized 128-bit floating-point vector of [4 x float] with
 ///    all elements set to zero.
-static __inline__ __m128 __DEFAULT_FN_ATTRS
+static __inline__ __m128 __DEFAULT_FN_ATTRS_CONSTEXPR
 _mm_setzero_ps(void)
 {
   return __extension__ (__m128){ 0, 0, 0, 0 };
 }
 
 /// Stores the upper 64 bits of a 128-bit vector of [4 x float] to a
 ///    memory location.
 ///

 #define _m_pavgb _mm_avg_pu8
 #define _m_pavgw _mm_avg_pu16
 #define _m_psadbw _mm_sad_pu8
 #define _m_ _mm_
 #define _m_ _mm_
 
 #undef __DEFAULT_FN_ATTRS
 #undef __DEFAULT_FN_ATTRS_MMX
+#undef __DEFAULT_FN_ATTRS_CONSTEXPR
 
 /* Ugly hack for backwards-compatibility (compatible with gcc) */
 #if defined(__SSE2__) && !__building_module(_Builtin_intrinsics)
 #include <emmintrin.h>
 #endif
 
 #endif /* __XMMINTRIN_H */

clang/test/CodeGen/X86/sse-builtins.c

-// RUN: %clang_cc1 -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse -emit-llvm -o - -Wall -Werror | FileCheck %s
-// RUN: %clang_cc1 -flax-vector-conversions=none -fms-extensions -fms-compatibility -ffreestanding %s -triple=x86_64-windows-msvc -target-feature +sse -emit-llvm -o - -Wall -Werror | FileCheck %s
-
+// RUN: %clang_cc1 -x c -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse -emit-llvm -o - -Wall -Werror | FileCheck %s
+// RUN: %clang_cc1 -x c -flax-vector-conversions=none -fms-extensions -fms-compatibility -ffreestanding %s -triple=x86_64-windows-msvc -target-feature +sse -emit-llvm -o - -Wall -Werror | FileCheck %s
+// RUN: %clang_cc1 -x c++ -std=c++11 -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse -emit-llvm -o - -Wall -Werror | FileCheck %s
+// RUN: %clang_cc1 -x c++ -std=c++11 -flax-vector-conversions=none -fms-extensions -fms-compatibility -ffreestanding %s -triple=x86_64-windows-msvc -target-feature +sse -emit-llvm -o - -Wall -Werror | FileCheck %s
+// RUN: %clang_cc1 -x c++ -std=c++14 -flax-vector-conversions=none -ffreestanding %s -triple=x86_64-apple-darwin -target-feature +sse -emit-llvm -o - -Wall -Werror | FileCheck %s
+// RUN: %clang_cc1 -x c++ -std=c++14 -flax-vector-conversions=none -fms-extensions -fms-compatibility -ffreestanding %s -triple=x86_64-windows-msvc -target-feature +sse -emit-llvm -o - -Wall -Werror | FileCheck %s
 
 #include <immintrin.h>
 
 // NOTE: This should match the tests in llvm/test/CodeGen/X86/sse-intrinsics-fast-isel.ll
 
 __m128 test_mm_add_ps(__m128 A, __m128 B) {
   // CHECK-LABEL: test_mm_add_ps
   // CHECK: fadd <4 x float>
__m128 test_mm_unpacklo_ps(__m128 A, __m128 B) {
   return _mm_unpacklo_ps(A, B);
 }
 
 __m128 test_mm_xor_ps(__m128 A, __m128 B) {
   // CHECK-LABEL: test_mm_xor_ps
   // CHECK: xor <4 x i32>
   return _mm_xor_ps(A, B);
 }
+
+// Test constexpr handling.
+#if defined(__cplusplus) && (__cplusplus >= 201103L)
+constexpr __m128 test_constexpr_mm_add_ps(__m128 A, __m128 B) {
+  return _mm_add_ps(A, B);
+}
+
+constexpr __m128 test_constexpr_mm_and_ps(__m128 A, __m128 B) {
+  return _mm_and_ps(A, B);
+}
+
+constexpr __m128 test_constexpr_mm_div_ps(__m128 A, __m128 B) {
+  return _mm_div_ps(A, B);
+}
+
+constexpr __m128 test_constexpr_mm_mul_ps(__m128 A, __m128 B) {
+  return _mm_mul_ps(A, B);
+}
+
+constexpr __m128 test_constexpr_mm_or_ps(__m128 A, __m128 B) {
+  return _mm_or_ps(A, B);
+}
+
+constexpr __m128 test_constexpr_mm_set_ss(float A) {
+  return _mm_set_ss(A);
+}
+
+constexpr __m128 test_constexpr_mm_set1_ps(float A) {
+  return _mm_set1_ps(A);
+}
+
+constexpr __m128 test_constexpr_mm_set_ps1(float A) {
+  return _mm_set_ps1(A);
+}
+
+constexpr __m128 test_constexpr_mm_set_ps(float A, float B, float C, float D) {
+  return _mm_set_ps(A, B, C, D);
+}
+
+constexpr __m128 test_constexpr_mm_setr_ps(float A, float B, float C, float D) {
+  return _mm_setr_ps(A, B, C, D);
+}
+
+constexpr __m128 test_constexpr_mm_setzero_ps() {
+  return _mm_setzero_ps();
+}
+
+constexpr __m128 test_constexpr_mm_xor_ps(__m128 A, __m128 B) {
+  return _mm_xor_ps(A, B);
+}
+#endif
+
+// Test constexpr method handling.
+#if defined(__cplusplus) && (__cplusplus >= 201402L)
+constexpr bool test() {
+  __m128 result =  _mm_setzero_ps();
+  result = _mm_add_ps(result, _mm_set_ss(1.0f));
+  result = _mm_div_ps(result, _mm_set1_ps(2.0f));
+  result = _mm_mul_ps(result, _mm_set_ps1(3.0f));
+  result = _mm_sub_ps(result, _mm_set_ps(4.0f, 5.0f, 6.0f, 7.0f));
+  result = _mm_and_ps(result, _mm_setr_ps(-1.0f, -2.0f, -3.0f, -4.0f));
+  result = _mm_or_ps(result, _mm_setr_ps(0.0f, 1.0f, 2.0f, 3.0f));
+  result = _mm_xor_ps(result, _mm_setr_ps(10.0f, 11.0f, 12.0f, 13.0f));
+  return true;
+}
+
+int main() {
+  test();
+  static_assert(test(), "SSE constexpr failure");
+  return 0;
+}
+#endif