test/CodeGenCXX/new-array-init.cpp - llvm-project/clang - Git at Google

 // RUN: %clang_cc1 -std=c++11 -triple i386-unknown-unknown %s -emit-llvm -o - | FileCheck %s
 // RUN: %clang_cc1 -std=c++20 -triple i386-unknown-unknown %s -emit-llvm -o - | FileCheck %s --check-prefix=CHECK --check-prefix=CHECKCXX20
 // RUN: %clang_cc1 -std=c++11 -triple i386-unknown-unknown %s -emit-llvm -fsanitize=signed-integer-overflow -o - | FileCheck --check-prefix=SIO %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
   // CHECK: store i32 1
   // CHECK: store i32 2
   // CHECK: store i32 3
   // CHECK: sub {{.*}}, 12
   // CHECK: call void @llvm.memset
   new int[n] { 1, 2, 3 };
 }

 #if __cplusplus >= 202002L
 // CHECKCXX20-LABEL: define{{.*}} void @_Z8fn_pareni
 void fn_paren(int n) {
   // CHECKCXX20: icmp ult i{{32|64}} %{{[^ ]+}}, 3
   // CHECKCXX20: store i32 1
   // CHECKCXX20: store i32 2
   // CHECKCXX20: store i32 3
   // CHECKCXX20: sub {{.*}}, 12
   // CHECKCXX20: call void @llvm.memset
   new int[n](1, 2, 3);
 }
 #endif

 // CHECK-LABEL: define{{.*}} void @_Z11const_exactv
 void const_exact() {
   // CHECK-NOT: icmp ult i{{32|64}} %{{[^ ]+}}, 3
   // CHECK-NOT: icmp eq ptr
   new int[3] { 1, 2, 3 };
 }

 #if __cplusplus >= 202002L
 // CHECKCXX20-LABEL: define{{.*}} void @_Z17const_exact_parenv
 void const_exact_paren() {
   // CHECKCXX20-NOT: icmp ult i{{32|64}} %{{[^ ]+}}, 3
   // CHECKCXX20-NOT: icmp eq ptr
   new int[3](1, 2, 3);
 }
 #endif

 // CHECK-LABEL: define{{.*}} void @_Z16const_sufficientv
 void const_sufficient() {
   // CHECK-NOT: icmp ult i{{32|64}} %{{[^ ]+}}, 3
   new int[4] { 1, 2, 3 };
   // CHECK: ret void
 }

 #if __cplusplus >= 202002L
 // CHECKCXX20-LABEL: define{{.*}} void @_Z22const_sufficient_parenv
 void const_sufficient_paren() {
   // CHECKCXX20-NOT: icmp ult i{{32|64}} %{{[^ ]+}}, 3
   new int[4](1, 2, 3);
   // CHECKCXX20: ret void
 }
 #endif

 // CHECK-LABEL: define{{.*}} void @_Z22check_array_value_initv
 void check_array_value_init() {
   struct S;
   new (int S::*[3][4][5]) ();

   // CHECK: call noalias noundef nonnull ptr @_Zna{{.}}(i{{32 noundef 240|64 noundef 480}})
   // CHECK: getelementptr inbounds i{{32|64}}, ptr {{.*}}, i{{32|64}} 60

   // CHECK: phi
   // CHECK: store i{{32|64}} -1,
   // CHECK: getelementptr inbounds i{{32|64}}, ptr {{.*}}, i{{32|64}} 1
   // CHECK: icmp eq
   // CHECK: br i1
 }

 // CHECK-LABEL: define{{.*}} void @_Z15string_nonconsti
 void string_nonconst(int n) {
   // CHECK: icmp {{s|u}}lt i{{32|64}} %{{[^ ]+}}, 4
   // FIXME: Conditionally throw an exception rather than passing -1 to alloc function
   // CHECK: select
   // CHECK: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}}
   // CHECK: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
   // CHECK: %[[REST:.*]] = getelementptr inbounds i8, ptr %[[PTR]], i32 4
   // CHECK: %[[RESTSIZE:.*]] = sub {{.*}}, 4
   // CHECK: call void @llvm.memset{{.*}}(ptr align {{[0-9]+}} %[[REST]], i8 0, i{{32|64}} %[[RESTSIZE]],
   new char[n] { "abc" };
 }

 #if __cplusplus >= 202002L
 // CHECKCXX20-LABEL: define{{.*}} void @_Z21string_nonconst_pareni
 void string_nonconst_paren(int n) {
   // CHECKCXX20: icmp {{s|u}}lt i{{32|64}} %{{[^ ]+}}, 4
   // FIXME: Conditionally throw an exception rather than passing -1 to alloc function
   // CHECKCXX20: select
   // CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}}
   // CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
   // CHECKCXX20: %[[REST:.*]] = getelementptr inbounds i8, ptr %[[PTR]], i32 4
   // CHECKCXX20: %[[RESTSIZE:.*]] = sub {{.*}}, 4
   // CHECKCXX20: call void @llvm.memset{{.*}}(ptr align {{[0-9]+}} %[[REST]], i8 0, i{{32|64}} %[[RESTSIZE]],
   new char[n]("abc");
 }

 // CHECKCXX20-LABEL: define{{.*}} void @_Z33string_nonconst_paren_extra_pareni
 void string_nonconst_paren_extra_paren(int n) {
   // CHECKCXX20: icmp {{s|u}}lt i{{32|64}} %{{[^ ]+}}, 4
   // FIXME: Conditionally throw an exception rather than passing -1 to alloc function
   // CHECKCXX20: select
   // CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}}
   // CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
   // CHECKCXX20: %[[REST:.*]] = getelementptr inbounds i8, ptr %[[PTR]], i32 4
   // CHECKCXX20: %[[RESTSIZE:.*]] = sub {{.*}}, 4
   // CHECKCXX20: call void @llvm.memset{{.*}}(ptr align {{[0-9]+}} %[[REST]], i8 0, i{{32|64}} %[[RESTSIZE]],
   new char[n](("abc"));
 }
 #endif

 // CHECK-LABEL: define{{.*}} void @_Z12string_exactv
 void string_exact() {
   // CHECK-NOT: icmp
   // CHECK: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 4)
   // CHECK: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
   // CHECK-NOT: memset
   new char[4] { "abc" };
 }

 #if __cplusplus >= 202002L
 // CHECKCXX20-LABEL: define{{.*}} void @_Z18string_exact_parenv
 void string_exact_paren() {
   // CHECKCXX20-NOT: icmp
   // CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 4)
   // CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
   // CHECKCXX20-NOT: memset
   new char[4]("abc");
 }

 // CHECKCXX20-LABEL: define{{.*}} void @_Z28string_exact_paren_extensionv
 void string_exact_paren_extension() {
   // CHECKCXX20-NOT: icmp
   // CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 4)
   // CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
   // CHECKCXX20-NOT: memset
   new char[4](__extension__ "abc");
 }
 #endif

 // CHECK-LABEL: define{{.*}} void @_Z17string_sufficientv
 void string_sufficient() {
   // CHECK-NOT: icmp
   // CHECK: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 15)
   // FIXME: For very large arrays, it would be preferable to emit a small copy and a memset.
   // CHECK: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC15]], i32 15,
   // CHECK-NOT: memset
   new char[15] { "abc" };
 }

 #if __cplusplus >= 202002L
 // CHECKCXX20-LABEL: define{{.*}} void @_Z23string_sufficient_parenv
 void string_sufficient_paren() {
   // CHECKCXX20-NOT: icmp
   // CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 15)
   // FIXME: For very large arrays, it would be preferable to emit a small copy and a memset.
   // CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC15]], i32 15,
   // CHECKCXX20-NOT: memset
   new char[15]("abc");
 }
 #endif

 // CHECK-LABEL: define{{.*}} void @_Z10aggr_exactv
 void aggr_exact() {
   // CHECK-NOT: icmp
   // CHECK: %[[MEM:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 16)
   // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR:.*]], ptr %[[MEM]], i32 0, i32 0{{$}}
   // CHECK: store i32 1, ptr %[[FIELD]]
   // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[MEM]], i32 0, i32 1{{$}}
   // CHECK: store i32 2, ptr %[[FIELD]]
   // CHECK: %[[PTR1:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[MEM]], i32 1{{$}}
   // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[PTR1]], i32 0, i32 0{{$}}
   // CHECK: store i32 3, ptr %[[FIELD]]
   // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[PTR1]], i32 0, i32 1{{$}}
   // CHECK: store i32 0, ptr %[[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 noalias noundef nonnull ptr @_Zna{{.}}(
   // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR:.*]], ptr %[[MEM]], i32 0, i32 0{{$}}
   // CHECK: store i32 1, ptr %[[FIELD]]
   // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[MEM]], i32 0, i32 1{{$}}
   // CHECK: store i32 2, ptr %[[FIELD]]
   // CHECK: %[[PTR1:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[MEM]], i32 1{{$}}
   // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[PTR1]], i32 0, i32 0{{$}}
   // CHECK: store i32 3, ptr %[[FIELD]]
   // CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[PTR1]], i32 0, i32 1{{$}}
   // CHECK: store i32 0, ptr %[[FIELD]]
   // CHECK: %[[PTR2:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[PTR1]], i32 1{{$}}
   // CHECK: %[[REMAIN:.*]] = sub i32 {{.*}}, 16
   // CHECK: call void @llvm.memset{{.*}}(ptr align {{[0-9]+}} %[[PTR2]], i8 0, i32 %[[REMAIN]],
   struct Aggr { int a, b; };
   new Aggr[n] { 1, 2, 3 };
 }

 // SIO-LABEL: define{{.*}} void @_Z14constexpr_testv
 void constexpr_test() {
   // SIO: call noalias noundef nonnull ptr @_Zna{{.}}(i32 noundef 4)
   new int[0+1]{0};
 }

 // CHECK-LABEL: define{{.*}} void @_Z13unknown_boundv
 void unknown_bound() {
   struct Aggr { int x, y, z; };
   new Aggr[]{1, 2, 3, 4};
   // CHECK: call {{.*}}_Znaj(i32 noundef 24)
   // CHECK: store i32 1
   // CHECK: store i32 2
   // CHECK: store i32 3
   // CHECK: store i32 4
   // CHECK: store i32 0
   // CHECK: store i32 0
   // CHECK-NOT: store
   // CHECK: }
 }

 // CHECK-LABEL: define{{.*}} void @_Z20unknown_bound_stringv
 void unknown_bound_string() {
   new char[]{"hello"};
   // CHECK: call {{.*}}_Znaj(i32 noundef 6)
   // CHECK: memcpy{{.*}} i32 6,
 }
	// RUN: %clang_cc1 -std=c++11 -triple i386-unknown-unknown %s -emit-llvm -o - \| FileCheck %s
	// RUN: %clang_cc1 -std=c++20 -triple i386-unknown-unknown %s -emit-llvm -o - \| FileCheck %s --check-prefix=CHECK --check-prefix=CHECKCXX20
	// RUN: %clang_cc1 -std=c++11 -triple i386-unknown-unknown %s -emit-llvm -fsanitize=signed-integer-overflow -o - \| FileCheck --check-prefix=SIO %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
	// CHECK: store i32 1
	// CHECK: store i32 2
	// CHECK: store i32 3
	// CHECK: sub {{.*}}, 12
	// CHECK: call void @llvm.memset
	new int[n] { 1, 2, 3 };
	}

	#if __cplusplus >= 202002L
	// CHECKCXX20-LABEL: define{{.*}} void @_Z8fn_pareni
	void fn_paren(int n) {
	// CHECKCXX20: icmp ult i{{32\|64}} %{{[^ ]+}}, 3
	// CHECKCXX20: store i32 1
	// CHECKCXX20: store i32 2
	// CHECKCXX20: store i32 3
	// CHECKCXX20: sub {{.*}}, 12
	// CHECKCXX20: call void @llvm.memset
	new int[n](1, 2, 3);
	}
	#endif

	// CHECK-LABEL: define{{.*}} void @_Z11const_exactv
	void const_exact() {
	// CHECK-NOT: icmp ult i{{32\|64}} %{{[^ ]+}}, 3
	// CHECK-NOT: icmp eq ptr
	new int[3] { 1, 2, 3 };
	}

	#if __cplusplus >= 202002L
	// CHECKCXX20-LABEL: define{{.*}} void @_Z17const_exact_parenv
	void const_exact_paren() {
	// CHECKCXX20-NOT: icmp ult i{{32\|64}} %{{[^ ]+}}, 3
	// CHECKCXX20-NOT: icmp eq ptr
	new int[3](1, 2, 3);
	}
	#endif

	// CHECK-LABEL: define{{.*}} void @_Z16const_sufficientv
	void const_sufficient() {
	// CHECK-NOT: icmp ult i{{32\|64}} %{{[^ ]+}}, 3
	new int[4] { 1, 2, 3 };
	// CHECK: ret void
	}

	#if __cplusplus >= 202002L
	// CHECKCXX20-LABEL: define{{.*}} void @_Z22const_sufficient_parenv
	void const_sufficient_paren() {
	// CHECKCXX20-NOT: icmp ult i{{32\|64}} %{{[^ ]+}}, 3
	new int[4](1, 2, 3);
	// CHECKCXX20: ret void
	}
	#endif

	// CHECK-LABEL: define{{.*}} void @_Z22check_array_value_initv
	void check_array_value_init() {
	struct S;
	new (int S::*[3][4][5]) ();

	// CHECK: call noalias noundef nonnull ptr @_Zna{{.}}(i{{32 noundef 240\|64 noundef 480}})
	// CHECK: getelementptr inbounds i{{32\|64}}, ptr {{.*}}, i{{32\|64}} 60

	// CHECK: phi
	// CHECK: store i{{32\|64}} -1,
	// CHECK: getelementptr inbounds i{{32\|64}}, ptr {{.*}}, i{{32\|64}} 1
	// CHECK: icmp eq
	// CHECK: br i1
	}

	// CHECK-LABEL: define{{.*}} void @_Z15string_nonconsti
	void string_nonconst(int n) {
	// CHECK: icmp {{s\|u}}lt i{{32\|64}} %{{[^ ]+}}, 4
	// FIXME: Conditionally throw an exception rather than passing -1 to alloc function
	// CHECK: select
	// CHECK: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32\|64}}
	// CHECK: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
	// CHECK: %[[REST:.*]] = getelementptr inbounds i8, ptr %[[PTR]], i32 4
	// CHECK: %[[RESTSIZE:.]] = sub {{.}}, 4
	// CHECK: call void @llvm.memset{{.*}}(ptr align {{[0-9]+}} %[[REST]], i8 0, i{{32\|64}} %[[RESTSIZE]],
	new char[n] { "abc" };
	}

	#if __cplusplus >= 202002L
	// CHECKCXX20-LABEL: define{{.*}} void @_Z21string_nonconst_pareni
	void string_nonconst_paren(int n) {
	// CHECKCXX20: icmp {{s\|u}}lt i{{32\|64}} %{{[^ ]+}}, 4
	// FIXME: Conditionally throw an exception rather than passing -1 to alloc function
	// CHECKCXX20: select
	// CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32\|64}}
	// CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
	// CHECKCXX20: %[[REST:.*]] = getelementptr inbounds i8, ptr %[[PTR]], i32 4
	// CHECKCXX20: %[[RESTSIZE:.]] = sub {{.}}, 4
	// CHECKCXX20: call void @llvm.memset{{.*}}(ptr align {{[0-9]+}} %[[REST]], i8 0, i{{32\|64}} %[[RESTSIZE]],
	new char[n]("abc");
	}

	// CHECKCXX20-LABEL: define{{.*}} void @_Z33string_nonconst_paren_extra_pareni
	void string_nonconst_paren_extra_paren(int n) {
	// CHECKCXX20: icmp {{s\|u}}lt i{{32\|64}} %{{[^ ]+}}, 4
	// FIXME: Conditionally throw an exception rather than passing -1 to alloc function
	// CHECKCXX20: select
	// CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32\|64}}
	// CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
	// CHECKCXX20: %[[REST:.*]] = getelementptr inbounds i8, ptr %[[PTR]], i32 4
	// CHECKCXX20: %[[RESTSIZE:.]] = sub {{.}}, 4
	// CHECKCXX20: call void @llvm.memset{{.*}}(ptr align {{[0-9]+}} %[[REST]], i8 0, i{{32\|64}} %[[RESTSIZE]],
	new char[n](("abc"));
	}
	#endif

	// CHECK-LABEL: define{{.*}} void @_Z12string_exactv
	void string_exact() {
	// CHECK-NOT: icmp
	// CHECK: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32\|64}} noundef 4)
	// CHECK: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
	// CHECK-NOT: memset
	new char[4] { "abc" };
	}

	#if __cplusplus >= 202002L
	// CHECKCXX20-LABEL: define{{.*}} void @_Z18string_exact_parenv
	void string_exact_paren() {
	// CHECKCXX20-NOT: icmp
	// CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32\|64}} noundef 4)
	// CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
	// CHECKCXX20-NOT: memset
	new char[4]("abc");
	}

	// CHECKCXX20-LABEL: define{{.*}} void @_Z28string_exact_paren_extensionv
	void string_exact_paren_extension() {
	// CHECKCXX20-NOT: icmp
	// CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32\|64}} noundef 4)
	// CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
	// CHECKCXX20-NOT: memset
	new char[4](__extension__ "abc");
	}
	#endif

	// CHECK-LABEL: define{{.*}} void @_Z17string_sufficientv
	void string_sufficient() {
	// CHECK-NOT: icmp
	// CHECK: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32\|64}} noundef 15)
	// FIXME: For very large arrays, it would be preferable to emit a small copy and a memset.
	// CHECK: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC15]], i32 15,
	// CHECK-NOT: memset
	new char[15] { "abc" };
	}

	#if __cplusplus >= 202002L
	// CHECKCXX20-LABEL: define{{.*}} void @_Z23string_sufficient_parenv
	void string_sufficient_paren() {
	// CHECKCXX20-NOT: icmp
	// CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32\|64}} noundef 15)
	// FIXME: For very large arrays, it would be preferable to emit a small copy and a memset.
	// CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC15]], i32 15,
	// CHECKCXX20-NOT: memset
	new char[15]("abc");
	}
	#endif

	// CHECK-LABEL: define{{.*}} void @_Z10aggr_exactv
	void aggr_exact() {
	// CHECK-NOT: icmp
	// CHECK: %[[MEM:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32\|64}} noundef 16)
	// CHECK: %[[FIELD:.]] = getelementptr inbounds %[[AGGR:.]], ptr %[[MEM]], i32 0, i32 0{{$}}
	// CHECK: store i32 1, ptr %[[FIELD]]
	// CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[MEM]], i32 0, i32 1{{$}}
	// CHECK: store i32 2, ptr %[[FIELD]]
	// CHECK: %[[PTR1:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[MEM]], i32 1{{$}}
	// CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[PTR1]], i32 0, i32 0{{$}}
	// CHECK: store i32 3, ptr %[[FIELD]]
	// CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[PTR1]], i32 0, i32 1{{$}}
	// CHECK: store i32 0, ptr %[[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 noalias noundef nonnull ptr @_Zna{{.}}(
	// CHECK: %[[FIELD:.]] = getelementptr inbounds %[[AGGR:.]], ptr %[[MEM]], i32 0, i32 0{{$}}
	// CHECK: store i32 1, ptr %[[FIELD]]
	// CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[MEM]], i32 0, i32 1{{$}}
	// CHECK: store i32 2, ptr %[[FIELD]]
	// CHECK: %[[PTR1:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[MEM]], i32 1{{$}}
	// CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[PTR1]], i32 0, i32 0{{$}}
	// CHECK: store i32 3, ptr %[[FIELD]]
	// CHECK: %[[FIELD:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[PTR1]], i32 0, i32 1{{$}}
	// CHECK: store i32 0, ptr %[[FIELD]]
	// CHECK: %[[PTR2:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[PTR1]], i32 1{{$}}
	// CHECK: %[[REMAIN:.]] = sub i32 {{.}}, 16
	// CHECK: call void @llvm.memset{{.*}}(ptr align {{[0-9]+}} %[[PTR2]], i8 0, i32 %[[REMAIN]],
	struct Aggr { int a, b; };
	new Aggr[n] { 1, 2, 3 };
	}

	// SIO-LABEL: define{{.*}} void @_Z14constexpr_testv
	void constexpr_test() {
	// SIO: call noalias noundef nonnull ptr @_Zna{{.}}(i32 noundef 4)
	new int[0+1]{0};
	}

	// CHECK-LABEL: define{{.*}} void @_Z13unknown_boundv
	void unknown_bound() {
	struct Aggr { int x, y, z; };
	new Aggr[]{1, 2, 3, 4};
	// CHECK: call {{.*}}_Znaj(i32 noundef 24)
	// CHECK: store i32 1
	// CHECK: store i32 2
	// CHECK: store i32 3
	// CHECK: store i32 4
	// CHECK: store i32 0
	// CHECK: store i32 0
	// CHECK-NOT: store
	// CHECK: }
	}

	// CHECK-LABEL: define{{.*}} void @_Z20unknown_bound_stringv
	void unknown_bound_string() {
	new char[]{"hello"};
	// CHECK: call {{.*}}_Znaj(i32 noundef 6)
	// CHECK: memcpy{{.*}} i32 6,
	}