1 // RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm %s -o - 2>&1 | FileCheck %s 2 // RUN: %clang_cc1 -DDYNAMIC -triple x86_64-apple-darwin -emit-llvm %s -o - 2>&1 | FileCheck %s 3 4 #ifdef DYNAMIC 5 #define OBJECT_SIZE_BUILTIN __builtin_dynamic_object_size 6 #else 7 #define OBJECT_SIZE_BUILTIN __builtin_object_size 8 #endif 9 10 #define NULL ((void *)0) 11 12 int gi; 13 14 typedef unsigned long size_t; 15 16 // CHECK-DAG-RE: define void @my_malloc({{.*}}) #[[MALLOC_ATTR_NUMBER:[0-9]+]] 17 // N.B. LLVM's allocsize arguments are base-0, whereas ours are base-1 (for 18 // compat with GCC) 19 // CHECK-DAG-RE: attributes #[[MALLOC_ATTR_NUMBER]] = {.*allocsize(0).*} 20 void *my_malloc(size_t) __attribute__((alloc_size(1))); 21 22 // CHECK-DAG-RE: define void @my_calloc({{.*}}) #[[CALLOC_ATTR_NUMBER:[0-9]+]] 23 // CHECK-DAG-RE: attributes #[[CALLOC_ATTR_NUMBER]] = {.*allocsize(0, 1).*} 24 void *my_calloc(size_t, size_t) __attribute__((alloc_size(1, 2))); 25 26 // CHECK-LABEL: @test1 27 void test1() { 28 void *const vp = my_malloc(100); 29 // CHECK: store i32 100 30 gi = OBJECT_SIZE_BUILTIN(vp, 0); 31 // CHECK: store i32 100 32 gi = OBJECT_SIZE_BUILTIN(vp, 1); 33 // CHECK: store i32 100 34 gi = OBJECT_SIZE_BUILTIN(vp, 2); 35 // CHECK: store i32 100 36 gi = OBJECT_SIZE_BUILTIN(vp, 3); 37 38 void *const arr = my_calloc(100, 5); 39 // CHECK: store i32 500 40 gi = OBJECT_SIZE_BUILTIN(arr, 0); 41 // CHECK: store i32 500 42 gi = OBJECT_SIZE_BUILTIN(arr, 1); 43 // CHECK: store i32 500 44 gi = OBJECT_SIZE_BUILTIN(arr, 2); 45 // CHECK: store i32 500 46 gi = OBJECT_SIZE_BUILTIN(arr, 3); 47 48 // CHECK: store i32 100 49 gi = OBJECT_SIZE_BUILTIN(my_malloc(100), 0); 50 // CHECK: store i32 100 51 gi = OBJECT_SIZE_BUILTIN(my_malloc(100), 1); 52 // CHECK: store i32 100 53 gi = OBJECT_SIZE_BUILTIN(my_malloc(100), 2); 54 // CHECK: store i32 100 55 gi = OBJECT_SIZE_BUILTIN(my_malloc(100), 3); 56 57 // CHECK: store i32 500 58 gi = OBJECT_SIZE_BUILTIN(my_calloc(100, 5), 0); 59 // CHECK: store i32 500 60 gi = OBJECT_SIZE_BUILTIN(my_calloc(100, 5), 1); 61 // CHECK: store i32 500 62 gi = OBJECT_SIZE_BUILTIN(my_calloc(100, 5), 2); 63 // CHECK: store i32 500 64 gi = OBJECT_SIZE_BUILTIN(my_calloc(100, 5), 3); 65 66 void *const zeroPtr = my_malloc(0); 67 // CHECK: store i32 0 68 gi = OBJECT_SIZE_BUILTIN(zeroPtr, 0); 69 // CHECK: store i32 0 70 gi = OBJECT_SIZE_BUILTIN(my_malloc(0), 0); 71 72 void *const zeroArr1 = my_calloc(0, 1); 73 void *const zeroArr2 = my_calloc(1, 0); 74 // CHECK: store i32 0 75 gi = OBJECT_SIZE_BUILTIN(zeroArr1, 0); 76 // CHECK: store i32 0 77 gi = OBJECT_SIZE_BUILTIN(zeroArr2, 0); 78 // CHECK: store i32 0 79 gi = OBJECT_SIZE_BUILTIN(my_calloc(1, 0), 0); 80 // CHECK: store i32 0 81 gi = OBJECT_SIZE_BUILTIN(my_calloc(0, 1), 0); 82 } 83 84 // CHECK-LABEL: @test2 85 void test2() { 86 void *const vp = my_malloc(gi); 87 // CHECK: @llvm.objectsize 88 gi = OBJECT_SIZE_BUILTIN(vp, 0); 89 90 void *const arr1 = my_calloc(gi, 1); 91 // CHECK: @llvm.objectsize 92 gi = OBJECT_SIZE_BUILTIN(arr1, 0); 93 94 void *const arr2 = my_calloc(1, gi); 95 // CHECK: @llvm.objectsize 96 gi = OBJECT_SIZE_BUILTIN(arr2, 0); 97 } 98 99 // CHECK-LABEL: @test3 100 void test3() { 101 char *const buf = (char *)my_calloc(100, 5); 102 // CHECK: store i32 500 103 gi = OBJECT_SIZE_BUILTIN(buf, 0); 104 // CHECK: store i32 500 105 gi = OBJECT_SIZE_BUILTIN(buf, 1); 106 // CHECK: store i32 500 107 gi = OBJECT_SIZE_BUILTIN(buf, 2); 108 // CHECK: store i32 500 109 gi = OBJECT_SIZE_BUILTIN(buf, 3); 110 } 111 112 struct Data { 113 int a; 114 int t[10]; 115 char pad[3]; 116 char end[1]; 117 }; 118 119 // CHECK-LABEL: @test5 120 void test5() { 121 struct Data *const data = my_malloc(sizeof(*data)); 122 // CHECK: store i32 48 123 gi = OBJECT_SIZE_BUILTIN(data, 0); 124 // CHECK: store i32 48 125 gi = OBJECT_SIZE_BUILTIN(data, 1); 126 // CHECK: store i32 48 127 gi = OBJECT_SIZE_BUILTIN(data, 2); 128 // CHECK: store i32 48 129 gi = OBJECT_SIZE_BUILTIN(data, 3); 130 131 // CHECK: store i32 40 132 gi = OBJECT_SIZE_BUILTIN(&data->t[1], 0); 133 // CHECK: store i32 36 134 gi = OBJECT_SIZE_BUILTIN(&data->t[1], 1); 135 // CHECK: store i32 40 136 gi = OBJECT_SIZE_BUILTIN(&data->t[1], 2); 137 // CHECK: store i32 36 138 gi = OBJECT_SIZE_BUILTIN(&data->t[1], 3); 139 140 struct Data *const arr = my_calloc(sizeof(*data), 2); 141 // CHECK: store i32 96 142 gi = OBJECT_SIZE_BUILTIN(arr, 0); 143 // CHECK: store i32 96 144 gi = OBJECT_SIZE_BUILTIN(arr, 1); 145 // CHECK: store i32 96 146 gi = OBJECT_SIZE_BUILTIN(arr, 2); 147 // CHECK: store i32 96 148 gi = OBJECT_SIZE_BUILTIN(arr, 3); 149 150 // CHECK: store i32 88 151 gi = OBJECT_SIZE_BUILTIN(&arr->t[1], 0); 152 // CHECK: store i32 36 153 gi = OBJECT_SIZE_BUILTIN(&arr->t[1], 1); 154 // CHECK: store i32 88 155 gi = OBJECT_SIZE_BUILTIN(&arr->t[1], 2); 156 // CHECK: store i32 36 157 gi = OBJECT_SIZE_BUILTIN(&arr->t[1], 3); 158 } 159 160 // CHECK-LABEL: @test6 161 void test6() { 162 // Things that would normally trigger conservative estimates don't need to do 163 // so when we know the source of the allocation. 164 struct Data *const data = my_malloc(sizeof(*data) + 10); 165 // CHECK: store i32 11 166 gi = OBJECT_SIZE_BUILTIN(data->end, 0); 167 // CHECK: store i32 11 168 gi = OBJECT_SIZE_BUILTIN(data->end, 1); 169 // CHECK: store i32 11 170 gi = OBJECT_SIZE_BUILTIN(data->end, 2); 171 // CHECK: store i32 11 172 gi = OBJECT_SIZE_BUILTIN(data->end, 3); 173 174 struct Data *const arr = my_calloc(sizeof(*arr) + 5, 3); 175 // AFAICT, GCC treats malloc and calloc identically. So, we should do the 176 // same. 177 // 178 // Additionally, GCC ignores the initial array index when determining whether 179 // we're writing off the end of an alloc_size base. e.g. 180 // arr[0].end 181 // arr[1].end 182 // arr[2].end 183 // ...Are all considered "writing off the end", because there's no way to tell 184 // with high accuracy if the user meant "allocate a single N-byte `Data`", 185 // or "allocate M smaller `Data`s with extra padding". 186 187 // CHECK: store i32 112 188 gi = OBJECT_SIZE_BUILTIN(arr->end, 0); 189 // CHECK: store i32 112 190 gi = OBJECT_SIZE_BUILTIN(arr->end, 1); 191 // CHECK: store i32 112 192 gi = OBJECT_SIZE_BUILTIN(arr->end, 2); 193 // CHECK: store i32 112 194 gi = OBJECT_SIZE_BUILTIN(arr->end, 3); 195 196 // CHECK: store i32 112 197 gi = OBJECT_SIZE_BUILTIN(arr[0].end, 0); 198 // CHECK: store i32 112 199 gi = OBJECT_SIZE_BUILTIN(arr[0].end, 1); 200 // CHECK: store i32 112 201 gi = OBJECT_SIZE_BUILTIN(arr[0].end, 2); 202 // CHECK: store i32 112 203 gi = OBJECT_SIZE_BUILTIN(arr[0].end, 3); 204 205 // CHECK: store i32 64 206 gi = OBJECT_SIZE_BUILTIN(arr[1].end, 0); 207 // CHECK: store i32 64 208 gi = OBJECT_SIZE_BUILTIN(arr[1].end, 1); 209 // CHECK: store i32 64 210 gi = OBJECT_SIZE_BUILTIN(arr[1].end, 2); 211 // CHECK: store i32 64 212 gi = OBJECT_SIZE_BUILTIN(arr[1].end, 3); 213 214 // CHECK: store i32 16 215 gi = OBJECT_SIZE_BUILTIN(arr[2].end, 0); 216 // CHECK: store i32 16 217 gi = OBJECT_SIZE_BUILTIN(arr[2].end, 1); 218 // CHECK: store i32 16 219 gi = OBJECT_SIZE_BUILTIN(arr[2].end, 2); 220 // CHECK: store i32 16 221 gi = OBJECT_SIZE_BUILTIN(arr[2].end, 3); 222 } 223 224 // CHECK-LABEL: @test7 225 void test7() { 226 struct Data *const data = my_malloc(sizeof(*data) + 5); 227 // CHECK: store i32 9 228 gi = OBJECT_SIZE_BUILTIN(data->pad, 0); 229 // CHECK: store i32 3 230 gi = OBJECT_SIZE_BUILTIN(data->pad, 1); 231 // CHECK: store i32 9 232 gi = OBJECT_SIZE_BUILTIN(data->pad, 2); 233 // CHECK: store i32 3 234 gi = OBJECT_SIZE_BUILTIN(data->pad, 3); 235 } 236 237 // CHECK-LABEL: @test8 238 void test8() { 239 // Non-const pointers aren't currently supported. 240 void *buf = my_calloc(100, 5); 241 // CHECK: @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1 242 gi = OBJECT_SIZE_BUILTIN(buf, 0); 243 // CHECK: @llvm.objectsize 244 gi = OBJECT_SIZE_BUILTIN(buf, 1); 245 // CHECK: @llvm.objectsize 246 gi = OBJECT_SIZE_BUILTIN(buf, 2); 247 // CHECK: store i32 0 248 gi = OBJECT_SIZE_BUILTIN(buf, 3); 249 } 250 251 // CHECK-LABEL: @test9 252 void test9() { 253 // Check to be sure that we unwrap things correctly. 254 short *const buf0 = (my_malloc(100)); 255 short *const buf1 = (short*)(my_malloc(100)); 256 short *const buf2 = ((short*)(my_malloc(100))); 257 258 // CHECK: store i32 100 259 gi = OBJECT_SIZE_BUILTIN(buf0, 0); 260 // CHECK: store i32 100 261 gi = OBJECT_SIZE_BUILTIN(buf1, 0); 262 // CHECK: store i32 100 263 gi = OBJECT_SIZE_BUILTIN(buf2, 0); 264 } 265 266 // CHECK-LABEL: @test10 267 void test10() { 268 // Yay overflow 269 short *const arr = my_calloc((size_t)-1 / 2 + 1, 2); 270 // CHECK: @llvm.objectsize 271 gi = OBJECT_SIZE_BUILTIN(arr, 0); 272 // CHECK: @llvm.objectsize 273 gi = OBJECT_SIZE_BUILTIN(arr, 1); 274 // CHECK: @llvm.objectsize 275 gi = OBJECT_SIZE_BUILTIN(arr, 2); 276 // CHECK: store i32 0 277 gi = OBJECT_SIZE_BUILTIN(arr, 3); 278 279 // As an implementation detail, CharUnits can't handle numbers greater than or 280 // equal to 2**63. Realistically, this shouldn't be a problem, but we should 281 // be sure we don't emit crazy results for this case. 282 short *const buf = my_malloc((size_t)-1); 283 // CHECK: @llvm.objectsize 284 gi = OBJECT_SIZE_BUILTIN(buf, 0); 285 // CHECK: @llvm.objectsize 286 gi = OBJECT_SIZE_BUILTIN(buf, 1); 287 // CHECK: @llvm.objectsize 288 gi = OBJECT_SIZE_BUILTIN(buf, 2); 289 // CHECK: store i32 0 290 gi = OBJECT_SIZE_BUILTIN(buf, 3); 291 292 short *const arr_big = my_calloc((size_t)-1 / 2 - 1, 2); 293 // CHECK: @llvm.objectsize 294 gi = OBJECT_SIZE_BUILTIN(arr_big, 0); 295 // CHECK: @llvm.objectsize 296 gi = OBJECT_SIZE_BUILTIN(arr_big, 1); 297 // CHECK: @llvm.objectsize 298 gi = OBJECT_SIZE_BUILTIN(arr_big, 2); 299 // CHECK: store i32 0 300 gi = OBJECT_SIZE_BUILTIN(arr_big, 3); 301 } 302 303 void *my_tiny_malloc(char) __attribute__((alloc_size(1))); 304 void *my_tiny_calloc(char, char) __attribute__((alloc_size(1, 2))); 305 306 // CHECK-LABEL: @test11 307 void test11() { 308 void *const vp = my_tiny_malloc(100); 309 // CHECK: store i32 100 310 gi = OBJECT_SIZE_BUILTIN(vp, 0); 311 // CHECK: store i32 100 312 gi = OBJECT_SIZE_BUILTIN(vp, 1); 313 // CHECK: store i32 100 314 gi = OBJECT_SIZE_BUILTIN(vp, 2); 315 // CHECK: store i32 100 316 gi = OBJECT_SIZE_BUILTIN(vp, 3); 317 318 // N.B. This causes char overflow, but not size_t overflow, so it should be 319 // supported. 320 void *const arr = my_tiny_calloc(100, 5); 321 // CHECK: store i32 500 322 gi = OBJECT_SIZE_BUILTIN(arr, 0); 323 // CHECK: store i32 500 324 gi = OBJECT_SIZE_BUILTIN(arr, 1); 325 // CHECK: store i32 500 326 gi = OBJECT_SIZE_BUILTIN(arr, 2); 327 // CHECK: store i32 500 328 gi = OBJECT_SIZE_BUILTIN(arr, 3); 329 } 330 331 void *my_signed_malloc(long) __attribute__((alloc_size(1))); 332 void *my_signed_calloc(long, long) __attribute__((alloc_size(1, 2))); 333 334 // CHECK-LABEL: @test12 335 void test12() { 336 // CHECK: store i32 100 337 gi = OBJECT_SIZE_BUILTIN(my_signed_malloc(100), 0); 338 // CHECK: store i32 500 339 gi = OBJECT_SIZE_BUILTIN(my_signed_calloc(100, 5), 0); 340 341 void *const vp = my_signed_malloc(-2); 342 // CHECK: @llvm.objectsize 343 gi = OBJECT_SIZE_BUILTIN(vp, 0); 344 // N.B. These get lowered to -1 because the function calls may have 345 // side-effects, and we can't determine the objectsize. 346 // CHECK: store i32 -1 347 gi = OBJECT_SIZE_BUILTIN(my_signed_malloc(-2), 0); 348 349 void *const arr1 = my_signed_calloc(-2, 1); 350 void *const arr2 = my_signed_calloc(1, -2); 351 // CHECK: @llvm.objectsize 352 gi = OBJECT_SIZE_BUILTIN(arr1, 0); 353 // CHECK: @llvm.objectsize 354 gi = OBJECT_SIZE_BUILTIN(arr2, 0); 355 // CHECK: store i32 -1 356 gi = OBJECT_SIZE_BUILTIN(my_signed_calloc(1, -2), 0); 357 // CHECK: store i32 -1 358 gi = OBJECT_SIZE_BUILTIN(my_signed_calloc(-2, 1), 0); 359 } 360 361 void *alloc_uchar(unsigned char) __attribute__((alloc_size(1))); 362 363 // CHECK-LABEL: @test13 364 void test13() { 365 // If 128 were incorrectly seen as negative, the result would become -1. 366 // CHECK: store i32 128, 367 gi = OBJECT_SIZE_BUILTIN(alloc_uchar(128), 0); 368 } 369 370 void *(*malloc_function_pointer)(int)__attribute__((alloc_size(1))); 371 void *(*calloc_function_pointer)(int, int)__attribute__((alloc_size(1, 2))); 372 373 // CHECK-LABEL: @test_fn_pointer 374 void test_fn_pointer() { 375 void *const vp = malloc_function_pointer(100); 376 // CHECK: store i32 100 377 gi = __builtin_object_size(vp, 0); 378 // CHECK: store i32 100 379 gi = __builtin_object_size(vp, 1); 380 // CHECK: store i32 100 381 gi = __builtin_object_size(vp, 2); 382 // CHECK: store i32 100 383 gi = __builtin_object_size(vp, 3); 384 385 void *const arr = calloc_function_pointer(100, 5); 386 // CHECK: store i32 500 387 gi = __builtin_object_size(arr, 0); 388 // CHECK: store i32 500 389 gi = __builtin_object_size(arr, 1); 390 // CHECK: store i32 500 391 gi = __builtin_object_size(arr, 2); 392 // CHECK: store i32 500 393 gi = __builtin_object_size(arr, 3); 394 395 // CHECK: store i32 100 396 gi = __builtin_object_size(malloc_function_pointer(100), 0); 397 // CHECK: store i32 100 398 gi = __builtin_object_size(malloc_function_pointer(100), 1); 399 // CHECK: store i32 100 400 gi = __builtin_object_size(malloc_function_pointer(100), 2); 401 // CHECK: store i32 100 402 gi = __builtin_object_size(malloc_function_pointer(100), 3); 403 404 // CHECK: store i32 500 405 gi = __builtin_object_size(calloc_function_pointer(100, 5), 0); 406 // CHECK: store i32 500 407 gi = __builtin_object_size(calloc_function_pointer(100, 5), 1); 408 // CHECK: store i32 500 409 gi = __builtin_object_size(calloc_function_pointer(100, 5), 2); 410 // CHECK: store i32 500 411 gi = __builtin_object_size(calloc_function_pointer(100, 5), 3); 412 413 void *const zeroPtr = malloc_function_pointer(0); 414 // CHECK: store i32 0 415 gi = __builtin_object_size(zeroPtr, 0); 416 // CHECK: store i32 0 417 gi = __builtin_object_size(malloc_function_pointer(0), 0); 418 419 void *const zeroArr1 = calloc_function_pointer(0, 1); 420 void *const zeroArr2 = calloc_function_pointer(1, 0); 421 // CHECK: store i32 0 422 gi = __builtin_object_size(zeroArr1, 0); 423 // CHECK: store i32 0 424 gi = __builtin_object_size(zeroArr2, 0); 425 // CHECK: store i32 0 426 gi = __builtin_object_size(calloc_function_pointer(1, 0), 0); 427 // CHECK: store i32 0 428 gi = __builtin_object_size(calloc_function_pointer(0, 1), 0); 429 } 430 431 typedef void *(__attribute__((warn_unused_result, alloc_size(1))) * my_malloc_function_pointer_type)(int); 432 typedef void *(__attribute__((alloc_size(1, 2))) * my_calloc_function_pointer_type)(int, int); 433 extern my_malloc_function_pointer_type malloc_function_pointer_with_typedef; 434 extern my_calloc_function_pointer_type calloc_function_pointer_with_typedef; 435 436 // CHECK-LABEL: @test_fn_pointer_typedef 437 void test_fn_pointer_typedef() { 438 malloc_function_pointer_with_typedef(100); 439 void *const vp = malloc_function_pointer_with_typedef(100); 440 // CHECK: store i32 100 441 gi = __builtin_object_size(vp, 0); 442 // CHECK: store i32 100 443 gi = __builtin_object_size(vp, 1); 444 // CHECK: store i32 100 445 gi = __builtin_object_size(vp, 2); 446 // CHECK: store i32 100 447 gi = __builtin_object_size(vp, 3); 448 449 void *const arr = calloc_function_pointer_with_typedef(100, 5); 450 // CHECK: store i32 500 451 gi = __builtin_object_size(arr, 0); 452 // CHECK: store i32 500 453 gi = __builtin_object_size(arr, 1); 454 // CHECK: store i32 500 455 gi = __builtin_object_size(arr, 2); 456 // CHECK: store i32 500 457 gi = __builtin_object_size(arr, 3); 458 459 // CHECK: store i32 100 460 gi = __builtin_object_size(malloc_function_pointer_with_typedef(100), 0); 461 // CHECK: store i32 100 462 gi = __builtin_object_size(malloc_function_pointer_with_typedef(100), 1); 463 // CHECK: store i32 100 464 gi = __builtin_object_size(malloc_function_pointer_with_typedef(100), 2); 465 // CHECK: store i32 100 466 gi = __builtin_object_size(malloc_function_pointer_with_typedef(100), 3); 467 468 // CHECK: store i32 500 469 gi = __builtin_object_size(calloc_function_pointer_with_typedef(100, 5), 0); 470 // CHECK: store i32 500 471 gi = __builtin_object_size(calloc_function_pointer_with_typedef(100, 5), 1); 472 // CHECK: store i32 500 473 gi = __builtin_object_size(calloc_function_pointer_with_typedef(100, 5), 2); 474 // CHECK: store i32 500 475 gi = __builtin_object_size(calloc_function_pointer_with_typedef(100, 5), 3); 476 477 void *const zeroPtr = malloc_function_pointer_with_typedef(0); 478 // CHECK: store i32 0 479 gi = __builtin_object_size(zeroPtr, 0); 480 // CHECK: store i32 0 481 gi = __builtin_object_size(malloc_function_pointer_with_typedef(0), 0); 482 483 void *const zeroArr1 = calloc_function_pointer_with_typedef(0, 1); 484 void *const zeroArr2 = calloc_function_pointer_with_typedef(1, 0); 485 // CHECK: store i32 0 486 gi = __builtin_object_size(zeroArr1, 0); 487 // CHECK: store i32 0 488 gi = __builtin_object_size(zeroArr2, 0); 489 // CHECK: store i32 0 490 gi = __builtin_object_size(calloc_function_pointer_with_typedef(1, 0), 0); 491 // CHECK: store i32 0 492 gi = __builtin_object_size(calloc_function_pointer_with_typedef(0, 1), 0); 493 } 494