Skip to content

[HLSL] Add additional overloads for min and max to allow for mixed scalar and vector arguments #129334

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 4 commits into from
Mar 3, 2025
Merged

[HLSL] Add additional overloads for min and max to allow for mixed scalar and vector arguments #129334

Show file tree
Hide file tree
Changes from 3 commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
ebaef38
new max overloads + new min overloads
spall Feb 28, 2025
4f121bf
tests
spall Feb 28, 2025
dabf384
use macro to make header file shorter
spall Mar 1, 2025
81dd7ee
forgot to call macro for max half case
spall Mar 3, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
61 changes: 61 additions & 0 deletions clang/lib/Headers/hlsl/hlsl_intrinsics.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -37,6 +37,26 @@ namespace hlsl {
#define _HLSL_16BIT_AVAILABILITY_STAGE(environment, version, stage)
#endif

#define GEN_VEC_SCALAR_OVERLOADS(FUNC_NAME, BASE_TYPE, AVAIL) \
GEN_BOTH_OVERLOADS(FUNC_NAME, BASE_TYPE, BASE_TYPE##2, AVAIL) \
GEN_BOTH_OVERLOADS(FUNC_NAME, BASE_TYPE, BASE_TYPE##3, AVAIL) \
GEN_BOTH_OVERLOADS(FUNC_NAME, BASE_TYPE, BASE_TYPE##4, AVAIL)

#define GEN_BOTH_OVERLOADS(FUNC_NAME, BASE_TYPE, VECTOR_TYPE, AVAIL) \
IF_TRUE_##AVAIL( \
_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)) constexpr VECTOR_TYPE \
FUNC_NAME(VECTOR_TYPE p0, BASE_TYPE p1) { \
return __builtin_elementwise_##FUNC_NAME(p0, (VECTOR_TYPE)p1); \
} \
IF_TRUE_##AVAIL( \
_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)) constexpr VECTOR_TYPE \
FUNC_NAME(BASE_TYPE p0, VECTOR_TYPE p1) { \
return __builtin_elementwise_##FUNC_NAME((VECTOR_TYPE)p0, p1); \
}

#define IF_TRUE_0(EXPR)
#define IF_TRUE_1(EXPR) EXPR

//===----------------------------------------------------------------------===//
// abs builtins
//===----------------------------------------------------------------------===//
Expand Down Expand Up @@ -1678,6 +1698,30 @@ half3 max(half3, half3);
_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
half4 max(half4, half4);
_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
constexpr half2 max(half2 p0, half p1) {
Copy link
Contributor

@bob80905 bob80905 Feb 28, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

If a user were to call the max function with, say, a half2 and a half3, is it our intention to reject that / emit an error?

Copy link
Contributor Author

@spall spall Feb 28, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Yes that is my understanding

Copy link
Contributor Author

@spall spall Feb 28, 2025 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

We only want to aditionally allow things of the form max(vector<T,N>, T) or max(T, vector<T,N>)

return __builtin_elementwise_max(p0, (half2)p1);
}
_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
constexpr half2 max(half p0, half2 p1) {
return __builtin_elementwise_max((half2)p0, p1);
}
_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
constexpr half3 max(half3 p0, half p1) {
return __builtin_elementwise_max(p0, (half3)p1);
}
_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
constexpr half3 max(half p0, half3 p1) {
return __builtin_elementwise_max((half3)p0, p1);
}
_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
constexpr half4 max(half4 p0, half p1) {
return __builtin_elementwise_max(p0, (half4)p1);
}
_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
constexpr half4 max(half p0, half4 p1) {
return __builtin_elementwise_max((half4)p0, p1);
}

#ifdef __HLSL_ENABLE_16_BIT
_HLSL_AVAILABILITY(shadermodel, 6.2)
Expand All @@ -1692,6 +1736,7 @@ int16_t3 max(int16_t3, int16_t3);
_HLSL_AVAILABILITY(shadermodel, 6.2)
_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
int16_t4 max(int16_t4, int16_t4);
GEN_VEC_SCALAR_OVERLOADS(max, int16_t, 1)

_HLSL_AVAILABILITY(shadermodel, 6.2)
_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
Expand All @@ -1705,6 +1750,7 @@ uint16_t3 max(uint16_t3, uint16_t3);
_HLSL_AVAILABILITY(shadermodel, 6.2)
_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
uint16_t4 max(uint16_t4, uint16_t4);
GEN_VEC_SCALAR_OVERLOADS(max, uint16_t, 1)
#endif

