ahmed/OpenCL-CTS
1
0
Fork 0
mirror of https://github.com/KhronosGroup/OpenCL-CTS.git synced 2026-03-19 06:09:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix several compile issues with Visual Studio toolchains (#2219)

Browse Source 
Fixes several compile issues I am seeing for my version of Visual Studio
related to an ambiguous call to `fpclassify`, which is called by `isnan`
and other similar functions, specifically for the `cl_half` type:

```
19>C:\Program Files (x86)\Windows Kits\10\Include\10.0.19041.0\ucrt\corecrt_math.h(401,1): error C2668: 'fpclassify': ambiguous call to overloaded function
19>C:\Program Files (x86)\Windows Kits\10\Include\10.0.19041.0\ucrt\corecrt_math.h(298,31): message : could be 'int fpclassify(long double) throw()'
19>C:\Program Files (x86)\Windows Kits\10\Include\10.0.19041.0\ucrt\corecrt_math.h(293,31): message : or       'int fpclassify(double) throw()'
19>C:\Program Files (x86)\Windows Kits\10\Include\10.0.19041.0\ucrt\corecrt_math.h(288,31): message : or       'int fpclassify(float) throw()'
19>C:\Program Files (x86)\Windows Kits\10\Include\10.0.19041.0\ucrt\corecrt_math.h(401,1): message : while trying to match the argument list '(_Ty)'
```

Some of these issues seem like differences in compiler behavior, but at
least one appears to have identified a legitimate bug.

Specifically, this change:

* Removes the special-case checks for finite half numbers for commonfns,
since this is already handled by `UlpFn`. (test with: `test_commonfns
degrees radians`)
* Assigns to temporary variables to eliminate the ambiguous function
call for relationals. (test with: `test_relationals relational*`)
* Properly converts from half to float when checking for NaNs for
select. This is the one that seems like a legitimate bug. (test with:
`test_select select_half_ushort select_half_short`)
* Uses `std::enable_if` to disambiguate a function call for spirv_new.
(test with: `test_spirv_new decorate_saturated*`)

If it's helpful, my specific Visual Studio version is:

```
Microsoft Visual Studio Professional 2019
Version 16.11.20
VisualStudio.16.Release/16.11.20+32929.386
```

I also have the Windows Software Development Kit 10.0.19041.685
installed.
This commit is contained in:
Ben Ashbaugh
2025-02-18 09:09:17 -08:00
committed by GitHub
parent 9f63decb9c
commit 9b247c06be
5 changed files with 43 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
test_conformance/spirv_new/test_decorate.cpp
View File

@@ -21,6 +21,7 @@
#include <algorithm>
#include <limits>
#include <cmath>
#include <type_traits>
#include <CL/cl_half.h>
@@ -216,29 +217,37 @@ static inline Ti generate_saturated_rhs_input(RandomSeed &seed)
}
template <typename Ti, typename Tl, typename To>
static inline To compute_saturated_output(Ti lhs, Ti rhs,
cl_half_rounding_mode half_rounding)
static inline
typename std::enable_if<std::is_same<Ti, cl_half>::value, To>::type
compute_saturated_output(Ti lhs, Ti rhs,
cl_half_rounding_mode half_rounding)
{
constexpr auto loVal = std::numeric_limits<To>::min();
constexpr auto hiVal = std::numeric_limits<To>::max();
if (std::is_same<Ti, cl_half>::value)
cl_float f = cl_half_to_float(lhs) * cl_half_to_float(rhs);
// Quantize to fp16:
f = cl_half_to_float(cl_half_from_float(f, half_rounding));
To val = static_cast<To>(std::min<float>(std::max<float>(f, loVal), hiVal));
if (isnan(cl_half_to_float(rhs)))
{
cl_float f = cl_half_to_float(lhs) * cl_half_to_float(rhs);
// Quantize to fp16:
f = cl_half_to_float(cl_half_from_float(f, half_rounding));
To val = (To)std::min<float>(std::max<float>(f, loVal), hiVal);
if (isnan(cl_half_to_float(rhs)))
{
val = 0;
}
return val;
val = 0;
}
return val;
}
Tl ival = (Tl)(lhs * rhs);
To val = (To)std::min<Ti>(std::max<Ti>(ival, loVal), hiVal);
template <typename Ti, typename Tl, typename To>
static inline
typename std::enable_if<!std::is_same<Ti, cl_half>::value, To>::type
compute_saturated_output(Ti lhs, Ti rhs, cl_half_rounding_mode)
{
constexpr auto loVal = std::numeric_limits<To>::min();
constexpr auto hiVal = std::numeric_limits<To>::max();
Tl ival = static_cast<Tl>(lhs * rhs);
To val = static_cast<To>(std::min<Tl>(std::max<Tl>(ival, loVal), hiVal));
if (isnan(rhs))
{