[PowerPC] Add max/min intrinsics to Clang and PPC backend

[tingwang]

Summary

Add support for builtin_[max|min] which has below prototype:
A builtin_max (A1, A2, A3, ...)
All arguments must have the same type; they must all be float, double, or long double.

Internally use SelectCC to get the result.

[tingwang]

Since this is compatibility support, I'm trying to match the result from XLC in scenarios where there is all kinds of QNaN, SNaN, +/-Infinity, +/-ZERO. Currently maxfl and maxfs still give different result compared with XLC in above scenario. This is one thing I'm still looking into.

[tingwang]

Option -mlong-double-128 is not supported on AIX currently, and clang fails due to type mismatch in the fe case. Add check logic to print diag message in this case.

[qiucf]

clang/include/clang/Basic/DiagnosticSemaKinds.td

9899 ↗

(On Diff #418485)

Can we re-use err_typecheck_convert_incompatible?

clang/lib/CodeGen/CGBuiltin.cpp

16305–16325

clang/lib/Sema/SemaChecking.cpp

3913

I think we don't need this fixme.

clang/test/CodeGen/PowerPC/builtins-ppc.c

65

Don't break CHECK lines.

clang/test/Sema/builtins-ppc.c

13–17

63–83

I don't know if it's convention in tests, but looks simpler.

llvm/include/llvm/IR/IntrinsicsPowerPC.td

192

Will we support llvm_f128_ty?

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

10572–10576

We can make it even simpler.

10583

We don't need to mention old behavior.

10584–10585

10587–10591

I don't think we need to manually call LowerSELECT_CC here. SelectionDAG knows ppc_fp128 should not be custom lowered.

This also makes the case pass. Thus D122462 is not needed.

11251

Why only two fe?

llvm/test/CodeGen/PowerPC/builtins-ppc-xlcompat-maxmin.ll

3

Can we add pwr8 run line?

[tingwang]

Update test case to show that we need D122462 to fix the crash.

[tingwang]

Update based on Chaofan's suggestions.

llvm/include/llvm/IR/IntrinsicsPowerPC.td

192

I'm afraid not at this moment. Document mentions only three types: float, double, or long double.

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

10587–10591

Thank you for pointing out this. Verified LowerSELECT_CC is not required here. This was added due to misconception.

11251

This is only for ppcf128 during type legalization: DAGTypeLegalizer::ExpandFloatResult -> CustomLowerNode -> PPCTargetLowering::ReplaceNodeResults. The other cases seem not hitting here. I will double check the code path to verify.

[qiucf]

clang/include/clang/Basic/DiagnosticSemaKinds.td

9897 ↗

(On Diff #418544)

Use err_target_unsupported_type?

llvm/include/llvm/IR/IntrinsicsPowerPC.td

192

Can we at least leave a TODO comment here for llvm_f128_ty support?

[tingwang]

Update based on comments:
(1) Reuse diag error message.
(2) Update clang test case for those diag messages.
(3) Add TODO comment.

[tingwang]

clang/include/clang/Basic/DiagnosticSemaKinds.td

9897 ↗

(On Diff #418544)

Thanks again for pointing it out!

[qiucf]

Looks good to me in my side. Thanks for implementing it.

clang/include/clang/Basic/BuiltinsPPC.def

 BUILTIN(__builtin_ppc_dcbtt, "vv*", "")
 BUILTIN(__builtin_ppc_mftbu, "Ui","")
 BUILTIN(__builtin_ppc_mfmsr, "Ui", "")
 BUILTIN(__builtin_ppc_mfspr, "ULiIi", "")
 BUILTIN(__builtin_ppc_mtmsr, "vUi", "")
 BUILTIN(__builtin_ppc_mtspr, "vIiULi", "")
 BUILTIN(__builtin_ppc_stfiw, "viC*d", "")
 BUILTIN(__builtin_ppc_addex, "LLiLLiLLiCIi", "")
+// select
+BUILTIN(__builtin_ppc_maxfe, "LdLdLdLd.", "t")
+BUILTIN(__builtin_ppc_maxfl, "dddd.", "t")
+BUILTIN(__builtin_ppc_maxfs, "ffff.", "t")
+BUILTIN(__builtin_ppc_minfe, "LdLdLdLd.", "t")
+BUILTIN(__builtin_ppc_minfl, "dddd.", "t")
+BUILTIN(__builtin_ppc_minfs, "ffff.", "t")
 
 BUILTIN(__builtin_ppc_get_timebase, "ULLi", "n")
 
 // This is just a placeholder, the types and attributes are wrong.
 BUILTIN(__builtin_altivec_vaddcuw, "V4UiV4UiV4Ui", "")
 
 BUILTIN(__builtin_altivec_vaddsbs, "V16ScV16ScV16Sc", "")
 BUILTIN(__builtin_altivec_vaddubs, "V16UcV16UcV16Uc", "")

clang/lib/Basic/Targets/PPC.cpp

static void defineXLCompatMacros(MacroBuilder &Builder) {
   Builder.defineMacro("__cmplxl", "__builtin_complex");
   Builder.defineMacro("__compare_exp_uo", "__builtin_ppc_compare_exp_uo");
   Builder.defineMacro("__compare_exp_lt", "__builtin_ppc_compare_exp_lt");
   Builder.defineMacro("__compare_exp_gt", "__builtin_ppc_compare_exp_gt");
   Builder.defineMacro("__compare_exp_eq", "__builtin_ppc_compare_exp_eq");
   Builder.defineMacro("__test_data_class", "__builtin_ppc_test_data_class");
   Builder.defineMacro("__swdiv", "__builtin_ppc_swdiv");
   Builder.defineMacro("__swdivs", "__builtin_ppc_swdivs");
+  Builder.defineMacro("__builtin_maxfe", "__builtin_ppc_maxfe");
+  Builder.defineMacro("__builtin_maxfl", "__builtin_ppc_maxfl");
+  Builder.defineMacro("__builtin_maxfs", "__builtin_ppc_maxfs");
+  Builder.defineMacro("__builtin_minfe", "__builtin_ppc_minfe");
+  Builder.defineMacro("__builtin_minfl", "__builtin_ppc_minfl");
+  Builder.defineMacro("__builtin_minfs", "__builtin_ppc_minfs");
 }
 
 /// PPCTargetInfo::getTargetDefines - Return a set of the PowerPC-specific
 /// #defines that are not tied to a specific subtarget.
 void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
                                      MacroBuilder &Builder) const {
 
   // We define the XLC compatibility macros only on AIX and Linux since XLC

clang/lib/CodeGen/CGBuiltin.cpp

if (ArgType->isDoubleTy())
       IntrinsicID = Intrinsic::ppc_test_data_class_d;
     else if (ArgType->isFloatTy())
       IntrinsicID = Intrinsic::ppc_test_data_class_f;
     else
       llvm_unreachable("Invalid Argument Type");
     return Builder.CreateCall(CGM.getIntrinsic(IntrinsicID), Ops,
                               "test_data_class");
   }
+  case PPC::BI__builtin_ppc_maxfe:
+    return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::ppc_maxfe), Ops);
+  case PPC::BI__builtin_ppc_maxfl:
+    return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::ppc_maxfl), Ops);
+  case PPC::BI__builtin_ppc_maxfs:
+    return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::ppc_maxfs), Ops);
+  case PPC::BI__builtin_ppc_minfe:
+    return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::ppc_minfe), Ops);
+  case PPC::BI__builtin_ppc_minfl:
+    return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::ppc_minfl), Ops);
+  case PPC::BI__builtin_ppc_minfs:
+    return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::ppc_minfs), Ops);
   case PPC::BI__builtin_ppc_swdiv:
   case PPC::BI__builtin_ppc_swdivs:
     return Builder.CreateFDiv(Ops[0], Ops[1], "swdiv");
   }
 }
 
 namespace {
 // If \p E is not null pointer, insert address space cast to match return
 // type of \p E if necessary.
 Value *EmitAMDGPUDispatchPtr(CodeGenFunction &CGF,
                              const CallExpr *E = nullptr) {
   auto *F = CGF.CGM.getIntrinsic(Intrinsic::amdgcn_dispatch_ptr);
   auto *Call = CGF.Builder.CreateCall(F);
   Call->addRetAttr(
       Attribute::getWithDereferenceableBytes(Call->getContext(), 64));
   Call->addRetAttr(Attribute::getWithAlignment(Call->getContext(), Align(4)));
   if (!E)

clang/lib/Sema/SemaChecking.cpp

if (ArgType != QualType(Context.FloatTy) &&
       return Diag(TheCall->getBeginLoc(),
                   diag::err_ppc_invalid_test_data_class_type);
     return SemaFeatureCheck(*this, TheCall, "isa-v30-instructions",
                             diag::err_ppc_builtin_only_on_arch, "9") ||
            SemaFeatureCheck(*this, TheCall, "vsx",
                             diag::err_ppc_builtin_requires_vsx) ||
            SemaBuiltinConstantArgRange(TheCall, 1, 0, 127);
   }
+  case PPC::BI__builtin_ppc_maxfe:
+  case PPC::BI__builtin_ppc_minfe:
+  case PPC::BI__builtin_ppc_maxfl:
+  case PPC::BI__builtin_ppc_minfl:
+  case PPC::BI__builtin_ppc_maxfs:
+  case PPC::BI__builtin_ppc_minfs: {
+    if (Context.getTargetInfo().getTriple().isOSAIX() &&
+        (BuiltinID == PPC::BI__builtin_ppc_maxfe ||
+         BuiltinID == PPC::BI__builtin_ppc_minfe))
+      return Diag(TheCall->getBeginLoc(), diag::err_target_unsupported_type)
+             << "builtin" << true << 128 << QualType(Context.LongDoubleTy)
+             << false << Context.getTargetInfo().getTriple().str();
+    // Argument type should be exact.
+    QualType ArgType = QualType(Context.LongDoubleTy);
+    if (BuiltinID == PPC::BI__builtin_ppc_maxfl ||
+        BuiltinID == PPC::BI__builtin_ppc_minfl)
+      ArgType = QualType(Context.DoubleTy);
+    else if (BuiltinID == PPC::BI__builtin_ppc_maxfs ||
+             BuiltinID == PPC::BI__builtin_ppc_minfs)
+      ArgType = QualType(Context.FloatTy);
+    for (unsigned I = 0, E = TheCall->getNumArgs(); I < E; ++I)
+      if (TheCall->getArg(I)->getType() != ArgType)
+        return Diag(TheCall->getBeginLoc(),
+                    diag::err_typecheck_convert_incompatible)
+               << TheCall->getArg(I)->getType() << ArgType << 1 << 0 << 0;
+    return false;
+  }
   case PPC::BI__builtin_ppc_load8r:
   case PPC::BI__builtin_ppc_store8r:
     return SemaFeatureCheck(*this, TheCall, "isa-v206-instructions",
                             diag::err_ppc_builtin_only_on_arch, "7");
 #define CUSTOM_BUILTIN(Name, Intr, Types, Acc)                                 \
   case PPC::BI__builtin_##Name:                                                \
     return SemaBuiltinPPCMMACall(TheCall, BuiltinID, Types);
 #include "clang/Basic/BuiltinsPPC.def"

clang/test/CodeGen/PowerPC/builtins-ppc.c

double test_builtin_unpack_ldbl(long double x) {
   // CHECK: call double @llvm.ppc.unpack.longdouble(ppc_fp128 %0, i32 1)
   return __builtin_unpack_longdouble(x, 1);
 }
 
 long double test_builtin_pack_ldbl(double x, double y) {
   // CHECK: call ppc_fp128 @llvm.ppc.pack.longdouble(double %0, double %1)
   return __builtin_pack_longdouble(x, y);
 }
+
+void test_builtin_ppc_maxminfe(long double a, long double b, long double c,
+                               long double d) {
+  volatile long double res;
+  // CHECK: call ppc_fp128 (ppc_fp128, ppc_fp128, ppc_fp128, ...) @llvm.ppc.maxfe(ppc_fp128 %0, ppc_fp128 %1, ppc_fp128 %2, ppc_fp128 %3)
+  res = __builtin_ppc_maxfe(a, b, c, d);
+
+  // CHECK: call ppc_fp128 (ppc_fp128, ppc_fp128, ppc_fp128, ...) @llvm.ppc.minfe(ppc_fp128 %5, ppc_fp128 %6, ppc_fp128 %7, ppc_fp128 %8)
+  res = __builtin_ppc_minfe(a, b, c, d);
+}
+
+void test_builtin_ppc_maxminfl(double a, double b, double c, double d) {
+  volatile double res;
+  // CHECK: call double (double, double, double, ...) @llvm.ppc.maxfl(double %0, double %1, double %2, double %3)
+  res = __builtin_ppc_maxfl(a, b, c, d);
+
+  // CHECK: call double (double, double, double, ...) @llvm.ppc.minfl(double %5, double %6, double %7, double %8)
+  res = __builtin_ppc_minfl(a, b, c, d);
+}
+
+void test_builtin_ppc_maxminfs(float a, float b, float c, float d) {
+  volatile float res;
+  // CHECK: call float (float, float, float, ...) @llvm.ppc.maxfs(float %0, float %1, float %2, float %3)
+  res = __builtin_ppc_maxfs(a, b, c, d);
+
+  // CHECK: call float (float, float, float, ...) @llvm.ppc.minfs(float %5, float %6, float %7, float %8)
+  res = __builtin_ppc_minfs(a, b, c, d);
+}

clang/test/Sema/builtins-ppc.c

 // REQUIRES: powerpc-registered-target
 // RUN: %clang_cc1 -target-feature +altivec -target-feature +htm                       \
 // RUN: -triple powerpc64-unknown-unknown -DTEST_HTM -fsyntax-only      \
 // RUN: -verify %s
 
 // RUN: %clang_cc1 -target-feature +altivec -target-feature +crypto                    \
 // RUN: -triple powerpc64le-unknown-unknown -DTEST_CRYPTO -fsyntax-only      \
 // RUN: -verify %s
 // RUN: %clang_cc1 -target-feature +altivec -target-feature +crypto \
 // RUN: -triple powerpc64le-unknown-unknown -DTEST_CRYPTO -fsyntax-only \
 // RUN: -target-feature +vsx -verify %s
 
+// RUN: %clang_cc1 -triple powerpc64le-unknown-unknown -DTEST_MAXMIN -fsyntax-only \
+// RUN: -verify %s
+
+// RUN: %clang_cc1 -triple powerpc64-ibm-aix-xcoff -DTEST_MAXMIN -fsyntax-only \
+// RUN: -verify %s
+
 #ifdef TEST_HTM
 void test_htm() {
   __builtin_tbegin(4); // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_tend(-1);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_tsr(55);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_tabortwc(-5, 2, 3); // expected-error-re {{argument value {{.*}} is outside the valid range}} 
   __builtin_tabortdc(55, 2, 3); // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_tabortwci(-5, 2, 5); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vector unsigned long long test_vshasigmad_or(void)
   vector unsigned long long d = __builtin_crypto_vshasigmad(a, 0, 85);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
   vector unsigned long long e = __builtin_crypto_vshasigmad(a, 1, -15); // expected-error-re {{argument value {{.*}} is outside the valid range}}
   return __builtin_crypto_vshasigmad(a, 0, 15);
 }
 #endif
 
 #endif
 
+#ifdef TEST_MAXMIN
+void test_maxmin() {
+  long double fe;
+  double fl;
+  float fs;
+#ifdef _AIX
+  __builtin_ppc_maxfe(fe, fe, fe, fe); // expected-error-re {{builtin requires 128 bit size 'long double' type support, but target {{.*}} does not support it}}
+  __builtin_ppc_minfe(fe, fe, fe, fe); // expected-error-re {{builtin requires 128 bit size 'long double' type support, but target {{.*}} does not support it}}
+  __builtin_ppc_maxfl(fs, fs, fs, fs); // expected-error-re {{passing {{.*}} to parameter of incompatible type {{.*}}}}
+  __builtin_ppc_minfl(fs, fs, fs, fs); // expected-error-re {{passing {{.*}} to parameter of incompatible type {{.*}}}}
+  __builtin_ppc_maxfs(fe, fe, fe, fe); // expected-error-re {{passing {{.*}} to parameter of incompatible type {{.*}}}}
+  __builtin_ppc_minfs(fe, fe, fe, fe); // expected-error-re {{passing {{.*}} to parameter of incompatible type {{.*}}}}
+#else
+  __builtin_ppc_maxfe(fl, fl, fl, fl); // expected-error-re {{passing {{.*}} to parameter of incompatible type {{.*}}}}
+  __builtin_ppc_minfe(fl, fl, fl, fl); // expected-error-re {{passing {{.*}} to parameter of incompatible type {{.*}}}}
+  __builtin_ppc_maxfl(fs, fs, fs, fs); // expected-error-re {{passing {{.*}} to parameter of incompatible type {{.*}}}}
+  __builtin_ppc_minfl(fs, fs, fs, fs); // expected-error-re {{passing {{.*}} to parameter of incompatible type {{.*}}}}
+  __builtin_ppc_maxfs(fe, fe, fe, fe); // expected-error-re {{passing {{.*}} to parameter of incompatible type {{.*}}}}
+  __builtin_ppc_minfs(fe, fe, fe, fe); // expected-error-re {{passing {{.*}} to parameter of incompatible type {{.*}}}}
+#endif
+}
+#endif

llvm/include/llvm/IR/IntrinsicsPowerPC.td

def int_ppc_fctiwz
       : GCCBuiltin<"__builtin_ppc_fctiwz">,
         Intrinsic <[llvm_double_ty], [llvm_double_ty], [IntrNoMem]>;
   def int_ppc_fctudz
       : GCCBuiltin<"__builtin_ppc_fctudz">,
         Intrinsic <[llvm_double_ty], [llvm_double_ty], [IntrNoMem]>;
   def int_ppc_fctuwz
       : GCCBuiltin<"__builtin_ppc_fctuwz">,
         Intrinsic <[llvm_double_ty], [llvm_double_ty], [IntrNoMem]>;
+
+  // XL compatible select functions
+  // TODO: Add llvm_f128_ty support.
+  def int_ppc_maxfe
+      : Intrinsic<
+            [llvm_ppcf128_ty],
+            [llvm_ppcf128_ty, llvm_ppcf128_ty, llvm_ppcf128_ty, llvm_vararg_ty],
+            [IntrNoMem]>;
+  def int_ppc_maxfl
+      : Intrinsic<
+            [llvm_double_ty],
+            [llvm_double_ty, llvm_double_ty, llvm_double_ty, llvm_vararg_ty],
+            [IntrNoMem]>;
+  def int_ppc_maxfs
+      : Intrinsic<[llvm_float_ty],
+                  [llvm_float_ty, llvm_float_ty, llvm_float_ty, llvm_vararg_ty],
+                  [IntrNoMem]>;
+  def int_ppc_minfe
+      : Intrinsic<
+            [llvm_ppcf128_ty],
+            [llvm_ppcf128_ty, llvm_ppcf128_ty, llvm_ppcf128_ty, llvm_vararg_ty],
+            [IntrNoMem]>;
+  def int_ppc_minfl
+      : Intrinsic<
+            [llvm_double_ty],
+            [llvm_double_ty, llvm_double_ty, llvm_double_ty, llvm_vararg_ty],
+            [IntrNoMem]>;
+  def int_ppc_minfs
+      : Intrinsic<[llvm_float_ty],
+                  [llvm_float_ty, llvm_float_ty, llvm_float_ty, llvm_vararg_ty],
+                  [IntrNoMem]>;
 }
 
 let TargetPrefix = "ppc" in {  // All PPC intrinsics start with "llvm.ppc.".
   /// PowerPC_Vec_Intrinsic - Base class for all altivec intrinsics.
   class PowerPC_Vec_Intrinsic<string GCCIntSuffix, list<LLVMType> ret_types,
                               list<LLVMType> param_types,
                               list<IntrinsicProperty> properties>
     : GCCBuiltin<!strconcat("__builtin_altivec_", GCCIntSuffix)>,

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

RTLIB::Libcall LC = IntrinsicID == Intrinsic::ppc_convert_ppcf128_to_f128
                             ? RTLIB::CONVERT_PPCF128_F128
                             : RTLIB::CONVERT_F128_PPCF128;
     MakeLibCallOptions CallOptions;
     std::pair<SDValue, SDValue> Result =
         makeLibCall(DAG, LC, Op.getValueType(), Op.getOperand(1), CallOptions,
                     dl, SDValue());
     return Result.first;
   }
+  case Intrinsic::ppc_maxfe:
+  case Intrinsic::ppc_maxfl:
+  case Intrinsic::ppc_maxfs:
+  case Intrinsic::ppc_minfe:
+  case Intrinsic::ppc_minfl:
+  case Intrinsic::ppc_minfs: {
+    EVT VT = Op.getValueType();
+    assert(
+        all_of(Op->ops().drop_front(4),
+               [VT](const SDUse &Use) { return Use.getValueType() == VT; }) &&
+        "ppc_[max|min]f[e|l|s] must have uniform type arguments");
+    ISD::CondCode CC = ISD::SETGT;
+    if (IntrinsicID == Intrinsic::ppc_minfe ||
+        IntrinsicID == Intrinsic::ppc_minfl ||
+        IntrinsicID == Intrinsic::ppc_minfs)
+      CC = ISD::SETLT;
+    unsigned I = Op.getNumOperands() - 2, Cnt = I;
+    SDValue Res = Op.getOperand(I);
+    for (--I; Cnt != 0; --Cnt, I = (--I == 0 ? (Op.getNumOperands() - 1) : I)) {
+      Res =
+          DAG.getSelectCC(dl, Res, Op.getOperand(I), Res, Op.getOperand(I), CC);
+    }
+    return Res;
+  }
   }
 
   // If this is a lowered altivec predicate compare, CompareOpc is set to the
   // opcode number of the comparison.
   int CompareOpc;
   bool isDot;
   if (!getVectorCompareInfo(Op, CompareOpc, isDot, Subtarget))
     return SDValue();    // Don't custom lower most intrinsics.
 
   // If this is a non-dot comparison, make the VCMP node and we are done.
