1 // RUN: %clang_cc1 -std=c++11 -triple i386-unknown-unknown %s -emit-llvm -o - | FileCheck %s 2 // RUN: %clang_cc1 -std=c++20 -triple i386-unknown-unknown %s -emit-llvm -o - | FileCheck %s --check-prefix=CHECK --check-prefix=CHECKCXX20 3 // RUN: %clang_cc1 -std=c++11 -triple i386-unknown-unknown %s -emit-llvm -fsanitize=signed-integer-overflow -o - | FileCheck --check-prefix=SIO %s 4 5 // CHECK: @[[ABC4:.*]] = {{.*}} constant [4 x i8] c"abc\00" 6 // CHECK: @[[ABC15:.*]] = {{.*}} constant [15 x i8] c"abc\00\00\00\00 7 8 // CHECK-LABEL: define{{.*}} void @_Z2fni 9 void fn(int n) { 10 // CHECK: icmp ult i{{32|64}} %{{[^ ]+}}, 3 11 // CHECK: store i32 1 12 // CHECK: store i32 2 13 // CHECK: store i32 3 14 // CHECK: sub {{.*}}, 12 15 // CHECK: call void @llvm.memset 16 new int[n] { 1, 2, 3 }; 17 } 18 19 #if __cplusplus >= 202002L 20 // CHECKCXX20-LABEL: define{{.*}} void @_Z8fn_pareni 21 void fn_paren(int n) { 22 // CHECKCXX20: icmp ult i{{32|64}} %{{[^ ]+}}, 3 23 // CHECKCXX20: store i32 1 24 // CHECKCXX20: store i32 2 25 // CHECKCXX20: store i32 3 26 // CHECKCXX20: sub {{.*}}, 12 27 // CHECKCXX20: call void @llvm.memset 28 new int[n](1, 2, 3); 29 } 30 #endif 31 32 // CHECK-LABEL: define{{.*}} void @_Z11const_exactv 33 void const_exact() { 34 // CHECK-NOT: icmp ult i{{32|64}} %{{[^ ]+}}, 3 35 // CHECK-NOT: icmp eq ptr 36 new int[3] { 1, 2, 3 }; 37 } 38 39 #if __cplusplus >= 202002L 40 // CHECKCXX20-LABEL: define{{.*}} void @_Z17const_exact_parenv 41 void const_exact_paren() { 42 // CHECKCXX20-NOT: icmp ult i{{32|64}} %{{[^ ]+}}, 3 43 // CHECKCXX20-NOT: icmp eq ptr 44 new int[3](1, 2, 3); 45 } 46 #endif 47 48 // CHECK-LABEL: define{{.*}} void @_Z16const_sufficientv 49 void const_sufficient() { 50 // CHECK-NOT: icmp ult i{{32|64}} %{{[^ ]+}}, 3 51 new int[4] { 1, 2, 3 }; 52 // CHECK: ret void 53 } 54 55 #if __cplusplus >= 202002L 56 // CHECKCXX20-LABEL: define{{.*}} void @_Z22const_sufficient_parenv 57 void const_sufficient_paren() { 58 // CHECKCXX20-NOT: icmp ult i{{32|64}} %{{[^ ]+}}, 3 59 new int[4](1, 2, 3); 60 // CHECKCXX20: ret void 61 } 62 #endif 63 64 // CHECK-LABEL: define{{.*}} void @_Z22check_array_value_initv 65 void check_array_value_init() { 66 struct S; 67 new (int S::*[3][4][5]) (); 68 69 // CHECK: call noalias noundef nonnull ptr @_Zna{{.}}(i{{32 noundef 240|64 noundef 480}}) 70 // CHECK: getelementptr inbounds i{{32|64}}, ptr {{.*}}, i{{32|64}} 60 71 72 // CHECK: phi 73 // CHECK: store i{{32|64}} -1, 74 // CHECK: getelementptr inbounds i{{32|64}}, ptr {{.*}}, i{{32|64}} 1 75 // CHECK: icmp eq 76 // CHECK: br i1 77 } 78 79 // CHECK-LABEL: define{{.*}} void @_Z15string_nonconsti 80 void string_nonconst(int n) { 81 // CHECK: icmp {{s|u}}lt i{{32|64}} %{{[^ ]+}}, 4 82 // FIXME: Conditionally throw an exception rather than passing -1 to alloc function 83 // CHECK: select 84 // CHECK: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} 85 // CHECK: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4, 86 // CHECK: %[[REST:.*]] = getelementptr inbounds i8, ptr %[[PTR]], i32 4 87 // CHECK: %[[RESTSIZE:.*]] = sub {{.*}}, 4 88 // CHECK: call void @llvm.memset{{.*}}(ptr align {{[0-9]+}} %[[REST]], i8 0, i{{32|64}} %[[RESTSIZE]], 89 new char[n] { "abc" }; 90 } 91 92 #if __cplusplus >= 202002L 93 // CHECKCXX20-LABEL: define{{.*}} void @_Z21string_nonconst_pareni 94 void string_nonconst_paren(int n) { 95 // CHECKCXX20: icmp {{s|u}}lt i{{32|64}} %{{[^ ]+}}, 4 96 // FIXME: Conditionally throw an exception rather than passing -1 to alloc function 97 // CHECKCXX20: select 98 // CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} 99 // CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4, 100 // CHECKCXX20: %[[REST:.*]] = getelementptr inbounds i8, ptr %[[PTR]], i32 4 101 // CHECKCXX20: %[[RESTSIZE:.*]] = sub {{.*}}, 4 102 // CHECKCXX20: call void @llvm.memset{{.*}}(ptr align {{[0-9]+}} %[[REST]], i8 0, i{{32|64}} %[[RESTSIZE]], 103 new char[n]("abc"); 104 } 105 106 // CHECKCXX20-LABEL: define{{.*}} void @_Z33string_nonconst_paren_extra_pareni 107 void string_nonconst_paren_extra_paren(int n) { 108 // CHECKCXX20: icmp {{s|u}}lt i{{32|64}} %{{[^ ]+}}, 4 109 // FIXME: Conditionally throw an exception rather than passing -1 to alloc function 110 // CHECKCXX20: select 111 // CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} 112 // CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4, 113 // CHECKCXX20: %[[REST:.*]] = getelementptr inbounds i8, ptr %[[PTR]], i32 4 114 // CHECKCXX20: %[[RESTSIZE:.*]] = sub {{.*}}, 4 115 // CHECKCXX20: call void @llvm.memset{{.*}}(ptr align {{[0-9]+}} %[[REST]], i8 0, i{{32|64}} %[[RESTSIZE]], 116 new char[n](("abc")); 117 } 118 #endif 119 120 // CHECK-LABEL: define{{.*}} void @_Z12string_exactv 121 void string_exact() { 122 // CHECK-NOT: icmp 123 // CHECK: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 4) 124 // CHECK: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4, 125 // CHECK-NOT: memset 126 new char[4] { "abc" }; 127 } 128 129 #if __cplusplus >= 202002L 130 // CHECKCXX20-LABEL: define{{.*}} void @_Z18string_exact_parenv 131 void string_exact_paren() { 132 // CHECKCXX20-NOT: icmp 133 // CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 4) 134 // CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4, 135 // CHECKCXX20-NOT: memset 136 new char[4]("abc"); 137 } 138 139 // CHECKCXX20-LABEL: define{{.*}} void @_Z28string_exact_paren_extensionv 140 void string_exact_paren_extension() { 141 // CHECKCXX20-NOT: icmp 142 // CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 4) 143 // CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4, 144 // CHECKCXX20-NOT: memset 145 new char[4](__extension__ "abc"); 146 } 147 #endif 148 149 // CHECK-LABEL: define{{.*}} void @_Z17string_sufficientv 150 void string_sufficient() { 151 // CHECK-NOT: icmp 152 // CHECK: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 15) 153 // FIXME: For very large arrays, it would be preferable to emit a small copy and a memset. 154 // CHECK: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC15]], i32 15, 155 // CHECK-NOT: memset 156 new char[15] { "abc" }; 157 } 158 159 #if __cplusplus >= 202002L 160 // CHECKCXX20-LABEL: define{{.*}} void @_Z23string_sufficient_parenv 161 void string_sufficient_paren() { 162 // CHECKCXX20-NOT: icmp 163 // CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 15) 164 // FIXME: For very large arrays, it would be preferable to emit a small copy and a memset. 165 // CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC15]], i32 15, 166 // CHECKCXX20-NOT: memset 167 new char[15]("abc"); 168 } 169 #endif 170 171 // CHECK-LABEL: define{{.*}} void @_Z10aggr_exactv 172 void aggr_exact() { 173 // CHECK-NOT: icmp 174 // CHECK: %[[MEM:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 16) 175 // CHECK: %[[FIELD:.*]] = getelementptr inbounds nuw %[[AGGR:.*]], ptr %[[MEM]], i32 0, i32 0{{$}} 176 // CHECK: store i32 1, ptr %[[FIELD]] 177 // CHECK: %[[FIELD:.*]] = getelementptr inbounds nuw %[[AGGR]], ptr %[[MEM]], i32 0, i32 1{{$}} 178 // CHECK: store i32 2, ptr %[[FIELD]] 179 // CHECK: %[[PTR1:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[MEM]], i32 1{{$}} 180 // CHECK: %[[FIELD:.*]] = getelementptr inbounds nuw %[[AGGR]], ptr %[[PTR1]], i32 0, i32 0{{$}} 181 // CHECK: store i32 3, ptr %[[FIELD]] 182 // CHECK: %[[FIELD:.*]] = getelementptr inbounds nuw %[[AGGR]], ptr %[[PTR1]], i32 0, i32 1{{$}} 183 // CHECK: store i32 0, ptr %[[FIELD]] 184 // CHECK-NOT: store 185 // CHECK-NOT: memset 186 struct Aggr { int a, b; }; 187 new Aggr[2] { 1, 2, 3 }; 188 } 189 190 // CHECK-LABEL: define{{.*}} void @_Z15aggr_sufficienti 191 void aggr_sufficient(int n) { 192 // CHECK: icmp ult i32 %{{.*}}, 2 193 // CHECK: %[[MEM:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}( 194 // CHECK: %[[FIELD:.*]] = getelementptr inbounds nuw %[[AGGR:.*]], ptr %[[MEM]], i32 0, i32 0{{$}} 195 // CHECK: store i32 1, ptr %[[FIELD]] 196 // CHECK: %[[FIELD:.*]] = getelementptr inbounds nuw %[[AGGR]], ptr %[[MEM]], i32 0, i32 1{{$}} 197 // CHECK: store i32 2, ptr %[[FIELD]] 198 // CHECK: %[[PTR1:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[MEM]], i32 1{{$}} 199 // CHECK: %[[FIELD:.*]] = getelementptr inbounds nuw %[[AGGR]], ptr %[[PTR1]], i32 0, i32 0{{$}} 200 // CHECK: store i32 3, ptr %[[FIELD]] 201 // CHECK: %[[FIELD:.*]] = getelementptr inbounds nuw %[[AGGR]], ptr %[[PTR1]], i32 0, i32 1{{$}} 202 // CHECK: store i32 0, ptr %[[FIELD]] 203 // CHECK: %[[PTR2:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[PTR1]], i32 1{{$}} 204 // CHECK: %[[REMAIN:.*]] = sub i32 {{.*}}, 16 205 // CHECK: call void @llvm.memset{{.*}}(ptr align {{[0-9]+}} %[[PTR2]], i8 0, i32 %[[REMAIN]], 206 struct Aggr { int a, b; }; 207 new Aggr[n] { 1, 2, 3 }; 208 } 209 210 // SIO-LABEL: define{{.*}} void @_Z14constexpr_testv 211 void constexpr_test() { 212 // SIO: call noalias noundef nonnull ptr @_Zna{{.}}(i32 noundef 4) 213 new int[0+1]{0}; 214 } 215 216 // CHECK-LABEL: define{{.*}} void @_Z13unknown_boundv 217 void unknown_bound() { 218 struct Aggr { int x, y, z; }; 219 new Aggr[]{1, 2, 3, 4}; 220 // CHECK: call {{.*}}_Znaj(i32 noundef 24) 221 // CHECK: store i32 1 222 // CHECK: store i32 2 223 // CHECK: store i32 3 224 // CHECK: store i32 4 225 // CHECK: store i32 0 226 // CHECK: store i32 0 227 // CHECK-NOT: store 228 // CHECK: } 229 } 230 231 // CHECK-LABEL: define{{.*}} void @_Z20unknown_bound_stringv 232 void unknown_bound_string() { 233 new char[]{"hello"}; 234 // CHECK: call {{.*}}_Znaj(i32 noundef 6) 235 // CHECK: memcpy{{.*}} i32 6, 236 } 237