[HLSL] add max/min library functions

[bob80905]

Summary

This change exposes the max and min library functions for HLSL, excluding long, and long long doubles.
The max / min functions are supported for all scalar, vector, and matrix types.
Long and long long double support is missing in this patch because those types
don't exist in HLSL.

The full documentation of the HLSL max / min functions are available here:
https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-max
https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-min

[bob80905]

clang/test/CodeGenHLSL/builtins/min.hlsl

11

I had to add a 0 here for the NO_HALF case for all these tests, which is unlike what I had to do for previous tests. Not sure why, but thought I would point it out.

[python3kgae]

max/min does work on integers in HLSL.
And __builtin_elementwise_max/min support both integers and floats.

[bob80905]

add int support for max/min.

[python3kgae]

In D144309#4156971, @bob80905 wrote:

add int support for max/min.

Sorry didn't check more :(.

Now i16/u16/i32/u32/i64/u64/f16/f32/f64 are all supported for min/max in hlsl.

[bob80905]

• add support for these types: i16/u16/i32/u32/i64/u64/f16/f32/f64

[bob80905]

• ushort is now unsigned

[bob80905]

• format

[python3kgae]

In D144309#4159431, @bob80905 wrote:

• ushort is now unsigned

Use uint16_t/int16_t/uint64_t/int64_t for 16/64 bit integers.

[bob80905]

• use already defined hlsl types

[python3kgae]

clang/test/CodeGenHLSL/builtins/max.hlsl

12

Just guard 16bit integer tests with #ifdef __HLSL_ENABLE_16_BIT.

[bob80905]

• only run tests if 16 bit is enabled

clang/lib/Headers/hlsl/hlsl_intrinsics.h

 log10(double);
 __attribute__((clang_builtin_alias(__builtin_elementwise_log10)))
 double2 log10(double2);
 __attribute__((clang_builtin_alias(__builtin_elementwise_log10)))
 double3 log10(double3);
 __attribute__((clang_builtin_alias(__builtin_elementwise_log10)))
 double4 log10(double4);
 
+// max builtins
+#ifdef __HLSL_ENABLE_16_BIT
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+half max(half, half);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+half2 max(half2, half2);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+half3 max(half3, half3);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+half4 max(half4, half4);
+
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+int16_t max(int16_t, int16_t);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+int16_t2 max(int16_t2, int16_t2);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+int16_t3 max(int16_t3, int16_t3);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+int16_t4 max(int16_t4, int16_t4);
+
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+uint16_t max(uint16_t, uint16_t);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+uint16_t2 max(uint16_t2, uint16_t2);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+uint16_t3 max(uint16_t3, uint16_t3);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+uint16_t4 max(uint16_t4, uint16_t4);
+#endif
+
+__attribute__((clang_builtin_alias(__builtin_elementwise_max))) int max(int,
+                                                                        int);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+int2 max(int2, int2);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+int3 max(int3, int3);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+int4 max(int4, int4);
+
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+uint max(uint, uint);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+uint2 max(uint2, uint2);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+uint3 max(uint3, uint3);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+uint4 max(uint4, uint4);
+
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+int64_t max(int64_t, int64_t);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+int64_t2 max(int64_t2, int64_t2);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+int64_t3 max(int64_t3, int64_t3);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+int64_t4 max(int64_t4, int64_t4);
+
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+uint64_t max(uint64_t, uint64_t);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+uint64_t2 max(uint64_t2, uint64_t2);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+uint64_t3 max(uint64_t3, uint64_t3);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+uint64_t4 max(uint64_t4, uint64_t4);
+
+__attribute__((clang_builtin_alias(__builtin_elementwise_max))) float
+max(float, float);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+float2 max(float2, float2);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+float3 max(float3, float3);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+float4 max(float4, float4);
+
+__attribute__((clang_builtin_alias(__builtin_elementwise_max))) double
+max(double, double);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+double2 max(double2, double2);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+double3 max(double3, double3);
+__attribute__((clang_builtin_alias(__builtin_elementwise_max)))
+double4 max(double4, double4);
+
+// min builtins
+#ifdef __HLSL_ENABLE_16_BIT
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+half min(half, half);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+half2 min(half2, half2);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+half3 min(half3, half3);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+half4 min(half4, half4);
+
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+int16_t min(int16_t, int16_t);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+int16_t2 min(int16_t2, int16_t2);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+int16_t3 min(int16_t3, int16_t3);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+int16_t4 min(int16_t4, int16_t4);
+
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+uint16_t min(uint16_t, uint16_t);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+uint16_t2 min(uint16_t2, uint16_t2);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+uint16_t3 min(uint16_t3, uint16_t3);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+uint16_t4 min(uint16_t4, uint16_t4);
+#endif
+
+__attribute__((clang_builtin_alias(__builtin_elementwise_min))) int min(int,
+                                                                        int);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+int2 min(int2, int2);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+int3 min(int3, int3);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+int4 min(int4, int4);
+
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+uint min(uint, uint);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+uint2 min(uint2, uint2);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+uint3 min(uint3, uint3);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+uint4 min(uint4, uint4);
+
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+int64_t min(int64_t, int64_t);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+int64_t2 min(int64_t2, int64_t2);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+int64_t3 min(int64_t3, int64_t3);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+int64_t4 min(int64_t4, int64_t4);
+
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+uint64_t min(uint64_t, uint64_t);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+uint64_t2 min(uint64_t2, uint64_t2);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+uint64_t3 min(uint64_t3, uint64_t3);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+uint64_t4 min(uint64_t4, uint64_t4);
+
+__attribute__((clang_builtin_alias(__builtin_elementwise_min))) float
+min(float, float);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+float2 min(float2, float2);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+float3 min(float3, float3);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+float4 min(float4, float4);
+
+__attribute__((clang_builtin_alias(__builtin_elementwise_min))) double
+min(double, double);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+double2 min(double2, double2);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+double3 min(double3, double3);
+__attribute__((clang_builtin_alias(__builtin_elementwise_min)))
+double4 min(double4, double4);
+
 } // namespace hlsl
 #endif //_HLSL_HLSL_INTRINSICS_H_

