[test-suite] Add tests for FP classification intrinsics

[RKSimon]

Something I noticed is that we don't have much test coverage in clang/test/codegen for the fpclass intrinsics - including no constexpr testing afaict (although I don't think __builtin_fpclassify is constexpr yet) - is that something you'd be willing to take a look at?

SingleSource/UnitTests/Float/classify.cpp

89

are asserts the best way to do this? most other unit tests print out something to help isolate diffs

[sepavloff]

Updated patch

• Moved tests into header files. It should facilitate writing tests for various modes (strict exceptions, fast math etc),
• Added Makefile,
• Enhanced diagnostics if test fails,
• Avoid C++, it makes easier to run test on simulator if there are fewer dependencies.

[sepavloff]

In D106804#2956881, @RKSimon wrote:

Something I noticed is that we don't have much test coverage in clang/test/codegen for the fpclass intrinsics - including no constexpr testing afaict (although I don't think __builtin_fpclassify is constexpr yet) - is that something you'd be willing to take a look at?

They present and are in clang/test/Sema/constant-builtins-2.c. This is C file but the constant evaluator is the same for C++. The tested functions are fpclassify, isinf, isnan, isfinite and isnormal. And yes, fpclassify is constexpr.

[RKSimon]

I've no objections to this - it seems to be orthogonal to the isnan ir intrinsic conversation.

Do we have test-suite buildbot coverage on anything other than x86? Cross platform uses of long double is always fun........

Any other comments?

[sepavloff]

In D106804#2991411, @RKSimon wrote:

Do we have test-suite buildbot coverage on anything other than x86? Cross platform uses of long double is always fun........

The following build bots have a stage named test-suite:

clang-ppc64be-linux-lnt
clang-ppc64le-linux-lnt
clang-s390x-linux-lnt
clang-armv7-lnt
clang-native-arm-lnt-perf
clang-aarch64-full-2stage
clang-armv7-vfpv3-full-2stage
clang-thumbv7-full-2stage
clang-cmake-x86_64-avx2-linux-perf
clang-cmake-x86_64-avx2-linux

So it looks like major targets are represented in testing.

[sepavloff]

If nobody objects, I would commit this change, as it would be useful in the forthcoming return of llvm.isnan.

[RKSimon]

LGTM

[sepavloff]

Thanks!

SingleSource/UnitTests/CMakeLists.txt

 include(CheckCCompilerFlag)
 
 add_subdirectory(C++11)
+add_subdirectory(Float)
 add_subdirectory(SignlessTypes)
 add_subdirectory(Threads)
 add_subdirectory(Vector)
 add_subdirectory(Vectorizer)
 # FIXME: Disable SJLJ tests for now, until EH edges are represented.
 # add_subdirectory(SetjmpLongjmp)
 if(TARGET_OS STREQUAL "Darwin")
   add_subdirectory(ObjC)

SingleSource/UnitTests/Float/CMakeLists.txt

+llvm_singlesource()

SingleSource/UnitTests/Float/classify.cpp

