Index: llvm/lib/Analysis/InstructionSimplify.cpp
===================================================================
--- llvm/lib/Analysis/InstructionSimplify.cpp
+++ llvm/lib/Analysis/InstructionSimplify.cpp
@@ -6121,6 +6121,47 @@
   return nullptr;
 }
 
+/// Given a min/max intrinsic, see if it can be removed based on having an
+/// operand that is another min/max intrinsic with shared operand(s). The caller
+/// is expected to swap the operand arguments to handle commutation.
+static Value *foldMinimumMaximumSharedOp(Intrinsic::ID IID, Value *Op0,
+                                         Value *Op1) {
+  auto *M0 = dyn_cast<IntrinsicInst>(Op0);
+  // If Op0 is not the same intrinsic as IID, do not process.
+  // This is a difference with integer min/max handling. We do not process the
+  // case like max(min(X,Y),min(X,Y)) => min(X,Y). But it can be handled by GVN.
+  if (!M0 || M0->getIntrinsicID() != IID)
+    return nullptr;
+  Value *X0 = M0->getOperand(0);
+  Value *Y0 = M0->getOperand(1);
+  // Simple case, m(m(X,Y), X) => m(X, Y)
+  //              m(m(X,Y), Y) => m(X, Y)
+  // For minimum/maximum, X is NaN => m(NaN, Y) == NaN and m(NaN, NaN) == NaN.
+  // For minimum/maximum, Y is NaN => m(X, NaN) == NaN  and m(NaN, NaN) == NaN.
+  // For minnum/maxnum, X is NaN => m(NaN, Y) == Y and m(Y, Y) == Y.
+  // For minnum/maxnum, Y is NaN => m(X, NaN) == X and m(X, NaN) == X.
+  if (X0 == Op1 || Y0 == Op1)
+    return M0;
+
+  auto *M1 = dyn_cast<IntrinsicInst>(Op1);
+  if (!M1)
+    return nullptr;
+  Value *X1 = M1->getOperand(0);
+  Value *Y1 = M1->getOperand(1);
+  Intrinsic::ID IID1 = M1->getIntrinsicID();
+  // we have a case m(m(X,Y),m'(X,Y)) taking into account m' is commutative.
+  // if m' is m or inversion of m => m(m(X,Y),m'(X,Y)) == m(X,Y).
+  // For minimum/maximum, X is NaN => m(NaN,Y) == m'(NaN, Y) == NaN.
+  // For minimum/maximum, Y is NaN => m(X,NaN) == m'(X, NaN) == NaN.
+  // For minnum/maxnum, X is NaN => m(NaN,Y) == m'(NaN, Y) == Y.
+  // For minnum/maxnum, Y is NaN => m(X,NaN) == m'(X, NaN) == X.
+  if ((X0 == X1 && Y0 == Y1) || (X0 == Y1 && Y0 == X1))
+    if (IID1 == IID || getInverseMinMaxIntrinsic(IID1) == IID)
+      return M0;
+
+  return nullptr;
+}
+
 static Value *simplifyBinaryIntrinsic(Function *F, Value *Op0, Value *Op1,
                                       const SimplifyQuery &Q) {
   Intrinsic::ID IID = F->getIntrinsicID();
@@ -6360,14 +6401,10 @@
 
     // Min/max of the same operation with common operand:
     // m(m(X, Y)), X --> m(X, Y) (4 commuted variants)
-    if (auto *M0 = dyn_cast<IntrinsicInst>(Op0))
-      if (M0->getIntrinsicID() == IID &&
-          (M0->getOperand(0) == Op1 || M0->getOperand(1) == Op1))
-        return Op0;
-    if (auto *M1 = dyn_cast<IntrinsicInst>(Op1))
-      if (M1->getIntrinsicID() == IID &&
-          (M1->getOperand(0) == Op0 || M1->getOperand(1) == Op0))
-        return Op1;
+    if (Value *V = foldMinimumMaximumSharedOp(IID, Op0, Op1))
+      return V;
+    if (Value *V = foldMinimumMaximumSharedOp(IID, Op1, Op0))
+      return V;
 
     break;
   }
