caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[libc][math] Implement issignaling and iscanonical macro. (#111403)

Browse Source 
#109201
This commit is contained in:
Shourya Goel
2024-10-09 22:55:49 +05:30
committed by GitHub
parent 3a08551a03
commit 4e33afee5a
9 changed files with 76 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
libc/cmake/modules/LLVMLibCTestRules.cmake
View File

@@ -68,6 +68,10 @@ function(get_object_files_for_test result skipped_entrypoints_list)
endif()
get_target_property(object_file_raw ${dep} "OBJECT_FILE_RAW")
if(object_file_raw)
# TODO: Remove this once we stop suffixing the target with ".__internal__"
if(fq_target_name STREQUAL "libc.test.include.issignaling_c_test.__unit__" OR fq_target_name STREQUAL "libc.test.include.iscanonical_c_test.__unit__")
string(REPLACE ".__internal__" "" object_file_raw ${object_file_raw})
endif()
list(APPEND dep_obj ${object_file_raw})
endif()
elseif(${dep_type} STREQUAL ${ENTRYPOINT_OBJ_VENDOR_TARGET_TYPE})

17
libc/include/llvm-libc-macros/math-function-macros.h
View File

@@ -11,6 +11,19 @@
#include "math-macros.h"
#ifndef __cplusplus
#define issignaling(x) \
_Generic((x), \
float: issignalingf, \
double: issignaling, \
long double: issignalingl)(x)
#define iscanonical(x) \
_Generic((x), \
float: iscanonicalf, \
double: iscanonical, \
long double: iscanonicall)(x)
#endif
#define isfinite(x) __builtin_isfinite(x)
#define isinf(x) __builtin_isinf(x)
#define isnan(x) __builtin_isnan(x)
@@ -20,9 +33,5 @@
__builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, x)
#define isnormal(x) __builtin_isnormal(x)
#define issubnormal(x) (fpclassify(x) == FP_SUBNORMAL)
#if (defined(__clang__) && __clang_major__ >= 18) || \
(defined(__GNUC__) && __GNUC__ >= 13)
#define issignaling(x) __builtin_issignaling(x)
#endif
#endif // LLVM_LIBC_MACROS_MATH_FUNCTION_MACROS_H

51
libc/test/include/CMakeLists.txt
View File

