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

spall · 2025-02-28T22:54:07Z

Add additional overloads for min and max to support
min(vector<T,N>, T) and min(T, vector<T,N>)
max(vector<T,N>, T) and max(T, vector<T,N>)
Add tests
Closes #128231

llvmbot · 2025-02-28T22:54:39Z

@llvm/pr-subscribers-hlsl
@llvm/pr-subscribers-clang

@llvm/pr-subscribers-backend-x86

Author: Sarah Spall (spall)

Changes

Add additional overloads for min and max to support
min(vector<T,N>, T) and min(T, vector<T,N>)
max(vector<T,N>, T) and max(T, vector<T,N>)
Add tests
Closes #128231

Patch is 29.15 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/129334.diff

3 Files Affected:

(modified) clang/lib/Headers/hlsl/hlsl_intrinsics.h (+360)
(modified) clang/test/CodeGenHLSL/builtins/max.hlsl (+32)
(modified) clang/test/CodeGenHLSL/builtins/min.hlsl (+32)

diff --git a/clang/lib/Headers/hlsl/hlsl_intrinsics.h b/clang/lib/Headers/hlsl/hlsl_intrinsics.h
index 239d7a3f59b77..68acdf1720318 100644
--- a/clang/lib/Headers/hlsl/hlsl_intrinsics.h
+++ b/clang/lib/Headers/hlsl/hlsl_intrinsics.h
@@ -1678,6 +1678,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) {
+  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)
@@ -1692,6 +1716,30 @@ 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);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr int16_t2 max(int16_t2 p0, int16_t p1) {
+  return __builtin_elementwise_max(p0, (int16_t2)p1);
+}
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr int16_t2 max(int16_t p0, int16_t2 p1) {
+  return __builtin_elementwise_max((int16_t2)p0, p1);
+}
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr int16_t3 max(int16_t3 p0, int16_t p1) {
+  return __builtin_elementwise_max(p0, (int16_t3)p1);
+}
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr int16_t3 max(int16_t p0, int16_t3 p1) {
+  return __builtin_elementwise_max((int16_t3)p0, p1);
+}
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr int16_t4 max(int16_t4 p0, int16_t p1) {
+  return __builtin_elementwise_max(p0, (int16_t4)p1);
+}
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr int16_t4 max(int16_t p0, int16_t4 p1) {
+  return __builtin_elementwise_max((int16_t4)p0, p1);
+}
 
 _HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