_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
Expand All @@ -1715,6 +1761,7 @@ _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
int3 max(int3, int3);
_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
int4 max(int4, int4);
GEN_VEC_SCALAR_OVERLOADS(max, int, 0)

_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
uint max(uint, uint);
Expand All @@ -1724,6 +1771,7 @@ _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
uint3 max(uint3, uint3);
_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
uint4 max(uint4, uint4);
GEN_VEC_SCALAR_OVERLOADS(max, uint, 0)

_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
int64_t max(int64_t, int64_t);
Expand All @@ -1733,6 +1781,7 @@ _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
int64_t3 max(int64_t3, int64_t3);
_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
int64_t4 max(int64_t4, int64_t4);
GEN_VEC_SCALAR_OVERLOADS(max, int64_t, 0)

_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
uint64_t max(uint64_t, uint64_t);
Expand All @@ -1742,6 +1791,7 @@ _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
uint64_t3 max(uint64_t3, uint64_t3);
_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
uint64_t4 max(uint64_t4, uint64_t4);
GEN_VEC_SCALAR_OVERLOADS(max, uint64_t, 0)

_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
float max(float, float);
Expand All @@ -1751,6 +1801,7 @@ _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
float3 max(float3, float3);
_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
float4 max(float4, float4);
GEN_VEC_SCALAR_OVERLOADS(max, float, 0)

_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
double max(double, double);
Expand All @@ -1760,6 +1811,7 @@ _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
double3 max(double3, double3);
_HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
double4 max(double4, double4);
GEN_VEC_SCALAR_OVERLOADS(max, double, 0)

//===----------------------------------------------------------------------===//
// min builtins
Expand All @@ -1782,6 +1834,7 @@ half3 min(half3, half3);
_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
half4 min(half4, half4);
GEN_VEC_SCALAR_OVERLOADS(min, half, 1)

#ifdef __HLSL_ENABLE_16_BIT
_HLSL_AVAILABILITY(shadermodel, 6.2)
Expand All @@ -1796,6 +1849,7 @@ int16_t3 min(int16_t3, int16_t3);
_HLSL_AVAILABILITY(shadermodel, 6.2)
_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
int16_t4 min(int16_t4, int16_t4);
GEN_VEC_SCALAR_OVERLOADS(min, int16_t, 1)

_HLSL_AVAILABILITY(shadermodel, 6.2)
_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
Expand All @@ -1809,6 +1863,7 @@ uint16_t3 min(uint16_t3, uint16_t3);
_HLSL_AVAILABILITY(shadermodel, 6.2)
_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
uint16_t4 min(uint16_t4, uint16_t4);
GEN_VEC_SCALAR_OVERLOADS(min, uint16_t, 1)
#endif

_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
Expand All @@ -1819,6 +1874,7 @@ _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
int3 min(int3, int3);
_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
int4 min(int4, int4);
GEN_VEC_SCALAR_OVERLOADS(min, int, 0)

_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
uint min(uint, uint);
Expand All @@ -1828,6 +1884,7 @@ _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
uint3 min(uint3, uint3);
_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
uint4 min(uint4, uint4);
GEN_VEC_SCALAR_OVERLOADS(min, uint, 0)

_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
float min(float, float);
Expand All @@ -1837,6 +1894,7 @@ _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
float3 min(float3, float3);
_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
float4 min(float4, float4);
GEN_VEC_SCALAR_OVERLOADS(min, float, 0)

_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
int64_t min(int64_t, int64_t);
Expand All @@ -1846,6 +1904,7 @@ _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
int64_t3 min(int64_t3, int64_t3);
_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
int64_t4 min(int64_t4, int64_t4);
GEN_VEC_SCALAR_OVERLOADS(min, int64_t, 0)

_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
uint64_t min(uint64_t, uint64_t);
Expand All @@ -1855,6 +1914,7 @@ _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
uint64_t3 min(uint64_t3, uint64_t3);
_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
uint64_t4 min(uint64_t4, uint64_t4);
GEN_VEC_SCALAR_OVERLOADS(min, uint64_t, 0)

_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
double min(double, double);
Expand All @@ -1864,6 +1924,7 @@ _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
double3 min(double3, double3);
_HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
double4 min(double4, double4);
GEN_VEC_SCALAR_OVERLOADS(min, double, 0)

