diff --git a/include/llvm/Support/PatternMatch.h b/include/llvm/Support/PatternMatch.h
index 9fbe434..a83a068 100644
--- a/include/llvm/Support/PatternMatch.h
+++ b/include/llvm/Support/PatternMatch.h
@@ -830,7 +830,7 @@
 // Matchers for max/min idioms, eg: "select (sgt x, y), x, y" -> smax(x,y).
 //
 
-template<typename LHS_t, typename RHS_t, typename Pred_t>
+template<typename CmpInst_t, typename LHS_t, typename RHS_t, typename Pred_t>
 struct MaxMin_match {
   LHS_t L;
   RHS_t R;
@@ -844,7 +844,7 @@
     SelectInst *SI = dyn_cast<SelectInst>(V);
     if (!SI)
       return false;
-    ICmpInst *Cmp = dyn_cast<ICmpInst>(SI->getCondition());
+    CmpInst_t *Cmp = dyn_cast<CmpInst_t>(SI->getCondition());
     if (!Cmp)
       return false;
     // At this point we have a select conditioned on a comparison.  Check that
@@ -856,7 +856,7 @@
     if ((TrueVal != LHS || FalseVal != RHS) &&
         (TrueVal != RHS || FalseVal != LHS))
       return false;
-    ICmpInst::Predicate Pred = LHS == TrueVal ?
+    typename CmpInst_t::Predicate Pred = LHS == TrueVal ?
       Cmp->getPredicate() : Cmp->getSwappedPredicate();
     // Does "(x pred y) ? x : y" represent the desired max/min operation?
     if (!Pred_t::match(Pred))
@@ -894,28 +894,116 @@
   }
 };
 
+/// ofmax_pred_ty - Helper class for identifying ordered max predicates.
+struct ofmax_pred_ty {
+  static bool match(FCmpInst::Predicate Pred) {
+    return Pred == CmpInst::FCMP_OGT || Pred == CmpInst::FCMP_OGE;
+  }
+};
+
+/// ofmin_pred_ty - Helper class for identifying ordered min predicates.
+struct ofmin_pred_ty {
+  static bool match(FCmpInst::Predicate Pred) {
+    return Pred == CmpInst::FCMP_OLT || Pred == CmpInst::FCMP_OLE;
+  }
+};
+
+/// ufmax_pred_ty - Helper class for identifying unordered max predicates.
+struct ufmax_pred_ty {
+  static bool match(FCmpInst::Predicate Pred) {
+    return Pred == CmpInst::FCMP_UGT || Pred == CmpInst::FCMP_UGE;
+  }
+};
+
+/// ufmin_pred_ty - Helper class for identifying unordered min predicates.
+struct ufmin_pred_ty {
+  static bool match(FCmpInst::Predicate Pred) {
+    return Pred == CmpInst::FCMP_ULT || Pred == CmpInst::FCMP_ULE;
+  }
+};
+
 template<typename LHS, typename RHS>
-inline MaxMin_match<LHS, RHS, smax_pred_ty>
+inline MaxMin_match<ICmpInst, LHS, RHS, smax_pred_ty>
 m_SMax(const LHS &L, const RHS &R) {
-  return MaxMin_match<LHS, RHS, smax_pred_ty>(L, R);
+  return MaxMin_match<ICmpInst, LHS, RHS, smax_pred_ty>(L, R);
 }
 
 template<typename LHS, typename RHS>
-inline MaxMin_match<LHS, RHS, smin_pred_ty>
+inline MaxMin_match<ICmpInst, LHS, RHS, smin_pred_ty>
 m_SMin(const LHS &L, const RHS &R) {
-  return MaxMin_match<LHS, RHS, smin_pred_ty>(L, R);
+  return MaxMin_match<ICmpInst, LHS, RHS, smin_pred_ty>(L, R);
 }
 
 template<typename LHS, typename RHS>
