llvm/libcxx
1
0
Fork 0
mirror of https://github.com/llvm-mirror/libcxx.git synced 2025-10-22 07:51:39 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fix FP comparisons when SSE isn't available

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@349387 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Eric Fiselier
2018-12-17 20:17:43 +00:00
parent 4b8645f0dc
commit dfa283e2cf
5 changed files with 66 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
test/std/depr/depr.c.headers/math_h.pass.cpp
View File

@@ -14,6 +14,7 @@
#include <cassert> #include <cassert>
#include "hexfloat.h" #include "hexfloat.h"
#include "truncate_fp.h"
// convertible to int/float/double/etc // convertible to int/float/double/etc
template <class T, int N=0> template <class T, int N=0>
@@ -807,23 +808,31 @@ void test_atanh()
assert(atanh(0) == 0); assert(atanh(0) == 0);
} }
void test_cbrt() void test_cbrt() {
{ static_assert((std::is_same<decltype(cbrt((float) 0)), float>::value), "");
static_assert((std::is_same<decltype(cbrt((float)0)), float>::value), ""); static_assert((std::is_same<decltype(cbrt((bool) 0)), double>::value), "");
static_assert((std::is_same<decltype(cbrt((bool)0)), double>::value), ""); static_assert((std::is_same<decltype(cbrt((unsigned short) 0)),
static_assert((std::is_same<decltype(cbrt((unsigned short)0)), double>::value), ""); double>::value), "");
static_assert((std::is_same<decltype(cbrt((int)0)), double>::value), ""); static_assert((std::is_same<decltype(cbrt((int) 0)), double>::value), "");
static_assert((std::is_same<decltype(cbrt((unsigned int)0)), double>::value), ""); static_assert((std::is_same<decltype(cbrt((unsigned int) 0)),
static_assert((std::is_same<decltype(cbrt((long)0)), double>::value), ""); double>::value), "");
static_assert((std::is_same<decltype(cbrt((unsigned long)0)), double>::value), ""); static_assert((std::is_same<decltype(cbrt((long) 0)), double>::value), "");
static_assert((std::is_same<decltype(cbrt((long long)0)), double>::value), ""); static_assert((std::is_same<decltype(cbrt((unsigned long) 0)),
static_assert((std::is_same<decltype(cbrt((unsigned long long)0)), double>::value), ""); double>::value), "");
static_assert((std::is_same<decltype(cbrt((double)0)), double>::value), ""); static_assert((std::is_same<decltype(cbrt((long long) 0)), double>::value),
static_assert((std::is_same<decltype(cbrt((long double)0)), long double>::value), ""); "");
static_assert((std::is_same<decltype(cbrt((unsigned long long) 0)),
double>::value), "");
static_assert((std::is_same<decltype(cbrt((double) 0)), double>::value),
"");
static_assert((std::is_same<decltype(cbrt((long double) 0)),
long double>::value), "");
static_assert((std::is_same<decltype(cbrtf(0)), float>::value), ""); static_assert((std::is_same<decltype(cbrtf(0)), float>::value), "");
static_assert((std::is_same<decltype(cbrtl(0)), long double>::value), ""); static_assert((std::is_same<decltype(cbrtl(0)), long double>::value), "");
static_assert((std::is_same<decltype(cbrt(Ambiguous())), Ambiguous>::value), ""); static_assert((std::is_same<decltype(cbrt(Ambiguous())), Ambiguous>::value),
assert(cbrt(1) == 1); "");
assert(truncate_fp(cbrt(1)) == 1);
} }
void test_copysign() void test_copysign()

3
test/std/numerics/c.math/cmath.pass.cpp
View File

@@ -16,6 +16,7 @@
#include "test_macros.h" #include "test_macros.h"
#include "hexfloat.h" #include "hexfloat.h"
#include "truncate_fp.h"
// convertible to int/float/double/etc // convertible to int/float/double/etc
template <class T, int N=0> template <class T, int N=0>
@@ -860,7 +861,7 @@ void test_cbrt()
static_assert((std::is_same<decltype(std::cbrtf(0)), float>::value), ""); static_assert((std::is_same<decltype(std::cbrtf(0)), float>::value), "");
static_assert((std::is_same<decltype(std::cbrtl(0)), long double>::value), ""); static_assert((std::is_same<decltype(std::cbrtl(0)), long double>::value), "");
static_assert((std::is_same<decltype(cbrt(Ambiguous())), Ambiguous>::value), ""); static_assert((std::is_same<decltype(cbrt(Ambiguous())), Ambiguous>::value), "");
assert(std::cbrt(1) == 1); assert(truncate_fp(std::cbrt(1)) == 1);
} }
void test_copysign() void test_copysign()

28
test/std/numerics/rand/rand.util/rand.util.canonical/generate_canonical.pass.cpp
View File