@@ -81,36 +81,6 @@ add_libc_test(
libc.include.llvm-libc-macros.stdckdint_macros
)
add_libc_test(
issignaling_test
SUITE
libc_include_tests
SRCS
issignaling_test.cpp
DEPENDS
libc.include.llvm-libc-macros.math_function_macros
)
add_libc_test(
issignalingf_test
SUITE
libc_include_tests
SRCS
issignalingf_test.cpp
DEPENDS
libc.include.llvm-libc-macros.math_function_macros
)
add_libc_test(
issignalingl_test
SUITE
libc_include_tests
SRCS
issignalingl_test.cpp
DEPENDS
libc.include.llvm-libc-macros.math_function_macros
)
add_libc_test(
issubnormal_test
SUITE
@@ -409,6 +379,27 @@ add_libc_test(
-Werror
DEPENDS
libc.include.llvm-libc-macros.math_function_macros
libc.src.math.issignaling
libc.src.math.issignalingf
libc.src.math.issignalingl
)
add_libc_test(
iscanonical_c_test
C_TEST
UNIT_TEST_ONLY
SUITE
libc_include_tests
SRCS
iscanonical_test.c
COMPILE_OPTIONS
-Wall
-Werror
DEPENDS
libc.include.llvm-libc-macros.math_function_macros
libc.src.math.iscanonical
libc.src.math.iscanonicalf
libc.src.math.iscanonicall
)
add_libc_test(

49
libc/test/include/IsSignalingTest.h
View File

@@ -1,49 +0,0 @@
//===-- Utility class to test the issignaling macro ------------*- 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
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LIBC_TEST_INCLUDE_MATH_ISSIGNALING_H
#define LLVM_LIBC_TEST_INCLUDE_MATH_ISSIGNALING_H
#include "test/UnitTest/FPMatcher.h"
#include "test/UnitTest/Test.h"
#include "include/llvm-libc-macros/math-function-macros.h"
template <typename T>
class IsSignalingTest : public LIBC_NAMESPACE::testing::Test {
DECLARE_SPECIAL_CONSTANTS(T)
public:
typedef int (*IsSignalingFunc)(T);
void testSpecialNumbers(IsSignalingFunc func) {
EXPECT_EQ(func(aNaN), 0);
EXPECT_EQ(func(neg_aNaN), 0);
EXPECT_EQ(func(sNaN), 1);
EXPECT_EQ(func(neg_sNaN), 1);
EXPECT_EQ(func(inf), 0);
EXPECT_EQ(func(neg_inf), 0);
EXPECT_EQ(func(min_normal), 0);
EXPECT_EQ(func(max_normal), 0);
EXPECT_EQ(func(neg_max_normal), 0);
EXPECT_EQ(func(min_denormal), 0);
EXPECT_EQ(func(neg_min_denormal), 0);
EXPECT_EQ(func(max_denormal), 0);
EXPECT_EQ(func(zero), 0);
EXPECT_EQ(func(neg_zero), 0);
}
};
#define LIST_ISSIGNALING_TESTS(T, func) \
using LlvmLibcIsSignalingTest = IsSignalingTest<T>; \
TEST_F(LlvmLibcIsSignalingTest, SpecialNumbers) { \
auto issignaling_func = [](T x) { return func(x); }; \
testSpecialNumbers(issignaling_func); \
}
#endif // LLVM_LIBC_TEST_INCLUDE_MATH_ISSIGNALING_H

29
libc/test/include/iscanonical_test.c Normal file
View File

@@ -0,0 +1,29 @@
//===-- Unittests for iscanonical macro -----------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDSList-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int iscanonical(double);
int iscanonicalf(float);
int iscanonicall(long double);
#include "include/llvm-libc-macros/math-function-macros.h"
#include <assert.h>
// check if macro is defined
#ifndef iscanonical
#error "iscanonical macro is not defined"
#else
int main(void) {
assert(iscanonical(__builtin_nans("")) == 0);
assert(iscanonical(__builtin_nansf("")) == 0);
assert(iscanonical(__builtin_nansl("")) == 0);
assert(iscanonical(1.819f) == 1);
assert(iscanonical(-1.726) == 1);
assert(iscanonical(1.426L) == 1);
return 0;
}
#endif

13
libc/test/include/issignaling_test.c
View File

@@ -5,20 +5,25 @@
// SPDSList-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
int issignaling(double);
int issignalingf(float);
int issignalingl(long double);
#include "include/llvm-libc-macros/math-function-macros.h"
#include <assert.h>
// TODO: enable the test unconditionally when issignaling macro is fixed for
// older compiler
// check if macro is defined
#ifndef issignaling
#error "issignaling macro is not defined"
#else
int main(void) {
#ifdef issignaling
assert(issignaling(__builtin_nans("")) == 1);
assert(issignaling(__builtin_nansf("")) == 1);
assert(issignaling(__builtin_nansl("")) == 1);
assert(issignaling(1.819f) == 0);
assert(issignaling(-1.726) == 0);
assert(issignaling(1.426L) == 0);
#endif
return 0;
}
#endif

18
libc/test/include/issignaling_test.cpp
View File

@@ -1,18 +0,0 @@
//===-- Unittest for issignaling[d] macro ---------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDSList-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "IsSignalingTest.h"
#include "include/llvm-libc-macros/math-function-macros.h"
// TODO: enable the test unconditionally when issignaling macro is fixed for
// older compiler
#ifdef issignaling
LIST_ISSIGNALING_TESTS(double, issignaling)
#else
TEST(LlvmLibcIsSignalingTest, Skip) {}
#endif

18
libc/test/include/issignalingf_test.cpp
View File

@@ -1,18 +0,0 @@
//===-- Unittest for issignaling[f] macro ---------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDSList-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "IsSignalingTest.h"
#include "include/llvm-libc-macros/math-function-macros.h"
// TODO: enable the test unconditionally when issignaling macro is fixed for
// older compiler
#ifdef issignaling
LIST_ISSIGNALING_TESTS(float, issignaling)
#else
TEST(LlvmLibcIsSignalingTest, Skip) {}
#endif

18
libc/test/include/issignalingl_test.cpp
View File

@@ -1,18 +0,0 @@
//===-- Unittest for issignaling[l] macro ---------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDSList-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "IsSignalingTest.h"
#include "include/llvm-libc-macros/math-function-macros.h"
// TODO: enable the test unconditionally when issignaling macro is fixed for
// older compiler
#ifdef issignaling
LIST_ISSIGNALING_TESTS(long double, issignaling)
#else
TEST(LlvmLibcIsSignalingTest, Skip) {}
#endif