+//===--- classify.cpp - Tess for FP classification intrinsics ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This is a general test for floating point classification intrinsic.
+//
+//===----------------------------------------------------------------------===//
+
+#undef NDEBUG
+#include <assert.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits>
+
+#define DimOf(x) (sizeof(x) / sizeof(x[0]))
+
+#define F32_SIGN 0x80000000U
+#define F32_EXP_MASK 0x7F800000U
+#define F32_MANTISSA_MASK 0x007FFFFFU
+#define F32_QNAN_BIT 0x00400000U
+#define F32_PAYLOAD_MASK F32_MANTISSA_MASK
+
+#define F64_SIGN 0x8000000000000000ULL
+#define F64_EXP_MASK 0x7FF0000000000000ULL
+#define F64_MANTISSA_MASK 0x000FFFFFFFFFFFFFULL
+#define F64_QNAN_BIT 0x0008000000000000ULL
+#define F64_PAYLOAD_MASK F64_MANTISSA_MASK
+
+
+uint32_t FloatNaNValues[] = {
+  F32_SIGN | F32_EXP_MASK | F32_QNAN_BIT | F32_PAYLOAD_MASK,
+             F32_EXP_MASK | F32_QNAN_BIT | F32_PAYLOAD_MASK,
+  F32_SIGN | F32_EXP_MASK |                F32_PAYLOAD_MASK,
+             F32_EXP_MASK |                F32_PAYLOAD_MASK,
+  F32_SIGN | F32_EXP_MASK | F32_QNAN_BIT,
+             F32_EXP_MASK | F32_QNAN_BIT,
+  F32_SIGN | F32_EXP_MASK | F32_QNAN_BIT | 0x00200000U,
+             F32_EXP_MASK | F32_QNAN_BIT | 0x00100000U,
+  F32_SIGN | F32_EXP_MASK |                0x00200000U,
+             F32_EXP_MASK |                0x00100000U,
+  F32_SIGN | F32_EXP_MASK | F32_QNAN_BIT | 0x00000001U,
+             F32_EXP_MASK | F32_QNAN_BIT | 0x00000002U,
+  F32_SIGN | F32_EXP_MASK |                0x00000001U,
+             F32_EXP_MASK |                0x00000002U,
+};
+
+uint32_t FloatInfValues[] = {
+  F32_SIGN | F32_EXP_MASK,   // -Inf
+             F32_EXP_MASK    // +Inf
+};
+
+uint32_t FloatZeroValues[] = {
+  F32_SIGN,                  // -0.0
+  0                          // +0.0
+};
+
+uint32_t FloatDenormValues[] = {
+  F32_SIGN | 0x00000001U,    // smallest negative denornal number
+             0x00000001U,    // smallest positive denornal number
+  F32_SIGN | 0x007FFFFFU,    // largest negative denormal number
+             0x007FFFFFU,    // largest positive normal number
+};
+
+uint32_t FloatNormalValues[] = {
+    F32_SIGN | 0x00800000U,  // smallest negative normal number
+               0x00800000U,  // smallest positive normal number
+    F32_SIGN | 0x7F7FFFFFU,  // largest negative normal number
+               0x7F7FFFFFU,  // largest positive normal number
+    F32_SIGN | 0x3F7FFFFFU,  // smallest number larger than -1
+    F32_SIGN | 0x3F800000U,  // -1
+    F32_SIGN | 0x3F800001U,  // largest number less than -1
+               0x3F7FFFFFU,  // largest number less than 1
+               0x3F800000U,  // +1
+               0x3F800001U,  // smallest number larger than 1
+};
+
+int test_float() {
+  for (unsigned i = 0; i < DimOf(FloatNaNValues); i++) {
+    float *FPtr = (float *)&FloatNaNValues[i];
+    assert(__builtin_isnan(*FPtr));
+    assert(!__builtin_isinf(*FPtr));
+    assert(!__builtin_isfinite(*FPtr));
+    assert(!__builtin_isnormal(*FPtr));
+    assert(__builtin_fpclassify(0, 1, 2, 3, 4, *FPtr) == 0);
+  }
+  for (unsigned i = 0; i < DimOf(FloatInfValues); i++) {
+    float *FPtr = (float *)&FloatInfValues[i];
+    assert(!__builtin_isnan(*FPtr));
+    assert(__builtin_isinf(*FPtr));
+    assert(!__builtin_isfinite(*FPtr));
+    assert(!__builtin_isnormal(*FPtr));
+    assert(__builtin_fpclassify(0, 1, 2, 3, 4, *FPtr) == 1);
+  }
+  for (unsigned i = 0; i < DimOf(FloatZeroValues); i++) {
+    float *FPtr = (float *)&FloatZeroValues[i];
+    assert(!__builtin_isnan(*FPtr));
+    assert(!__builtin_isinf(*FPtr));
+    assert(__builtin_isfinite(*FPtr));
+    assert(!__builtin_isnormal(*FPtr));
+    assert(__builtin_fpclassify(0, 1, 2, 3, 4, *FPtr) == 4);
+  }
+  for (unsigned i = 0; i < DimOf(FloatDenormValues); i++) {
+    float *FPtr = (float *)&FloatDenormValues[i];
+    assert(!__builtin_isnan(*FPtr));
+    assert(!__builtin_isinf(*FPtr));
+    assert(__builtin_isfinite(*FPtr));
+    assert(!__builtin_isnormal(*FPtr));
+    assert(__builtin_fpclassify(0, 1, 2, 3, 4, *FPtr) == 3);
+  }
+  for (unsigned i = 0; i < DimOf(FloatNormalValues); i++) {
+    float *FPtr = (float *)&FloatNormalValues[i];
+    assert(!__builtin_isnan(*FPtr));
+    assert(!__builtin_isinf(*FPtr));
+    assert(__builtin_isfinite(*FPtr));
+    assert(__builtin_isnormal(*FPtr));
+    assert(__builtin_fpclassify(0, 1, 2, 3, 4, *FPtr) == 2);
+  }
+  return 0;
+}
+
+
+uint64_t DoubleNaNValues[] = {
+  F64_SIGN | F64_EXP_MASK | F64_QNAN_BIT | F64_PAYLOAD_MASK,
+             F64_EXP_MASK | F64_QNAN_BIT | F64_PAYLOAD_MASK,
+  F64_SIGN | F64_EXP_MASK |                F64_PAYLOAD_MASK,
+             F64_EXP_MASK |                F64_PAYLOAD_MASK,
+  F64_SIGN | F64_EXP_MASK | F64_QNAN_BIT,
+             F64_EXP_MASK | F64_QNAN_BIT,
+  F64_SIGN | F64_EXP_MASK | F64_QNAN_BIT | 0x0004000000000000ULL,
+             F64_EXP_MASK | F64_QNAN_BIT | 0x0002000000000000ULL,
+  F64_SIGN | F64_EXP_MASK |                0x0004000000000000ULL,
+             F64_EXP_MASK |                0x0002000000000000ULL,
+  F64_SIGN | F64_EXP_MASK | F64_QNAN_BIT | 0x00000000000000001ULL,
+             F64_EXP_MASK | F64_QNAN_BIT | 0x00000000000000002ULL,
+  F64_SIGN | F64_EXP_MASK |                0x00000000000000001ULL,
+             F64_EXP_MASK |                0x00000000000000002ULL,
+};
+
+uint64_t DoubleInfValues[] = {
+  F64_SIGN | F64_EXP_MASK,   // -Inf
+             F64_EXP_MASK    // +Inf
+};
+
+uint64_t DoubleZeroValues[] = {
+  F64_SIGN,                  // -0.0
+  0                          // +0.0
+};
+
+uint64_t DoubleDenormValues[] = {
+  F64_SIGN | 0x0000000000000001ULL,   // smallest negative denornal number
+             0x0000000000000001ULL,   // smallest positive denornal number
+  F64_SIGN | 0x000FFFFFFFFFFFFFULL,   // largest negative denormal number
+             0x000FFFFFFFFFFFFFULL,   // largest positive normal number
+};
+
+uint64_t DoubleNormalValues[] = {
+  F64_SIGN | 0x0010000000000000ULL,   // smallest negative normal number
+             0x0010000000000000ULL,   // smallest positive normal number
+  F64_SIGN | 0x7FEFFFFFFFFFFFFFULL,   // largest negative normal number
+             0x7FEFFFFFFFFFFFFFULL,   // largest positive normal number
+  F64_SIGN | 0x3FEFFFFFFFFFFFFFULL,   // smallest number larger than -1
+  F64_SIGN | 0x3FF0000000000000ULL,   // -1
+  F64_SIGN | 0x3FF0000000000001ULL,   // largest number less than -1
+             0x3FEFFFFFFFFFFFFFULL,   // largest number less than 1
+             0x3FF0000000000000ULL,   // +1
+             0x3FF0000000000001ULL,   // smallest number larger than 1
+};
+
+int test_double() {
+  for (unsigned i = 0; i < DimOf(DoubleNaNValues); i++) {
+    double *FPtr = (double *)&DoubleNaNValues[i];
+    assert(__builtin_isnan(*FPtr));
+    assert(!__builtin_isinf(*FPtr));
+    assert(!__builtin_isfinite(*FPtr));
+    assert(!__builtin_isnormal(*FPtr));
+    assert(__builtin_fpclassify(0, 1, 2, 3, 4, *FPtr) == 0);
+  }
+  for (unsigned i = 0; i < DimOf(DoubleInfValues); i++) {
+    double *FPtr = (double *)&DoubleInfValues[i];
+    assert(!__builtin_isnan(*FPtr));
+    assert(__builtin_isinf(*FPtr));
+    assert(!__builtin_isfinite(*FPtr));
+    assert(!__builtin_isnormal(*FPtr));
+    assert(__builtin_fpclassify(0, 1, 2, 3, 4, *FPtr) == 1);
+  }
+  for (unsigned i = 0; i < DimOf(DoubleZeroValues); i++) {
+    double *FPtr = (double *)&DoubleZeroValues[i];
+    assert(!__builtin_isnan(*FPtr));
+    assert(!__builtin_isinf(*FPtr));
+    assert(__builtin_isfinite(*FPtr));
+    assert(!__builtin_isnormal(*FPtr));
+    assert(__builtin_fpclassify(0, 1, 2, 3, 4, *FPtr) == 4);
+  }
+  for (unsigned i = 0; i < DimOf(DoubleDenormValues); i++) {
+    double *FPtr = (double *)&DoubleDenormValues[i];
+    assert(!__builtin_isnan(*FPtr));
+    assert(!__builtin_isinf(*FPtr));
+    assert(__builtin_isfinite(*FPtr));
+    assert(!__builtin_isnormal(*FPtr));
+    assert(__builtin_fpclassify(0, 1, 2, 3, 4, *FPtr) == 3);
+  }
+  for (unsigned i = 0; i < DimOf(DoubleNormalValues); i++) {
+    double *FPtr = (double *)&DoubleNormalValues[i];
+    assert(!__builtin_isnan(*FPtr));
+    assert(!__builtin_isinf(*FPtr));
+    assert(__builtin_isfinite(*FPtr));
+    assert(__builtin_isnormal(*FPtr));
+    assert(__builtin_fpclassify(0, 1, 2, 3, 4, *FPtr) == 2);
+  }
+  return 0;
+}
+
+
+long double LongDoubleNaNValues[] = {
+  __builtin_nanl(""),
+  -__builtin_nanl(""),
+  __builtin_nanl("0x01"),
+  -__builtin_nanl("0x01"),
+  __builtin_nansl(""),
+  -__builtin_nansl(""),
+  __builtin_nansl("0x01"),
+  -__builtin_nansl("0x01")
+};
+
+long double LongDoubleInfValues[] = {
+  __builtin_infl(),
+  -__builtin_infl()
+};
+
+long double LongDoubleZeroValues[] = {
+  0.0L,
+  -0.0L
+};
+
+long double LongDoubleDenormValues[] = {
+  std::numeric_limits<long double>::denorm_min(),
+  -std::numeric_limits<long double>::denorm_min(),
+};
+
+long double LongDoubleNormalValues[] = {
+  1.0L,
+  -1.0L,
+  std::numeric_limits<long double>::max(),
+  -std::numeric_limits<long double>::max(),
+  std::numeric_limits<long double>::min(),
+  -std::numeric_limits<long double>::min()
+};
+
+int test_ldouble() {
+  for (unsigned i = 0; i < DimOf(LongDoubleNaNValues); i++) {
+    long double *FPtr = &LongDoubleNaNValues[i];
+    assert(__builtin_isnan(*FPtr));
+    assert(!__builtin_isinf(*FPtr));
+    assert(!__builtin_isfinite(*FPtr));
+    assert(!__builtin_isnormal(*FPtr));
+    assert(__builtin_fpclassify(0, 1, 2, 3, 4, *FPtr) == 0);
+  }
+  for (unsigned i = 0; i < DimOf(LongDoubleInfValues); i++) {
+    long double *FPtr = &LongDoubleInfValues[i];
+    assert(!__builtin_isnan(*FPtr));
+    assert(__builtin_isinf(*FPtr));
+    assert(!__builtin_isfinite(*FPtr));
+    assert(!__builtin_isnormal(*FPtr));
+    assert(__builtin_fpclassify(0, 1, 2, 3, 4, *FPtr) == 1);
+  }
+  for (unsigned i = 0; i < DimOf(LongDoubleZeroValues); i++) {
+    long double *FPtr = &LongDoubleZeroValues[i];
+    assert(!__builtin_isnan(*FPtr));
+    assert(!__builtin_isinf(*FPtr));
+    assert(__builtin_isfinite(*FPtr));
+    assert(!__builtin_isnormal(*FPtr));
+    assert(__builtin_fpclassify(0, 1, 2, 3, 4, *FPtr) == 4);
+  }
+  for (unsigned i = 0; i < DimOf(LongDoubleDenormValues); i++) {
+    long double *FPtr = &LongDoubleDenormValues[i];
+    assert(!__builtin_isnan(*FPtr));
+    assert(!__builtin_isinf(*FPtr));
+    assert(__builtin_isfinite(*FPtr));
+    assert(!__builtin_isnormal(*FPtr));
+    assert(__builtin_fpclassify(0, 1, 2, 3, 4, *FPtr) == 3);
+  }
+  for (unsigned i = 0; i < DimOf(LongDoubleNormalValues); i++) {
+    long double *FPtr = &LongDoubleNormalValues[i];
+    assert(!__builtin_isnan(*FPtr));
+    assert(!__builtin_isinf(*FPtr));
+    assert(__builtin_isfinite(*FPtr));
+    assert(__builtin_isnormal(*FPtr));
+    assert(__builtin_fpclassify(0, 1, 2, 3, 4, *FPtr) == 2);
+  }
+  return 0;
+}
+
+
+int main()
+{
+  test_float();
+  test_double();
+  test_ldouble();
+  return 0;
+}
+

SingleSource/UnitTests/Float/classify.reference_output

+exit 0