Revert the new reference binding code; I came up with a way simpler solution for...

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

diff --git a/lib/CodeGen/CGCall.cpp b/lib/CodeGen/CGCall.cpp
index e1fe0d29a2dbb1170db4070e37fc2ba8166dea73..ce361f08fef5ad135621dbde9fe979b823e43d21 100644 (file)
--- a/lib/CodeGen/CGCall.cpp
+++ b/lib/CodeGen/CGCall.cpp
@@ -802,11 +802,8 @@ void CodeGenFunction::EmitFunctionEpilog(const CGFunctionInfo &FI,
 }
 
 RValue CodeGenFunction::EmitCallArg(const Expr *E, QualType ArgType) {
-  if (const CXXBindReferenceExpr *BE = dyn_cast<CXXBindReferenceExpr>(E))
-    return RValue::get(EmitCXXBindReferenceExpr(BE));
-  
   if (ArgType->isReferenceType())
-    return EmitReferenceBindingToExpr(E, ArgType);
+    return EmitReferenceBindingToExpr(E);
 
   return EmitAnyExprToTemp(E);
 }

diff --git a/lib/CodeGen/CGClass.cpp b/lib/CodeGen/CGClass.cpp
index 8362945e1edbea4a8a99f389b2015ac46a8a4bb6..70973a456047f7a794806a2f50502b26ddf3dbc2 100644 (file)
--- a/lib/CodeGen/CGClass.cpp
+++ b/lib/CodeGen/CGClass.cpp
@@ -838,7 +838,7 @@ static void EmitMemberInitializer(CodeGenFunction &CGF,
   // was implicitly generated, we shouldn't be zeroing memory.
   RValue RHS;
   if (FieldType->isReferenceType()) {
-    RHS = CGF.EmitReferenceBindingToExpr(MemberInit->getInit(), FieldType,
+    RHS = CGF.EmitReferenceBindingToExpr(MemberInit->getInit(),
                                          /*IsInitializer=*/true);
     CGF.EmitStoreThroughLValue(RHS, LHS, FieldType);
   } else if (FieldType->isArrayType() && !MemberInit->getInit()) {

diff --git a/lib/CodeGen/CGDecl.cpp b/lib/CodeGen/CGDecl.cpp
index 6ba537e528c27e4c6590c914486a80f7e77772e5..e27c5e4e51ae51aba31b09ce5e4468a25eedab7c 100644 (file)
--- a/lib/CodeGen/CGDecl.cpp
+++ b/lib/CodeGen/CGDecl.cpp
@@ -507,12 +507,8 @@ void CodeGenFunction::EmitLocalBlockVarDecl(const VarDecl &D) {
         
         Builder.CreateCall4(CGM.getMemCpyFn(), Loc, SrcPtr, SizeVal, AlignVal);
       }
-    } else if (const CXXBindReferenceExpr *BE = 
-                dyn_cast<CXXBindReferenceExpr>(Init)) {
-      llvm::Value *V = EmitCXXBindReferenceExpr(BE);
-      EmitStoreOfScalar(V, Loc, /*Volatile=*/false, Ty);
     } else if (Ty->isReferenceType()) {
-      RValue RV = EmitReferenceBindingToExpr(Init, Ty, /*IsInitializer=*/true);
+      RValue RV = EmitReferenceBindingToExpr(Init, /*IsInitializer=*/true);
       EmitStoreOfScalar(RV.getScalarVal(), Loc, false, Ty);
     } else if (!hasAggregateLLVMType(Init->getType())) {
       llvm::Value *V = EmitScalarExpr(Init);

diff --git a/lib/CodeGen/CGDeclCXX.cpp b/lib/CodeGen/CGDeclCXX.cpp
index 3f1a7225fbc405b3650e53ec8a9555f56ea31921..3d5a4e8051bd4cc83be31145314a6cbeee4fb429 100644 (file)
--- a/lib/CodeGen/CGDeclCXX.cpp
+++ b/lib/CodeGen/CGDeclCXX.cpp
@@ -81,7 +81,7 @@ void CodeGenFunction::EmitCXXGlobalVarDeclInit(const VarDecl &D,
     return;
   }
   if (Init->isLvalue(getContext()) == Expr::LV_Valid) {
-    RValue RV = EmitReferenceBindingToExpr(Init, T, /*IsInitializer=*/true);
+    RValue RV = EmitReferenceBindingToExpr(Init, /*IsInitializer=*/true);
     EmitStoreOfScalar(RV.getScalarVal(), DeclPtr, false, T);
     return;
   }
@@ -225,7 +225,7 @@ CodeGenFunction::EmitStaticCXXBlockVarDeclInit(const VarDecl &D,
     QualType T = D.getType();
     // We don't want to pass true for IsInitializer here, because a static
     // reference to a temporary does not extend its lifetime.
-    RValue RV = EmitReferenceBindingToExpr(D.getInit(), T,
+    RValue RV = EmitReferenceBindingToExpr(D.getInit(),
                                            /*IsInitializer=*/false);
     EmitStoreOfScalar(RV.getScalarVal(), GV, /*Volatile=*/false, T);
 

diff --git a/lib/CodeGen/CGExpr.cpp b/lib/CodeGen/CGExpr.cpp
index ab4f8f19353c1de9226c0a1819fb4cc43c673052..2ceefae0a0f77a8301da8b2b66b310a54ed250b3 100644 (file)
--- a/lib/CodeGen/CGExpr.cpp
+++ b/lib/CodeGen/CGExpr.cpp
@@ -92,31 +92,8 @@ RValue CodeGenFunction::EmitAnyExprToTemp(const Expr *E,
                      IsInitializer);
 }
 
-llvm::Value * 
-CodeGenFunction::EmitCXXBindReferenceExpr(const CXXBindReferenceExpr *E) {
-  QualType T = E->getType();
-  assert(T->isAnyComplexType() && "FIXME: Unhandled bind expression!");
-  
-  const Expr *SubExpr = E->getSubExpr();
-
-  if (!E->requiresTemporaryCopy())
-    return EmitLValue(SubExpr).getAddress();
-
-  llvm::Value *Value = CreateTempAlloca(ConvertTypeForMem(T), "reftmp");
-    
-  if (T->isAnyComplexType()) 
-    EmitComplexExprIntoAddr(SubExpr, Value, /*DestIsVolatile=*/false);
-  else
-    assert(false && "Unhandled bind expression");
-    
-  return Value;
-}
-
 RValue CodeGenFunction::EmitReferenceBindingToExpr(const Expr* E,
-                                                   QualType DestType,
                                                    bool IsInitializer) {
-  assert(!E->getType()->isAnyComplexType() && 
-         "Should not use this function for complex types!");
   bool ShouldDestroyTemporaries = false;
   unsigned OldNumLiveTemporaries = 0;
 
@@ -478,8 +455,6 @@ LValue CodeGenFunction::EmitLValue(const Expr *E) {
     return EmitCXXConstructLValue(cast<CXXConstructExpr>(E));
   case Expr::CXXBindTemporaryExprClass:
     return EmitCXXBindTemporaryLValue(cast<CXXBindTemporaryExpr>(E));
-  case Expr::CXXBindReferenceExprClass:
-    return EmitLValue(cast<CXXBindReferenceExpr>(E)->getSubExpr());
   case Expr::CXXExprWithTemporariesClass:
     return EmitCXXExprWithTemporariesLValue(cast<CXXExprWithTemporaries>(E));
   case Expr::CXXZeroInitValueExprClass:

diff --git a/lib/CodeGen/CodeGenFunction.h b/lib/CodeGen/CodeGenFunction.h
index 5de91ee3351ce23d92a2cd81a6f2e1beec50c002..3e47469e76cd4d3410baee393531930a47afce80 100644 (file)
--- a/lib/CodeGen/CodeGenFunction.h
+++ b/lib/CodeGen/CodeGenFunction.h
@@ -1111,10 +1111,7 @@ public:
 
   /// EmitReferenceBindingToExpr - Emits a reference binding to the passed in
   /// expression. Will emit a temporary variable if E is not an LValue.
-  RValue EmitReferenceBindingToExpr(const Expr* E, QualType DestType,
-                                    bool IsInitializer = false);
-
-  llvm::Value *EmitCXXBindReferenceExpr(const CXXBindReferenceExpr *E);
+  RValue EmitReferenceBindingToExpr(const Expr* E, bool IsInitializer = false);
 
   //===--------------------------------------------------------------------===//
   //                           Expression Emission

diff --git a/lib/Sema/SemaInit.cpp b/lib/Sema/SemaInit.cpp
index 7c52df5f7c497f5a97a1de74999878e5cb254461..1f1e76c9999b57f019af56b6944d03def01fd5e9 100644 (file)
--- a/lib/Sema/SemaInit.cpp
+++ b/lib/Sema/SemaInit.cpp
@@ -3304,31 +3304,16 @@ InitializationSequence::Perform(Sema &S,
       // Check exception specifications
       if (S.CheckExceptionSpecCompatibility(CurInitExpr, DestType))
         return S.ExprError();
-      
-      // FIXME: We should do this for all types.
-      if (DestType->isAnyComplexType()) {
-        CurInit = 
-          S.Owned(CXXBindReferenceExpr::Create(S.Context, 
-                                               CurInit.takeAs<Expr>(), 
-                                               /*ExtendsLifetime=*/false,
-                                               /*RequiresTemporaryCopy=*/false));
-      }
 
       break;
 
     case SK_BindReferenceToTemporary:
+      // Reference binding does not have any corresponding ASTs.
+
       // Check exception specifications
       if (S.CheckExceptionSpecCompatibility(CurInitExpr, DestType))
         return S.ExprError();
 
-      // FIXME: We should do this for all types.
-      if (DestType->isAnyComplexType()) {
-        CurInit = 
-          S.Owned(CXXBindReferenceExpr::Create(S.Context, 
-                                               CurInit.takeAs<Expr>(), 
-                                               /*ExtendsLifetime=*/false,
-                                               /*RequiresTemporaryCopy=*/true));
-      }
       break;
         
     case SK_UserConversion: {