diff --git a/lib/CodeGen/CGCXX.cpp b/lib/CodeGen/CGCXX.cpp
index 2d7b27b..b805d13 100644
--- a/lib/CodeGen/CGCXX.cpp
+++ b/lib/CodeGen/CGCXX.cpp
@@ -330,6 +330,11 @@
     << S;
 }
 
+static llvm::Constant *GetBogusMemberPointer(CodeGenModule &CGM,
+                                             QualType T) {
+  return llvm::Constant::getNullValue(CGM.getTypes().ConvertType(T));
+}
+
 llvm::Value *CGCXXABI::EmitLoadOfMemberFunctionPointer(CodeGenFunction &CGF,
                                                        llvm::Value *&This,
                                                        llvm::Value *MemPtr,
@@ -341,32 +346,16 @@
   const CXXRecordDecl *RD = 
     cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl());
   const llvm::FunctionType *FTy = 
-    CGF.CGM.getTypes().GetFunctionType(
-                                 CGF.CGM.getTypes().getFunctionInfo(RD, FPT),
-                                 FPT->isVariadic());
+    CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(RD, FPT),
+                                   FPT->isVariadic());
   return llvm::Constant::getNullValue(FTy->getPointerTo());
 }
 
-void CGCXXABI::EmitMemberFunctionPointerConversion(CodeGenFunction &CGF,
-                                                   const CastExpr *E,
-                                                   llvm::Value *Src,
-                                                   llvm::Value *Dest,
-                                                   bool VolatileDest) {
+llvm::Value *CGCXXABI::EmitMemberFunctionPointerConversion(CodeGenFunction &CGF,
+                                                           const CastExpr *E,
+                                                           llvm::Value *Src) {
   ErrorUnsupportedABI(CGF, "member function pointer conversions");
-}
-
-void CGCXXABI::EmitNullMemberFunctionPointer(CodeGenFunction &CGF,
-                                             const MemberPointerType *MPT,
-                                             llvm::Value *Dest,
-                                             bool VolatileDest) {
-  ErrorUnsupportedABI(CGF, "null member function pointers");
-}
-
-void CGCXXABI::EmitMemberFunctionPointer(CodeGenFunction &CGF,
-                                         const CXXMethodDecl *MD,
-                                         llvm::Value *DestPtr,
-                                         bool VolatileDest) {
-  ErrorUnsupportedABI(CGF, "member function pointers");
+  return GetBogusMemberPointer(CGM, E->getType());
 }
 
 llvm::Value *
@@ -390,16 +379,18 @@
 llvm::Constant *
 CGCXXABI::EmitMemberFunctionPointerConversion(llvm::Constant *C,
                                               const CastExpr *E) {
-  return 0;
+  return GetBogusMemberPointer(CGM, E->getType());
 }
 
 llvm::Constant *
 CGCXXABI::EmitNullMemberFunctionPointer(const MemberPointerType *MPT) {
-  return 0;
+  return GetBogusMemberPointer(CGM, QualType(MPT, 0));
 }
 
 llvm::Constant *CGCXXABI::EmitMemberFunctionPointer(const CXXMethodDecl *MD) {
-  return 0;
+  return GetBogusMemberPointer(CGM,
+                         CGM.getContext().getMemberPointerType(MD->getType(),
+                                         MD->getParent()->getTypeForDecl()));
 }
 
 bool CGCXXABI::RequiresNonZeroInitializer(QualType T) {
diff --git a/lib/CodeGen/CGCXXABI.h b/lib/CodeGen/CGCXXABI.h
index 8478df4..d0bb0e8 100644
--- a/lib/CodeGen/CGCXXABI.h
+++ b/lib/CodeGen/CGCXXABI.h
@@ -34,7 +34,13 @@
 
 /// Implements C++ ABI-specific code generation functions.
 class CGCXXABI {
+protected:
+  CodeGenModule &CGM;
+
+  CGCXXABI(CodeGenModule &CGM) : CGM(CGM) {}
+
 public:
+
   virtual ~CGCXXABI();
 
   /// Gets the mangle context.
@@ -46,18 +52,11 @@
                                   llvm::Value *MemPtr,
                                   const MemberPointerType *MPT);
 
-  virtual void
+  virtual llvm::Value *
   EmitMemberFunctionPointerConversion(CodeGenFunction &CGF,
                                       const CastExpr *E,
-                                      llvm::Value *Src,
-                                      llvm::Value *Dest,
-                                      bool VolatileDest);
+                                      llvm::Value *Src);
 
-  virtual void EmitNullMemberFunctionPointer(CodeGenFunction &CGF,
-                                             const MemberPointerType *MPT,
-                                             llvm::Value *Dest,
-                                             bool VolatileDest);
-  
   // Manipulations on constant expressions.
 
   /// \brief Returns true if zero-initializing the given type requires
@@ -73,10 +72,6 @@
   EmitNullMemberFunctionPointer(const MemberPointerType *MPT);
 
   virtual llvm::Constant *EmitMemberFunctionPointer(const CXXMethodDecl *MD);
-  virtual void EmitMemberFunctionPointer(CodeGenFunction &CGF,
-                                         const CXXMethodDecl *MD,
-                                         llvm::Value *DestPtr,
-                                         bool VolatileDest);
 
   virtual llvm::Value *
   EmitMemberFunctionPointerComparison(CodeGenFunction &CGF,
@@ -87,7 +82,7 @@
 
   virtual llvm::Value *
   EmitMemberFunctionPointerIsNotNull(CodeGenFunction &CGF,
-                                     llvm::Value *Addr,
+                                     llvm::Value *MemPtr,
                                      const MemberPointerType *MPT);
 };
 
diff --git a/lib/CodeGen/CGExpr.cpp b/lib/CodeGen/CGExpr.cpp
index 753af76..55abaa3 100644
--- a/lib/CodeGen/CGExpr.cpp
+++ b/lib/CodeGen/CGExpr.cpp
@@ -67,10 +67,8 @@
 llvm::Value *CodeGenFunction::EvaluateExprAsBool(const Expr *E) {
   QualType BoolTy = getContext().BoolTy;
   if (E->getType()->isMemberFunctionPointerType()) {
-    LValue LV = EmitAggExprToLValue(E);
-
-    return CGM.getCXXABI().EmitMemberFunctionPointerIsNotNull(CGF,
-                                                              LV.getAddress(),
+    llvm::Value *MemPtr = EmitScalarExpr(E);
+    return CGM.getCXXABI().EmitMemberFunctionPointerIsNotNull(CGF, MemPtr,
                                     E->getType()->getAs<MemberPointerType>());
   }
   if (!E->getType()->isAnyComplexType())
@@ -614,18 +612,15 @@
 
   if (LV.isSimple()) {
     llvm::Value *Ptr = LV.getAddress();
-    const llvm::Type *EltTy =
-      cast<llvm::PointerType>(Ptr->getType())->getElementType();
 
-    // Simple scalar l-value.
-    //
-    // FIXME: We shouldn't have to use isSingleValueType here.
-    if (EltTy->isSingleValueType())
-      return RValue::get(EmitLoadOfScalar(Ptr, LV.isVolatileQualified(),
-                                          LV.getAlignment(), ExprType));
+    // Functions are l-values that don't require loading.
+    if (ExprType->isFunctionType())
+      return RValue::get(Ptr);
 
-    assert(ExprType->isFunctionType() && "Unknown scalar value");
-    return RValue::get(Ptr);
+    // Everything needs a load.
+    return RValue::get(EmitLoadOfScalar(Ptr, LV.isVolatileQualified(),
+                                        LV.getAlignment(), ExprType));
+
   }
 
   if (LV.isVectorElt()) {
@@ -1177,12 +1172,19 @@
     return LV;
   }
   
+  // If we're emitting an instance method as an independent lvalue,
+  // we're actually emitting a member pointer.
+  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(ND))
+    if (MD->isInstance()) {
+      llvm::Value *V = CGM.getCXXABI().EmitMemberFunctionPointer(MD);
+      return MakeAddrLValue(V, MD->getType(), Alignment);
+    }
   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
     return EmitFunctionDeclLValue(*this, E, FD);
   
-  // FIXME: the qualifier check does not seem sufficient here
-  if (E->getQualifier()) {
-    const FieldDecl *FD = cast<FieldDecl>(ND);
+  // If we're emitting a field as an independent lvalue, we're
+  // actually emitting a member pointer.
+  if (const FieldDecl *FD = dyn_cast<FieldDecl>(ND)) {
     llvm::Value *V = CGM.EmitPointerToDataMember(FD);
     return MakeAddrLValue(V, FD->getType(), Alignment);
   }
diff --git a/lib/CodeGen/CGExprAgg.cpp b/lib/CodeGen/CGExprAgg.cpp
index b75aeb1..890a07f 100644
--- a/lib/CodeGen/CGExprAgg.cpp
+++ b/lib/CodeGen/CGExprAgg.cpp
@@ -108,7 +108,6 @@
   void VisitPointerToDataMemberBinaryOperator(const BinaryOperator *BO);
   void VisitBinAssign(const BinaryOperator *E);
   void VisitBinComma(const BinaryOperator *E);
-  void VisitUnaryAddrOf(const UnaryOperator *E);
 
   void VisitObjCMessageExpr(ObjCMessageExpr *E);
   void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
@@ -287,46 +286,9 @@
     Visit(E->getSubExpr());
     break;
 
-  case CastExpr::CK_NullToMemberPointer: {
-    // If the subexpression's type is the C++0x nullptr_t, emit the
-    // subexpression, which may have side effects.
-    if (E->getSubExpr()->getType()->isNullPtrType())
-      Visit(E->getSubExpr());
-
-    CGF.CGM.getCXXABI().EmitNullMemberFunctionPointer(CGF,
-                                    E->getType()->getAs<MemberPointerType>(),
-                                                      DestPtr, VolatileDest);
-
-    break;
-  }
-      
   case CastExpr::CK_LValueBitCast:
     llvm_unreachable("there are no lvalue bit-casts on aggregates");
     break;
-      
-  case CastExpr::CK_BitCast: {
-    // This must be a member function pointer cast.
-    Visit(E->getSubExpr());
-    break;
-  }
-
-  case CastExpr::CK_DerivedToBaseMemberPointer:
-  case CastExpr::CK_BaseToDerivedMemberPointer: {
-    QualType SrcType = E->getSubExpr()->getType();
-    
-    llvm::Value *Src = CGF.CreateMemTemp(SrcType, "tmp");
-    CGF.EmitAggExpr(E->getSubExpr(), Src, SrcType.isVolatileQualified());
-
-    // Note that the AST doesn't distinguish between checked and
-    // unchecked member pointer conversions, so we always have to
-    // implement checked conversions here.  This is inefficient for
-    // ABIs where an actual null check is thus required; fortunately,
-    // the Itanium and ARM ABIs ignore the adjustment value when
-    // considering null-ness.
-    CGF.CGM.getCXXABI().EmitMemberFunctionPointerConversion(CGF, E, Src,
-                                                   DestPtr, VolatileDest);
-    break;
-  }
   }
 }
 
@@ -362,23 +324,6 @@
                   /*IgnoreResult=*/false, IsInitializer);
 }
 
