Implement __builtin_fmaximum/fminimum*

[tra]

Summary

The builtins provide FP min/max conforming to IEEE754-2018 standard.

[tra]

formatting cleanup

[tra]

clang-formatted new tests.

[tra]

@fhahn who else should take a look at the patch?

[tra]

Fixed test RUN lines

[Groverkss]

LGTM, the fmaximum/fminimum fallback support backends has been blocking us for a while in IREE. This patch is a welcome addition to start the support for this. I will let @fhahn accept the patch, since I'm not an expert in this part of code.

clang/include/clang/Basic/Builtins.def

 BUILTIN(__builtin_fmaxf16, "hhh", "FncE")
 BUILTIN(__builtin_fmaxl, "LdLdLd", "FncE")
 BUILTIN(__builtin_fmaxf128, "LLdLLdLLd", "FncE")
 BUILTIN(__builtin_fmin, "ddd", "FncE")
 BUILTIN(__builtin_fminf, "fff", "FncE")
 BUILTIN(__builtin_fminf16, "hhh", "FncE")
 BUILTIN(__builtin_fminl, "LdLdLd", "FncE")
 BUILTIN(__builtin_fminf128, "LLdLLdLLd", "FncE")
+BUILTIN(__builtin_fmaximum, "ddd", "FncE")
+BUILTIN(__builtin_fmaximumf, "fff", "FncE")
+BUILTIN(__builtin_fmaximumf16, "hhh", "FncE")
+BUILTIN(__builtin_fmaximumbf16, "yyy", "FncE")
+BUILTIN(__builtin_fmaximuml, "LdLdLd", "FncE")
+BUILTIN(__builtin_fmaximumf128, "LLdLLdLLd", "FncE")
+BUILTIN(__builtin_fminimum, "ddd", "FncE")
+BUILTIN(__builtin_fminimumf, "fff", "FncE")
+BUILTIN(__builtin_fminimumf16, "hhh", "FncE")
+BUILTIN(__builtin_fminimumbf16, "yyy", "FncE")
+BUILTIN(__builtin_fminimuml, "LdLdLd", "FncE")
+BUILTIN(__builtin_fminimumf128, "LLdLLdLLd", "FncE")
 BUILTIN(__builtin_hypot , "ddd"  , "Fne")
 BUILTIN(__builtin_hypotf, "fff"  , "Fne")
 BUILTIN(__builtin_hypotl, "LdLdLd", "Fne")
 BUILTIN(__builtin_hypotf128, "LLdLLdLLd", "Fne")
 BUILTIN(__builtin_ilogb , "id", "Fne")
 BUILTIN(__builtin_ilogbf, "if", "Fne")
 BUILTIN(__builtin_ilogbl, "iLd", "Fne")
 BUILTIN(__builtin_ilogbf128, "iLLd", "Fne")

clang/lib/AST/ExprConstant.cpp

if (!EvaluateFloat(E->getArg(0), Result, Info) ||
       return false;
     // When comparing zeroes, return -0.0 if one of the zeroes is negative.
     if (Result.isZero() && RHS.isZero() && RHS.isNegative())
       Result = RHS;
     else if (Result.isNaN() || RHS < Result)
       Result = RHS;
     return true;
   }
