[HLSL] Add new int overloads for math builtins #133162
Merged
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
llvmbot
added
clang
|
@llvm/pr-subscribers-hlsl @llvm/pr-subscribers-clang Author: Sarah Spall (spall) ChangesAdd int overloads which cast the various ints to a float and call the float builtin. Patch is 191.53 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/133162.diff 57 Files Affected:
diff --git a/clang/lib/Headers/hlsl/hlsl_compat_overloads.h b/clang/lib/Headers/hlsl/hlsl_compat_overloads.h
index d8dac0a3942ad..47ae34adfe541 100644
--- a/clang/lib/Headers/hlsl/hlsl_compat_overloads.h
+++ b/clang/lib/Headers/hlsl/hlsl_compat_overloads.h
@@ -50,35 +50,148 @@ namespace hlsl {
return fn((float4)V1, (float4)V2, (float4)V3); \
}
+#define _DXC_COMPAT_UNARY_INTEGER_OVERLOADS(fn) \
+ constexpr float fn(int V) { return fn((float)V); } \
+ constexpr float2 fn(int2 V) { return fn((float2)V); } \
+ constexpr float3 fn(int3 V) { return fn((float3)V); } \
+ constexpr float4 fn(int4 V) { return fn((float4)V); } \
+ constexpr float fn(uint V) { return fn((float)V); } \
+ constexpr float2 fn(uint2 V) { return fn((float2)V); } \
+ constexpr float3 fn(uint3 V) { return fn((float3)V); } \
+ constexpr float4 fn(uint4 V) { return fn((float4)V); } \
+ constexpr float fn(int64_t V) { return fn((float)V); } \
+ constexpr float2 fn(int64_t2 V) { return fn((float2)V); } \
+ constexpr float3 fn(int64_t3 V) { return fn((float3)V); } \
+ constexpr float4 fn(int64_t4 V) { return fn((float4)V); } \
+ constexpr float fn(uint64_t V) { return fn((float)V); } \
+ constexpr float2 fn(uint64_t2 V) { return fn((float2)V); } \
+ constexpr float3 fn(uint64_t3 V) { return fn((float3)V); } \
+ constexpr float4 fn(uint64_t4 V) { return fn((float4)V); }
+
+#define _DXC_COMPAT_BINARY_INTEGER_OVERLOADS(fn) \
+ constexpr float fn(int V1, int V2) { return fn((float)V1, (float)V2); } \
+ constexpr float2 fn(int2 V1, int2 V2) { return fn((float2)V1, (float2)V2); } \
+ constexpr float3 fn(int3 V1, int3 V2) { return fn((float3)V1, (float3)V2); } \
+ constexpr float4 fn(int4 V1, int4 V2) { return fn((float4)V1, (float4)V2); } \
+ constexpr float fn(uint V1, uint V2) { return fn((float)V1, (float)V2); } \
+ constexpr float2 fn(uint2 V1, uint2 V2) { \
+ return fn((float2)V1, (float2)V2); \
+ } \
+ constexpr float3 fn(uint3 V1, uint3 V2) { \
+ return fn((float3)V1, (float3)V2); \
+ } \
+ constexpr float4 fn(uint4 V1, uint4 V2) { \
+ return fn((float4)V1, (float4)V2); \
+ } \
+ constexpr float fn(int64_t V1, int64_t V2) { \
+ return fn((float)V1, (float)V2); \
+ } \
+ constexpr float2 fn(int64_t2 V1, int64_t2 V2) { \
+ return fn((float2)V1, (float2)V2); \
+ } \
+ constexpr float3 fn(int64_t3 V1, int64_t3 V2) { \
+ return fn((float3)V1, (float3)V2); \
+ } \
+ constexpr float4 fn(int64_t4 V1, int64_t4 V2) { \
+ return fn((float4)V1, (float4)V2); \
+ } \
+ constexpr float fn(uint64_t V1, uint64_t V2) { \
+ return fn((float)V1, (float)V2); \
+ } \
+ constexpr float2 fn(uint64_t2 V1, uint64_t2 V2) { \
+ return fn((float2)V1, (float2)V2); \
+ } \
+ constexpr float3 fn(uint64_t3 V1, uint64_t3 V2) { \
+ return fn((float3)V1, (float3)V2); \
+ } \
+ constexpr float4 fn(uint64_t4 V1, uint64_t4 V2) { \
+ return fn((float4)V1, (float4)V2); \
+ }
+
+#define _DXC_COMPAT_TERNARY_INTEGER_OVERLOADS(fn) \
+ constexpr float fn(int V1, int V2, int V3) { \
+ return fn((float)V1, (float)V2, (float)V3); \
+ } \
+ constexpr float2 fn(int2 V1, int2 V2, int2 V3) { \
+ return fn((float2)V1, (float2)V2, (float2)V3); \
+ } \
+ constexpr float3 fn(int3 V1, int3 V2, int3 V3) { \
+ return fn((float3)V1, (float3)V2, (float3)V3); \
+ } \
+ constexpr float4 fn(int4 V1, int4 V2, int4 V3) { \
+ return fn((float4)V1, (float4)V2, (float4)V3); \
+ } \
+ constexpr float fn(uint V1, uint V2, uint V3) { \
+ return fn((float)V1, (float)V2, (float)V3); \
+ } \
+ constexpr float2 fn(uint2 V1, uint2 V2, uint2 V3) { \
+ return fn((float2)V1, (float2)V2, (float2)V3); \
+ } \
+ constexpr float3 fn(uint3 V1, uint3 V2, uint3 V3) { \
+ return fn((float3)V1, (float3)V2, (float3)V3); \
+ } \
+ constexpr float4 fn(uint4 V1, uint4 V2, uint4 V3) { \
+ return fn((float4)V1, (float4)V2, (float4)V3); \
+ } \
+ constexpr float fn(int64_t V1, int64_t V2, int64_t V3) { \
+ return fn((float)V1, (float)V2, (float)V3); \
+ } \
+ constexpr float2 fn(int64_t2 V1, int64_t2 V2, int64_t2 V3) { \
+ return fn((float2)V1, (float2)V2, (float2)V3); \
+ } \
+ constexpr float3 fn(int64_t3 V1, int64_t3 V2, int64_t3 V3) { \
+ return fn((float3)V1, (float3)V2, (float3)V3); \
+ } \
+ constexpr float4 fn(int64_t4 V1, int64_t4 V2, int64_t4 V3) { \
+ return fn((float4)V1, (float4)V2, (float4)V3); \
+ } \
+ constexpr float fn(uint64_t V1, uint64_t V2, uint64_t V3) { \
+ return fn((float)V1, (float)V2, (float)V3); \
+ } \
+ constexpr float2 fn(uint64_t2 V1, uint64_t2 V2, uint64_t2 V3) { \
+ return fn((float2)V1, (float2)V2, (float2)V3); \
+ } \
+ constexpr float3 fn(uint64_t3 V1, uint64_t3 V2, uint64_t3 V3) { \
+ return fn((float3)V1, (float3)V2, (float3)V3); \
+ } \
+ constexpr float4 fn(uint64_t4 V1, uint64_t4 V2, uint64_t4 V3) { \
+ return fn((float4)V1, (float4)V2, (float4)V3); \
+ }
+
//===----------------------------------------------------------------------===//
// acos builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(acos)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(acos)
//===----------------------------------------------------------------------===//
// asin builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(asin)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(asin)
//===----------------------------------------------------------------------===//
// atan builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(atan)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(atan)
//===----------------------------------------------------------------------===//
// atan2 builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(atan2)
+_DXC_COMPAT_BINARY_INTEGER_OVERLOADS(atan2)
//===----------------------------------------------------------------------===//
// ceil builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(ceil)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(ceil)
//===----------------------------------------------------------------------===//
// clamp builtins overloads
@@ -107,42 +220,49 @@ clamp(vector<T, N> p0, T p1, T p2) {
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(cos)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(cos)
//===----------------------------------------------------------------------===//
// cosh builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(cosh)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(cosh)
//===----------------------------------------------------------------------===//
// degrees builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(degrees)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(degrees)
//===----------------------------------------------------------------------===//
// exp builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(exp)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(exp)
//===----------------------------------------------------------------------===//
// exp2 builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(exp2)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(exp2)
//===----------------------------------------------------------------------===//
// floor builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(floor)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(floor)
//===----------------------------------------------------------------------===//
// frac builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(frac)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(frac)
//===----------------------------------------------------------------------===//
// isinf builtins overloads
@@ -158,24 +278,28 @@ constexpr bool4 isinf(double4 V) { return isinf((float4)V); }
//===----------------------------------------------------------------------===//
_DXC_COMPAT_TERNARY_DOUBLE_OVERLOADS(lerp)
+_DXC_COMPAT_TERNARY_INTEGER_OVERLOADS(lerp)
//===----------------------------------------------------------------------===//
// log builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(log)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(log)
//===----------------------------------------------------------------------===//
// log10 builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(log10)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(log10)
//===----------------------------------------------------------------------===//
// log2 builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(log2)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(log2)
//===----------------------------------------------------------------------===//
// max builtins overloads
@@ -214,72 +338,84 @@ min(T p0, vector<T, N> p1) {
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(normalize)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(normalize)
//===----------------------------------------------------------------------===//
// pow builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(pow)
+_DXC_COMPAT_BINARY_INTEGER_OVERLOADS(pow)
//===----------------------------------------------------------------------===//
// rsqrt builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(rsqrt)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(rsqrt)
//===----------------------------------------------------------------------===//
// round builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(round)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(round)
//===----------------------------------------------------------------------===//
// sin builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(sin)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(sin)
//===----------------------------------------------------------------------===//
// sinh builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(sinh)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(sinh)
//===----------------------------------------------------------------------===//
// sqrt builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(sqrt)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(sqrt)
//===----------------------------------------------------------------------===//
// step builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_BINARY_DOUBLE_OVERLOADS(step)
+_DXC_COMPAT_BINARY_INTEGER_OVERLOADS(step)
//===----------------------------------------------------------------------===//
// tan builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(tan)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(tan)
//===----------------------------------------------------------------------===//
// tanh builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(tanh)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(tanh)
//===----------------------------------------------------------------------===//
// trunc builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(trunc)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(trunc)
//===----------------------------------------------------------------------===//
// radians builtins overloads
//===----------------------------------------------------------------------===//
_DXC_COMPAT_UNARY_DOUBLE_OVERLOADS(radians)
+_DXC_COMPAT_UNARY_INTEGER_OVERLOADS(radians)
} // namespace hlsl
#endif // _HLSL_COMPAT_OVERLOADS_H_
diff --git a/clang/test/CodeGenHLSL/builtins/acos-overloads.hlsl b/clang/test/CodeGenHLSL/builtins/acos-overloads.hlsl
new file mode 100644
index 0000000000000..e39ae43d205ee
--- /dev/null
+++ b/clang/test/CodeGenHLSL/builtins/acos-overloads.hlsl
@@ -0,0 +1,123 @@
+// RUN: %clang_cc1 -std=hlsl202x -finclude-default-header -x hlsl -triple \
+// RUN: spirv-unknown-vulkan-compute %s -emit-llvm -disable-llvm-passes \
+// RUN: -o - | FileCheck %s --check-prefixes=CHECK
+
+// CHECK-LABEL: test_acos_double
+// CHECK: call reassoc nnan ninf nsz arcp afn float @llvm.acos.f32
+float test_acos_double ( double p0 ) {
+ return acos ( p0 );
+}
+
+// CHECK-LABEL: test_acos_double2
+// CHECK: call reassoc nnan ninf nsz arcp afn <2 x float> @llvm.acos.v2f32
+float2 test_acos_double2 ( double2 p0 ) {
+ return acos ( p0 );
+}
+
+// CHECK-LABEL: test_acos_double3
+// CHECK: call reassoc nnan ninf nsz arcp afn <3 x float> @llvm.acos.v3f32
+float3 test_acos_double3 ( double3 p0 ) {
+ return acos ( p0 );
+}
+
+// CHECK-LABEL: test_acos_double4
+// CHECK: call reassoc nnan ninf nsz arcp afn <4 x float> @llvm.acos.v4f32
+float4 test_acos_double4 ( double4 p0 ) {
+ return acos ( p0 );
+}
+
+// CHECK-LABEL: test_acos_int
+// CHECK: call reassoc nnan ninf nsz arcp afn float @llvm.acos.f32
+float test_acos_int ( int p0 ) {
+ return acos ( p0 );
+}
+
+// CHECK-LABEL: test_acos_int2
+// CHECK: call reassoc nnan ninf nsz arcp afn <2 x float> @llvm.acos.v2f32
+float2 test_acos_int2 ( int2 p0 ) {
+ return acos ( p0 );
+}
+
+// CHECK-LABEL: test_acos_int3
+// CHECK: call reassoc nnan ninf nsz arcp afn <3 x float> @llvm.acos.v3f32
+float3 test_acos_int3 ( int3 p0 ) {
+ return acos ( p0 );
+}
+
+// CHECK-LABEL: test_acos_int4
+// CHECK: call reassoc nnan ninf nsz arcp afn <4 x float> @llvm.acos.v4f32
+float4 test_acos_int4 ( int4 p0 ) {
+ return acos ( p0 );
+}
+
+// CHECK-LABEL: test_acos_uint
+// CHECK: call reassoc nnan ninf nsz arcp afn float @llvm.acos.f32
+float test_acos_uint ( uint p0 ) {
+ return acos ( p0 );
+}
+
+// CHECK-LABEL: test_acos_uint2
+// CHECK: call reassoc nnan ninf nsz arcp afn <2 x float> @llvm.acos.v2f32
+float2 test_acos_uint2 ( uint2 p0 ) {
+ return acos ( p0 );
+}
+
+// CHECK-LABEL: test_acos_uint3
+// CHECK: call reassoc nnan ninf nsz arcp afn <3 x float> @llvm.acos.v3f32
+float3 test_acos_uint3 ( uint3 p0 ) {
+ return acos ( p0 );
+}
+
+// CHECK-LABEL: test_acos_uint4
+// CHECK: call reassoc nnan ninf nsz arcp afn <4 x float> @llvm.acos.v4f32
+float4 test_acos_uint4 ( uint4 p0 ) {
+ return acos ( p0 );
+}
+
+// CHECK-LABEL: test_acos_int64_t
+// CHECK: call reassoc nnan ninf nsz arcp afn float @llvm.acos.f32
+float test_acos_int64_t ( int64_t p0 ) {
+ return acos ( p0 );
+}
+
+// CHECK-LABEL: test_acos_int64_t2
+// CHECK: call reassoc nnan ninf nsz arcp afn <2 x float> @llvm.acos.v2f32
+float2 test_acos_int64_t2 ( int64_t2 p0 ) {
+ return acos ( p0 );
+}
+
+// CHECK-LABEL: test_acos_int64_t3
+// CHECK: call reassoc nnan ninf nsz arcp afn <3 x float> @llvm.acos.v3f32
+float3 test_acos_int64_t3 ( int64_t3 p0 ) {
+ return acos ( p0 );
+}
+
+// CHECK-LABEL: test_acos_int64_t4
+// CHECK: call reassoc nnan ninf nsz arcp afn <4 x float> @llvm.acos.v4f32
+float4 test_acos_int64_t4 ( int64_t4 p0 ) {
+ return acos ( p0 );
+}
+
+// CHECK-LABEL: test_acos_uint64_t
+// CHECK: call reassoc nnan ninf nsz arcp afn float @llvm.acos.f32
+float test_acos_uint64_t ( uint64_t p0 ) {
+ return acos ( p0 );
+}
+
+// CHECK-LABEL: test_acos_...
[truncated]
|
llvm-beanz
approved these changes
Mar 26, 2025
farzonl
approved these changes
Mar 27, 2025
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Add int overloads which cast the various ints to a float and call the float builtin.
These overloads are conditional on hlsl version 202x or earlier.
Add tests and puts tests in own files, including some of the tests added for double overloads.
Closes #128229