@@ -1705,6 +1753,30 @@ 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);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr uint16_t2 max(uint16_t2 p0, uint16_t p1) {
+  return __builtin_elementwise_max(p0, (uint16_t2)p1);
+}
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr uint16_t2 max(uint16_t p0, uint16_t2 p1) {
+  return __builtin_elementwise_max((uint16_t2)p0, p1);
+}
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr uint16_t3 max(uint16_t3 p0, uint16_t p1) {
+  return __builtin_elementwise_max(p0, (uint16_t3)p1);
+}
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr uint16_t3 max(uint16_t p0, uint16_t3 p1) {
+  return __builtin_elementwise_max((uint16_t3)p0, p1);
+}
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr uint16_t4 max(uint16_t4 p0, uint16_t p1) {
+  return __builtin_elementwise_max(p0, (uint16_t4)p1);
+}
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr uint16_t4 max(uint16_t p0, uint16_t4 p1) {
+  return __builtin_elementwise_max((uint16_t4)p0, p1);
+}
 #endif
 
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
@@ -1715,6 +1787,24 @@ _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
 int3 max(int3, int3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
 int4 max(int4, int4);
+constexpr int2 max(int2 p0, int p1) {
+  return __builtin_elementwise_max(p0, (int2)p1);
+}
+constexpr int2 max(int p0, int2 p1) {
+  return __builtin_elementwise_max((int2)p0, p1);
+}
+constexpr int3 max(int3 p0, int p1) {
+  return __builtin_elementwise_max(p0, (int3)p1);
+}
+constexpr int3 max(int p0, int3 p1) {
+  return __builtin_elementwise_max((int3)p0, p1);
+}
+constexpr int4 max(int4 p0, int p1) {
+  return __builtin_elementwise_max(p0, (int4)p1);
+}
+constexpr int4 max(int p0, int4 p1) {
+  return __builtin_elementwise_max((int4)p0, p1);
+}
 
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
 uint max(uint, uint);
@@ -1724,6 +1814,24 @@ _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
 uint3 max(uint3, uint3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
 uint4 max(uint4, uint4);
+constexpr uint2 max(uint2 p0, uint p1) {
+  return __builtin_elementwise_max(p0, (uint2)p1);
+}
+constexpr uint2 max(uint p0, uint2 p1) {
+  return __builtin_elementwise_max((uint2)p0, p1);
+}
+constexpr uint3 max(uint3 p0, uint p1) {
+  return __builtin_elementwise_max(p0, (uint3)p1);
+}
+constexpr uint3 max(uint p0, uint3 p1) {
+  return __builtin_elementwise_max((uint3)p0, p1);
+}
+constexpr uint4 max(uint4 p0, uint p1) {
+  return __builtin_elementwise_max(p0, (uint4)p1);
+}
+constexpr uint4 max(uint p0, uint4 p1) {
+  return __builtin_elementwise_max((uint4)p0, p1);
+}
 
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
 int64_t max(int64_t, int64_t);
@@ -1733,6 +1841,24 @@ _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);
+constexpr int64_t2 max(int64_t2 p0, int64_t p1) {
+  return __builtin_elementwise_max(p0, (int64_t2)p1);
+}
+constexpr int64_t2 max(int64_t p0, int64_t2 p1) {
+  return __builtin_elementwise_max((int64_t2)p0, p1);
+}
+constexpr int64_t3 max(int64_t3 p0, int64_t p1) {
+  return __builtin_elementwise_max(p0, (int64_t3)p1);
+}
+constexpr int64_t3 max(int64_t p0, int64_t3 p1) {
+  return __builtin_elementwise_max((int64_t3)p0, p1);
+}
+constexpr int64_t4 max(int64_t4 p0, int64_t p1) {
+  return __builtin_elementwise_max(p0, (int64_t4)p1);
+}
+constexpr int64_t4 max(int64_t p0, int64_t4 p1) {
+  return __builtin_elementwise_max((int64_t4)p0, p1);
+}
 
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
 uint64_t max(uint64_t, uint64_t);
@@ -1742,6 +1868,24 @@ _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);
+constexpr uint64_t2 max(uint64_t2 p0, uint64_t p1) {
+  return __builtin_elementwise_max(p0, (uint64_t2)p1);
+}
+constexpr uint64_t2 max(uint64_t p0, uint64_t2 p1) {
+  return __builtin_elementwise_max((uint64_t2)p0, p1);
+}
+constexpr uint64_t3 max(uint64_t3 p0, uint64_t p1) {
+  return __builtin_elementwise_max(p0, (uint64_t3)p1);
+}
+constexpr uint64_t3 max(uint64_t p0, uint64_t3 p1) {
+  return __builtin_elementwise_max((uint64_t3)p0, p1);
+}
+constexpr uint64_t4 max(uint64_t4 p0, uint64_t p1) {
+  return __builtin_elementwise_max(p0, (uint64_t4)p1);
+}
+constexpr uint64_t4 max(uint64_t p0, uint64_t4 p1) {
+  return __builtin_elementwise_max((uint64_t4)p0, p1);
+}
 
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
 float max(float, float);
