Remove constant member pointer support from Expr-based constant emission now

that APValue-based constant emission knows how to emit member pointers.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@148336 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/CodeGen/CGCXXABI.cpp b/lib/CodeGen/CGCXXABI.cpp
index 702029dd34768ba0cd18fd9a0a1f59b73a77de5c..c1b20af799fcc103b8e6d246129cc270980910f2 100644 (file)
--- a/lib/CodeGen/CGCXXABI.cpp
+++ b/lib/CodeGen/CGCXXABI.cpp
@@ -89,11 +89,6 @@ CGCXXABI::EmitMemberPointerIsNotNull(CodeGenFunction &CGF,
   return CGF.Builder.getFalse();
 }
 
-llvm::Constant *
-CGCXXABI::EmitMemberPointerConversion(llvm::Constant *C, const CastExpr *E) {
-  return GetBogusMemberPointer(CGM, E->getType());
-}
-
 llvm::Constant *
 CGCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
   return GetBogusMemberPointer(CGM, QualType(MPT, 0));

diff --git a/lib/CodeGen/CGCXXABI.h b/lib/CodeGen/CGCXXABI.h
index e86e639627b8243af76eba853919619a1ca41887..5fd611d44f382180793fc6879544c1428440bce3 100644 (file)
--- a/lib/CodeGen/CGCXXABI.h
+++ b/lib/CodeGen/CGCXXABI.h
@@ -106,11 +106,6 @@ public:
                                                    const CastExpr *E,
                                                    llvm::Value *Src);
 
-  /// Perform a derived-to-base or base-to-derived member pointer
-  /// conversion on a constant member pointer.
-  virtual llvm::Constant *EmitMemberPointerConversion(llvm::Constant *C,
-                                                      const CastExpr *E);
-
   /// Return true if the given member pointer can be zero-initialized
   /// (in the C++ sense) with an LLVM zeroinitializer.
   virtual bool isZeroInitializable(const MemberPointerType *MPT);

diff --git a/lib/CodeGen/CGExprConstant.cpp b/lib/CodeGen/CGExprConstant.cpp
index 789d863bbd009324555339d49e4d69f74f52b74d..d95a37c584351479cc26adbe48f8964ca2c9571b 100644 (file)
--- a/lib/CodeGen/CGExprConstant.cpp
+++ b/lib/CodeGen/CGExprConstant.cpp
@@ -535,7 +535,11 @@ llvm::Constant *ConstStructBuilder::BuildStruct(CodeGenModule &CGM,
 //===----------------------------------------------------------------------===//
 //                             ConstExprEmitter
 //===----------------------------------------------------------------------===//
-  
+
+/// This class only needs to handle two cases:
+/// 1) Literals (this is used by APValue emission to emit literals).
+/// 2) Arrays, structs and unions (outside C++11 mode, we don't currently
+///    constant fold these types).
 class ConstExprEmitter :
   public StmtVisitor<ConstExprEmitter, llvm::Constant*> {
   CodeGenModule &CGM;
@@ -571,13 +575,6 @@ public:
     return Visit(E->getInitializer());
   }
 
-  llvm::Constant *VisitUnaryAddrOf(UnaryOperator *E) {
-    if (E->getType()->isMemberPointerType())
-      return CGM.getMemberPointerConstant(E);
-
-    return 0;
-  }
-    
   llvm::Constant *VisitCastExpr(CastExpr* E) {
     Expr *subExpr = E->getSubExpr();
     llvm::Constant *C = CGM.EmitConstantExpr(subExpr, subExpr->getType(), CGF);
@@ -614,14 +611,6 @@ public:
         llvm::StructType::get(C->getType()->getContext(), Types, false);
       return llvm::ConstantStruct::get(STy, Elts);
     }
-    case CK_NullToMemberPointer: {
-      const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>();
-      return CGM.getCXXABI().EmitNullMemberPointer(MPT);
-    }
-
-    case CK_DerivedToBaseMemberPointer:
-    case CK_BaseToDerivedMemberPointer:
-      return CGM.getCXXABI().EmitMemberPointerConversion(C, E);
 
     case CK_LValueToRValue:
     case CK_AtomicToNonAtomic:
@@ -633,22 +622,22 @@ public:
 
     // These will never be supported.
     case CK_ObjCObjectLValueCast:
-    case CK_ToVoid:
-    case CK_Dynamic:
     case CK_ARCProduceObject:
     case CK_ARCConsumeObject:
     case CK_ARCReclaimReturnedObject:
     case CK_ARCExtendBlockObject:
-    case CK_LValueBitCast:
       return 0;
 
-    // These might need to be supported for constexpr.
+    // These don't need to be handled here because Evaluate knows how to
+    // evaluate them in the cases where they can be folded.
+    case CK_ToVoid:
+    case CK_Dynamic:
+    case CK_LValueBitCast:
+    case CK_NullToMemberPointer:
+    case CK_DerivedToBaseMemberPointer:
+    case CK_BaseToDerivedMemberPointer:
     case CK_UserDefinedConversion:
     case CK_ConstructorConversion:
-      return 0;
-
-    // These don't need to be handled here because Evaluate knows how to
-    // evaluate all scalar expressions which can be constant-evaluated.
     case CK_CPointerToObjCPointerCast:
     case CK_BlockPointerToObjCPointerCast:
     case CK_AnyPointerToBlockPointerCast:

diff --git a/lib/CodeGen/ItaniumCXXABI.cpp b/lib/CodeGen/ItaniumCXXABI.cpp
index 969f03a8b06083936d32fedb0e728fe1c69d0b51..b319420342504bdd5cadc03e85cd32e1e21496bc 100644 (file)
--- a/lib/CodeGen/ItaniumCXXABI.cpp
+++ b/lib/CodeGen/ItaniumCXXABI.cpp
@@ -74,9 +74,6 @@ public:
                                            const CastExpr *E,
                                            llvm::Value *Src);
 