//===----------------------------------------------------------------------===//
// normalize builtins
Expand Down
32 changes: 32 additions & 0 deletions clang/test/CodeGenHLSL/builtins/max.hlsl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,6 +18,9 @@ int16_t3 test_max_short3(int16_t3 p0, int16_t3 p1) { return max(p0, p1); }
// NATIVE_HALF-LABEL: define noundef <4 x i16> @_Z15test_max_short4
// NATIVE_HALF: call <4 x i16> @llvm.smax.v4i16
int16_t4 test_max_short4(int16_t4 p0, int16_t4 p1) { return max(p0, p1); }
// NATIVE_HALF-LABEL: define noundef <4 x i16> {{.*}}test_max_short4_mismatch
// NATIVE_HALF: call <4 x i16> @llvm.smax.v4i16
int16_t4 test_max_short4_mismatch(int16_t4 p0, int16_t p1) { return max(p0, p1); }

// NATIVE_HALF-LABEL: define noundef i16 @_Z15test_max_ushort
// NATIVE_HALF: call i16 @llvm.umax.i16(
Expand All @@ -31,6 +34,9 @@ uint16_t3 test_max_ushort3(uint16_t3 p0, uint16_t3 p1) { return max(p0, p1); }
// NATIVE_HALF-LABEL: define noundef <4 x i16> @_Z16test_max_ushort4
// NATIVE_HALF: call <4 x i16> @llvm.umax.v4i16
uint16_t4 test_max_ushort4(uint16_t4 p0, uint16_t4 p1) { return max(p0, p1); }
// NATIVE_HALF-LABEL: define noundef <4 x i16> {{.*}}test_max_ushort4_mismatch
// NATIVE_HALF: call <4 x i16> @llvm.umax.v4i16
uint16_t4 test_max_ushort4_mismatch(uint16_t4 p0, uint16_t p1) { return max(p0, p1); }
#endif

// CHECK-LABEL: define noundef i32 @_Z12test_max_int
Expand All @@ -45,6 +51,9 @@ int3 test_max_int3(int3 p0, int3 p1) { return max(p0, p1); }
// CHECK-LABEL: define noundef <4 x i32> @_Z13test_max_int4
// CHECK: call <4 x i32> @llvm.smax.v4i32
int4 test_max_int4(int4 p0, int4 p1) { return max(p0, p1); }
// CHECK-LABEL: define noundef <4 x i32> {{.*}}test_max_int4_mismatch
// CHECK: call <4 x i32> @llvm.smax.v4i32
int4 test_max_int4_mismatch(int4 p0, int p1) { return max(p0, p1); }

// CHECK-LABEL: define noundef i32 @_Z13test_max_uint
// CHECK: call i32 @llvm.umax.i32(
Expand All @@ -58,6 +67,9 @@ uint3 test_max_uint3(uint3 p0, uint3 p1) { return max(p0, p1); }
// CHECK-LABEL: define noundef <4 x i32> @_Z14test_max_uint4
// CHECK: call <4 x i32> @llvm.umax.v4i32
uint4 test_max_uint4(uint4 p0, uint4 p1) { return max(p0, p1); }
// CHECK-LABEL: define noundef <4 x i32> {{.*}}test_max_uint4_mismatch
// CHECK: call <4 x i32> @llvm.umax.v4i32
uint4 test_max_uint4_mismatch(uint4 p0, uint p1) { return max(p0, p1); }

// CHECK-LABEL: define noundef i64 @_Z13test_max_long
// CHECK: call i64 @llvm.smax.i64(
Expand All @@ -71,6 +83,9 @@ int64_t3 test_max_long3(int64_t3 p0, int64_t3 p1) { return max(p0, p1); }
// CHECK-LABEL: define noundef <4 x i64> @_Z14test_max_long4
// CHECK: call <4 x i64> @llvm.smax.v4i64
int64_t4 test_max_long4(int64_t4 p0, int64_t4 p1) { return max(p0, p1); }
// CHECK-LABEL: define noundef <4 x i64> {{.*}}test_max_long4_mismatch
// CHECK: call <4 x i64> @llvm.smax.v4i64
int64_t4 test_max_long4_mismatch(int64_t4 p0, int64_t p1) { return max(p0, p1); }