-inline MaxMin_match<LHS, RHS, umax_pred_ty>
+inline MaxMin_match<ICmpInst, LHS, RHS, umax_pred_ty>
 m_UMax(const LHS &L, const RHS &R) {
-  return MaxMin_match<LHS, RHS, umax_pred_ty>(L, R);
+  return MaxMin_match<ICmpInst, LHS, RHS, umax_pred_ty>(L, R);
 }
 
 template<typename LHS, typename RHS>
-inline MaxMin_match<LHS, RHS, umin_pred_ty>
+inline MaxMin_match<ICmpInst, LHS, RHS, umin_pred_ty>
 m_UMin(const LHS &L, const RHS &R) {
-  return MaxMin_match<LHS, RHS, umin_pred_ty>(L, R);
+  return MaxMin_match<ICmpInst, LHS, RHS, umin_pred_ty>(L, R);
+}
+
+/// \brief Match an 'ordered' floating point maximum attribute.
+/// Floating point has one special value 'NaN'. Therefore, there is no total
+/// order. However, if we can ignore the 'NaN' value (for example, because of a
+/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'maximum'
+/// semantics. In the presence of 'NaN' we have to preserve the original
+/// select(fcmp(ogt/ge, L, R), L, R) semantics matched by this predicate.
+///
+///                         max(L, R)  iff L and R are not NaN
+///  m_OrdFMax(L, R) =      R          iff L or R are NaN
+template<typename LHS, typename RHS>
+inline MaxMin_match<FCmpInst, LHS, RHS, ofmax_pred_ty>
+m_OrdFMax(const LHS &L, const RHS &R) {
+  return MaxMin_match<FCmpInst, LHS, RHS, ofmax_pred_ty>(L, R);
+}
+
+/// \brief Match an 'ordered' floating point minimum attribute.
+/// Floating point has one special value 'NaN'. Therefore, there is no total
+/// order. However, if we can ignore the 'NaN' value (for example, because of a
+/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'minimum'
+/// semantics. In the presence of 'NaN' we have to preserve the original
+/// select(fcmp(olt/le, L, R), L, R) semantics matched by this predicate.
+///
+///                         max(L, R)  iff L and R are not NaN
+///  m_OrdFMin(L, R) =      R          iff L or R are NaN
+template<typename LHS, typename RHS>
+inline MaxMin_match<FCmpInst, LHS, RHS, ofmin_pred_ty>
+m_OrdFMin(const LHS &L, const RHS &R) {
+  return MaxMin_match<FCmpInst, LHS, RHS, ofmin_pred_ty>(L, R);
+}
+
+/// \brief Match an 'unordered' floating point maximum attribute.
+/// Floating point has one special value 'NaN'. Therefore, there is no total
+/// order. However, if we can ignore the 'NaN' value (for example, because of a
+/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'maximum'
+/// semantics. In the presence of 'NaN' we have to preserve the original
+/// select(fcmp(ugt/ge, L, R), L, R) semantics matched by this predicate.
+///
+///                         max(L, R)  iff L and R are not NaN
+///  m_UnordFMin(L, R) =    L          iff L or R are NaN
+template<typename LHS, typename RHS>
+inline MaxMin_match<FCmpInst, LHS, RHS, ufmax_pred_ty>
+m_UnordFMax(const LHS &L, const RHS &R) {
+  return MaxMin_match<FCmpInst, LHS, RHS, ufmax_pred_ty>(L, R);
+}
+
+/// \brief Match an 'unordered' floating point minimum attribute.
+/// Floating point has one special value 'NaN'. Therefore, there is no total
+/// order. However, if we can ignore the 'NaN' value (for example, because of a
+/// 'no-nans-float-math' flag) a combination of a fcmp and select has 'minimum'
+/// semantics. In the presence of 'NaN' we have to preserve the original
+/// select(fcmp(ult/le, L, R), L, R) semantics matched by this predicate.
+///
+///                          max(L, R)  iff L and R are not NaN
+///  m_UnordFMin(L, R) =     L          iff L or R are NaN
+template<typename LHS, typename RHS>
+inline MaxMin_match<FCmpInst, LHS, RHS, ufmin_pred_ty>
+m_UnordFMin(const LHS &L, const RHS &R) {
+  return MaxMin_match<FCmpInst, LHS, RHS, ufmin_pred_ty>(L, R);
 }
 
 template<typename Opnd_t>