@@ -1751,6 +1895,24 @@ _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
 float3 max(float3, float3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
 float4 max(float4, float4);
+constexpr float2 max(float2 p0, float p1) {
+  return __builtin_elementwise_max(p0, (float2)p1);
+}
+constexpr float2 max(float p0, float2 p1) {
+  return __builtin_elementwise_max((float2)p0, p1);
+}
+constexpr float3 max(float3 p0, float p1) {
+  return __builtin_elementwise_max(p0, (float3)p1);
+}
+constexpr float3 max(float p0, float3 p1) {
+  return __builtin_elementwise_max((float3)p0, p1);
+}
+constexpr float4 max(float4 p0, float p1) {
+  return __builtin_elementwise_max(p0, (float4)p1);
+}
+constexpr float4 max(float p0, float4 p1) {
+  return __builtin_elementwise_max((float4)p0, p1);
+}
 
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
 double max(double, double);
@@ -1760,6 +1922,24 @@ _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
 double3 max(double3, double3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
 double4 max(double4, double4);
+constexpr double2 max(double2 p0, double p1) {
+  return __builtin_elementwise_max(p0, (double2)p1);
+}
+constexpr double2 max(double p0, double2 p1) {
+  return __builtin_elementwise_max((double2)p0, p1);
+}
+constexpr double3 max(double3 p0, double p1) {
+  return __builtin_elementwise_max(p0, (double3)p1);
+}
+constexpr double3 max(double p0, double3 p1) {
+  return __builtin_elementwise_max((double3)p0, p1);
+}
+constexpr double4 max(double4 p0, double p1) {
+  return __builtin_elementwise_max(p0, (double4)p1);
+}
+constexpr double4 max(double p0, double4 p1) {
+  return __builtin_elementwise_max((double4)p0, p1);
+}
 
 //===----------------------------------------------------------------------===//
 // min builtins
@@ -1782,6 +1962,30 @@ half3 min(half3, half3);
 _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
 half4 min(half4, half4);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+constexpr half2 min(half2 p0, half p1) {
+  return __builtin_elementwise_min(p0, (half2)p1);
+}
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+constexpr half2 min(half p0, half2 p1) {
+  return __builtin_elementwise_min((half2)p0, p1);
+}
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+constexpr half3 min(half3 p0, half p1) {
+  return __builtin_elementwise_min(p0, (half3)p1);
+}
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+constexpr half3 min(half p0, half3 p1) {
+  return __builtin_elementwise_min((half3)p0, p1);
+}
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+constexpr half4 min(half4 p0, half p1) {
+  return __builtin_elementwise_min(p0, (half4)p1);
+}
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+constexpr half4 min(half p0, half4 p1) {
+  return __builtin_elementwise_min((half4)p0, p1);
+}
 
 #ifdef __HLSL_ENABLE_16_BIT
 _HLSL_AVAILABILITY(shadermodel, 6.2)
@@ -1796,6 +2000,30 @@ 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);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr int16_t2 min(int16_t2 p0, int16_t p1) {
+  return __builtin_elementwise_min(p0, (int16_t2)p1);
+}
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr int16_t2 min(int16_t p0, int16_t2 p1) {
+  return __builtin_elementwise_min((int16_t2)p0, p1);
+}
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr int16_t3 min(int16_t3 p0, int16_t p1) {
+  return __builtin_elementwise_min(p0, (int16_t3)p1);
+}
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr int16_t3 min(int16_t p0, int16_t3 p1) {
+  return __builtin_elementwise_min((int16_t3)p0, p1);
+}
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr int16_t4 min(int16_t4 p0, int16_t p1) {
+  return __builtin_elementwise_min(p0, (int16_t4)p1);
+}
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr int16_t4 min(int16_t p0, int16_t4 p1) {
+  return __builtin_elementwise_min((int16_t4)p0, p1);
+}
 
 _HLSL_AVAILABILITY(shadermodel, 6.2)
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
@@ -1809,6 +2037,30 @@ 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);
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr uint16_t2 min(uint16_t2 p0, uint16_t p1) {
+  return __builtin_elementwise_min(p0, (uint16_t2)p1);
+}
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr uint16_t2 min(uint16_t p0, uint16_t2 p1) {
+  return __builtin_elementwise_min((uint16_t2)p0, p1);
+}
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr uint16_t3 min(uint16_t3 p0, uint16_t p1) {
+  return __builtin_elementwise_min(p0, (uint16_t3)p1);
+}
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr uint16_t3 min(uint16_t p0, uint16_t3 p1) {
+  return __builtin_elementwise_min((uint16_t3)p0, p1);
+}
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr uint16_t4 min(uint16_t4 p0, uint16_t p1) {
+  return __builtin_elementwise_min(p0, (uint16_t4)p1);
+}
+_HLSL_AVAILABILITY(shadermodel, 6.2)
+constexpr uint16_t4 min(uint16_t p0, uint16_t4 p1) {
+  return __builtin_elementwise_min((uint16_t4)p0, p1);
+}
 #endif
 
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
@@ -1819,6 +2071,24 @@ _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
 int3 min(int3, int3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
 int4 min(int4, int4);
+constexpr int2 min(int2 p0, int p1) {
+  return __builtin_elementwise_min(p0, (int2)p1);
+}
+constexpr int2 min(int p0, int2 p1) {
+  return __builtin_elementwise_min((int2)p0, p1);
+}
+constexpr int3 min(int3 p0, int p1) {
+  return __builtin_elementwise_min(p0, (int3)p1);
+}
+constexpr int3 min(int p0, int3 p1) {
+  return __builtin_elementwise_min((int3)p0, p1);
+}
+constexpr int4 min(int4 p0, int p1) {
+  return __builtin_elementwise_min(p0, (int4)p1);
+}
+constexpr int4 min(int p0, int4 p1) {
+  return __builtin_elementwise_min((int4)p0, p1);
+}
 
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
 uint min(uint, uint);
@@ -1828,6 +2098,24 @@ _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
 uint3 min(uint3, uint3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
 uint4 min(uint4, uint4);
+constexpr uint2 min(uint2 p0, uint p1) {
+  return __builtin_elementwise_min(p0, (uint2)p1);
+}
+constexpr uint2 min(uint p0, uint2 p1) {
+  return __builtin_elementwise_min((uint2)p0, p1);
+}
+constexpr uint3 min(uint3 p0, uint p1) {
+  return __builtin_elementwise_min(p0, (uint3)p1);
+}
+constexpr uint3 min(uint p0, uint3 p1) {
+  return __builtin_elementwise_min((uint3)p0, p1);
+}
+constexpr uint4 min(uint4 p0, uint p1) {
+  return __builtin_elementwise_min(p0, (uint4)p1);
+}
+constexpr uint4 min(uint p0, uint4 p1) {
+  return __builtin_elementwise_min((uint4)p0, p1);
+}
 
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
 float min(float, float);
@@ -1837,6 +2125,24 @@ _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
 float3 min(float3, float3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
 float4 min(float4, float4);
+constexpr float2 min(float2 p0, float p1) {
+  return __builtin_elementwise_min(p0, (float2)p1);
+}
+constexpr float2 min(float p0, float2 p1) {
+  return __builtin_elementwise_min((float2)p0, p1);
+}
+constexpr float3 min(float3 p0, float p1) {
+  return __builtin_elementwise_min(p0, (float3)p1);
+}
+constexpr float3 min(float p0, float3 p1) {
+  return __builtin_elementwise_min((float3)p0, p1);
+}
+constexpr float4 min(float4 p0, float p1) {
+  return __builtin_elementwise_min(p0, (float4)p1);
+}
+constexpr float4 min(float p0, float4 p1) {
+  return __builtin_elementwise_min((float4)p0, p1);
+}
 
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
 int64_t min(int64_t, int64_t);
@@ -1846,6 +2152,24 @@ _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);
+constexpr int64_t2 min(int64_t2 p0, int64_t p1) {
+  return __builtin_elementwise_min(p0, (int64_t2)p1);
+}
+constexpr int64_t2 min(int64_t p0, int64_t2 p1) {
+  return __builtin_elementwise_min((int64_t2)p0, p1);
+}
+constexpr int64_t3 min(int64_t3 p0, int64_t p1) {
+  return __builtin_elementwise_min(p0, (int64_t3)p1);
+}
+constexpr int64_t3 min(int64_t p0, int64_t3 p1) {
+  return __builtin_elementwise_min((int64_t3)p0, p1);
+}
+constexpr int64_t4 min(int64_t4 p0, int64_t p1) {
+  return __builtin_elementwise_min(p0, (int64_t4)p1);
+}
+constexpr int64_t4 min(int64_t p0, int64_t4 p1) {
+  return __builtin_elementwise_min((int64_t4)p0, p1);
+}
 
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
 uint64_t min(uint64_t, uint64_t);
@@ -1855,6 +2179,24 @@ _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);
+constexpr uint64_t2 min(uint64_t2 p0, uint64_t p1) {
+  return __builtin_elementwise_min(p0, (uint64_t2)p1);
+}
+constexpr uint64_t2 min(uint64_t p0, uint64_t2 p1) {
+  return __builtin_elementwise_min((uint64_t2)p0, p1);
+}
+constexpr uint64_t3 min(uint64_t3 p0, uint64_t p1) {
+  return __builtin_elementwise_min(p0, (uint64_t3)p1);
+}
+constexpr uint64_t3 min(uint64_t p0, uint64_t3 p1) {
+  return __builtin_elementwise_min((uint64_t3)p0, p1);
+}
+constexpr uint64_t4 min(uint64_t4 p0, uint64_t p1) {
+  return __builtin_elementwise_min(p0, (uint64_t4)p1);
+}
+constexpr uint64_t4 min(uint64_t p0, uint64_t4 p1) {
+  return __builtin_elementwise_min((uint64_t4)p0, p1);
+}
 
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
 double min(double, double);
@@ -1864,6 +2206,24 @@ _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
 double3 min(double3, double3);
 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_min)
 double4 min(double4, double4);