case ISD::INTRINSIC_W_CHAIN: {
     break;
   }
   case ISD::INTRINSIC_WO_CHAIN: {
     switch (cast<ConstantSDNode>(N->getOperand(0))->getZExtValue()) {
     case Intrinsic::ppc_pack_longdouble:
       Results.push_back(DAG.getNode(ISD::BUILD_PAIR, dl, MVT::ppcf128,
                                     N->getOperand(2), N->getOperand(1)));
       break;
+    case Intrinsic::ppc_maxfe:
+    case Intrinsic::ppc_minfe:
     case Intrinsic::ppc_fnmsub:
     case Intrinsic::ppc_convert_f128_to_ppcf128:
       Results.push_back(LowerINTRINSIC_WO_CHAIN(SDValue(N, 0), DAG));
       break;
     }
     break;
   }
   case ISD::VAARG: {

llvm/test/CodeGen/PowerPC/builtins-ppc-xlcompat-maxmin.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc -mcpu=pwr9 -verify-machineinstrs -mtriple=powerpc64le-unknown-linux \
+; RUN:    < %s | FileCheck --check-prefixes=CHECK,CHECK-P9 %s
+; RUN: llc -mcpu=pwr8 -verify-machineinstrs -mtriple=powerpc64le-unknown-linux \
+; RUN:    < %s | FileCheck --check-prefixes=CHECK,CHECK-P8 %s
+
+declare ppc_fp128 @llvm.ppc.maxfe(ppc_fp128 %a, ppc_fp128 %b, ppc_fp128 %c, ...)
+define ppc_fp128 @test_maxfe(ppc_fp128 %a, ppc_fp128 %b, ppc_fp128 %c, ppc_fp128 %d) {
+; CHECK-LABEL: test_maxfe:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    fcmpu 0, 6, 4
+; CHECK-NEXT:    fcmpu 1, 5, 3
+; CHECK-NEXT:    crand 20, 6, 1
+; CHECK-NEXT:    cror 20, 5, 20
+; CHECK-NEXT:    bc 12, 20, .LBB0_2
+; CHECK-NEXT:  # %bb.1: # %entry
+; CHECK-NEXT:    fmr 6, 4
+; CHECK-NEXT:  .LBB0_2: # %entry
+; CHECK-NEXT:    fcmpu 0, 6, 2
+; CHECK-NEXT:    bc 12, 20, .LBB0_4
+; CHECK-NEXT:  # %bb.3: # %entry
+; CHECK-NEXT:    fmr 5, 3
+; CHECK-NEXT:  .LBB0_4: # %entry
+; CHECK-NEXT:    fcmpu 1, 5, 1
+; CHECK-NEXT:    crand 20, 6, 1
+; CHECK-NEXT:    cror 20, 5, 20
+; CHECK-NEXT:    bc 12, 20, .LBB0_6
+; CHECK-NEXT:  # %bb.5: # %entry
+; CHECK-NEXT:    fmr 6, 2
+; CHECK-NEXT:  .LBB0_6: # %entry
+; CHECK-NEXT:    fcmpu 0, 6, 8
+; CHECK-NEXT:    bc 12, 20, .LBB0_8
+; CHECK-NEXT:  # %bb.7: # %entry
+; CHECK-NEXT:    fmr 5, 1
+; CHECK-NEXT:  .LBB0_8: # %entry
+; CHECK-NEXT:    fcmpu 1, 5, 7
+; CHECK-NEXT:    crand 20, 6, 1
+; CHECK-NEXT:    cror 20, 5, 20
+; CHECK-NEXT:    bc 12, 20, .LBB0_10
+; CHECK-NEXT:  # %bb.9: # %entry
+; CHECK-NEXT:    fmr 5, 7
+; CHECK-NEXT:  .LBB0_10: # %entry
+; CHECK-NEXT:    bc 12, 20, .LBB0_12
+; CHECK-NEXT:  # %bb.11: # %entry
+; CHECK-NEXT:    fmr 6, 8
+; CHECK-NEXT:  .LBB0_12: # %entry
+; CHECK-NEXT:    fmr 1, 5
+; CHECK-NEXT:    fmr 2, 6
+; CHECK-NEXT:    blr
+entry:
+  %0 = call ppc_fp128 (ppc_fp128, ppc_fp128, ppc_fp128, ...) @llvm.ppc.maxfe(ppc_fp128 %a, ppc_fp128 %b, ppc_fp128 %c, ppc_fp128 %d)
+  ret ppc_fp128 %0
+}
+
+declare double @llvm.ppc.maxfl(double %a, double %b, double %c, ...)
+define double @test_maxfl(double %a, double %b, double %c, double %d) {
+; CHECK-P9-LABEL: test_maxfl:
+; CHECK-P9:       # %bb.0: # %entry
+; CHECK-P9-NEXT:    xsmaxcdp 0, 3, 2
+; CHECK-P9-NEXT:    xsmaxcdp 0, 0, 1
+; CHECK-P9-NEXT:    xsmaxcdp 1, 0, 4
+; CHECK-P9-NEXT:    blr
+;
+; CHECK-P8-LABEL: test_maxfl:
+; CHECK-P8:       # %bb.0: # %entry
+; CHECK-P8-NEXT:    xscmpudp 0, 3, 2
+; CHECK-P8-NEXT:    ble 0, .LBB1_4
+; CHECK-P8-NEXT:  # %bb.1: # %entry
+; CHECK-P8-NEXT:    xscmpudp 0, 3, 1
+; CHECK-P8-NEXT:    ble 0, .LBB1_5
+; CHECK-P8-NEXT:  .LBB1_2: # %entry
+; CHECK-P8-NEXT:    xscmpudp 0, 3, 4
+; CHECK-P8-NEXT:    ble 0, .LBB1_6
+; CHECK-P8-NEXT:  .LBB1_3: # %entry
+; CHECK-P8-NEXT:    fmr 1, 3
+; CHECK-P8-NEXT:    blr
+; CHECK-P8-NEXT:  .LBB1_4: # %entry
+; CHECK-P8-NEXT:    fmr 3, 2
+; CHECK-P8-NEXT:    xscmpudp 0, 3, 1
+; CHECK-P8-NEXT:    bgt 0, .LBB1_2
+; CHECK-P8-NEXT:  .LBB1_5: # %entry
+; CHECK-P8-NEXT:    fmr 3, 1
+; CHECK-P8-NEXT:    xscmpudp 0, 3, 4
+; CHECK-P8-NEXT:    bgt 0, .LBB1_3
+; CHECK-P8-NEXT:  .LBB1_6: # %entry
+; CHECK-P8-NEXT:    fmr 3, 4
+; CHECK-P8-NEXT:    fmr 1, 3
+; CHECK-P8-NEXT:    blr
+entry:
+  %0 = call double (double, double, double, ...) @llvm.ppc.maxfl(double %a, double %b, double %c, double %d)
+  ret double %0
+}
+
+declare float @llvm.ppc.maxfs(float %a, float %b, float %c, ...)
+define float @test_maxfs(float %a, float %b, float %c, float %d) {
+; CHECK-P9-LABEL: test_maxfs:
+; CHECK-P9:       # %bb.0: # %entry
+; CHECK-P9-NEXT:    xsmaxcdp 0, 3, 2
+; CHECK-P9-NEXT:    xsmaxcdp 0, 0, 1
+; CHECK-P9-NEXT:    xsmaxcdp 1, 0, 4
+; CHECK-P9-NEXT:    blr
+;
+; CHECK-P8-LABEL: test_maxfs:
+; CHECK-P8:       # %bb.0: # %entry
+; CHECK-P8-NEXT:    fcmpu 0, 3, 2
+; CHECK-P8-NEXT:    ble 0, .LBB2_4
+; CHECK-P8-NEXT:  # %bb.1: # %entry
+; CHECK-P8-NEXT:    fcmpu 0, 3, 1
+; CHECK-P8-NEXT:    ble 0, .LBB2_5
+; CHECK-P8-NEXT:  .LBB2_2: # %entry
+; CHECK-P8-NEXT:    fcmpu 0, 3, 4
+; CHECK-P8-NEXT:    ble 0, .LBB2_6
+; CHECK-P8-NEXT:  .LBB2_3: # %entry
+; CHECK-P8-NEXT:    fmr 1, 3
+; CHECK-P8-NEXT:    blr
+; CHECK-P8-NEXT:  .LBB2_4: # %entry
+; CHECK-P8-NEXT:    fmr 3, 2
+; CHECK-P8-NEXT:    fcmpu 0, 3, 1
+; CHECK-P8-NEXT:    bgt 0, .LBB2_2
+; CHECK-P8-NEXT:  .LBB2_5: # %entry
+; CHECK-P8-NEXT:    fmr 3, 1
+; CHECK-P8-NEXT:    fcmpu 0, 3, 4
+; CHECK-P8-NEXT:    bgt 0, .LBB2_3
+; CHECK-P8-NEXT:  .LBB2_6: # %entry
+; CHECK-P8-NEXT:    fmr 3, 4
+; CHECK-P8-NEXT:    fmr 1, 3
+; CHECK-P8-NEXT:    blr
+entry:
+  %0 = call float (float, float, float, ...) @llvm.ppc.maxfs(float %a, float %b, float %c, float %d)
+  ret float %0
+}
+
+declare ppc_fp128 @llvm.ppc.minfe(ppc_fp128 %a, ppc_fp128 %b, ppc_fp128 %c, ...)
+define ppc_fp128 @test_minfe(ppc_fp128 %a, ppc_fp128 %b, ppc_fp128 %c, ppc_fp128 %d) {
+; CHECK-LABEL: test_minfe:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    fcmpu 0, 6, 4
+; CHECK-NEXT:    fcmpu 1, 5, 3
+; CHECK-NEXT:    crand 20, 6, 0
+; CHECK-NEXT:    cror 20, 4, 20
+; CHECK-NEXT:    bc 12, 20, .LBB3_2
+; CHECK-NEXT:  # %bb.1: # %entry
+; CHECK-NEXT:    fmr 6, 4
+; CHECK-NEXT:  .LBB3_2: # %entry
+; CHECK-NEXT:    fcmpu 0, 6, 2
+; CHECK-NEXT:    bc 12, 20, .LBB3_4
+; CHECK-NEXT:  # %bb.3: # %entry
+; CHECK-NEXT:    fmr 5, 3
+; CHECK-NEXT:  .LBB3_4: # %entry
+; CHECK-NEXT:    fcmpu 1, 5, 1
+; CHECK-NEXT:    crand 20, 6, 0
+; CHECK-NEXT:    cror 20, 4, 20
+; CHECK-NEXT:    bc 12, 20, .LBB3_6
+; CHECK-NEXT:  # %bb.5: # %entry
+; CHECK-NEXT:    fmr 6, 2
+; CHECK-NEXT:  .LBB3_6: # %entry
+; CHECK-NEXT:    fcmpu 0, 6, 8
+; CHECK-NEXT:    bc 12, 20, .LBB3_8
+; CHECK-NEXT:  # %bb.7: # %entry
+; CHECK-NEXT:    fmr 5, 1
+; CHECK-NEXT:  .LBB3_8: # %entry
+; CHECK-NEXT:    fcmpu 1, 5, 7
+; CHECK-NEXT:    crand 20, 6, 0
+; CHECK-NEXT:    cror 20, 4, 20
+; CHECK-NEXT:    bc 12, 20, .LBB3_10
+; CHECK-NEXT:  # %bb.9: # %entry
+; CHECK-NEXT:    fmr 5, 7
+; CHECK-NEXT:  .LBB3_10: # %entry
+; CHECK-NEXT:    bc 12, 20, .LBB3_12
+; CHECK-NEXT:  # %bb.11: # %entry
+; CHECK-NEXT:    fmr 6, 8
+; CHECK-NEXT:  .LBB3_12: # %entry
+; CHECK-NEXT:    fmr 1, 5
+; CHECK-NEXT:    fmr 2, 6
+; CHECK-NEXT:    blr
+entry:
+  %0 = call ppc_fp128 (ppc_fp128, ppc_fp128, ppc_fp128, ...) @llvm.ppc.minfe(ppc_fp128 %a, ppc_fp128 %b, ppc_fp128 %c, ppc_fp128 %d)
+  ret ppc_fp128 %0
+}
+
+declare double @llvm.ppc.minfl(double %a, double %b, double %c, ...)
+define double @test_minfl(double %a, double %b, double %c, double %d) {
+; CHECK-P9-LABEL: test_minfl:
+; CHECK-P9:       # %bb.0: # %entry
+; CHECK-P9-NEXT:    xsmincdp 0, 3, 2
+; CHECK-P9-NEXT:    xsmincdp 0, 0, 1
+; CHECK-P9-NEXT:    xsmincdp 1, 0, 4
+; CHECK-P9-NEXT:    blr
+;
+; CHECK-P8-LABEL: test_minfl:
+; CHECK-P8:       # %bb.0: # %entry
+; CHECK-P8-NEXT:    xscmpudp 0, 3, 2
+; CHECK-P8-NEXT:    bge 0, .LBB4_4
+; CHECK-P8-NEXT:  # %bb.1: # %entry
+; CHECK-P8-NEXT:    xscmpudp 0, 3, 1
+; CHECK-P8-NEXT:    bge 0, .LBB4_5
+; CHECK-P8-NEXT:  .LBB4_2: # %entry
+; CHECK-P8-NEXT:    xscmpudp 0, 3, 4
+; CHECK-P8-NEXT:    bge 0, .LBB4_6
+; CHECK-P8-NEXT:  .LBB4_3: # %entry
+; CHECK-P8-NEXT:    fmr 1, 3
+; CHECK-P8-NEXT:    blr
+; CHECK-P8-NEXT:  .LBB4_4: # %entry
+; CHECK-P8-NEXT:    fmr 3, 2
+; CHECK-P8-NEXT:    xscmpudp 0, 3, 1
+; CHECK-P8-NEXT:    blt 0, .LBB4_2
+; CHECK-P8-NEXT:  .LBB4_5: # %entry
+; CHECK-P8-NEXT:    fmr 3, 1
+; CHECK-P8-NEXT:    xscmpudp 0, 3, 4
+; CHECK-P8-NEXT:    blt 0, .LBB4_3
+; CHECK-P8-NEXT:  .LBB4_6: # %entry
+; CHECK-P8-NEXT:    fmr 3, 4
+; CHECK-P8-NEXT:    fmr 1, 3
+; CHECK-P8-NEXT:    blr
+entry:
+  %0 = call double (double, double, double, ...) @llvm.ppc.minfl(double %a, double %b, double %c, double %d)
+  ret double %0
+}
+
+declare float @llvm.ppc.minfs(float %a, float %b, float %c, ...)
+define float @test_minfs(float %a, float %b, float %c, float %d) {
+; CHECK-P9-LABEL: test_minfs:
+; CHECK-P9:       # %bb.0: # %entry
+; CHECK-P9-NEXT:    xsmincdp 0, 3, 2
+; CHECK-P9-NEXT:    xsmincdp 0, 0, 1
+; CHECK-P9-NEXT:    xsmincdp 1, 0, 4
+; CHECK-P9-NEXT:    blr
+;
+; CHECK-P8-LABEL: test_minfs:
+; CHECK-P8:       # %bb.0: # %entry
+; CHECK-P8-NEXT:    fcmpu 0, 3, 2
+; CHECK-P8-NEXT:    bge 0, .LBB5_4
+; CHECK-P8-NEXT:  # %bb.1: # %entry
+; CHECK-P8-NEXT:    fcmpu 0, 3, 1
+; CHECK-P8-NEXT:    bge 0, .LBB5_5
+; CHECK-P8-NEXT:  .LBB5_2: # %entry
+; CHECK-P8-NEXT:    fcmpu 0, 3, 4
+; CHECK-P8-NEXT:    bge 0, .LBB5_6
+; CHECK-P8-NEXT:  .LBB5_3: # %entry
+; CHECK-P8-NEXT:    fmr 1, 3
+; CHECK-P8-NEXT:    blr
+; CHECK-P8-NEXT:  .LBB5_4: # %entry
+; CHECK-P8-NEXT:    fmr 3, 2
+; CHECK-P8-NEXT:    fcmpu 0, 3, 1
+; CHECK-P8-NEXT:    blt 0, .LBB5_2
+; CHECK-P8-NEXT:  .LBB5_5: # %entry
+; CHECK-P8-NEXT:    fmr 3, 1
+; CHECK-P8-NEXT:    fcmpu 0, 3, 4
+; CHECK-P8-NEXT:    blt 0, .LBB5_3
+; CHECK-P8-NEXT:  .LBB5_6: # %entry
+; CHECK-P8-NEXT:    fmr 3, 4
+; CHECK-P8-NEXT:    fmr 1, 3
+; CHECK-P8-NEXT:    blr
+entry:
+  %0 = call float (float, float, float, ...) @llvm.ppc.minfs(float %a, float %b, float %c, float %d)
+  ret float %0
+}