diff --git a/unittests/IR/PatternMatch.cpp b/unittests/IR/PatternMatch.cpp
new file mode 100644
index 0000000..7c6d8ce
--- /dev/null
+++ b/unittests/IR/PatternMatch.cpp
@@ -0,0 +1,265 @@
+//===---- llvm/unittest/IR/PatternMatch.cpp - PatternMatch unit tests ----===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Analysis/ValueTracking.h"
+#include "llvm/IR/BasicBlock.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/DataLayout.h"
+#include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/Instructions.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/MDBuilder.h"
+#include "llvm/IR/Operator.h"
+#include "llvm/Support/NoFolder.h"
+#include "llvm/Support/PatternMatch.h"
+#include "gtest/gtest.h"
+
+using namespace llvm::PatternMatch;
+
+namespace llvm {
+namespace {
+
+/// Ordered floating point minimum/maximum tests.
+
+static void m_OrdFMin_expect_match_and_delete(Value *Cmp, Value *Select,
+                                              Value *L, Value *R) {
+  Value *MatchL, *MatchR;
+  EXPECT_TRUE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)).match(Select));
+  EXPECT_EQ(L, MatchL);
+  EXPECT_EQ(R, MatchR);
+  delete Select;
+  delete Cmp;
+}
+
+static void m_OrdFMin_expect_nomatch_and_delete(Value *Cmp, Value *Select,
+                                                Value *L, Value *R) {
+  Value *MatchL, *MatchR;
+  EXPECT_FALSE(m_OrdFMin(m_Value(MatchL), m_Value(MatchR)).match(Select));
+  delete Select;
+  delete Cmp;
+}
+
+static void m_OrdFMax_expect_match_and_delete(Value *Cmp, Value *Select,
+                                              Value *L, Value *R) {
+  Value *MatchL, *MatchR;
+  EXPECT_TRUE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)).match(Select));
+  EXPECT_EQ(L, MatchL);
+  EXPECT_EQ(R, MatchR);
+  delete Select;
+  delete Cmp;
+}
+
+static void m_OrdFMax_expect_nomatch_and_delete(Value *Cmp, Value *Select,
+                                                Value *L, Value *R) {
+  Value *MatchL, *MatchR;
+  EXPECT_FALSE(m_OrdFMax(m_Value(MatchL), m_Value(MatchR)).match(Select));
+  delete Select;
+  delete Cmp;
+}
+
+
+
+TEST(PatternMatchTest, FloatingPointOrderedMin) {
+  LLVMContext &C(getGlobalContext());
+  IRBuilder<true, NoFolder> Builder(C);
+
+  Type *FltTy = Builder.getFloatTy();
+  Value *L = ConstantFP::get(FltTy, 1.0);
+  Value *R = ConstantFP::get(FltTy, 2.0);
+
+  // Test OLT.
+  Value *Cmp = Builder.CreateFCmpOLT(L, R);
+  Value *Select = Builder.CreateSelect(Cmp, L, R);
+  m_OrdFMin_expect_match_and_delete(Cmp, Select, L, R);
+
+  // Test OLE.
+  Cmp = Builder.CreateFCmpOLE(L, R);
+  Select = Builder.CreateSelect(Cmp, L, R);
+  m_OrdFMin_expect_match_and_delete(Cmp, Select, L, R);
+
+  // Test no match on OGE.
+  Cmp = Builder.CreateFCmpOGE(L, R);
+  Select = Builder.CreateSelect(Cmp, L, R);
+  m_OrdFMin_expect_nomatch_and_delete(Cmp, Select, L, R);
+
+  // Test no match on OGT.
+  Cmp = Builder.CreateFCmpOGT(L, R);
+  Select = Builder.CreateSelect(Cmp, L, R);
+  m_OrdFMin_expect_nomatch_and_delete(Cmp, Select, L, R);
+
+  // Test match on OGE with inverted select.
+  Cmp = Builder.CreateFCmpOGE(L, R);
+  Select = Builder.CreateSelect(Cmp, R, L);
+  m_OrdFMin_expect_match_and_delete(Cmp, Select, L, R);
+
+  // Test match on OGT with inverted select.
+  Cmp = Builder.CreateFCmpOGT(L, R);
+  Select = Builder.CreateSelect(Cmp, R, L);
+  m_OrdFMin_expect_match_and_delete(Cmp, Select, L, R);
+}
+
+TEST(PatternMatchTest, FloatingPointOrderedMax) {
+  LLVMContext &C(getGlobalContext());
+  IRBuilder<true, NoFolder> Builder(C);
+
+  Type *FltTy = Builder.getFloatTy();
+  Value *L = ConstantFP::get(FltTy, 1.0);
+  Value *R = ConstantFP::get(FltTy, 2.0);
+
+  // Test OGT.
+  Value *Cmp = Builder.CreateFCmpOGT(L, R);
+  Value *Select = Builder.CreateSelect(Cmp, L, R);
+  m_OrdFMax_expect_match_and_delete(Cmp, Select, L, R);
+
+  // Test OGE.
+  Cmp = Builder.CreateFCmpOGE(L, R);
+  Select = Builder.CreateSelect(Cmp, L, R);
+  m_OrdFMax_expect_match_and_delete(Cmp, Select, L, R);
+
+  // Test no match on OLE.
+  Cmp = Builder.CreateFCmpOLE(L, R);
+  Select = Builder.CreateSelect(Cmp, L, R);
+  m_OrdFMax_expect_nomatch_and_delete(Cmp, Select, L, R);
+
+  // Test no match on OLT.
+  Cmp = Builder.CreateFCmpOLT(L, R);
+  Select = Builder.CreateSelect(Cmp, L, R);
+  m_OrdFMax_expect_nomatch_and_delete(Cmp, Select, L, R);
+
+  // Test match on OLE with inverted select.
+  Cmp = Builder.CreateFCmpOLE(L, R);
+  Select = Builder.CreateSelect(Cmp, R, L);
+  m_OrdFMax_expect_match_and_delete(Cmp, Select, L, R);
+
+  // Test match on OLT with inverted select.
+  Cmp = Builder.CreateFCmpOLT(L, R);
+  Select = Builder.CreateSelect(Cmp, R, L);
+  m_OrdFMax_expect_match_and_delete(Cmp, Select, L, R);
+}
+
+/// Unordered floating point minimum/maximum tests.
+
+static void m_UnordFMin_expect_match_and_delete(Value *Cmp, Value *Select,
+                                              Value *L, Value *R) {
+  Value *MatchL, *MatchR;
+  EXPECT_TRUE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)).match(Select));
+  EXPECT_EQ(L, MatchL);
+  EXPECT_EQ(R, MatchR);
+  delete Select;
+  delete Cmp;
+}
+
+static void m_UnordFMin_expect_nomatch_and_delete(Value *Cmp, Value *Select,
+                                                Value *L, Value *R) {
+  Value *MatchL, *MatchR;
+  EXPECT_FALSE(m_UnordFMin(m_Value(MatchL), m_Value(MatchR)).match(Select));
+  delete Select;
+  delete Cmp;
+}
+
+static void m_UnordFMax_expect_match_and_delete(Value *Cmp, Value *Select,
+                                              Value *L, Value *R) {
+  Value *MatchL, *MatchR;
+  EXPECT_TRUE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)).match(Select));
+  EXPECT_EQ(L, MatchL);
+  EXPECT_EQ(R, MatchR);
+  delete Select;
+  delete Cmp;
+}
+
+static void m_UnordFMax_expect_nomatch_and_delete(Value *Cmp, Value *Select,
+                                                Value *L, Value *R) {
+  Value *MatchL, *MatchR;
+  EXPECT_FALSE(m_UnordFMax(m_Value(MatchL), m_Value(MatchR)).match(Select));
+  delete Select;
+  delete Cmp;
+}
+
+TEST(PatternMatchTest, FloatingPointUnorderedMin) {
+  LLVMContext &C(getGlobalContext());
+  IRBuilder<true, NoFolder> Builder(C);
+
+  Type *FltTy = Builder.getFloatTy();
+  Value *L = ConstantFP::get(FltTy, 1.0);
+  Value *R = ConstantFP::get(FltTy, 2.0);
+
+  // Test ULT.
+  Value *Cmp = Builder.CreateFCmpULT(L, R);
+  Value *Select = Builder.CreateSelect(Cmp, L, R);
+  m_UnordFMin_expect_match_and_delete(Cmp, Select, L, R);
+
+  // Test ULE.
+  Cmp = Builder.CreateFCmpULE(L, R);
+  Select = Builder.CreateSelect(Cmp, L, R);
+  m_UnordFMin_expect_match_and_delete(Cmp, Select, L, R);
+
+  // Test no match on UGE.
+  Cmp = Builder.CreateFCmpUGE(L, R);
+  Select = Builder.CreateSelect(Cmp, L, R);
+  m_UnordFMin_expect_nomatch_and_delete(Cmp, Select, L, R);
+
+  // Test no match on UGT.
+  Cmp = Builder.CreateFCmpUGT(L, R);
+  Select = Builder.CreateSelect(Cmp, L, R);
+  m_UnordFMin_expect_nomatch_and_delete(Cmp, Select, L, R);
+
+  // Test match on UGE with inverted select.
+  Cmp = Builder.CreateFCmpUGE(L, R);
+  Select = Builder.CreateSelect(Cmp, R, L);
+  m_UnordFMin_expect_match_and_delete(Cmp, Select, L, R);
+
+  // Test match on UGT with inverted select.
+  Cmp = Builder.CreateFCmpUGT(L, R);
+  Select = Builder.CreateSelect(Cmp, R, L);
+  m_UnordFMin_expect_match_and_delete(Cmp, Select, L, R);
+}
+
+TEST(PatternMatchTest, FloatingPointUnorderedMax) {
+  LLVMContext &C(getGlobalContext());
+  IRBuilder<true, NoFolder> Builder(C);
+
+  Type *FltTy = Builder.getFloatTy();
+  Value *L = ConstantFP::get(FltTy, 1.0);
+  Value *R = ConstantFP::get(FltTy, 2.0);
+
+  // Test UGT.
+  Value *Cmp = Builder.CreateFCmpUGT(L, R);
+  Value *Select = Builder.CreateSelect(Cmp, L, R);
+  m_UnordFMax_expect_match_and_delete(Cmp, Select, L, R);
+
+  // Test UGE.
+  Cmp = Builder.CreateFCmpUGE(L, R);
+  Select = Builder.CreateSelect(Cmp, L, R);
+  m_UnordFMax_expect_match_and_delete(Cmp, Select, L, R);
+
+  // Test no match on ULE.
+  Cmp = Builder.CreateFCmpULE(L, R);
+  Select = Builder.CreateSelect(Cmp, L, R);
+  m_UnordFMax_expect_nomatch_and_delete(Cmp, Select, L, R);
+
+  // Test no match on ULT.
+  Cmp = Builder.CreateFCmpULT(L, R);
+  Select = Builder.CreateSelect(Cmp, L, R);
+  m_UnordFMax_expect_nomatch_and_delete(Cmp, Select, L, R);
+
+  // Test match on ULE with inverted select.
+  Cmp = Builder.CreateFCmpULE(L, R);
+  Select = Builder.CreateSelect(Cmp, R, L);
+  m_UnordFMax_expect_match_and_delete(Cmp, Select, L, R);
+
+  // Test match on ULT with inverted select.
+  Cmp = Builder.CreateFCmpULT(L, R);
+  Select = Builder.CreateSelect(Cmp, R, L);
+  m_UnordFMax_expect_match_and_delete(Cmp, Select, L, R);
+}
+
+} // anonymous namespace.
+} // llvm namespace.