-  llvm::Constant *EmitMemberPointerConversion(llvm::Constant *C,
-                                              const CastExpr *E);
-
   llvm::Constant *EmitNullMemberPointer(const MemberPointerType *MPT);
 
   llvm::Constant *EmitMemberPointer(const CXXMethodDecl *MD);
@@ -342,9 +339,6 @@ ItaniumCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
   assert(E->getCastKind() == CK_DerivedToBaseMemberPointer ||
          E->getCastKind() == CK_BaseToDerivedMemberPointer);
 
-  if (isa<llvm::Constant>(Src))
-    return EmitMemberPointerConversion(cast<llvm::Constant>(Src), E);
-
   CGBuilderTy &Builder = CGF.Builder;
 
   const MemberPointerType *SrcTy =
@@ -401,84 +395,6 @@ ItaniumCXXABI::EmitMemberPointerConversion(CodeGenFunction &CGF,
   return Builder.CreateInsertValue(Src, DstAdj, 1);
 }
 
-llvm::Constant *
-ItaniumCXXABI::EmitMemberPointerConversion(llvm::Constant *C,
-                                           const CastExpr *E) {
-  const MemberPointerType *SrcTy = 
-    E->getSubExpr()->getType()->getAs<MemberPointerType>();
-  const MemberPointerType *DestTy = 
-    E->getType()->getAs<MemberPointerType>();
-
-  bool DerivedToBase =
-    E->getCastKind() == CK_DerivedToBaseMemberPointer;
-
-  const CXXRecordDecl *DerivedDecl;
-  if (DerivedToBase)
-    DerivedDecl = SrcTy->getClass()->getAsCXXRecordDecl();
-  else
-    DerivedDecl = DestTy->getClass()->getAsCXXRecordDecl();
-
-  // Calculate the offset to the base class.
-  llvm::Constant *Offset = 
-    CGM.GetNonVirtualBaseClassOffset(DerivedDecl,
-                                     E->path_begin(),
-                                     E->path_end());
-  // If there's no offset, we're done.
-  if (!Offset) return C;
-
-  // If the source is a member data pointer, we have to do a null
-  // check and then add the offset.  In the common case, we can fold
-  // away the offset.
-  if (SrcTy->isMemberDataPointer()) {
-    assert(C->getType() == getPtrDiffTy());
-
-    // If it's a constant int, just create a new constant int.
-    if (llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(C)) {
-      int64_t Src = CI->getSExtValue();
-
-      // Null converts to null.
-      if (Src == -1) return CI;
-
-      // Otherwise, just add the offset.
-      int64_t OffsetV = cast<llvm::ConstantInt>(Offset)->getSExtValue();
-      int64_t Dst = (DerivedToBase ? Src - OffsetV : Src + OffsetV);
-      return llvm::ConstantInt::get(CI->getType(), Dst, /*signed*/ true);
-    }
-
-    // Otherwise, we have to form a constant select expression.
-    llvm::Constant *Null = llvm::Constant::getAllOnesValue(C->getType());
-
-    llvm::Constant *IsNull =
-      llvm::ConstantExpr::getICmp(llvm::ICmpInst::ICMP_EQ, C, Null);
-
-    llvm::Constant *Dst;
-    if (DerivedToBase)
-      Dst = llvm::ConstantExpr::getNSWSub(C, Offset);
-    else
-      Dst = llvm::ConstantExpr::getNSWAdd(C, Offset);
-
-    return llvm::ConstantExpr::getSelect(IsNull, Null, Dst);
-  }
-
-  // The this-adjustment is left-shifted by 1 on ARM.
-  if (IsARM) {
-    int64_t OffsetV = cast<llvm::ConstantInt>(Offset)->getSExtValue();
-    OffsetV <<= 1;
-    Offset = llvm::ConstantInt::get(Offset->getType(), OffsetV);
-  }
-
-  llvm::ConstantStruct *CS = cast<llvm::ConstantStruct>(C);
-
-  llvm::Constant *Values[2] = { CS->getOperand(0), 0 };
-  if (DerivedToBase)
-    Values[1] = llvm::ConstantExpr::getSub(CS->getOperand(1), Offset);
-  else
-    Values[1] = llvm::ConstantExpr::getAdd(CS->getOperand(1), Offset);
-
-  return llvm::ConstantStruct::get(CS->getType(), Values);
-}        
-
-
 llvm::Constant *
 ItaniumCXXABI::EmitNullMemberPointer(const MemberPointerType *MPT) {
   llvm::Type *ptrdiff_t = getPtrDiffTy();