+constexpr double2 min(double2 p0, double p1) {
+  return __builtin_elementwise_min(p0, (double2)p1);
+}
+constexpr double2 min(double p0, double2 p1) {
+  return __builtin_elementwise_min((double2)p0, p1);
+}
+constexpr double3 min(double3 p0, double p1) {
+  return __builtin_elementwise_min(p0, (double3)p1);
+}
+constexpr double3 min(double p0, double3 p1) {
+  return __builtin_elementwise_min((double3)p0, p1);
+}
+constexpr double4 min(double4 p0, double p1) {
+  return __builtin_elementwise_min(p0, (double4)p1);
+}
+constexpr double4 min(double p0, double4 p1) {
+  return __builtin_elementwise_min((double4)p0, p1);
+}
 
 //===----------------------------------------------------------------------===//
 // normalize builtins
diff --git a/clang/test/CodeGenHLSL/builtins/max.hlsl b/clang/test/CodeGenHLSL/builtins/max.hlsl
index 0b767335556ee..6b5fb6ae59534 100644
--- a/clang/test/CodeGenHLSL/builtins/max.hlsl
+++ b/clang/test/CodeGenHLSL/builtins/max.hlsl
@@ -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(
@@ -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
@@ -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(
@@ -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(
@@ -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 ma...
[truncated]

bob80905 · 2025-02-28T23:09:13Z

clang/lib/Headers/hlsl/hlsl_intrinsics.h

 _HLSL_BUILTIN_ALIAS(__builtin_elementwise_max)
 half4 max(half4, half4);
+_HLSL_16BIT_AVAILABILITY(shadermodel, 6.2)
+constexpr half2 max(half2 p0, half p1) {


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?

Yes that is my understanding

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

bob80905 · 2025-02-28T23:18:27Z

clang/test/CodeGenHLSL/builtins/min.hlsl

+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); }


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

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.

bob80905

I can approve this, though it might be worth considering adding a macro at the top of hlsl_intrinsics.h, along with some of the other macros there, to shrink the change and possibly simplify future changes that need these types of sets of overloads.

damyanp

Are there any error conditions that need testing as well?

spall · 2025-03-01T00:48:41Z

Are there any error conditions that need testing as well?

I don't think there were any hlsl specific error tests for min and max originally. I could add some to make sure things like min(int4, int3) are still not allowed.

spall added 2 commits February 28, 2025 14:46

new max overloads + new min overloads

ebaef38

tests

4f121bf

llvmbot added clang Clang issues not falling into any other category backend:X86 clang:headers Headers provided by Clang, e.g. for intrinsics HLSL HLSL Language Support labels Feb 28, 2025

github-project-automation bot added this to HLSL Support Feb 28, 2025

bob80905 reviewed Feb 28, 2025

View reviewed changes

bob80905 approved these changes Feb 28, 2025

View reviewed changes

damyanp reviewed Mar 1, 2025

View reviewed changes

use macro to make header file shorter

dabf384

bob80905 approved these changes Mar 1, 2025

View reviewed changes

forgot to call macro for max half case

81dd7ee

spall merged commit 25713ed into llvm:main Mar 3, 2025
11 checks passed

damyanp moved this to Closed in HLSL Support Apr 25, 2025

damyanp removed this from HLSL Support Jun 25, 2025

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

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

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

Uh oh!

spall commented Feb 28, 2025

Uh oh!

llvmbot commented Feb 28, 2025 •

edited

Loading

Uh oh!

bob80905 Feb 28, 2025

Uh oh!

spall Feb 28, 2025

Uh oh!

spall Feb 28, 2025 •

edited

Loading

Uh oh!

bob80905 Feb 28, 2025

Uh oh!

spall Feb 28, 2025

Uh oh!

bob80905 left a comment

Uh oh!

damyanp left a comment

Uh oh!

spall commented Mar 1, 2025 •

edited

Loading

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants

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

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

Uh oh!

Conversation

spall commented Feb 28, 2025

Uh oh!

llvmbot commented Feb 28, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

bob80905 Feb 28, 2025

Choose a reason for hiding this comment

Uh oh!

spall Feb 28, 2025

Choose a reason for hiding this comment

Uh oh!

spall Feb 28, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

bob80905 Feb 28, 2025

Choose a reason for hiding this comment

Uh oh!

spall Feb 28, 2025

Choose a reason for hiding this comment

Uh oh!

bob80905 left a comment

Choose a reason for hiding this comment

Uh oh!

damyanp left a comment

Choose a reason for hiding this comment

Uh oh!

spall commented Mar 1, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants

llvmbot commented Feb 28, 2025 •

edited

Loading

spall Feb 28, 2025 •

edited

Loading

spall commented Mar 1, 2025 •

edited

Loading