diff --git a/lib/Sema/SemaInherit.cpp b/lib/Sema/SemaInherit.cpp
index b5bd893..307c527 100644
--- a/lib/Sema/SemaInherit.cpp
+++ b/lib/Sema/SemaInherit.cpp
@@ -218,9 +218,9 @@
   BasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false,
                   /*DetectVirtual=*/false);
   bool DerivationOkay = IsDerivedFrom(Derived, Base, Paths);
-  assert(DerivationOkay && "Can only be used with a derived-to-base conversion");
-  if (!DerivationOkay)
-    return true;
+  assert(DerivationOkay &&
+         "Can only be used with a derived-to-base conversion");
+  (void)DerivationOkay;
 
   if (!Paths.isAmbiguous(Context.getCanonicalType(Base).getUnqualifiedType()))
     return false;
@@ -235,8 +235,7 @@
   Paths.setRecordingPaths(true);
   bool StillOkay = IsDerivedFrom(Derived, Base, Paths);
   assert(StillOkay && "Can only be used with a derived-to-base conversion");
-  if (!StillOkay)
-    return true;
+  (void)StillOkay;
   
   // Build up a textual representation of the ambiguous paths, e.g.,
   // D -> B -> A, that will be used to illustrate the ambiguous
diff --git a/lib/Sema/SemaNamedCast.cpp b/lib/Sema/SemaNamedCast.cpp
index e88a3b2..cac76b6 100644
--- a/lib/Sema/SemaNamedCast.cpp
+++ b/lib/Sema/SemaNamedCast.cpp
@@ -44,6 +44,8 @@
   Sema &Self, Expr *SrcExpr, QualType DestType, const SourceRange &OpRange);
 static TryStaticCastResult TryStaticPointerDowncast(
   Sema &Self, QualType SrcType, QualType DestType, const SourceRange &OpRange);
+static TryStaticCastResult TryStaticMemberPointerUpcast(
+  Sema &Self, QualType SrcType, QualType DestType, const SourceRange &OpRange);
 static TryStaticCastResult TryStaticDowncast(Sema &Self, QualType SrcType,
                                              QualType DestType,
                                              const SourceRange &OpRange,
@@ -479,10 +481,13 @@
     return;
   }
 
-  // Reverse member pointer conversion. C++ 5.11 specifies member pointer
+  // Reverse member pointer conversion. C++ 4.11 specifies member pointer
   // conversion. C++ 5.2.9p9 has additional information.
   // DR54's access restrictions apply here also.
-  // FIXME: Don't have member pointers yet.
+  if (TryStaticMemberPointerUpcast(Self, SrcType, DestType, OpRange)
+      > TSC_NotApplicable) {
+    return;
+  }
 
   // Reverse pointer conversion to void*. C++ 4.10.p2 specifies conversion to
   // void*. C++ 5.2.9p10 specifies additional restrictions, which really is
@@ -655,6 +660,64 @@
   return TSC_Success;
 }
 
+/// TryStaticMemberPointerUpcast - Tests whether a conversion according to
+/// C++ 5.2.9p9 is valid:
+///
+///   An rvalue of type "pointer to member of D of type cv1 T" can be
+///   converted to an rvalue of type "pointer to member of B of type cv2 T",
+///   where B is a base class of D [...].
+///
+TryStaticCastResult
+TryStaticMemberPointerUpcast(Sema &Self, QualType SrcType, QualType DestType,
+                             const SourceRange &OpRange)
+{
+  const MemberPointerType *SrcMemPtr = SrcType->getAsMemberPointerType();
+  if (!SrcMemPtr)
+    return TSC_NotApplicable;
+  const MemberPointerType *DestMemPtr = DestType->getAsMemberPointerType();
+  if (!DestMemPtr)
+    return TSC_NotApplicable;
+
+  // T == T, modulo cv
+  if (Self.Context.getCanonicalType(
+        SrcMemPtr->getPointeeType().getUnqualifiedType()) !=
+      Self.Context.getCanonicalType(DestMemPtr->getPointeeType().
+                                    getUnqualifiedType()))
+    return TSC_NotApplicable;
+
+  // B base of D
+  QualType SrcClass(SrcMemPtr->getClass(), 0);
+  QualType DestClass(DestMemPtr->getClass(), 0);
+  BasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false,
+                  /*DetectVirtual=*/true);
+  if (!Self.IsDerivedFrom(SrcClass, DestClass, Paths)) {
+    return TSC_NotApplicable;
+  }
+
+  // B is a base of D. But is it an allowed base? If not, it's a hard error.
+  if (Paths.isAmbiguous(DestClass)) {
+    Paths.clear();
+    Paths.setRecordingPaths(true);
+    bool StillOkay = Self.IsDerivedFrom(SrcClass, DestClass, Paths);
+    assert(StillOkay);
+    StillOkay = StillOkay;
+    std::string PathDisplayStr = Self.getAmbiguousPathsDisplayString(Paths);
+    Self.Diag(OpRange.getBegin(), diag::err_ambiguous_memptr_conv)
+      << 1 << SrcClass << DestClass << PathDisplayStr << OpRange;
+    return TSC_Failed;
+  }
+
+  if (const CXXRecordType *VBase = Paths.getDetectedVirtual()) {
+    Self.Diag(OpRange.getBegin(), diag::err_memptr_conv_via_virtual)
+      << SrcClass << DestClass << QualType(VBase, 0) << OpRange;
+    return TSC_Failed;
+  }
+
+  // FIXME: Test accessibility.
+
+  return TSC_Success;
+}
+
 /// TryStaticImplicitCast - Tests whether a conversion according to C++ 5.2.9p2
 /// is valid:
 ///
diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp
index b2ae90b..0f9f0cf 100644
--- a/lib/Sema/SemaOverload.cpp
+++ b/lib/Sema/SemaOverload.cpp
@@ -1087,51 +1087,50 @@
 /// otherwise.
 bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType) {
   QualType FromType = From->getType();
+  const MemberPointerType *FromPtrType = FromType->getAsMemberPointerType();
+  if (!FromPtrType)
+    return false;
 
-  if (const MemberPointerType *FromPtrType =
-        FromType->getAsMemberPointerType()) {
-    if (const MemberPointerType *ToPtrType =
-          ToType->getAsMemberPointerType()) {
-      QualType FromClass = QualType(FromPtrType->getClass(), 0);
-      QualType ToClass   = QualType(ToPtrType->getClass(), 0);
+  const MemberPointerType *ToPtrType = ToType->getAsMemberPointerType();
+  assert(ToPtrType && "No member pointer cast has a target type "
+                      "that is not a member pointer.");
 
-      // FIXME: What about dependent types?
-      assert(FromClass->isRecordType() && "Pointer into non-class.");
-      assert(ToClass->isRecordType() && "Pointer into non-class.");
+  QualType FromClass = QualType(FromPtrType->getClass(), 0);
+  QualType ToClass   = QualType(ToPtrType->getClass(), 0);
 
-      BasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false,
-                      /*DetectVirtual=*/true);
-      bool DerivationOkay = IsDerivedFrom(ToClass, FromClass, Paths);
-      assert(DerivationOkay &&
-             "Should not have been called if derivation isn't OK.");
-      if (!DerivationOkay)
-        return true;
+  // FIXME: What about dependent types?
+  assert(FromClass->isRecordType() && "Pointer into non-class.");
+  assert(ToClass->isRecordType() && "Pointer into non-class.");
 
-      if (Paths.isAmbiguous(Context.getCanonicalType(FromClass).
-                                      getUnqualifiedType())) {
-        // Derivation is ambiguous. Redo the check to find the exact paths.
-        Paths.clear();
-        Paths.setRecordingPaths(true);
-        bool StillOkay = IsDerivedFrom(ToClass, FromClass, Paths);
-        assert(StillOkay && "Derivation changed due to quantum fluctuation.");
-        if (!StillOkay)
-          return true;
+  BasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/false,
+                  /*DetectVirtual=*/true);
+  bool DerivationOkay = IsDerivedFrom(ToClass, FromClass, Paths);
+  assert(DerivationOkay &&
+         "Should not have been called if derivation isn't OK.");
+  (void)DerivationOkay;
 
-        std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
-        Diag(From->getExprLoc(),
-             diag::err_ambiguous_base_to_derived_memptr_conv)
-          << FromClass << ToClass << PathDisplayStr << From->getSourceRange();
-        return true;
-      }
+  if (Paths.isAmbiguous(Context.getCanonicalType(FromClass).
+                                  getUnqualifiedType())) {
+    // Derivation is ambiguous. Redo the check to find the exact paths.
+    Paths.clear();
+    Paths.setRecordingPaths(true);
+    bool StillOkay = IsDerivedFrom(ToClass, FromClass, Paths);
+    assert(StillOkay && "Derivation changed due to quantum fluctuation.");
+    (void)StillOkay;
 
-      if (const CXXRecordType *VBase = Paths.getDetectedVirtual()) {
-        Diag(From->getExprLoc(), diag::err_memptr_conv_via_virtual)
-          << FromClass << ToClass << QualType(VBase, 0)
-          << From->getSourceRange();
-        return true;
-      }
-    }
+    std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
+    Diag(From->getExprLoc(), diag::err_ambiguous_memptr_conv)
+      << 0 << FromClass << ToClass << PathDisplayStr << From->getSourceRange();
+    return true;
   }
+
+  if (const CXXRecordType *VBase = Paths.getDetectedVirtual()) {
+    Diag(From->getExprLoc(), diag::err_memptr_conv_via_virtual)
+      << FromClass << ToClass << QualType(VBase, 0)
+      << From->getSourceRange();
+    return true;
+  }
+
   return false;
 }
 
@@ -1148,7 +1147,7 @@
   // qualification conversion.
   if (FromType == ToType)
     return false;
-    
+
   // (C++ 4.4p4):
   //   A conversion can add cv-qualifiers at levels other than the first
   //   in multi-level pointers, subject to the following rules: [...]
diff --git a/lib/Sema/SemaType.cpp b/lib/Sema/SemaType.cpp
index 60219fe..5d54f46 100644
--- a/lib/Sema/SemaType.cpp
+++ b/lib/Sema/SemaType.cpp
@@ -662,7 +662,9 @@
 
   const MemberPointerType *T1MPType = T1->getAsMemberPointerType(),
                           *T2MPType = T2->getAsMemberPointerType();
-  if (T1MPType && T2MPType) {
+  if (T1MPType && T2MPType &&
+      Context.getCanonicalType(T1MPType->getClass()) ==
+      Context.getCanonicalType(T2MPType->getClass())) {
     T1 = T1MPType->getPointeeType();
     T2 = T2MPType->getPointeeType();
     return true;