clang/test/CodeGenHLSL/builtins/max.hlsl

+// RUN: %clang_cc1 -std=hlsl2021 -finclude-default-header -x hlsl -triple \
+// RUN:   dxil-pc-shadermodel6.3-library %s -fnative-half-type \
+// RUN:   -emit-llvm -disable-llvm-passes -O3 -o - | FileCheck %s
+// RUN: %clang_cc1 -std=hlsl2021 -finclude-default-header -x hlsl -triple \
+// RUN:   dxil-pc-shadermodel6.3-library %s -emit-llvm -disable-llvm-passes \
+// RUN:   -D__HLSL_ENABLE_16_BIT -o - | FileCheck %s --check-prefix=NO_HALF
+
+// CHECK: define noundef i16 @
+// CHECK: call i16 @llvm.smax.i16(
+// NO_HALF: define noundef i16 @"?test_max_short@@YAFFF@Z"(
+// NO_HALF: call i16 @llvm.smax.i16(
+int16_t test_max_short ( int16_t p0, int16_t p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <2 x i16> @
+// CHECK: call <2 x i16> @llvm.smax.v2i16(
+// NO_HALF: define noundef <2 x i16> @"?test_max_short2@@YAT?$__vector@F$01@__clang@@T12@0@Z"(
+// NO_HALF: call <2 x i16> @llvm.smax.v2i16(
+int16_t2 test_max_short2 ( int16_t2 p0, int16_t2 p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <3 x i16> @
+// CHECK: call <3 x i16> @llvm.smax.v3i16
+// NO_HALF: define noundef <3 x i16> @"?test_max_short3@@YAT?$__vector@F$02@__clang@@T12@0@Z"(
+// NO_HALF: call <3 x i16> @llvm.smax.v3i16(
+int16_t3 test_max_short3 ( int16_t3 p0, int16_t3 p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <4 x i16> @
+// CHECK: call <4 x i16> @llvm.smax.v4i16
+// NO_HALF: define noundef <4 x i16> @"?test_max_short4@@YAT?$__vector@F$03@__clang@@T12@0@Z"(
+// NO_HALF: call <4 x i16> @llvm.smax.v4i16(
+int16_t4 test_max_short4 ( int16_t4 p0, int16_t4 p1 ) {
+  return max ( p0, p1 );
+}
+
+// CHECK: define noundef i16 @
+// CHECK: call i16 @llvm.umax.i16(
+// NO_HALF: define noundef i16 @"?test_max_ushort@@YAGGG@Z"(
+// NO_HALF: call i16 @llvm.umax.i16(
+uint16_t test_max_ushort ( uint16_t p0, uint16_t p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <2 x i16> @
+// CHECK: call <2 x i16> @llvm.umax.v2i16
+// NO_HALF: define noundef <2 x i16> @"?test_max_ushort2@@YAT?$__vector@G$01@__clang@@T12@0@Z"(
+// NO_HALF: call <2 x i16> @llvm.umax.v2i16(
+uint16_t2 test_max_ushort2 ( uint16_t2 p0, uint16_t2 p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <3 x i16> @
+// CHECK: call <3 x i16> @llvm.umax.v3i16
+// NO_HALF: define noundef <3 x i16> @"?test_max_ushort3@@YAT?$__vector@G$02@__clang@@T12@0@Z"(
+// NO_HALF: call <3 x i16> @llvm.umax.v3i16(
+uint16_t3 test_max_ushort3 ( uint16_t3 p0, uint16_t3 p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <4 x i16> @
+// CHECK: call <4 x i16> @llvm.umax.v4i16
+// NO_HALF: define noundef <4 x i16> @"?test_max_ushort4@@YAT?$__vector@G$03@__clang@@T12@0@Z"(
+// NO_HALF: call <4 x i16> @llvm.umax.v4i16(
+uint16_t4 test_max_ushort4 ( uint16_t4 p0, uint16_t4 p1 ) {
+  return max ( p0, p1 );
+}
+
+// CHECK: define noundef i32 @
+// CHECK: call i32 @llvm.smax.i32(
+int test_max_int ( int p0, int p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <2 x i32> @
+// CHECK: call <2 x i32> @llvm.smax.v2i32
+int2 test_max_int2 ( int2 p0, int2 p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <3 x i32> @
+// CHECK: call <3 x i32> @llvm.smax.v3i32
+int3 test_max_int3 ( int3 p0, int3 p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <4 x i32> @
+// CHECK: call <4 x i32> @llvm.smax.v4i32
+int4 test_max_int4 ( int4 p0, int4 p1) {
+  return max ( p0, p1 );
+}
+
+// CHECK: define noundef i32 @
+// CHECK: call i32 @llvm.umax.i32(
+int test_max_uint ( uint p0, uint p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <2 x i32> @
+// CHECK: call <2 x i32> @llvm.umax.v2i32
+uint2 test_max_uint2 ( uint2 p0, uint2 p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <3 x i32> @
+// CHECK: call <3 x i32> @llvm.umax.v3i32
+uint3 test_max_uint3 ( uint3 p0, uint3 p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <4 x i32> @
+// CHECK: call <4 x i32> @llvm.umax.v4i32
+uint4 test_max_uint4 ( uint4 p0, uint4 p1) {
+  return max ( p0, p1 );
+}
+
+// CHECK: define noundef i64 @
+// CHECK: call i64 @llvm.smax.i64(
+int64_t test_max_long ( int64_t p0, int64_t p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <2 x i64> @
+// CHECK: call <2 x i64> @llvm.smax.v2i64
+int64_t2 test_max_long2 ( int64_t2 p0, int64_t2 p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <3 x i64> @
+// CHECK: call <3 x i64> @llvm.smax.v3i64
+int64_t3 test_max_long3 ( int64_t3 p0, int64_t3 p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <4 x i64> @
+// CHECK: call <4 x i64> @llvm.smax.v4i64
+int64_t4 test_max_long4 ( int64_t4 p0, int64_t4 p1) {
+  return max ( p0, p1 );
+}
+
+// CHECK: define noundef i64 @
+// CHECK: call i64 @llvm.umax.i64(
+uint64_t test_max_long ( uint64_t p0, uint64_t p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <2 x i64> @
+// CHECK: call <2 x i64> @llvm.umax.v2i64
+uint64_t2 test_max_long2 ( uint64_t2 p0, uint64_t2 p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <3 x i64> @
+// CHECK: call <3 x i64> @llvm.umax.v3i64
+uint64_t3 test_max_long3 ( uint64_t3 p0, uint64_t3 p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <4 x i64> @
+// CHECK: call <4 x i64> @llvm.umax.v4i64
+uint64_t4 test_max_long4 ( uint64_t4 p0, uint64_t4 p1) {
+  return max ( p0, p1 );
+}
+
+
+// CHECK: define noundef half @
+// CHECK: call half @llvm.maxnum.f16(
+// NO_HALF: define noundef float @"?test_max_half@@YA$halff@$halff@0@Z"(
+// NO_HALF: call float @llvm.maxnum.f32(
+half test_max_half ( half p0, half p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <2 x half> @
+// CHECK: call <2 x half> @llvm.maxnum.v2f16
+// NO_HALF: define noundef <2 x float> @"?test_max_float2@@YAT?$__vector@M$01@__clang@@T12@0@Z"(
+// NO_HALF: call <2 x float> @llvm.maxnum.v2f32(
+half2 test_max_half2 ( half2 p0, half2 p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <3 x half> @
+// CHECK: call <3 x half> @llvm.maxnum.v3f16
+// NO_HALF: define noundef <3 x float> @"?test_max_float3@@YAT?$__vector@M$02@__clang@@T12@0@Z"(
+// NO_HALF: call <3 x float> @llvm.maxnum.v3f32(
+half3 test_max_half3 ( half3 p0, half3 p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <4 x half> @
+// CHECK: call <4 x half> @llvm.maxnum.v4f16
+// NO_HALF: define noundef <4 x float> @"?test_max_float4@@YAT?$__vector@M$03@__clang@@T12@0@Z"(
+// NO_HALF: call <4 x float> @llvm.maxnum.v4f32(
+half4 test_max_half4 ( half4 p0, half4 p1 ) {
+  return max ( p0, p1 );
+}
+
+// CHECK: define noundef float @
+// CHECK: call float @llvm.maxnum.f32(
+float test_max_float ( float p0, float p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <2 x float> @
+// CHECK: call <2 x float> @llvm.maxnum.v2f32
+float2 test_max_float2 ( float2 p0, float2 p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <3 x float> @
+// CHECK: call <3 x float> @llvm.maxnum.v3f32
+float3 test_max_float3 ( float3 p0, float3 p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <4 x float> @
+// CHECK: call <4 x float> @llvm.maxnum.v4f32
+float4 test_max_float4 ( float4 p0, float4 p1) {
+  return max ( p0, p1 );
+}
+
+// CHECK: define noundef double @
+// CHECK: call double @llvm.maxnum.f64(
+double test_max_double ( double p0, double p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <2 x double> @
+// CHECK: call <2 x double> @llvm.maxnum.v2f64
+double2 test_max_double2 ( double2 p0, double2 p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <3 x double> @
+// CHECK: call <3 x double> @llvm.maxnum.v3f64
+double3 test_max_double3 ( double3 p0, double3 p1 ) {
+  return max ( p0, p1 );
+}
+// CHECK: define noundef <4 x double> @
+// CHECK: call <4 x double> @llvm.maxnum.v4f64
+double4 test_max_double4 ( double4 p0, double4 p1) {
+  return max ( p0, p1 );
+}

clang/test/CodeGenHLSL/builtins/min.hlsl

+// RUN: %clang_cc1 -std=hlsl2021 -finclude-default-header -x hlsl -triple \
+// RUN:   dxil-pc-shadermodel6.3-library %s -fnative-half-type \
+// RUN:   -emit-llvm -disable-llvm-passes -O3 -o - | FileCheck %s
+// RUN: %clang_cc1 -std=hlsl2021 -finclude-default-header -x hlsl -triple \
+// RUN:   dxil-pc-shadermodel6.3-library %s -emit-llvm -disable-llvm-passes \
+// RUN:   -D__HLSL_ENABLE_16_BIT -o - | FileCheck %s --check-prefix=NO_HALF
+
+// CHECK: define noundef i16 @
+// CHECK: call i16 @llvm.smin.i16(
+// NO_HALF: define noundef i16 @"?test_min_short@@YAFFF@Z"(
+// NO_HALF: call i16 @llvm.smin.i16(
+int16_t test_min_short ( int16_t p0, int16_t p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <2 x i16> @
+// CHECK: call <2 x i16> @llvm.smin.v2i16(
+// NO_HALF: define noundef <2 x i16> @"?test_min_short2@@YAT?$__vector@F$01@__clang@@T12@0@Z"(
+// NO_HALF: call <2 x i16> @llvm.smin.v2i16(
+int16_t2 test_min_short2 ( int16_t2 p0, int16_t2 p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <3 x i16> @
+// CHECK: call <3 x i16> @llvm.smin.v3i16
+// NO_HALF: define noundef <3 x i16> @"?test_min_short3@@YAT?$__vector@F$02@__clang@@T12@0@Z"(
+// NO_HALF: call <3 x i16> @llvm.smin.v3i16(
+int16_t3 test_min_short3 ( int16_t3 p0, int16_t3 p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <4 x i16> @
+// CHECK: call <4 x i16> @llvm.smin.v4i16
+// NO_HALF: define noundef <4 x i16> @"?test_min_short4@@YAT?$__vector@F$03@__clang@@T12@0@Z"(
+// NO_HALF: call <4 x i16> @llvm.smin.v4i16(
+int16_t4 test_min_short4 ( int16_t4 p0, int16_t4 p1 ) {
+  return min ( p0, p1 );
+}
+
+// CHECK: define noundef i16 @
+// CHECK: call i16 @llvm.umin.i16(
+// NO_HALF: define noundef i16 @"?test_min_ushort@@YAGGG@Z"(
+// NO_HALF: call i16 @llvm.umin.i16(
+uint16_t test_min_ushort ( uint16_t p0, uint16_t p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <2 x i16> @
+// CHECK: call <2 x i16> @llvm.umin.v2i16
+// NO_HALF: define noundef <2 x i16> @"?test_min_ushort2@@YAT?$__vector@G$01@__clang@@T12@0@Z"(
+// NO_HALF: call <2 x i16> @llvm.umin.v2i16(
+uint16_t2 test_min_ushort2 ( uint16_t2 p0, uint16_t2 p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <3 x i16> @
+// CHECK: call <3 x i16> @llvm.umin.v3i16
+// NO_HALF: define noundef <3 x i16> @"?test_min_ushort3@@YAT?$__vector@G$02@__clang@@T12@0@Z"(
+// NO_HALF: call <3 x i16> @llvm.umin.v3i16(
+uint16_t3 test_min_ushort3 ( uint16_t3 p0, uint16_t3 p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <4 x i16> @
+// CHECK: call <4 x i16> @llvm.umin.v4i16
+// NO_HALF: define noundef <4 x i16> @"?test_min_ushort4@@YAT?$__vector@G$03@__clang@@T12@0@Z"(
+// NO_HALF: call <4 x i16> @llvm.umin.v4i16(
+uint16_t4 test_min_ushort4 ( uint16_t4 p0, uint16_t4 p1 ) {
+  return min ( p0, p1 );
+}
+
+// CHECK: define noundef i32 @
+// CHECK: call i32 @llvm.smin.i32(
+int test_min_int ( int p0, int p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <2 x i32> @
+// CHECK: call <2 x i32> @llvm.smin.v2i32
+int2 test_min_int2 ( int2 p0, int2 p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <3 x i32> @
+// CHECK: call <3 x i32> @llvm.smin.v3i32
+int3 test_min_int3 ( int3 p0, int3 p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <4 x i32> @
+// CHECK: call <4 x i32> @llvm.smin.v4i32
+int4 test_min_int4 ( int4 p0, int4 p1) {
+  return min ( p0, p1 );
+}
+
+// CHECK: define noundef i32 @
+// CHECK: call i32 @llvm.umin.i32(
+int test_min_uint ( uint p0, uint p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <2 x i32> @
+// CHECK: call <2 x i32> @llvm.umin.v2i32
+uint2 test_min_uint2 ( uint2 p0, uint2 p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <3 x i32> @
+// CHECK: call <3 x i32> @llvm.umin.v3i32
+uint3 test_min_uint3 ( uint3 p0, uint3 p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <4 x i32> @
+// CHECK: call <4 x i32> @llvm.umin.v4i32
+uint4 test_min_uint4 ( uint4 p0, uint4 p1) {
+  return min ( p0, p1 );
+}
+
+// CHECK: define noundef i64 @
+// CHECK: call i64 @llvm.smin.i64(
+int64_t test_min_long ( int64_t p0, int64_t p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <2 x i64> @
+// CHECK: call <2 x i64> @llvm.smin.v2i64
+int64_t2 test_min_long2 ( int64_t2 p0, int64_t2 p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <3 x i64> @
+// CHECK: call <3 x i64> @llvm.smin.v3i64
+int64_t3 test_min_long3 ( int64_t3 p0, int64_t3 p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <4 x i64> @
+// CHECK: call <4 x i64> @llvm.smin.v4i64
+int64_t4 test_min_long4 ( int64_t4 p0, int64_t4 p1) {
+  return min ( p0, p1 );
+}
+
+// CHECK: define noundef i64 @
+// CHECK: call i64 @llvm.umin.i64(
+uint64_t test_min_long ( uint64_t p0, uint64_t p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <2 x i64> @
+// CHECK: call <2 x i64> @llvm.umin.v2i64
+uint64_t2 test_min_long2 ( uint64_t2 p0, uint64_t2 p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <3 x i64> @
+// CHECK: call <3 x i64> @llvm.umin.v3i64
+uint64_t3 test_min_long3 ( uint64_t3 p0, uint64_t3 p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <4 x i64> @
+// CHECK: call <4 x i64> @llvm.umin.v4i64
+uint64_t4 test_min_long4 ( uint64_t4 p0, uint64_t4 p1) {
+  return min ( p0, p1 );
+}
+
+
+// CHECK: define noundef half @
+// CHECK: call half @llvm.minnum.f16(
+// NO_HALF: define noundef float @"?test_min_half@@YA$halff@$halff@0@Z"(
+// NO_HALF: call float @llvm.minnum.f32(
+half test_min_half ( half p0, half p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <2 x half> @
+// CHECK: call <2 x half> @llvm.minnum.v2f16
+// NO_HALF: define noundef <2 x float> @"?test_min_float2@@YAT?$__vector@M$01@__clang@@T12@0@Z"(
+// NO_HALF: call <2 x float> @llvm.minnum.v2f32(
+half2 test_min_half2 ( half2 p0, half2 p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <3 x half> @
+// CHECK: call <3 x half> @llvm.minnum.v3f16
+// NO_HALF: define noundef <3 x float> @"?test_min_float3@@YAT?$__vector@M$02@__clang@@T12@0@Z"(
+// NO_HALF: call <3 x float> @llvm.minnum.v3f32(
+half3 test_min_half3 ( half3 p0, half3 p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <4 x half> @
+// CHECK: call <4 x half> @llvm.minnum.v4f16
+// NO_HALF: define noundef <4 x float> @"?test_min_float4@@YAT?$__vector@M$03@__clang@@T12@0@Z"(
+// NO_HALF: call <4 x float> @llvm.minnum.v4f32(
+half4 test_min_half4 ( half4 p0, half4 p1 ) {
+  return min ( p0, p1 );
+}
+
+// CHECK: define noundef float @
+// CHECK: call float @llvm.minnum.f32(
+float test_min_float ( float p0, float p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <2 x float> @
+// CHECK: call <2 x float> @llvm.minnum.v2f32
+float2 test_min_float2 ( float2 p0, float2 p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <3 x float> @
+// CHECK: call <3 x float> @llvm.minnum.v3f32
+float3 test_min_float3 ( float3 p0, float3 p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <4 x float> @
+// CHECK: call <4 x float> @llvm.minnum.v4f32
+float4 test_min_float4 ( float4 p0, float4 p1) {
+  return min ( p0, p1 );
+}
+
+// CHECK: define noundef double @
+// CHECK: call double @llvm.minnum.f64(
+double test_min_double ( double p0, double p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <2 x double> @
+// CHECK: call <2 x double> @llvm.minnum.v2f64
+double2 test_min_double2 ( double2 p0, double2 p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <3 x double> @
+// CHECK: call <3 x double> @llvm.minnum.v3f64
+double3 test_min_double3 ( double3 p0, double3 p1 ) {
+  return min ( p0, p1 );
+}
+// CHECK: define noundef <4 x double> @
+// CHECK: call <4 x double> @llvm.minnum.v4f64
+double4 test_min_double4 ( double4 p0, double4 p1) {
+  return min ( p0, p1 );
+}