From: Richard Smith <richard-llvm@metafoo.co.uk>
Date: Wed, 7 Nov 2012 23:56:21 +0000 (+0000)
Subject: When deciding whether to convert an array construction loop into a memcpy, look
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=993f25a2f9a852509c61abf1c167b6421890bb39;p=platform%2Fupstream%2Fllvm.git

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.

llvm-svn: 167562
---

diff --git a/clang/lib/CodeGen/CGClass.cpp b/clang/lib/CodeGen/CGClass.cpp
index b583c62..b2225e4 100644
--- a/clang/lib/CodeGen/CGClass.cpp
+++ b/clang/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/clang/test/CodeGenCXX/implicit-copy-constructor.cpp b/clang/test/CodeGenCXX/implicit-copy-constructor.cpp
index 8bc84a5..8a3a422 100644
--- a/clang/test/CodeGenCXX/implicit-copy-constructor.cpp
+++ b/clang/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: }
+  }
+}