Index: llvm/lib/Analysis/ValueTracking.cpp
===================================================================
--- llvm/lib/Analysis/ValueTracking.cpp
+++ llvm/lib/Analysis/ValueTracking.cpp
@@ -7161,6 +7161,10 @@
   case Intrinsic::smin: return Intrinsic::smax;
   case Intrinsic::umax: return Intrinsic::umin;
   case Intrinsic::umin: return Intrinsic::umax;
+  case Intrinsic::maximum: return Intrinsic::minimum;
+  case Intrinsic::minimum: return Intrinsic::maximum;
+  case Intrinsic::maxnum: return Intrinsic::minnum;
+  case Intrinsic::minnum: return Intrinsic::maxnum;
   default: llvm_unreachable("Unexpected intrinsic");
   }
 }
Index: llvm/test/Transforms/InstSimplify/fminmax-folds.ll
===================================================================
--- llvm/test/Transforms/InstSimplify/fminmax-folds.ll
+++ llvm/test/Transforms/InstSimplify/fminmax-folds.ll
@@ -1199,3 +1199,187 @@
   %val = call float @llvm.maximum.f32(float 0x7FF0000000000000, float %x)
   ret float %val
 }
+
+define float @maximum_maximum_minimum(float %x, float %y) {
+; CHECK-LABEL: @maximum_maximum_minimum(
+; CHECK-NEXT:    [[MAX:%.*]] = call float @llvm.maximum.f32(float [[X:%.*]], float [[Y:%.*]])
+; CHECK-NEXT:    ret float [[MAX]]
+;
+  %max = call float @llvm.maximum.f32(float %x, float %y)
+  %min = call float @llvm.minimum.f32(float %x, float %y)
+  %val = call float @llvm.maximum.f32(float %max, float %min)
+  ret float %val
+}
+
+define float @maximum_minimum_maximum(float %x, float %y) {
+; CHECK-LABEL: @maximum_minimum_maximum(
+; CHECK-NEXT:    [[MAX:%.*]] = call float @llvm.maximum.f32(float [[X:%.*]], float [[Y:%.*]])
+; CHECK-NEXT:    ret float [[MAX]]
+;
+  %max = call float @llvm.maximum.f32(float %x, float %y)
+  %min = call float @llvm.minimum.f32(float %x, float %y)
+  %val = call float @llvm.maximum.f32(float %min, float %max)
+  ret float %val
+}
+
+define float @maximum_minimum_minimum(float %x, float %y) {
+; CHECK-LABEL: @maximum_minimum_minimum(
+; CHECK-NEXT:    [[MIN1:%.*]] = call float @llvm.minimum.f32(float [[X:%.*]], float [[Y:%.*]])
+; CHECK-NEXT:    [[MIN2:%.*]] = call float @llvm.minimum.f32(float [[X]], float [[Y]])
+; CHECK-NEXT:    [[VAL:%.*]] = call float @llvm.maximum.f32(float [[MIN1]], float [[MIN2]])
+; CHECK-NEXT:    ret float [[VAL]]
+;
+  %min1 = call float @llvm.minimum.f32(float %x, float %y)
+  %min2 = call float @llvm.minimum.f32(float %x, float %y)
+  %val = call float @llvm.maximum.f32(float %min1, float %min2)
+  ret float %val
+}
+
+define float @maximum_maximum_maximum(float %x, float %y) {
+; CHECK-LABEL: @maximum_maximum_maximum(
+; CHECK-NEXT:    [[MAX1:%.*]] = call float @llvm.maximum.f32(float [[X:%.*]], float [[Y:%.*]])
+; CHECK-NEXT:    ret float [[MAX1]]
+;
+  %max1 = call float @llvm.maximum.f32(float %x, float %y)
+  %max2 = call float @llvm.maximum.f32(float %x, float %y)
+  %val = call float @llvm.maximum.f32(float %max1, float %max2)
+  ret float %val
+}
+
+define float @minimum_maximum_minimum(float %x, float %y) {
+; CHECK-LABEL: @minimum_maximum_minimum(
+; CHECK-NEXT:    [[MIN:%.*]] = call float @llvm.minimum.f32(float [[X:%.*]], float [[Y:%.*]])
+; CHECK-NEXT:    ret float [[MIN]]
+;
+  %max = call float @llvm.maximum.f32(float %x, float %y)
+  %min = call float @llvm.minimum.f32(float %x, float %y)
+  %val = call float @llvm.minimum.f32(float %max, float %min)
+  ret float %val
+}
+
+define float @minimum_minimum_maximum(float %x, float %y) {
+; CHECK-LABEL: @minimum_minimum_maximum(
+; CHECK-NEXT:    [[MIN:%.*]] = call float @llvm.minimum.f32(float [[X:%.*]], float [[Y:%.*]])
+; CHECK-NEXT:    ret float [[MIN]]
+;
+  %max = call float @llvm.maximum.f32(float %x, float %y)
+  %min = call float @llvm.minimum.f32(float %x, float %y)
+  %val = call float @llvm.minimum.f32(float %min, float %max)
+  ret float %val
+}
+
+define float @minimum_maximum_maximum(float %x, float %y) {
+; CHECK-LABEL: @minimum_maximum_maximum(
+; CHECK-NEXT:    [[MAX1:%.*]] = call float @llvm.maximum.f32(float [[X:%.*]], float [[Y:%.*]])
+; CHECK-NEXT:    [[MAX2:%.*]] = call float @llvm.maximum.f32(float [[X]], float [[Y]])
+; CHECK-NEXT:    [[VAL:%.*]] = call float @llvm.minimum.f32(float [[MAX1]], float [[MAX2]])
+; CHECK-NEXT:    ret float [[VAL]]
+;
+  %max1 = call float @llvm.maximum.f32(float %x, float %y)
+  %max2 = call float @llvm.maximum.f32(float %x, float %y)
+  %val = call float @llvm.minimum.f32(float %max1, float %max2)
+  ret float %val
+}
+
+define float @minimum_minimum_minimum(float %x, float %y) {
+; CHECK-LABEL: @minimum_minimum_minimum(
+; CHECK-NEXT:    [[MIN1:%.*]] = call float @llvm.minimum.f32(float [[X:%.*]], float [[Y:%.*]])
+; CHECK-NEXT:    ret float [[MIN1]]
+;
+  %min1 = call float @llvm.minimum.f32(float %x, float %y)
+  %min2 = call float @llvm.minimum.f32(float %x, float %y)
+  %val = call float @llvm.minimum.f32(float %min1, float %min2)
+  ret float %val
+}
+
+define float @maxnum_maxnum_minnum(float %x, float %y) {
+; CHECK-LABEL: @maxnum_maxnum_minnum(
+; CHECK-NEXT:    [[MAX:%.*]] = call float @llvm.maxnum.f32(float [[X:%.*]], float [[Y:%.*]])
+; CHECK-NEXT:    ret float [[MAX]]
+;
+  %max = call float @llvm.maxnum.f32(float %x, float %y)
+  %min = call float @llvm.minnum.f32(float %x, float %y)
+  %val = call float @llvm.maxnum.f32(float %max, float %min)
+  ret float %val
+}
+
+define float @maxnum_minnum_maxnum(float %x, float %y) {
+; CHECK-LABEL: @maxnum_minnum_maxnum(
+; CHECK-NEXT:    [[MAX:%.*]] = call float @llvm.maxnum.f32(float [[X:%.*]], float [[Y:%.*]])
+; CHECK-NEXT:    ret float [[MAX]]
+;
+  %max = call float @llvm.maxnum.f32(float %x, float %y)
+  %min = call float @llvm.minnum.f32(float %x, float %y)
+  %val = call float @llvm.maxnum.f32(float %min, float %max)
+  ret float %val
+}
+
+define float @maxnum_minnum_minmum(float %x, float %y) {
+; CHECK-LABEL: @maxnum_minnum_minmum(
+; CHECK-NEXT:    [[MIN1:%.*]] = call float @llvm.minnum.f32(float [[X:%.*]], float [[Y:%.*]])
+; CHECK-NEXT:    [[MIN2:%.*]] = call float @llvm.minnum.f32(float [[X]], float [[Y]])
+; CHECK-NEXT:    [[VAL:%.*]] = call float @llvm.maxnum.f32(float [[MIN1]], float [[MIN2]])
+; CHECK-NEXT:    ret float [[VAL]]
+;
+  %min1 = call float @llvm.minnum.f32(float %x, float %y)
+  %min2 = call float @llvm.minnum.f32(float %x, float %y)
+  %val = call float @llvm.maxnum.f32(float %min1, float %min2)
+  ret float %val
+}
+
+define float @maxnum_maxnum_maxnum(float %x, float %y) {
+; CHECK-LABEL: @maxnum_maxnum_maxnum(
+; CHECK-NEXT:    [[MAX1:%.*]] = call float @llvm.maxnum.f32(float [[X:%.*]], float [[Y:%.*]])
+; CHECK-NEXT:    ret float [[MAX1]]
+;
+  %max1 = call float @llvm.maxnum.f32(float %x, float %y)
+  %max2 = call float @llvm.maxnum.f32(float %x, float %y)
+  %val = call float @llvm.maxnum.f32(float %max1, float %max2)
+  ret float %val
+}
+
+define float @minnum_maxnum_minnum(float %x, float %y) {
+; CHECK-LABEL: @minnum_maxnum_minnum(
+; CHECK-NEXT:    [[MIN:%.*]] = call float @llvm.minnum.f32(float [[X:%.*]], float [[Y:%.*]])
+; CHECK-NEXT:    ret float [[MIN]]
+;
+  %max = call float @llvm.maxnum.f32(float %x, float %y)
+  %min = call float @llvm.minnum.f32(float %x, float %y)
+  %val = call float @llvm.minnum.f32(float %max, float %min)
+  ret float %val
+}
+
+define float @minnum_minnum_maxnum(float %x, float %y) {
+; CHECK-LABEL: @minnum_minnum_maxnum(
+; CHECK-NEXT:    [[MIN:%.*]] = call float @llvm.minnum.f32(float [[X:%.*]], float [[Y:%.*]])
+; CHECK-NEXT:    ret float [[MIN]]
+;
+  %max = call float @llvm.maxnum.f32(float %x, float %y)
+  %min = call float @llvm.minnum.f32(float %x, float %y)
+  %val = call float @llvm.minnum.f32(float %min, float %max)
+  ret float %val
+}
+
+define float @minnum_maxnum_maxnum(float %x, float %y) {
+; CHECK-LABEL: @minnum_maxnum_maxnum(
+; CHECK-NEXT:    [[MAX1:%.*]] = call float @llvm.maxnum.f32(float [[X:%.*]], float [[Y:%.*]])
+; CHECK-NEXT:    [[MAX2:%.*]] = call float @llvm.maxnum.f32(float [[X]], float [[Y]])
+; CHECK-NEXT:    [[VAL:%.*]] = call float @llvm.minnum.f32(float [[MAX1]], float [[MAX2]])
+; CHECK-NEXT:    ret float [[VAL]]
+;
+  %max1 = call float @llvm.maxnum.f32(float %x, float %y)
+  %max2 = call float @llvm.maxnum.f32(float %x, float %y)
+  %val = call float @llvm.minnum.f32(float %max1, float %max2)
+  ret float %val
+}
+
+define float @minnum_minnum_minmum(float %x, float %y) {
+; CHECK-LABEL: @minnum_minnum_minmum(
+; CHECK-NEXT:    [[MIN1:%.*]] = call float @llvm.minnum.f32(float [[X:%.*]], float [[Y:%.*]])
+; CHECK-NEXT:    ret float [[MIN1]]
+;
+  %min1 = call float @llvm.minnum.f32(float %x, float %y)
+  %min2 = call float @llvm.minnum.f32(float %x, float %y)
+  %val = call float @llvm.minnum.f32(float %min1, float %min2)
+  ret float %val
+}