3 files changed, 118 insertions, 18 deletions
diff --git a/clang/test/Analysis/cfg.cpp b/clang/test/Analysis/cfg.cpp
index 28cc440c46f..f35a1fcc1c3 100644
--- a/clang/test/Analysis/cfg.cpp
+++ b/clang/test/Analysis/cfg.cpp
@@ -138,7 +138,7 @@ void test_deletedtor() {
 // CHECK: [B1]
 // CHECK-NEXT:   1: 5
 // CHECK-NEXT:   2: CFGNewAllocator(A *)
-// CHECK-NEXT:   3:  (CXXConstructExpr, class A)
+// CHECK-NEXT:   3:  (CXXConstructExpr, class A [5])
 // CHECK-NEXT:   4: new A {{\[\[}}B1.1]]
 // CHECK-NEXT:   5: A *a = new A [5];
 // CHECK-NEXT:   6: a
@@ -363,7 +363,7 @@ void test_placement_new() {
 // CHECK-NEXT:  4: [B1.3] (ImplicitCastExpr, BitCast, void *)
 // CHECK-NEXT:  5: 5
 // CHECK-NEXT:  6: CFGNewAllocator(MyClass *)
-// CHECK-NEXT:  7:  (CXXConstructExpr, class MyClass)
+// CHECK-NEXT:  7:  (CXXConstructExpr, class MyClass [5])
 // CHECK-NEXT:  8: new ([B1.4]) MyClass {{\[\[}}B1.5]]
 // CHECK-NEXT:  9: MyClass *obj = new (buffer) MyClass [5];
 // CHECK-NEXT:  Preds (1): B2
diff --git a/clang/test/CodeGenCXX/new-array-init.cpp b/clang/test/CodeGenCXX/new-array-init.cpp
index 602f93c34f0..0429ae770bc 100644
--- a/clang/test/CodeGenCXX/new-array-init.cpp
+++ b/clang/test/CodeGenCXX/new-array-init.cpp
@@ -1,5 +1,8 @@
 // RUN: %clang_cc1 -std=c++11 -triple i386-unknown-unknown %s -emit-llvm -o - | FileCheck %s
 
+// CHECK: @[[ABC4:.*]] = {{.*}} constant [4 x i8] c"abc\00"
+// CHECK: @[[ABC15:.*]] = {{.*}} constant [15 x i8] c"abc\00\00\00\00
+
 // CHECK-LABEL: define void @_Z2fni
 void fn(int n) {
   // CHECK: icmp ult i{{32|64}} %{{[^ ]+}}, 3
@@ -11,13 +14,6 @@ void fn(int n) {
   new int[n] { 1, 2, 3 };
 }
 
-// CHECK-LABEL: define void @_Z15const_underflowv
-void const_underflow() {
-  // CHECK-NOT: icmp ult i{{32|64}} %{{[^ ]+}}, 3
-  // CHECK: call i8* @_Zna{{.}}(i{{32|64}} -1)
-  new int[2] { 1, 2, 3 };
-}
-
 // CHECK-LABEL: define void @_Z11const_exactv
 void const_exact() {
   // CHECK-NOT: icmp ult i{{32|64}} %{{[^ ]+}}, 3
@@ -46,3 +42,77 @@ void check_array_value_init() {
   // CHECK: icmp eq
   // CHECK: br i1
 }
+
+// CHECK-LABEL: define void @_Z15string_nonconsti
+void string_nonconst(int n) {
+  // CHECK: icmp slt i{{32|64}} %{{[^ ]+}}, 4
+  // FIXME: Conditionally throw an exception rather than passing -1 to alloc function
+  // CHECK: select
+  // CHECK: %[[PTR:.*]] = call i8* @_Zna{{.}}(i{{32|64}}
+  // CHECK: call void @llvm.memcpy{{.*}}(i8* %[[PTR]], i8* getelementptr inbounds ([4 x i8], [4 x i8]* @[[ABC4]], i32 0, i32 0), i32 4,
+  // CHECK: %[[REST:.*]] = getelementptr inbounds i8, i8* %[[PTR]], i32 4
+  // CHECK: %[[RESTSIZE:.*]] = sub {{.*}}, 4
+  // CHECK: call void @llvm.memset{{.*}}(i8* %[[REST]], i8 0, i{{32|64}} %[[RESTSIZE]],
+  new char[n] { "abc" };
+}
+
+// CHECK-LABEL: define void @_Z12string_exactv
+void string_exact() {
+  // CHECK-NOT: icmp
+  // CHECK: %[[PTR:.*]] = call i8* @_Zna{{.}}(i{{32|64}} 4)
+  // CHECK: call void @llvm.memcpy{{.*}}(i8* %[[PTR]], i8* getelementptr inbounds ([4 x i8], [4 x i8]* @[[ABC4]], i32 0, i32 0), i32 4,
+  // CHECK-NOT: memset
+  new char[4] { "abc" };
+}
+
+// CHECK-LABEL: define void @_Z17string_sufficientv
+void string_sufficient() {
+  // CHECK-NOT: icmp
+  // CHECK: %[[PTR:.*]] = call i8* @_Zna{{.}}(i{{32|64}} 15)
+  // FIXME: For very large arrays, it would be preferable to emit a small copy and a memset.
+  // CHECK: call void @llvm.memcpy{{.*}}(i8* %[[PTR]], i8* getelementptr inbounds ([15 x i8], [15 x i8]* @[[ABC15]], i32 0, i32 0), i32 15,
+  // CHECK-NOT: memset
+  new char[15] { "abc" };
+}
+
+// CHECK-LABEL: define void @_Z10aggr_exactv
+void aggr_exact() {
+  // CHECK-NOT: icmp
+  // CHECK: %[[MEM:.*]] = call i8* @_Zna{{.}}(i{{32|64}} 16)
+  // CHECK: %[[PTR0:.*]] = bitcast i8* %[[MEM]] to %[[AGGR:.*]]*
+  // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], %[[AGGR]]* %[[PTR0]], i32 0, i32 0{{$}}
+  // CHECK: store i32 1, i32* %[[FIELD]]
+  // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], %[[AGGR]]* %[[PTR0]], i32 0, i32 1{{$}}
+  // CHECK: store i32 2, i32* %[[FIELD]]
+  // CHECK: %[[PTR1:.*]] = getelementptr inbounds %[[AGGR]], %[[AGGR]]* %[[PTR0]], i32 1{{$}}
+  // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], %[[AGGR]]* %[[PTR1]], i32 0, i32 0{{$}}
+  // CHECK: store i32 3, i32* %[[FIELD]]
+  // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], %[[AGGR]]* %[[PTR1]], i32 0, i32 1{{$}}
+  // CHECK: store i32 0, i32* %[[FIELD]]
+  // CHECK-NOT: store
+  // CHECK-NOT: memset
+  struct Aggr { int a, b; };
+  new Aggr[2] { 1, 2, 3 };
+}
+
+// CHECK-LABEL: define void @_Z15aggr_sufficienti
+void aggr_sufficient(int n) {
+  // CHECK: icmp ult i32 %{{.*}}, 2
+  // CHECK: %[[MEM:.*]] = call i8* @_Zna{{.}}(
+  // CHECK: %[[PTR0:.*]] = bitcast i8* %[[MEM]] to %[[AGGR:.*]]*
+  // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], %[[AGGR]]* %[[PTR0]], i32 0, i32 0{{$}}
+  // CHECK: store i32 1, i32* %[[FIELD]]
+  // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], %[[AGGR]]* %[[PTR0]], i32 0, i32 1{{$}}
+  // CHECK: store i32 2, i32* %[[FIELD]]
+  // CHECK: %[[PTR1:.*]] = getelementptr inbounds %[[AGGR]], %[[AGGR]]* %[[PTR0]], i32 1{{$}}
+  // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], %[[AGGR]]* %[[PTR1]], i32 0, i32 0{{$}}
+  // CHECK: store i32 3, i32* %[[FIELD]]
+  // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], %[[AGGR]]* %[[PTR1]], i32 0, i32 1{{$}}
+  // CHECK: store i32 0, i32* %[[FIELD]]
+  // CHECK: %[[PTR2:.*]] = getelementptr inbounds %[[AGGR]], %[[AGGR]]* %[[PTR1]], i32 1{{$}}
+  // CHECK: %[[REMAIN:.*]] = sub i32 {{.*}}, 16
+  // CHECK: %[[MEM:.*]] = bitcast %[[AGGR]]* %[[PTR2]] to i8*
+  // CHECK: call void @llvm.memset{{.*}}(i8* %[[MEM]], i8 0, i32 %[[REMAIN]],
+  struct Aggr { int a, b; };
+  new Aggr[n] { 1, 2, 3 };
+}
diff --git a/clang/test/SemaCXX/new-delete-cxx0x.cpp b/clang/test/SemaCXX/new-delete-cxx0x.cpp
index 899cb4cda87..c55152510e1 100644
--- a/clang/test/SemaCXX/new-delete-cxx0x.cpp
+++ b/clang/test/SemaCXX/new-delete-cxx0x.cpp
@@ -1,13 +1,19 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 -triple=i686-pc-linux-gnu
 
 void ugly_news(int *ip) {
-  // These are ill-formed according to one reading of C++98, and at the least
-  // have undefined behavior.
-  // FIXME: They're ill-formed in C++11.
-  (void)new int[-1]; // expected-warning {{array size is negative}}
-  (void)new int[2000000000]; // expected-warning {{array is too large}}
+  (void)new int[-1]; // expected-error {{array size is negative}}
+  (void)new int[2000000000]; // expected-error {{array is too large}}
 }
 
+void pr22845a() {
+  constexpr int i = -1;
+  int *p = new int[i]; // expected-error {{array size is negative}}
+}
+
+void pr22845b() {
+  constexpr int i = 1;
+  int *p = new int[i]{1, 2}; // expected-error {{excess elements in array initializer}}
+}
 
 struct S {
   S(int);
@@ -15,13 +21,14 @@ struct S {
   ~S();
 };
 
-struct T { // expected-note 2 {{not viable}}
-  T(int); // expected-note {{not viable}}
+struct T { // expected-note 1+{{not viable}}
+  T(int); // expected-note 1+{{not viable}}
 };
 
-void fn() {
+void fn(int n) {
   (void) new int[2] {1, 2};
   (void) new S[2] {1, 2};
+  (void) new S[3] {1, 2};
   // C++11 [expr.new]p19:
   //   If the new-expression creates an object or an array of objects of class
   //   type, access and ambiguity control are done for the allocation function,
@@ -29,5 +36,28 @@ void fn() {
   //
   // Note that this happens even if the array bound is constant and the
   // initializer initializes every array element.
-  (void) new T[2] {1, 2}; // expected-error {{no matching constructor}} expected-note {{in implicit initialization of array element 2}}
+  //
+  // It's not clear that this is the intended interpretation, however -- we
+  // obviously don't want to check for a default constructor for 'new S(0)'.
+  // Instead, we only check for a default constructor in the case of an array
+  // new with a non-constant bound or insufficient initializers.
+  (void) new T[2] {1, 2}; // ok
+  (void) new T[3] {1, 2}; // expected-error {{no matching constructor}} expected-note {{in implicit initialization of array element 2}}
+  (void) new T[n] {1, 2}; // expected-error {{no matching constructor}} expected-note {{in implicit initialization of trailing array elements in runtime-sized array new}}
+}
+
+struct U {
+  T t; // expected-note 3{{in implicit initialization of field 't'}}
+  S s;
+};
+void g(int n) {
+  // Aggregate initialization, brace-elision, and array new combine to create
+  // this monstrosity.
+  (void) new U[2] {1, 2}; // expected-error {{no matching constructor}} expected-note {{in implicit initialization of array element 1}}
+  (void) new U[2] {1, 2, 3}; // ok
+  (void) new U[2] {1, 2, 3, 4}; // ok
+  (void) new U[2] {1, 2, 3, 4, 5}; // expected-error {{excess elements in array initializer}}
+
+  (void) new U[n] {1, 2}; // expected-error {{no matching constructor}} expected-note {{in implicit initialization of trailing array elements}}
+  (void) new U[n] {1, 2, 3}; // expected-error {{no matching constructor}} expected-note {{in implicit initialization of trailing array elements}}
 }