// CHECK-LABEL: define noundef i64 @_Z14test_max_ulong
// CHECK: call i64 @llvm.umax.i64(
Expand All @@ -84,6 +99,9 @@ uint64_t3 test_max_ulong3(uint64_t3 p0, uint64_t3 p1) { return max(p0, p1); }
// CHECK-LABEL: define noundef <4 x i64> @_Z15test_max_ulong4
// CHECK: call <4 x i64> @llvm.umax.v4i64
uint64_t4 test_max_ulong4(uint64_t4 p0, uint64_t4 p1) { return max(p0, p1); }
// CHECK-LABEL: define noundef <4 x i64> {{.*}}test_max_ulong4_mismatch
// CHECK: call <4 x i64> @llvm.umax.v4i64
uint64_t4 test_max_ulong4_mismatch(uint64_t4 p0, uint64_t p1) { return max(p0, p1); }

// NATIVE_HALF-LABEL: define noundef nofpclass(nan inf) half @_Z13test_max_half
// NATIVE_HALF: call reassoc nnan ninf nsz arcp afn half @llvm.maxnum.f16(
Expand All @@ -105,6 +123,11 @@ half3 test_max_half3(half3 p0, half3 p1) { return max(p0, p1); }
// NO_HALF-LABEL: define noundef nofpclass(nan inf) <4 x float> @_Z14test_max_half4
// NO_HALF: call reassoc nnan ninf nsz arcp afn <4 x float> @llvm.maxnum.v4f32(
half4 test_max_half4(half4 p0, half4 p1) { return max(p0, p1); }
// NATIVE_HALF-LABEL: define noundef nofpclass(nan inf) <4 x half> {{.*}}test_max_half4_mismatch
// NATIVE_HALF: call reassoc nnan ninf nsz arcp afn <4 x half> @llvm.maxnum.v4f16
// NO_HALF-LABEL: define noundef nofpclass(nan inf) <4 x float> {{.*}}test_max_half4_mismatch
// NO_HALF: call reassoc nnan ninf nsz arcp afn <4 x float> @llvm.maxnum.v4f32(
half4 test_max_half4_mismatch(half4 p0, half p1) { return max(p0, p1); }

// CHECK-LABEL: define noundef nofpclass(nan inf) float @_Z14test_max_float
// CHECK: call reassoc nnan ninf nsz arcp afn float @llvm.maxnum.f32(
Expand All @@ -118,6 +141,9 @@ float3 test_max_float3(float3 p0, float3 p1) { return max(p0, p1); }
// CHECK-LABEL: define noundef nofpclass(nan inf) <4 x float> @_Z15test_max_float4
// CHECK: call reassoc nnan ninf nsz arcp afn <4 x float> @llvm.maxnum.v4f32
float4 test_max_float4(float4 p0, float4 p1) { return max(p0, p1); }
// CHECK-LABEL: define noundef nofpclass(nan inf) <4 x float> {{.*}}test_max_float4_mismatch
// CHECK: call reassoc nnan ninf nsz arcp afn <4 x float> @llvm.maxnum.v4f32
float4 test_max_float4_mismatch(float4 p0, float p1) { return max(p0, p1); }

// CHECK-LABEL: define noundef nofpclass(nan inf) double @_Z15test_max_double
// CHECK: call reassoc nnan ninf nsz arcp afn double @llvm.maxnum.f64(
Expand All @@ -131,3 +157,9 @@ double3 test_max_double3(double3 p0, double3 p1) { return max(p0, p1); }
// CHECK-LABEL: define noundef nofpclass(nan inf) <4 x double> @_Z16test_max_double4
// CHECK: call reassoc nnan ninf nsz arcp afn <4 x double> @llvm.maxnum.v4f64
double4 test_max_double4(double4 p0, double4 p1) { return max(p0, p1); }
// CHECK-LABEL: define noundef nofpclass(nan inf) <4 x double> {{.*}}test_max_double4_mismatch
// CHECK: call reassoc nnan ninf nsz arcp afn <4 x double> @llvm.maxnum.v4f64
double4 test_max_double4_mismatch(double4 p0, double p1) { return max(p0, p1); }
// CHECK-LABEL: define noundef nofpclass(nan inf) <4 x double> {{.*}}test_max_double4_mismatch2
// CHECK: call reassoc nnan ninf nsz arcp afn <4 x double> @llvm.maxnum.v4f64
double4 test_max_double4_mismatch2(double4 p0, double p1) { return max(p1, p0); }
32 changes: 32 additions & 0 deletions clang/test/CodeGenHLSL/builtins/min.hlsl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,6 +18,9 @@ int16_t3 test_min_short3(int16_t3 p0, int16_t3 p1) { return min(p0, p1); }
// NATIVE_HALF-LABEL: define noundef <4 x i16> @_Z15test_min_short4
// NATIVE_HALF: call <4 x i16> @llvm.smin.v4i16
int16_t4 test_min_short4(int16_t4 p0, int16_t4 p1) { return min(p0, p1); }
// NATIVE_HALF-LABEL: define noundef <4 x i16> {{.*}}test_min_short4_mismatch
// NATIVE_HALF: call <4 x i16> @llvm.smin.v4i16
int16_t4 test_min_short4_mismatch(int16_t4 p0, int16_t p1) { return min(p0, p1); }