@@ -15,6 +15,8 @@
#include <random> #include <random>
#include <cassert> #include <cassert>
#include "truncate_fp.h"
int main() int main()
{ {
{ {
@@ -22,35 +24,35 @@ int main()
typedef float F; typedef float F;
E r; E r;
F f = std::generate_canonical<F, 0>(r); F f = std::generate_canonical<F, 0>(r);
assert(f == (16807 - E::min()) / (E::max() - E::min() + F(1))); assert(f == truncate_fp((16807 - E::min()) / (E::max() - E::min() + F(1))));
} }
{ {
typedef std::minstd_rand0 E; typedef std::minstd_rand0 E;
typedef float F; typedef float F;
E r; E r;
F f = std::generate_canonical<F, 1>(r); F f = std::generate_canonical<F, 1>(r);
assert(f == (16807 - E::min()) / (E::max() - E::min() + F(1))); assert(f == truncate_fp((16807 - E::min()) / (E::max() - E::min() + F(1))));
} }
{ {
typedef std::minstd_rand0 E; typedef std::minstd_rand0 E;
typedef float F; typedef float F;
E r; E r;
F f = std::generate_canonical<F, std::numeric_limits<F>::digits - 1>(r); F f = std::generate_canonical<F, std::numeric_limits<F>::digits - 1>(r);
assert(f == (16807 - E::min()) / (E::max() - E::min() + F(1))); assert(f == truncate_fp((16807 - E::min()) / (E::max() - E::min() + F(1))));
} }
{ {
typedef std::minstd_rand0 E; typedef std::minstd_rand0 E;
typedef float F; typedef float F;
E r; E r;
F f = std::generate_canonical<F, std::numeric_limits<F>::digits>(r); F f = std::generate_canonical<F, std::numeric_limits<F>::digits>(r);
assert(f == (16807 - E::min()) / (E::max() - E::min() + F(1))); assert(f == truncate_fp((16807 - E::min()) / (E::max() - E::min() + F(1))));
} }
{ {
typedef std::minstd_rand0 E; typedef std::minstd_rand0 E;
typedef float F; typedef float F;
E r; E r;
F f = std::generate_canonical<F, std::numeric_limits<F>::digits + 1>(r); F f = std::generate_canonical<F, std::numeric_limits<F>::digits + 1>(r);
assert(f == (16807 - E::min()) / (E::max() - E::min() + F(1))); assert(f == truncate_fp((16807 - E::min()) / (E::max() - E::min() + F(1))));
} }
{ {
@@ -58,43 +60,43 @@ int main()
typedef double F; typedef double F;
E r; E r;
F f = std::generate_canonical<F, 0>(r); F f = std::generate_canonical<F, 0>(r);
assert(f == (16807 - E::min()) / (E::max() - E::min() + F(1))); assert(f == truncate_fp((16807 - E::min()) / (E::max() - E::min() + F(1))));
} }
{ {
typedef std::minstd_rand0 E; typedef std::minstd_rand0 E;
typedef double F; typedef double F;
E r; E r;
F f = std::generate_canonical<F, 1>(r); F f = std::generate_canonical<F, 1>(r);
assert(f == (16807 - E::min()) / (E::max() - E::min() + F(1))); assert(f == truncate_fp((16807 - E::min()) / (E::max() - E::min() + F(1))));
} }
{ {
typedef std::minstd_rand0 E; typedef std::minstd_rand0 E;
typedef double F; typedef double F;
E r; E r;
F f = std::generate_canonical<F, std::numeric_limits<F>::digits - 1>(r); F f = std::generate_canonical<F, std::numeric_limits<F>::digits - 1>(r);
assert(f == assert(f == truncate_fp(
(16807 - E::min() + (16807 - E::min() +
(282475249 - E::min()) * (E::max() - E::min() + F(1))) / (282475249 - E::min()) * (E::max() - E::min() + F(1))) /
((E::max() - E::min() + F(1)) * (E::max() - E::min() + F(1)))); ((E::max() - E::min() + F(1)) * (E::max() - E::min() + F(1)))));
} }
{ {
typedef std::minstd_rand0 E; typedef std::minstd_rand0 E;
typedef double F; typedef double F;
E r; E r;
F f = std::generate_canonical<F, std::numeric_limits<F>::digits>(r); F f = std::generate_canonical<F, std::numeric_limits<F>::digits>(r);
assert(f == assert(f == truncate_fp(
(16807 - E::min() + (16807 - E::min() +
(282475249 - E::min()) * (E::max() - E::min() + F(1))) / (282475249 - E::min()) * (E::max() - E::min() + F(1))) /
((E::max() - E::min() + F(1)) * (E::max() - E::min() + F(1)))); ((E::max() - E::min() + F(1)) * (E::max() - E::min() + F(1)))));
} }
{ {
typedef std::minstd_rand0 E; typedef std::minstd_rand0 E;
typedef double F; typedef double F;
E r; E r;
F f = std::generate_canonical<F, std::numeric_limits<F>::digits + 1>(r); F f = std::generate_canonical<F, std::numeric_limits<F>::digits + 1>(r);
assert(f == assert(f == truncate_fp(
(16807 - E::min() + (16807 - E::min() +
(282475249 - E::min()) * (E::max() - E::min() + F(1))) / (282475249 - E::min()) * (E::max() - E::min() + F(1))) /
((E::max() - E::min() + F(1)) * (E::max() - E::min() + F(1)))); ((E::max() - E::min() + F(1)) * (E::max() - E::min() + F(1)))));
} }
} }

3
test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_duration.pass.cpp
View File

@@ -20,6 +20,7 @@
#include <cassert> #include <cassert>
#include "test_macros.h" #include "test_macros.h"
#include "truncate_fp.h"
int main() int main()
{ {
@@ -41,7 +42,7 @@ int main()
{ {
std::chrono::duration<int, std::ratio<2, 3> > s1(30); std::chrono::duration<int, std::ratio<2, 3> > s1(30);
std::chrono::duration<double, std::ratio<3, 5> > s2(5); std::chrono::duration<double, std::ratio<3, 5> > s2(5);
assert(s1 / s2 == 20./3); assert(s1 / s2 == truncate_fp(20./3));
} }
#if TEST_STD_VER >= 11 #if TEST_STD_VER >= 11
{ {

23
test/support/truncate_fp.h Normal file
View File

@@ -0,0 +1,23 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
inline long double truncate_fp(long double val) {
volatile long double sink = val;
return sink;
}
inline double truncate_fp(double val) {
volatile double sink = val;
return sink;
}
inline float truncate_fp(float val) {
volatile float sink = val;
return sink;
}