-void AggExprEmitter::VisitUnaryAddrOf(const UnaryOperator *E) {
-  // We have a member function pointer.
-  assert(E->getType()->getAs<MemberPointerType>()
-          ->getPointeeType()->isFunctionProtoType() &&
-         "Unexpected member pointer type!");
-
-  // The creation of member function pointers has no side effects; if
-  // there is no destination pointer, we have nothing to do.
-  if (!DestPtr)
-    return;
-  
-  const DeclRefExpr *DRE = cast<DeclRefExpr>(E->getSubExpr());
-  const CXXMethodDecl *MD = cast<CXXMethodDecl>(DRE->getDecl());
-
-  CGF.CGM.getCXXABI().EmitMemberFunctionPointer(CGF, MD, DestPtr, VolatileDest);
-}
-
 void AggExprEmitter::VisitStmtExpr(const StmtExpr *E) {
   CGF.EmitCompoundStmt(*E->getSubStmt(), true, DestPtr, VolatileDest);
 }
diff --git a/lib/CodeGen/CGExprCXX.cpp b/lib/CodeGen/CGExprCXX.cpp
index fb54140..ad65b10 100644
--- a/lib/CodeGen/CGExprCXX.cpp
+++ b/lib/CodeGen/CGExprCXX.cpp
@@ -160,8 +160,7 @@
     cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl());
 
   // Get the member function pointer.