// NATIVE_HALF-LABEL: define noundef i16 @_Z15test_min_ushort
// NATIVE_HALF: call i16 @llvm.umin.i16(
Expand All @@ -31,6 +34,9 @@ uint16_t3 test_min_ushort3(uint16_t3 p0, uint16_t3 p1) { return min(p0, p1); }
// NATIVE_HALF-LABEL: define noundef <4 x i16> @_Z16test_min_ushort4
// NATIVE_HALF: call <4 x i16> @llvm.umin.v4i16
uint16_t4 test_min_ushort4(uint16_t4 p0, uint16_t4 p1) { return min(p0, p1); }
// NATIVE_HALF-LABEL: define noundef <4 x i16> {{.*}}test_min_ushort4_mismatch
// NATIVE_HALF: call <4 x i16> @llvm.umin.v4i16
uint16_t4 test_min_ushort4_mismatch(uint16_t4 p0, uint16_t p1) { return min(p0, p1); }
#endif

// CHECK-LABEL: define noundef i32 @_Z12test_min_int
Expand All @@ -45,6 +51,9 @@ int3 test_min_int3(int3 p0, int3 p1) { return min(p0, p1); }
// CHECK-LABEL: define noundef <4 x i32> @_Z13test_min_int4
// CHECK: call <4 x i32> @llvm.smin.v4i32
int4 test_min_int4(int4 p0, int4 p1) { return min(p0, p1); }
// CHECK-LABEL: define noundef <4 x i32> {{.*}}test_min_int4_mismatch
// CHECK: call <4 x i32> @llvm.smin.v4i32
int4 test_min_int4_mismatch(int4 p0, int p1) { return min(p0, p1); }

// CHECK-LABEL: define noundef i32 @_Z13test_min_uint
// CHECK: call i32 @llvm.umin.i32(
Expand All @@ -58,6 +67,9 @@ uint3 test_min_uint3(uint3 p0, uint3 p1) { return min(p0, p1); }
// CHECK-LABEL: define noundef <4 x i32> @_Z14test_min_uint4
// CHECK: call <4 x i32> @llvm.umin.v4i32
uint4 test_min_uint4(uint4 p0, uint4 p1) { return min(p0, p1); }
// CHECK-LABEL: define noundef <4 x i32> {{.*}}test_min_uint4_mismatch
// CHECK: call <4 x i32> @llvm.umin.v4i32
uint4 test_min_uint4_mismatch(uint4 p0, uint p1) { return min(p0, p1); }

// CHECK-LABEL: define noundef i64 @_Z13test_min_long
// CHECK: call i64 @llvm.smin.i64(
Expand All @@ -71,6 +83,9 @@ int64_t3 test_min_long3(int64_t3 p0, int64_t3 p1) { return min(p0, p1); }
// CHECK-LABEL: define noundef <4 x i64> @_Z14test_min_long4
// CHECK: call <4 x i64> @llvm.smin.v4i64
int64_t4 test_min_long4(int64_t4 p0, int64_t4 p1) { return min(p0, p1); }
// CHECK-LABEL: define noundef <4 x i64> {{.*}}test_min_long4_mismatch
// CHECK: call <4 x i64> @llvm.smin.v4i64
int64_t4 test_min_long4_mismatch(int64_t4 p0, int64_t p1) { return min(p0, p1); }

