When deciding whether to convert an array construction loop into a memcpy, look

at whether the *selected* constructor would be trivial rather than considering
whether the array's element type has *any* non-trivial constructors of the
relevant kind.


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

2 files changed, 31 insertions, 12 deletions

diff --git a/lib/CodeGen/CGClass.cpp b/lib/CodeGen/CGClass.cpp
index b583c62f10..b2225e48e3 100644
--- a/lib/CodeGen/CGClass.cpp
+++ b/lib/CodeGen/CGClass.cpp
@@ -542,12 +542,6 @@ namespace {
   };
 }
 
-static bool hasTrivialCopyOrMoveConstructor(const CXXRecordDecl *Record,
-                                            bool Moving) {
-  return Moving ? Record->hasTrivialMoveConstructor() :
-                  Record->hasTrivialCopyConstructor();
-}
-
 static void EmitMemberInitializer(CodeGenFunction &CGF,
                                   const CXXRecordDecl *ClassDecl,
                                   CXXCtorInitializer *MemberInit,
@@ -588,12 +582,11 @@ static void EmitMemberInitializer(CodeGenFunction &CGF,
   if (Array && Constructor->isImplicitlyDefined() &&
       Constructor->isCopyOrMoveConstructor()) {
     QualType BaseElementTy = CGF.getContext().getBaseElementType(Array);
-    const CXXRecordDecl *Record = BaseElementTy->getAsCXXRecordDecl();
+    CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(MemberInit->getInit());
     if (BaseElementTy.isPODType(CGF.getContext()) ||
-        (Record && hasTrivialCopyOrMoveConstructor(Record,
-                       Constructor->isMoveConstructor()))) {
-      // Find the source pointer. We knows it's the last argument because
-      // we know we're in a copy constructor.
+        (CE && CE->getConstructor()->isTrivial())) {
+      // Find the source pointer. We know it's the last argument because
+      // we know we're in an implicit copy constructor.
       unsigned SrcArgIndex = Args.size() - 1;
       llvm::Value *SrcPtr
         = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(Args[SrcArgIndex]));
diff --git a/test/CodeGenCXX/implicit-copy-constructor.cpp b/test/CodeGenCXX/implicit-copy-constructor.cpp
index 8bc84a534b..8a3a422e0b 100644
--- a/test/CodeGenCXX/implicit-copy-constructor.cpp
+++ b/test/CodeGenCXX/implicit-copy-constructor.cpp
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -o - %s -std=c++11 | FileCheck %s
 
 struct A { 
   A();
@@ -80,3 +80,29 @@ namespace test3 {
     y = x;
   }
 }
+
+namespace test4 {
+  // When determining whether to implement an array copy as a memcpy, look at
+  // whether the *selected* constructor is trivial.
+  struct S {
+    int arr[5][5];
+    S(S &);
+    S(const S &) = default;
+  };
+  // CHECK: @_ZN5test42f1
+  void f1(S a) {
+    // CHECK-NOT: memcpy
+    // CHECK: call void @_ZN5test41SC1ERS0_
+    // CHECK-NOT: memcpy
+    S b(a);
+    // CHECK: }
+  }
+  // CHECK: @_ZN5test42f2
+  void f2(const S a) {
+    // CHECK-NOT: call void @_ZN5test41SC1ERS0_
+    // CHECK: memcpy
+    // CHECK-NOT: call void @_ZN5test41SC1ERS0_
+    S b(a);
+    // CHECK: }
+  }
+}