-  llvm::Value *MemFnPtr = CreateMemTemp(MemFnExpr->getType(), "mem.fn");
-  EmitAggExpr(MemFnExpr, MemFnPtr, /*VolatileDest=*/false);
+  llvm::Value *MemFnPtr = EmitScalarExpr(MemFnExpr);
 
   // Emit the 'this' pointer.
   llvm::Value *This;
diff --git a/lib/CodeGen/CGExprConstant.cpp b/lib/CodeGen/CGExprConstant.cpp
index e0335b6..b97e725 100644
--- a/lib/CodeGen/CGExprConstant.cpp
+++ b/lib/CodeGen/CGExprConstant.cpp
@@ -460,7 +460,7 @@
 
   llvm::Constant *VisitUnaryAddrOf(UnaryOperator *E) {
     if (const MemberPointerType *MPT = 
-        E->getType()->getAs<MemberPointerType>()) {
+          E->getType()->getAs<MemberPointerType>()) {
       QualType T = MPT->getPointeeType();
       DeclRefExpr *DRE = cast<DeclRefExpr>(E->getSubExpr());
 
@@ -533,13 +533,21 @@
         llvm::StructType::get(C->getType()->getContext(), Types, false);
       return llvm::ConstantStruct::get(STy, Elts);
     }
-    case CastExpr::CK_NullToMemberPointer:
-      return CGM.getCXXABI().EmitNullMemberFunctionPointer(
-                                   E->getType()->getAs<MemberPointerType>());
+    case CastExpr::CK_NullToMemberPointer: {
+      const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>();
+      if (MPT->getPointeeType()->isFunctionType())
+        return CGM.getCXXABI().EmitNullMemberFunctionPointer(MPT);
+      return CGM.EmitNullConstant(E->getType());
+    }
       
     case CastExpr::CK_BaseToDerivedMemberPointer: {
-      Expr *SubExpr = E->getSubExpr();
+      const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>();
 
+      // TODO: support data-member conversions here!
+      if (!MPT->getPointeeType()->isFunctionType())
+        return 0;
+
+      Expr *SubExpr = E->getSubExpr();
       llvm::Constant *C = 
         CGM.EmitConstantExpr(SubExpr, SubExpr->getType(), CGF);
       if (!C) return 0;
diff --git a/lib/CodeGen/CGExprScalar.cpp b/lib/CodeGen/CGExprScalar.cpp
index d65c22a..38a49ee 100644
--- a/lib/CodeGen/CGExprScalar.cpp
+++ b/lib/CodeGen/CGExprScalar.cpp
@@ -238,6 +238,9 @@
 
     
   Value *VisitUnaryAddrOf(const UnaryOperator *E) {
+    // If the sub-expression is an instance member reference,
+    // EmitDeclRefLValue will magically emit it with the appropriate
+    // value as the "address".
     return EmitLValue(E->getSubExpr()).getAddress();
   }
   Value *VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); }
@@ -995,11 +998,31 @@
     return EmitLValue(E).getAddress();
 
   case CastExpr::CK_NullToMemberPointer:
+    // If the subexpression's type is the C++0x nullptr_t, emit the
+    // subexpression, which may have side effects.
+    if (E->getType()->isNullPtrType())
+      (void) Visit(E);
+
+    if (CE->getType()->isMemberFunctionPointerType())
+      return CGF.CGM.getCXXABI().EmitNullMemberFunctionPointer(
+                                   CE->getType()->getAs<MemberPointerType>());
+
     return CGF.CGM.EmitNullConstant(DestTy);
 
   case CastExpr::CK_BaseToDerivedMemberPointer:
   case CastExpr::CK_DerivedToBaseMemberPointer: {
     Value *Src = Visit(E);
+    
+    // Note that the AST doesn't distinguish between checked and
+    // unchecked member pointer conversions, so we always have to
+    // implement checked conversions here.  This is inefficient when
+    // actual control flow may be required in order to perform the
+    // check, which it is for data member pointers (but not member
+    // function pointers on Itanium and ARM).
+
+    if (CE->getType()->isMemberFunctionPointerType())
+      return CGF.CGM.getCXXABI().EmitMemberFunctionPointerConversion(CGF, CE,
+                                                                     Src);
 
     // See if we need to adjust the pointer.
     const CXXRecordDecl *BaseDecl = 
@@ -1804,10 +1827,10 @@
   if (LHSTy->isMemberFunctionPointerType()) {
     assert(E->getOpcode() == BinaryOperator::EQ ||
            E->getOpcode() == BinaryOperator::NE);
-    Value *LHSPtr = CGF.EmitAnyExprToTemp(E->getLHS()).getAggregateAddr();
-    Value *RHSPtr = CGF.EmitAnyExprToTemp(E->getRHS()).getAggregateAddr();
+    Value *LHS = CGF.EmitScalarExpr(E->getLHS());
+    Value *RHS = CGF.EmitScalarExpr(E->getRHS());
     Result = CGF.CGM.getCXXABI().EmitMemberFunctionPointerComparison(
-                     CGF, LHSPtr, RHSPtr, LHSTy->getAs<MemberPointerType>(),
+                         CGF, LHS, RHS, LHSTy->getAs<MemberPointerType>(),
                                     E->getOpcode() == BinaryOperator::NE);
   } else if (!LHSTy->isAnyComplexType()) {
     Value *LHS = Visit(E->getLHS());
diff --git a/lib/CodeGen/CodeGenFunction.cpp b/lib/CodeGen/CodeGenFunction.cpp
index ca4e698..91442fa 100644
--- a/lib/CodeGen/CodeGenFunction.cpp
+++ b/lib/CodeGen/CodeGenFunction.cpp
@@ -77,7 +77,7 @@
 
 bool CodeGenFunction::hasAggregateLLVMType(QualType T) {
   return T->isRecordType() || T->isArrayType() || T->isAnyComplexType() ||
-    T->isMemberFunctionPointerType() || T->isObjCObjectType();
+    T->isObjCObjectType();
 }
 
 void CodeGenFunction::EmitReturnBlock() {
diff --git a/lib/CodeGen/ItaniumCXXABI.cpp b/lib/CodeGen/ItaniumCXXABI.cpp
index cd8b278..efaddf2 100644
--- a/lib/CodeGen/ItaniumCXXABI.cpp
+++ b/lib/CodeGen/ItaniumCXXABI.cpp
@@ -31,12 +31,11 @@
 namespace {
 class ItaniumCXXABI : public CodeGen::CGCXXABI {
 protected:
-  CodeGenModule &CGM;
   CodeGen::MangleContext MangleCtx;
   bool IsARM;
 public:
   ItaniumCXXABI(CodeGen::CodeGenModule &CGM, bool IsARM = false) :
-    CGM(CGM), MangleCtx(CGM.getContext(), CGM.getDiags()), IsARM(IsARM) { }
+    CGCXXABI(CGM), MangleCtx(CGM.getContext(), CGM.getDiags()), IsARM(IsARM) { }
 
   CodeGen::MangleContext &getMangleContext() {
     return MangleCtx;
@@ -50,27 +49,15 @@
                                                llvm::Value *MemFnPtr,
                                                const MemberPointerType *MPT);
 
-  void EmitMemberFunctionPointerConversion(CodeGenFunction &CGF,
-                                           const CastExpr *E,
-                                           llvm::Value *Src,
-                                           llvm::Value *Dest,
-                                           bool VolatileDest);
+  llvm::Value *EmitMemberFunctionPointerConversion(CodeGenFunction &CGF,
+                                                   const CastExpr *E,
+                                                   llvm::Value *Src);
 
   llvm::Constant *EmitMemberFunctionPointerConversion(llvm::Constant *C,
                                                       const CastExpr *E);
 
-  void EmitNullMemberFunctionPointer(CodeGenFunction &CGF,
-                                     const MemberPointerType *MPT,
-                                     llvm::Value *Dest,
-                                     bool VolatileDest);
-
   llvm::Constant *EmitNullMemberFunctionPointer(const MemberPointerType *MPT);
 
-  void EmitMemberFunctionPointer(CodeGenFunction &CGF,
-                                 const CXXMethodDecl *MD,
-                                 llvm::Value *Dest,
-                                 bool VolatileDest);
-
   llvm::Constant *EmitMemberFunctionPointer(const CXXMethodDecl *MD);
 
   llvm::Value *EmitMemberFunctionPointerComparison(CodeGenFunction &CGF,
@@ -104,57 +91,6 @@
 
 void ItaniumCXXABI::GetMemberFunctionPointer(const CXXMethodDecl *MD,
                                              llvm::Constant *(&MemPtr)[2]) {
-  assert(MD->isInstance() && "Member function must not be static!");
-    
-  MD = MD->getCanonicalDecl();
-
-  CodeGenTypes &Types = CGM.getTypes();
-  const llvm::Type *ptrdiff_t = 
-    Types.ConvertType(CGM.getContext().getPointerDiffType());
-
-  // Get the function pointer (or index if this is a virtual function).
-  if (MD->isVirtual()) {
-    uint64_t Index = CGM.getVTables().getMethodVTableIndex(MD);
-
-    // FIXME: We shouldn't use / 8 here.
-    uint64_t PointerWidthInBytes =
-      CGM.getContext().Target.getPointerWidth(0) / 8;
-    uint64_t VTableOffset = (Index * PointerWidthInBytes);
-
-    if (IsARM) {
-      // ARM C++ ABI 3.2.1:
-      //   This ABI specifies that adj contains twice the this
-      //   adjustment, plus 1 if the member function is virtual. The
-      //   least significant bit of adj then makes exactly the same
-      //   discrimination as the least significant bit of ptr does for
-      //   Itanium.
-      MemPtr[0] = llvm::ConstantInt::get(ptrdiff_t, VTableOffset);
-      MemPtr[1] = llvm::ConstantInt::get(ptrdiff_t, 1);
-    } else {
-      // Itanium C++ ABI 2.3:
-      //   For a virtual function, [the pointer field] is 1 plus the
-      //   virtual table offset (in bytes) of the function,
-      //   represented as a ptrdiff_t.
-      MemPtr[0] = llvm::ConstantInt::get(ptrdiff_t, VTableOffset + 1);
-      MemPtr[1] = llvm::ConstantInt::get(ptrdiff_t, 0);
-    }
-  } else {
-    const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
-    const llvm::Type *Ty;
-    // Check whether the function has a computable LLVM signature.
-    if (!CodeGenTypes::VerifyFuncTypeComplete(FPT)) {
-      // The function has a computable LLVM signature; use the correct type.
-      Ty = Types.GetFunctionType(Types.getFunctionInfo(MD), FPT->isVariadic());
-    } else {
-      // Use an arbitrary non-function type to tell GetAddrOfFunction that the
-      // function type is incomplete.
-      Ty = ptrdiff_t;
-    }
-
-    llvm::Constant *Addr = CGM.GetAddrOfFunction(MD, Ty);
-    MemPtr[0] = llvm::ConstantExpr::getPtrToInt(Addr, ptrdiff_t);
-    MemPtr[1] = llvm::ConstantInt::get(ptrdiff_t, 0);
-  }
 }
 
 
@@ -201,9 +137,8 @@
   llvm::BasicBlock *FnNonVirtual = CGF.createBasicBlock("memptr.nonvirtual");
   llvm::BasicBlock *FnEnd = CGF.createBasicBlock("memptr.end");
 
-  // Load memptr.adj, which is in the second field.
-  llvm::Value *RawAdj = Builder.CreateStructGEP(MemFnPtr, 1);
-  RawAdj = Builder.CreateLoad(RawAdj, "memptr.adj");
+  // Extract memptr.adj, which is in the second field.
+  llvm::Value *RawAdj = Builder.CreateExtractValue(MemFnPtr, 1, "memptr.adj");
 
   // Compute the true adjustment.
   llvm::Value *Adj = RawAdj;
@@ -217,8 +152,7 @@
   This = Builder.CreateBitCast(Ptr, This->getType(), "this.adjusted");
   
   // Load the function pointer.
-  llvm::Value *FnPtr = Builder.CreateStructGEP(MemFnPtr, 0);
-  llvm::Value *FnAsInt = Builder.CreateLoad(FnPtr, "memptr.ptr");
+  llvm::Value *FnAsInt = Builder.CreateExtractValue(MemFnPtr, 0, "memptr.ptr");
   
   // If the LSB in the function pointer is 1, the function pointer points to
   // a virtual function.
@@ -266,14 +200,16 @@
 }
 
 /// Perform a derived-to-base or base-to-derived member pointer conversion.
-void ItaniumCXXABI::EmitMemberFunctionPointerConversion(CodeGenFunction &CGF,
-                                                        const CastExpr *E,
-                                                        llvm::Value *Src,
-                                                        llvm::Value *Dest,
-                                                        bool VolatileDest) {
+llvm::Value *
+ItaniumCXXABI::EmitMemberFunctionPointerConversion(CodeGenFunction &CGF,
+                                                   const CastExpr *E,
+                                                   llvm::Value *Src) {
   assert(E->getCastKind() == CastExpr::CK_DerivedToBaseMemberPointer ||
          E->getCastKind() == CastExpr::CK_BaseToDerivedMemberPointer);
 
+  if (isa<llvm::Constant>(Src))
+    return EmitMemberFunctionPointerConversion(cast<llvm::Constant>(Src), E);
+
   CGBuilderTy &Builder = CGF.Builder;
 
   const MemberPointerType *SrcTy =
@@ -283,17 +219,6 @@
   const CXXRecordDecl *SrcDecl = SrcTy->getClass()->getAsCXXRecordDecl();
   const CXXRecordDecl *DestDecl = DestTy->getClass()->getAsCXXRecordDecl();
 
-  llvm::Value *SrcPtr = Builder.CreateStructGEP(Src, 0, "src.ptr");
-  SrcPtr = Builder.CreateLoad(SrcPtr);
-    
-  llvm::Value *SrcAdj = Builder.CreateStructGEP(Src, 1, "src.adj");
-  SrcAdj = Builder.CreateLoad(SrcAdj);
-    
-  llvm::Value *DstPtr = Builder.CreateStructGEP(Dest, 0, "dst.ptr");
-  Builder.CreateStore(SrcPtr, DstPtr, VolatileDest);
-    
-  llvm::Value *DstAdj = Builder.CreateStructGEP(Dest, 1, "dst.adj");
-
   bool DerivedToBase =
     E->getCastKind() == CastExpr::CK_DerivedToBaseMemberPointer;
 
@@ -303,24 +228,33 @@
   else
     BaseDecl = SrcDecl, DerivedDecl = DestDecl;
 
-  if (llvm::Constant *Adj = 
-        CGF.CGM.GetNonVirtualBaseClassOffset(DerivedDecl,
-                                             E->path_begin(),
-                                             E->path_end())) {
-    // The this-adjustment is left-shifted by 1 on ARM.
-    if (IsARM) {
-      uint64_t Offset = cast<llvm::ConstantInt>(Adj)->getZExtValue();
-      Offset <<= 1;
-      Adj = llvm::ConstantInt::get(Adj->getType(), Offset);
-    }
+  llvm::Constant *Adj = 
+    CGF.CGM.GetNonVirtualBaseClassOffset(DerivedDecl,
+                                         E->path_begin(),
+                                         E->path_end());
+  if (!Adj) return Src;
 
-    if (DerivedToBase)
-      SrcAdj = Builder.CreateSub(SrcAdj, Adj, "adj");
-    else
-      SrcAdj = Builder.CreateAdd(SrcAdj, Adj, "adj");
-  }
+  llvm::Value *SrcPtr = Builder.CreateExtractValue(Src, 0, "src.ptr");
+  llvm::Value *SrcAdj = Builder.CreateExtractValue(Src, 1, "src.adj");
+
+  llvm::Value *Result = llvm::UndefValue::get(Src->getType());
+  Result = Builder.CreateInsertValue(Result, SrcPtr, 0);
     
-  Builder.CreateStore(SrcAdj, DstAdj, VolatileDest);
+  // The this-adjustment is left-shifted by 1 on ARM.
+  if (IsARM) {
+    uint64_t Offset = cast<llvm::ConstantInt>(Adj)->getZExtValue();
+    Offset <<= 1;
+    Adj = llvm::ConstantInt::get(Adj->getType(), Offset);
+  }
+
+  llvm::Value *DstAdj;
+  if (DerivedToBase)
+    DstAdj = Builder.CreateSub(SrcAdj, Adj, "adj");
+  else
+    DstAdj = Builder.CreateAdd(SrcAdj, Adj, "adj");
+
+  Result = Builder.CreateInsertValue(Result, DstAdj, 1);
+  return Result;
 }
 
 llvm::Constant *
@@ -366,53 +300,73 @@
 }        
 
 
-void ItaniumCXXABI::EmitNullMemberFunctionPointer(CodeGenFunction &CGF,
-                                                  const MemberPointerType *MPT,
-                                                  llvm::Value *Dest,
-                                                  bool VolatileDest) {
-  // Should this be "unabstracted" and implemented in terms of the
-  // Constant version?
-
-  CGBuilderTy &Builder = CGF.Builder;
-
-  const llvm::IntegerType *PtrDiffTy = CGF.IntPtrTy;
-  llvm::Value *Zero = llvm::ConstantInt::get(PtrDiffTy, 0);
-
-  llvm::Value *Ptr = Builder.CreateStructGEP(Dest, 0, "ptr");
-  Builder.CreateStore(Zero, Ptr, VolatileDest);
-    
-  llvm::Value *Adj = Builder.CreateStructGEP(Dest, 1, "adj");
-  Builder.CreateStore(Zero, Adj, VolatileDest);
-}
-
 llvm::Constant *
 ItaniumCXXABI::EmitNullMemberFunctionPointer(const MemberPointerType *MPT) {
-  return CGM.EmitNullConstant(QualType(MPT, 0));
+  const llvm::Type *ptrdiff_t =
+    CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
+
+  llvm::Constant *Zero = llvm::ConstantInt::get(ptrdiff_t, 0);
+  llvm::Constant *Values[2] = { Zero, Zero };
+  return llvm::ConstantStruct::get(CGM.getLLVMContext(), Values, 2,
+                                   /*Packed=*/false);
 }
 
 llvm::Constant *
 ItaniumCXXABI::EmitMemberFunctionPointer(const CXXMethodDecl *MD) {
-  llvm::Constant *Values[2];
-  GetMemberFunctionPointer(MD, Values);
+  assert(MD->isInstance() && "Member function must not be static!");
+  MD = MD->getCanonicalDecl();
+
+  CodeGenTypes &Types = CGM.getTypes();
+  const llvm::Type *ptrdiff_t = 
+    Types.ConvertType(CGM.getContext().getPointerDiffType());
+
+  // Get the function pointer (or index if this is a virtual function).
+  llvm::Constant *MemPtr[2];
+  if (MD->isVirtual()) {
+    uint64_t Index = CGM.getVTables().getMethodVTableIndex(MD);
+
+    // FIXME: We shouldn't use / 8 here.
+    uint64_t PointerWidthInBytes =
+      CGM.getContext().Target.getPointerWidth(0) / 8;
+    uint64_t VTableOffset = (Index * PointerWidthInBytes);
+
+    if (IsARM) {
+      // ARM C++ ABI 3.2.1:
+      //   This ABI specifies that adj contains twice the this
+      //   adjustment, plus 1 if the member function is virtual. The
+      //   least significant bit of adj then makes exactly the same
+      //   discrimination as the least significant bit of ptr does for
+      //   Itanium.
+      MemPtr[0] = llvm::ConstantInt::get(ptrdiff_t, VTableOffset);
+      MemPtr[1] = llvm::ConstantInt::get(ptrdiff_t, 1);
+    } else {
+      // Itanium C++ ABI 2.3:
+      //   For a virtual function, [the pointer field] is 1 plus the
+      //   virtual table offset (in bytes) of the function,
+      //   represented as a ptrdiff_t.
+      MemPtr[0] = llvm::ConstantInt::get(ptrdiff_t, VTableOffset + 1);
+      MemPtr[1] = llvm::ConstantInt::get(ptrdiff_t, 0);
+    }
+  } else {
+    const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
+    const llvm::Type *Ty;
+    // Check whether the function has a computable LLVM signature.
+    if (!CodeGenTypes::VerifyFuncTypeComplete(FPT)) {
+      // The function has a computable LLVM signature; use the correct type.
+      Ty = Types.GetFunctionType(Types.getFunctionInfo(MD), FPT->isVariadic());
+    } else {
+      // Use an arbitrary non-function type to tell GetAddrOfFunction that the
+      // function type is incomplete.
+      Ty = ptrdiff_t;
+    }
+
+    llvm::Constant *Addr = CGM.GetAddrOfFunction(MD, Ty);
+    MemPtr[0] = llvm::ConstantExpr::getPtrToInt(Addr, ptrdiff_t);
+    MemPtr[1] = llvm::ConstantInt::get(ptrdiff_t, 0);
+  }
   
   return llvm::ConstantStruct::get(CGM.getLLVMContext(),
-                                   Values, 2, /*Packed=*/false);
-}
-
-void ItaniumCXXABI::EmitMemberFunctionPointer(CodeGenFunction &CGF,
-                                              const CXXMethodDecl *MD,
-                                              llvm::Value *DestPtr,
-                                              bool VolatileDest) {
-  llvm::Constant *Values[2];
-  GetMemberFunctionPointer(MD, Values);
-
-  CGBuilderTy &Builder = CGF.Builder;
-  
-  llvm::Value *DstPtr = Builder.CreateStructGEP(DestPtr, 0, "memptr.ptr");
-  Builder.CreateStore(Values[0], DstPtr, VolatileDest);
-
-  llvm::Value *AdjPtr = Builder.CreateStructGEP(DestPtr, 1, "memptr.adj");
-  Builder.CreateStore(Values[1], AdjPtr, VolatileDest);
+                                   MemPtr, 2, /*Packed=*/false);
 }
 
 /// The comparison algorithm is pretty easy: the member pointers are
@@ -427,10 +381,8 @@
                                                    bool Inequality) {
   CGBuilderTy &Builder = CGF.Builder;
 
-  llvm::Value *LPtr = Builder.CreateLoad(Builder.CreateStructGEP(L, 0),
-                                         "lhs.memptr.ptr");
-  llvm::Value *RPtr = Builder.CreateLoad(Builder.CreateStructGEP(R, 0),
-                                         "rhs.memptr.ptr");
+  llvm::Value *LPtr = Builder.CreateExtractValue(L, 0, "lhs.memptr.ptr");
+  llvm::Value *RPtr = Builder.CreateExtractValue(R, 0, "rhs.memptr.ptr");
 
   // The Itanium tautology is:
   //   (L == R) <==> (L.ptr == R.ptr /\ (L.ptr == 0 \/ L.adj == R.adj))
@@ -465,10 +417,8 @@
 
   // This condition tests whether L.adj == R.adj.  If this isn't
   // true, the pointers are unequal unless they're both null.
-  llvm::Value *LAdj = Builder.CreateLoad(Builder.CreateStructGEP(L, 1),
-                                         "lhs.memptr.adj");
-  llvm::Value *RAdj = Builder.CreateLoad(Builder.CreateStructGEP(R, 1),
-                                         "rhs.memptr.adj");
+  llvm::Value *LAdj = Builder.CreateExtractValue(L, 1, "lhs.memptr.adj");
+  llvm::Value *RAdj = Builder.CreateExtractValue(R, 1, "rhs.memptr.adj");
   llvm::Value *AdjEq = Builder.CreateICmp(Eq, LAdj, RAdj, "cmp.adj");
 
   // Null member function pointers on ARM clear the low bit of Adj,
@@ -498,8 +448,7 @@
   CGBuilderTy &Builder = CGF.Builder;
   
   // In Itanium, a member function pointer is null if 'ptr' is null.
-  llvm::Value *Ptr =
-    Builder.CreateLoad(Builder.CreateStructGEP(MemPtr, 0), "memptr.ptr");
+  llvm::Value *Ptr = Builder.CreateExtractValue(MemPtr, 0, "memptr.ptr");
 
   llvm::Constant *Zero = llvm::ConstantInt::get(Ptr->getType(), 0);
   llvm::Value *Result = Builder.CreateICmpNE(Ptr, Zero, "memptr.tobool");
@@ -507,8 +456,7 @@
   // In ARM, it's that, plus the low bit of 'adj' must be zero.
   if (IsARM) {
     llvm::Constant *One = llvm::ConstantInt::get(Ptr->getType(), 1);
-    llvm::Value *Adj =
-      Builder.CreateLoad(Builder.CreateStructGEP(MemPtr, 1), "memptr.adj");
+    llvm::Value *Adj = Builder.CreateExtractValue(MemPtr, 1, "memptr.adj");
     llvm::Value *VirtualBit = Builder.CreateAnd(Adj, One, "memptr.virtualbit");
     llvm::Value *IsNotVirtual = Builder.CreateICmpEQ(VirtualBit, Zero,
                                                      "memptr.notvirtual");
diff --git a/lib/CodeGen/MicrosoftCXXABI.cpp b/lib/CodeGen/MicrosoftCXXABI.cpp
index b719c7a..f894f66 100644
--- a/lib/CodeGen/MicrosoftCXXABI.cpp
+++ b/lib/CodeGen/MicrosoftCXXABI.cpp
@@ -112,7 +112,7 @@
   MicrosoftMangleContext MangleCtx;
 public:
   MicrosoftCXXABI(CodeGenModule &CGM)
-   : MangleCtx(CGM.getContext(), CGM.getDiags()) {}
+    : CGCXXABI(CGM), MangleCtx(CGM.getContext(), CGM.getDiags()) {}
 
   MicrosoftMangleContext &getMangleContext() {
     return MangleCtx;
diff --git a/lib/CodeGen/TargetInfo.cpp b/lib/CodeGen/TargetInfo.cpp
index 5ea77be..b98b219 100644
--- a/lib/CodeGen/TargetInfo.cpp
+++ b/lib/CodeGen/TargetInfo.cpp
@@ -36,6 +36,11 @@
   }
 }
 
+static bool isAggregateTypeForABI(QualType T) {
+  return CodeGenFunction::hasAggregateLLVMType(T) ||
+         T->isMemberFunctionPointerType();
+}
+
 ABIInfo::~ABIInfo() {}
 
 ASTContext &ABIInfo::getContext() const {
@@ -218,7 +223,7 @@
       FT = AT->getElementType();
     }
 
-    if (!CodeGenFunction::hasAggregateLLVMType(FT)) {
+    if (!isAggregateTypeForABI(FT)) {
       Found = FT.getTypePtr();
     } else {
       Found = isSingleElementStruct(FT, Context);
@@ -314,7 +319,7 @@
 }
 
 ABIArgInfo DefaultABIInfo::classifyArgumentType(QualType Ty) const {
-  if (CodeGenFunction::hasAggregateLLVMType(Ty))
+  if (isAggregateTypeForABI(Ty))
     return ABIArgInfo::getIndirect(0);
 
   // Treat an enum type as its underlying type.
@@ -467,7 +472,7 @@
     return ABIArgInfo::getDirect();
   }
   
-  if (CodeGenFunction::hasAggregateLLVMType(RetTy)) {
+  if (isAggregateTypeForABI(RetTy)) {
     if (const RecordType *RT = RetTy->getAs<RecordType>()) {
       // Structures with either a non-trivial destructor or a non-trivial
       // copy constructor are always indirect.
@@ -557,7 +562,7 @@
 
 ABIArgInfo X86_32ABIInfo::classifyArgumentType(QualType Ty) const {
   // FIXME: Set alignment on indirect arguments.
-  if (CodeGenFunction::hasAggregateLLVMType(Ty)) {
+  if (isAggregateTypeForABI(Ty)) {
     // Structures with flexible arrays are always indirect.
     if (const RecordType *RT = Ty->getAs<RecordType>()) {
       // Structures with either a non-trivial destructor or a non-trivial
@@ -1094,7 +1099,7 @@
 ABIArgInfo X86_64ABIInfo::getIndirectReturnResult(QualType Ty) const {
   // If this is a scalar LLVM value then assume LLVM will pass it in the right
   // place naturally.
-  if (!CodeGenFunction::hasAggregateLLVMType(Ty)) {
+  if (!isAggregateTypeForABI(Ty)) {
     // Treat an enum type as its underlying type.
     if (const EnumType *EnumTy = Ty->getAs<EnumType>())
       Ty = EnumTy->getDecl()->getIntegerType();
@@ -1109,7 +1114,7 @@
 ABIArgInfo X86_64ABIInfo::getIndirectResult(QualType Ty) const {
   // If this is a scalar LLVM value then assume LLVM will pass it in the right
   // place naturally.
-  if (!CodeGenFunction::hasAggregateLLVMType(Ty)) {
+  if (!isAggregateTypeForABI(Ty)) {
     // Treat an enum type as its underlying type.
     if (const EnumType *EnumTy = Ty->getAs<EnumType>())
       Ty = EnumTy->getDecl()->getIntegerType();
@@ -2079,7 +2084,7 @@
 }
 
 ABIArgInfo ARMABIInfo::classifyArgumentType(QualType Ty) const {
-  if (!CodeGenFunction::hasAggregateLLVMType(Ty)) {
+  if (!isAggregateTypeForABI(Ty)) {
     // Treat an enum type as its underlying type.
     if (const EnumType *EnumTy = Ty->getAs<EnumType>())
       Ty = EnumTy->getDecl()->getIntegerType();
@@ -2205,7 +2210,7 @@
   if (RetTy->isVoidType())
     return ABIArgInfo::getIgnore();
 
-  if (!CodeGenFunction::hasAggregateLLVMType(RetTy)) {
+  if (!isAggregateTypeForABI(RetTy)) {
     // Treat an enum type as its underlying type.
     if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
       RetTy = EnumTy->getDecl()->getIntegerType();
@@ -2295,7 +2300,7 @@
   if (RetTy->isVoidType())
     return ABIArgInfo::getIgnore();
 
-  if (CodeGenFunction::hasAggregateLLVMType(RetTy))
+  if (isAggregateTypeForABI(RetTy))
     return ABIArgInfo::getIndirect(0);
 
   // Treat an enum type as its underlying type.
@@ -2370,7 +2375,7 @@
 ABIArgInfo SystemZABIInfo::classifyReturnType(QualType RetTy) const {
   if (RetTy->isVoidType())
     return ABIArgInfo::getIgnore();
-  if (CodeGenFunction::hasAggregateLLVMType(RetTy))
+  if (isAggregateTypeForABI(RetTy))
     return ABIArgInfo::getIndirect(0);
 
   return (isPromotableIntegerType(RetTy) ?
@@ -2378,7 +2383,7 @@
 }
 
 ABIArgInfo SystemZABIInfo::classifyArgumentType(QualType Ty) const {
-  if (CodeGenFunction::hasAggregateLLVMType(Ty))
+  if (isAggregateTypeForABI(Ty))
     return ABIArgInfo::getIndirect(0);
 
   return (isPromotableIntegerType(Ty) ?