+
+  case Builtin::BI__builtin_fmaximum:
+  case Builtin::BI__builtin_fmaximumf:
+  case Builtin::BI__builtin_fmaximuml:
+  case Builtin::BI__builtin_fmaximumf16:
+  case Builtin::BI__builtin_fmaximumbf16:
+  case Builtin::BI__builtin_fmaximumf128: {
+    APFloat RHS(0.);
+    if (!EvaluateFloat(E->getArg(0), Result, Info) ||
+        !EvaluateFloat(E->getArg(1), RHS, Info))
+      return false;
+    Result = maximum(Result, RHS);
+    return true;
+  }
+
+  case Builtin::BI__builtin_fminimum:
+  case Builtin::BI__builtin_fminimumf:
+  case Builtin::BI__builtin_fminimuml:
+  case Builtin::BI__builtin_fminimumf16:
+  case Builtin::BI__builtin_fminimumbf16:
+  case Builtin::BI__builtin_fminimumf128: {
+    APFloat RHS(0.);
+    if (!EvaluateFloat(E->getArg(0), Result, Info) ||
+        !EvaluateFloat(E->getArg(1), RHS, Info))
+      return false;
+    Result = minimum(Result, RHS);
+    return true;
+  }
   }
 }
 
 bool FloatExprEvaluator::VisitUnaryReal(const UnaryOperator *E) {
   if (E->getSubExpr()->getType()->isAnyComplexType()) {
     ComplexValue CV;
     if (!EvaluateComplex(E->getSubExpr(), CV, Info))
       return false;

clang/lib/AST/Interp/InterpBuiltin.cpp

else if (LHS.isNan() || RHS > LHS)
     Result = RHS;
   else
     Result = LHS;
 
   S.Stk.push<Floating>(Result);
   return true;
 }
 
+/// Implements IEEE 754-2018 minimum semantics. Returns the smaller of 2
+/// arguments, propagating NaNs and treating -0 as less than +0.
+static bool interp__builtin_fminimum(InterpState &S, CodePtr OpPC,
+                                     const InterpFrame *Frame,
+                                     const Function *F) {
+  const Floating &LHS = getParam<Floating>(Frame, 0);
+  const Floating &RHS = getParam<Floating>(Frame, 1);
+
+  Floating Result;
+
+  if (LHS.isNan())
+    Result = LHS;
+  else if (RHS.isNan())
+    Result = RHS;
+  else if (LHS.isZero() && RHS.isZero() &&
+           (LHS.isNegative() != RHS.isNegative()))
+    Result = LHS.isNegative() ? LHS : RHS;
+  else
+    Result =  RHS < LHS ? RHS : LHS;
+
+  S.Stk.push<Floating>(Result);
+  return true;
+}
+
+/// Implements IEEE 754-2018 maximum semantics. Returns the smaller of 2
+/// arguments, propagating NaNs and treating -0 as less than +0.
+static bool interp__builtin_fmaximum(InterpState &S, CodePtr OpPC,
+                                     const InterpFrame *Frame,
+                                     const Function *Func) {
+  const Floating &LHS = getParam<Floating>(Frame, 0);
+  const Floating &RHS = getParam<Floating>(Frame, 1);
+
+  Floating Result;
+
+  if (LHS.isNan())
+    Result = LHS;
+  else if (RHS.isNan())
+    Result = RHS;
+  else if (LHS.isZero() && RHS.isZero() &&
+           (LHS.isNegative() != RHS.isNegative()))
+    Result = LHS.isNegative() ? RHS : LHS;
+  else
+    Result =  LHS < RHS ? RHS : LHS;
+
+  S.Stk.push<Floating>(Result);
+  return true;
+}
+
 /// Defined as __builtin_isnan(...), to accommodate the fact that it can
 /// take a float, double, long double, etc.
 /// But for us, that's all a Floating anyway.
 static bool interp__builtin_isnan(InterpState &S, CodePtr OpPC,
                                   const InterpFrame *Frame, const Function *F) {
   const Floating &Arg = S.Stk.peek<Floating>();
 
   pushInt(S, Arg.isNan());
bool InterpretBuiltin(InterpState &S, CodePtr OpPC, const Function *F,
   case Builtin::BI__builtin_fmaxf:
   case Builtin::BI__builtin_fmaxl:
   case Builtin::BI__builtin_fmaxf16:
   case Builtin::BI__builtin_fmaxf128:
     if (interp__builtin_fmax(S, OpPC, Frame, F))
       return Ret<PT_Float>(S, OpPC, Dummy);
     break;
 
+  case Builtin::BI__builtin_fminimum:
+  case Builtin::BI__builtin_fminimumf:
+  case Builtin::BI__builtin_fminimuml:
+  case Builtin::BI__builtin_fminimumf16:
+  case Builtin::BI__builtin_fminimumbf16:
+  case Builtin::BI__builtin_fminimumf128:
+    if (interp__builtin_fminimum(S, OpPC, Frame, F))
+      return Ret<PT_Float>(S, OpPC, Dummy);
+    break;
+
+  case Builtin::BI__builtin_fmaximum:
+  case Builtin::BI__builtin_fmaximumf:
+  case Builtin::BI__builtin_fmaximuml:
+  case Builtin::BI__builtin_fmaximumf16:
+  case Builtin::BI__builtin_fmaximumbf16:
+  case Builtin::BI__builtin_fmaximumf128:
+    if (interp__builtin_fmaximum(S, OpPC, Frame, F))
+      return Ret<PT_Float>(S, OpPC, Dummy);
+    break;
+
   case Builtin::BI__builtin_isnan:
     if (interp__builtin_isnan(S, OpPC, Frame, F))
       return retInt(S, OpPC, Dummy);
     break;
 
   case Builtin::BI__builtin_isinf:
     if (interp__builtin_isinf(S, OpPC, Frame, F, /*Sign=*/false))
       return retInt(S, OpPC, Dummy);

clang/lib/CodeGen/CGBuiltin.cpp

if (FD->hasAttr<ConstAttr>() ||
     case Builtin::BI__builtin_fminf:
     case Builtin::BI__builtin_fminf16:
     case Builtin::BI__builtin_fminl:
     case Builtin::BI__builtin_fminf128:
       return RValue::get(emitBinaryMaybeConstrainedFPBuiltin(*this, E,
                                    Intrinsic::minnum,
                                    Intrinsic::experimental_constrained_minnum));
 
+    case Builtin::BI__builtin_fmaximum:
+    case Builtin::BI__builtin_fmaximumf:
+    case Builtin::BI__builtin_fmaximumf16:
+    case Builtin::BI__builtin_fmaximumbf16:
+    case Builtin::BI__builtin_fmaximuml:
+    case Builtin::BI__builtin_fmaximumf128:
+      return RValue::get(emitBinaryMaybeConstrainedFPBuiltin(*this, E,
+                                   Intrinsic::maximum,
+                                   Intrinsic::experimental_constrained_maximum));
+
+    case Builtin::BI__builtin_fminimum:
+    case Builtin::BI__builtin_fminimumf:
+    case Builtin::BI__builtin_fminimumf16:
+    case Builtin::BI__builtin_fminimumbf16:
+    case Builtin::BI__builtin_fminimuml:
+    case Builtin::BI__builtin_fminimumf128:
+      return RValue::get(emitBinaryMaybeConstrainedFPBuiltin(*this, E,
+                                   Intrinsic::minimum,
+                                   Intrinsic::experimental_constrained_minimum));
+
     // fmod() is a special-case. It maps to the frem instruction rather than an
     // LLVM intrinsic.
     case Builtin::BIfmod:
     case Builtin::BIfmodf:
     case Builtin::BIfmodl:
     case Builtin::BI__builtin_fmod:
     case Builtin::BI__builtin_fmodf:
     case Builtin::BI__builtin_fmodf16:

clang/test/CodeGen/builtins.c

-// RUN: %clang_cc1 -emit-llvm -o %t %s
+// RUN: %clang_cc1 -emit-llvm -o %t %s -Wno-format
 // RUN: not grep __builtin %t
-// RUN: %clang_cc1 -emit-llvm -triple x86_64-darwin-apple -o - %s | FileCheck %s
+// RUN: %clang_cc1 -emit-llvm -triple x86_64-darwin-apple -o - %s -Wno-format | FileCheck %s
 
 int printf(const char *, ...);
 
 void p(char *str, int x) {
   printf("%s: %d\n", str, x);
 }
 void q(char *str, double x) {
   printf("%s: %f\n", str, x);
void test_float_builtins(__fp16 *H, float F, double D, long double LD) {
   // CHECK: zext i1 [[TMP]] to i32
 
   res = __builtin_flt_rounds();
   // CHECK: call i32 @llvm.get.rounding(
 }
 
 // CHECK-LABEL: define{{.*}} void @test_float_builtin_ops
 void test_float_builtin_ops(float F, double D, long double LD) {
+  volatile __fp16 resf16 = F;
+  volatile __bf16 resbf16 = F;
   volatile float resf;
   volatile double resd;
   volatile long double resld;
   volatile long int resli;
   volatile long long int reslli;
 
   resf = __builtin_fmodf(F,F);
   // CHECK: frem float
void test_float_builtin_ops(float F, double D, long double LD) {
   // CHECK: call float @llvm.maxnum.f32
 
   resd = __builtin_fmax(D, D);
   // CHECK: call double @llvm.maxnum.f64
 
   resld = __builtin_fmaxl(LD, LD);
   // CHECK: call x86_fp80 @llvm.maxnum.f80
 
+  resf16 = __builtin_fminimumf16(F, F);
+  // CHECK: call half @llvm.minimum.f16
+
+  resbf16 = __builtin_fminimumbf16(F, F);
+  // CHECK: call bfloat @llvm.minimum.bf16
+
+  resf = __builtin_fminimumf(F, F);
+  // CHECK: call float @llvm.minimum.f32
+
+  resd = __builtin_fminimum(D, D);
+  // CHECK: call double @llvm.minimum.f64
+
+  resld = __builtin_fminimuml(LD, LD);
+  // CHECK: call x86_fp80 @llvm.minimum.f80
+
+  resf16 = __builtin_fmaximumf16(F, F);
+  // CHECK: call half @llvm.maximum.f16
+
+  resbf16 = __builtin_fmaximumbf16(F, F);
+  // CHECK: call bfloat @llvm.maximum.bf16
+
+  resf = __builtin_fmaximumf(F, F);
+  // CHECK: call float @llvm.maximum.f32
+
+  resd = __builtin_fmaximum(D, D);
+  // CHECK: call double @llvm.maximum.f64
+
+  resld = __builtin_fmaximuml(LD, LD);
+  // CHECK: call x86_fp80 @llvm.maximum.f80
+
   resf = __builtin_fabsf(F);
   // CHECK: call float @llvm.fabs.f32
 
   resd = __builtin_fabs(D);
   // CHECK: call double @llvm.fabs.f64
 
   resld = __builtin_fabsl(LD);
   // CHECK: call x86_fp80 @llvm.fabs.f80
void test_float_builtin_ops(float F, double D, long double LD) {
   resf = __builtin_roundevenf(F);
   // CHECK: call float @llvm.roundeven.f32
 
   resd = __builtin_roundeven(D);
   // CHECK: call double @llvm.roundeven.f64
 
   resld = __builtin_roundevenl(LD);
   // CHECK: call x86_fp80 @llvm.roundeven.f80
-  
   resli = __builtin_lroundf (F);
   // CHECK: call i64 @llvm.lround.i64.f32
 
   resli = __builtin_lround (D);
   // CHECK: call i64 @llvm.lround.i64.f64
 
   resli = __builtin_lroundl (LD);
   // CHECK: call i64 @llvm.lround.i64.f80

clang/test/CodeGen/math-builtins.c

 // NO__ERRNO: declare float @llvm.minnum.f32(float, float) [[READNONE_INTRINSIC]]
 // NO__ERRNO: declare x86_fp80 @llvm.minnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]]
 // NO__ERRNO: declare fp128 @llvm.minnum.f128(fp128, fp128) [[READNONE_INTRINSIC]]
 // HAS_ERRNO: declare double @llvm.minnum.f64(double, double) [[READNONE_INTRINSIC]]
 // HAS_ERRNO: declare float @llvm.minnum.f32(float, float) [[READNONE_INTRINSIC]]
 // HAS_ERRNO: declare x86_fp80 @llvm.minnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]]
 // HAS_ERRNO: declare fp128 @llvm.minnum.f128(fp128, fp128) [[READNONE_INTRINSIC]]
 
+__builtin_fmaximum(f,f);       __builtin_fmaximumf(f,f);      __builtin_fmaximuml(f,f);
+__builtin_fmaximumf128(f,f);   __builtin_fmaximumf16(f,f);    __builtin_fmaximumbf16(f,f);
+// NO__ERRNO: declare double @llvm.maximum.f64(double, double) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare float @llvm.maximum.f32(float, float) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare x86_fp80 @llvm.maximum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare fp128 @llvm.maximum.f128(fp128, fp128) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare half @llvm.maximum.f16(half, half) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare bfloat @llvm.maximum.bf16(bfloat, bfloat) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare double @llvm.maximum.f64(double, double) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare float @llvm.maximum.f32(float, float) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare x86_fp80 @llvm.maximum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare fp128 @llvm.maximum.f128(fp128, fp128) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare half @llvm.maximum.f16(half, half) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare bfloat @llvm.maximum.bf16(bfloat, bfloat) [[READNONE_INTRINSIC]]
+
+__builtin_fminimum(f,f);       __builtin_fminimumf(f,f);      __builtin_fminimuml(f,f);
+__builtin_fminimumf128(f,f);   __builtin_fminimumf16(f,f);    __builtin_fminimumbf16(f,f);
+
+// NO__ERRNO: declare double @llvm.minimum.f64(double, double) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare float @llvm.minimum.f32(float, float) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare x86_fp80 @llvm.minimum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare fp128 @llvm.minimum.f128(fp128, fp128) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare half @llvm.minimum.f16(half, half) [[READNONE_INTRINSIC]]
+// NO__ERRNO: declare bfloat @llvm.minimum.bf16(bfloat, bfloat) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare double @llvm.minimum.f64(double, double) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare float @llvm.minimum.f32(float, float) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare x86_fp80 @llvm.minimum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare fp128 @llvm.minimum.f128(fp128, fp128) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare half @llvm.minimum.f16(half, half) [[READNONE_INTRINSIC]]
+// HAS_ERRNO: declare bfloat @llvm.minimum.bf16(bfloat, bfloat) [[READNONE_INTRINSIC]]
+
 __builtin_hypot(f,f);      __builtin_hypotf(f,f);     __builtin_hypotl(f,f); __builtin_hypotf128(f,f);
 
 // NO__ERRNO: declare double @hypot(double noundef, double noundef) [[READNONE]]
 // NO__ERRNO: declare float @hypotf(float noundef, float noundef) [[READNONE]]
 // NO__ERRNO: declare x86_fp80 @hypotl(x86_fp80 noundef, x86_fp80 noundef) [[READNONE]]
 // NO__ERRNO: declare fp128 @hypotf128(fp128 noundef, fp128 noundef) [[READNONE]]
 // HAS_ERRNO: declare double @hypot(double noundef, double noundef) [[NOT_READNONE]]
 // HAS_ERRNO: declare float @hypotf(float noundef, float noundef) [[NOT_READNONE]]

clang/test/Sema/constant-builtins-fmaximum.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -verify -fexperimental-new-constant-interpreter %s
+// expected-no-diagnostics
+
+constexpr double NaN = __builtin_nan("");
+constexpr double Inf = __builtin_inf();
+constexpr double NegInf = -__builtin_inf();
+
+#define FMAX_TEST_SIMPLE(T, FUNC)                                              \
+  static_assert(T(6.7890) == FUNC(T(1.2345), T(6.7890)));                      \
+  static_assert(T(6.7890) == FUNC(T(6.7890), T(1.2345)));
+
+#define FMAX_TEST_NAN(T, FUNC)                                                 \
+  static_assert(__builtin_isnan(FUNC(NaN, Inf)));                              \
+  static_assert(__builtin_isnan(FUNC(NegInf, NaN)));                           \
+  static_assert(__builtin_isnan(FUNC(NaN, 0.0)));                              \
+  static_assert(__builtin_isnan(FUNC(-0.0, NaN)));                             \
+  static_assert(__builtin_isnan(FUNC(NaN, T(-1.2345))));                       \
+  static_assert(__builtin_isnan(FUNC(T(1.2345), NaN)));                        \
+  static_assert(__builtin_isnan(FUNC(NaN, NaN)));
+
+#define FMAX_TEST_INF(T, FUNC)                                                 \
+  static_assert(Inf == FUNC(NegInf, Inf));                                     \
+  static_assert(Inf == FUNC(Inf, 0.0));                                        \
+  static_assert(Inf == FUNC(-0.0, Inf));                                       \
+  static_assert(Inf == FUNC(Inf, T(1.2345)));                                  \
+  static_assert(Inf == FUNC(T(-1.2345), Inf));
+
+#define FMAX_TEST_NEG_INF(T, FUNC)                                             \
+  static_assert(Inf == FUNC(Inf, NegInf));                                     \
+  static_assert(0.0 == FUNC(NegInf, 0.0));                                     \
+  static_assert(-0.0 == FUNC(-0.0, NegInf));                                   \
+  static_assert(T(-1.2345) == FUNC(NegInf, T(-1.2345)));                       \
+  static_assert(T(1.2345) == FUNC(T(1.2345), NegInf));
+
+#define FMAX_TEST_BOTH_ZERO(T, FUNC)                                           \
+  static_assert(__builtin_copysign(1.0, FUNC(0.0, 0.0)) == 1.0);               \
+  static_assert(__builtin_copysign(1.0, FUNC(-0.0, 0.0)) == 1.0);              \
+  static_assert(__builtin_copysign(1.0, FUNC(0.0, -0.0)) == 1.0);              \
+  static_assert(__builtin_copysign(1.0, FUNC(-0.0, -0.0)) == -1.0);
+
+#define LIST_FMAX_TESTS(T, FUNC)                                               \
+  FMAX_TEST_SIMPLE(T, FUNC)                                                    \
+  FMAX_TEST_NAN(T, FUNC)                                                       \
+  FMAX_TEST_INF(T, FUNC)                                                       \
+  FMAX_TEST_NEG_INF(T, FUNC)                                                   \
+  FMAX_TEST_BOTH_ZERO(T, FUNC)
+
+LIST_FMAX_TESTS(double, __builtin_fmaximum)
+LIST_FMAX_TESTS(float, __builtin_fmaximumf)
+LIST_FMAX_TESTS((long double), __builtin_fmaximuml)
+LIST_FMAX_TESTS(__fp16, __builtin_fmaximumf16)
+LIST_FMAX_TESTS(__bf16, __builtin_fmaximumbf16)
+#ifdef __FLOAT128__
+LIST_FMAX_TESTS(__float128, __builtin_fmaximumf128)
+#endif

clang/test/Sema/constant-builtins-fminimum.cpp

+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++17 -fsyntax-only -verify -fexperimental-new-constant-interpreter %s
+// expected-no-diagnostics
+
+constexpr double NaN = __builtin_nan("");
+constexpr double Inf = __builtin_inf();
+constexpr double NegInf = -__builtin_inf();
+
+#define FMIN_TEST_SIMPLE(T, FUNC)                                              \
+  static_assert(T(1.2345) == FUNC(T(1.2345), T(6.7890)));                      \
+  static_assert(T(1.2345) == FUNC(T(6.7890), T(1.2345)));
+
+#define FMIN_TEST_NAN(T, FUNC)                                                 \
+  static_assert(__builtin_isnan(FUNC(NaN, Inf)));                              \
+  static_assert(__builtin_isnan(FUNC(NegInf, NaN)));                           \
+  static_assert(__builtin_isnan(FUNC(NaN, 0.0)));                              \
+  static_assert(__builtin_isnan(FUNC(-0.0, NaN)));                             \
+  static_assert(__builtin_isnan(FUNC(NaN, T(-1.2345))));                       \
+  static_assert(__builtin_isnan(FUNC(T(1.2345), NaN)));                        \
+  static_assert(__builtin_isnan(FUNC(NaN, NaN)));
+
+#define FMIN_TEST_INF(T, FUNC)                                                 \
+  static_assert(NegInf == FUNC(NegInf, Inf));                                  \
+  static_assert(0.0 == FUNC(Inf, 0.0));                                        \
+  static_assert(-0.0 == FUNC(-0.0, Inf));                                      \
+  static_assert(T(1.2345) == FUNC(Inf, T(1.2345)));                            \
+  static_assert(T(-1.2345) == FUNC(T(-1.2345), Inf));
+
+#define FMIN_TEST_NEG_INF(T, FUNC)                                             \
+  static_assert(NegInf == FUNC(Inf, NegInf));                                  \
+  static_assert(NegInf == FUNC(NegInf, 0.0));                                  \
+  static_assert(NegInf == FUNC(-0.0, NegInf));                                 \
+  static_assert(NegInf == FUNC(NegInf, T(-1.2345)));                           \
+  static_assert(NegInf == FUNC(T(1.2345), NegInf));
+
+#define FMIN_TEST_BOTH_ZERO(T, FUNC)                                           \
+  static_assert(__builtin_copysign(1.0, FUNC(0.0, 0.0)) == 1.0);               \
+  static_assert(__builtin_copysign(1.0, FUNC(-0.0, 0.0)) == -1.0);             \
+  static_assert(__builtin_copysign(1.0, FUNC(0.0, -0.0)) == -1.0);             \
+  static_assert(__builtin_copysign(1.0, FUNC(-0.0, -0.0)) == -1.0);
+
+#define LIST_FMIN_TESTS(T, FUNC)                                               \
+  FMIN_TEST_SIMPLE(T, FUNC)                                                    \
+  FMIN_TEST_NAN(T, FUNC)                                                       \
+  FMIN_TEST_INF(T, FUNC)                                                       \
+  FMIN_TEST_NEG_INF(T, FUNC)                                                   \
+  FMIN_TEST_BOTH_ZERO(T, FUNC)
+
+LIST_FMIN_TESTS(double, __builtin_fminimum)
+LIST_FMIN_TESTS(float, __builtin_fminimumf)
+LIST_FMIN_TESTS((long double), __builtin_fminimuml)
+LIST_FMIN_TESTS(__fp16, __builtin_fminimumf16)
+LIST_FMIN_TESTS(__bf16, __builtin_fminimumbf16)
+#ifdef __FLOAT128__
+LIST_FMIN_TESTS(__float128, __builtin_fminimumf128)
+#endif

clang/test/Sema/overloaded-math-builtins.c

float test_fminf(float f, int i, int *ptr, float4 v) {
 
 
   int *r5 = __builtin_fminf(f, f);
   // expected-error@-1 {{initializing 'int *' with an expression of incompatible type 'float'}}
 
   int *r6 = __builtin_fminf(f, v);
   // expected-error@-1 {{passing 'float4' (vector of 4 'float' values) to parameter of incompatible type 'float'}}
 }
+
+float test_fminimumf(float f, int i, int *ptr, float4 v) {
+  float r1 = __builtin_fminimumf(f, ptr);
+  // expected-error@-1 {{passing 'int *' to parameter of incompatible type 'float'}}
+  float r2 = __builtin_fminimumf(ptr, f);
+  // expected-error@-1 {{passing 'int *' to parameter of incompatible type 'float'}}
+  float r3 = __builtin_fminimumf(v, f);
+  // expected-error@-1 {{passing 'float4' (vector of 4 'float' values) to parameter of incompatible type 'float'}}
+  float r4 = __builtin_fminimumf(f, v);
+  // expected-error@-1 {{passing 'float4' (vector of 4 'float' values) to parameter of incompatible type 'float'}}
+
+
+  int *r5 = __builtin_fminimumf(f, f);
+  // expected-error@-1 {{initializing 'int *' with an expression of incompatible type 'float'}}
+
+  int *r6 = __builtin_fminimumf(f, v);
+  // expected-error@-1 {{passing 'float4' (vector of 4 'float' values) to parameter of incompatible type 'float'}}
+}