// CHECK-LABEL: define noundef i64 @_Z14test_min_ulong
// CHECK: call i64 @llvm.umin.i64(
Expand All @@ -84,6 +99,9 @@ uint64_t3 test_min_ulong3(uint64_t3 p0, uint64_t3 p1) { return min(p0, p1); }
// CHECK-LABEL: define noundef <4 x i64> @_Z15test_min_ulong4
// CHECK: call <4 x i64> @llvm.umin.v4i64
uint64_t4 test_min_ulong4(uint64_t4 p0, uint64_t4 p1) { return min(p0, p1); }
// CHECK-LABEL: define noundef <4 x i64> {{.*}}test_min_ulong4_mismatch
// CHECK: call <4 x i64> @llvm.umin.v4i64
uint64_t4 test_min_ulong4_mismatch(uint64_t4 p0, uint64_t p1) { return min(p0, p1); }

// NATIVE_HALF-LABEL: define noundef nofpclass(nan inf) half @_Z13test_min_half
// NATIVE_HALF: call reassoc nnan ninf nsz arcp afn half @llvm.minnum.f16(
Expand All @@ -105,6 +123,11 @@ half3 test_min_half3(half3 p0, half3 p1) { return min(p0, p1); }
// NO_HALF-LABEL: define noundef nofpclass(nan inf) <4 x float> @_Z14test_min_half4
// NO_HALF: call reassoc nnan ninf nsz arcp afn <4 x float> @llvm.minnum.v4f32(
half4 test_min_half4(half4 p0, half4 p1) { return min(p0, p1); }
// NATIVE_HALF-LABEL: define noundef nofpclass(nan inf) <4 x half> {{.*}}test_min_half4_mismatch
// NATIVE_HALF: call reassoc nnan ninf nsz arcp afn <4 x half> @llvm.minnum.v4f16
// NO_HALF-LABEL: define noundef nofpclass(nan inf) <4 x float> {{.*}}test_min_half4_mismatch
// NO_HALF: call reassoc nnan ninf nsz arcp afn <4 x float> @llvm.minnum.v4f32(
half4 test_min_half4_mismatch(half4 p0, half p1) { return min(p0, p1); }

// CHECK-LABEL: define noundef nofpclass(nan inf) float @_Z14test_min_float
// CHECK: call reassoc nnan ninf nsz arcp afn float @llvm.minnum.f32(
Expand All @@ -118,6 +141,9 @@ float3 test_min_float3(float3 p0, float3 p1) { return min(p0, p1); }
// CHECK-LABEL: define noundef nofpclass(nan inf) <4 x float> @_Z15test_min_float4
// CHECK: call reassoc nnan ninf nsz arcp afn <4 x float> @llvm.minnum.v4f32
float4 test_min_float4(float4 p0, float4 p1) { return min(p0, p1); }
// CHECK-LABEL: define noundef nofpclass(nan inf) <4 x float> {{.*}}test_min_float4_mismatch
// CHECK: call reassoc nnan ninf nsz arcp afn <4 x float> @llvm.minnum.v4f32
float4 test_min_float4_mismatch(float4 p0, float p1) { return min(p0, p1); }

// CHECK-LABEL: define noundef nofpclass(nan inf) double @_Z15test_min_double
// CHECK: call reassoc nnan ninf nsz arcp afn double @llvm.minnum.f64(
Expand All @@ -131,3 +157,9 @@ double3 test_min_double3(double3 p0, double3 p1) { return min(p0, p1); }
// CHECK-LABEL: define noundef nofpclass(nan inf) <4 x double> @_Z16test_min_double4
// CHECK: call reassoc nnan ninf nsz arcp afn <4 x double> @llvm.minnum.v4f64
double4 test_min_double4(double4 p0, double4 p1) { return min(p0, p1); }
// CHECK-LABEL: define noundef nofpclass(nan inf) <4 x double> {{.*}}test_min_double4_mismatch
// CHECK: call reassoc nnan ninf nsz arcp afn <4 x double> @llvm.minnum.v4f64
double4 test_min_double4_mismatch(double4 p0, double p1) { return min(p0, p1); }
// CHECK-LABEL: define noundef nofpclass(nan inf) <4 x double> {{.*}}test_min_double4_mismatch2
// CHECK: call reassoc nnan ninf nsz arcp afn <4 x double> @llvm.minnum.v4f64
double4 test_min_double4_mismatch2(double4 p0, double p1) { return min(p1, p0); }
Copy link
Contributor

@bob80905 bob80905 Feb 28, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Shouldn't this parameter swap test be applicable to all the rest of the tests? Why just double?

Copy link
Contributor Author

@spall spall Feb 28, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Yes, I just didn't want to add tons of tests; I also didn't add a test for each size of vector, only the vec4s. I can add more tests if you think its important.