wangtao
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
llvm-project/clang/test/CodeGen/alloc-size.c

369 lines
11 KiB
C
Raw Blame History

// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm %s -o - 2>&1 | FileCheck %s
// RUN: %clang_cc1 -DDYNAMIC -triple x86_64-apple-darwin -emit-llvm %s -o - 2>&1 | FileCheck %s
#ifdef DYNAMIC
#define OBJECT_SIZE_BUILTIN __builtin_dynamic_object_size
#else
#define OBJECT_SIZE_BUILTIN __builtin_object_size
#endif
#define NULL ((void *)0)
int gi;
typedef unsigned long size_t;
// CHECK-DAG-RE: define void @my_malloc({{.*}}) #[[MALLOC_ATTR_NUMBER:[0-9]+]]
// N.B. LLVM's allocsize arguments are base-0, whereas ours are base-1 (for
// compat with GCC)
// CHECK-DAG-RE: attributes #[[MALLOC_ATTR_NUMBER]] = {.*allocsize(0).*}
void *my_malloc(size_t) __attribute__((alloc_size(1)));
// CHECK-DAG-RE: define void @my_calloc({{.*}}) #[[CALLOC_ATTR_NUMBER:[0-9]+]]
// CHECK-DAG-RE: attributes #[[CALLOC_ATTR_NUMBER]] = {.*allocsize(0, 1).*}
void *my_calloc(size_t, size_t) __attribute__((alloc_size(1, 2)));
// CHECK-LABEL: @test1
void test1() {
void *const vp = my_malloc(100);
// CHECK: store i32 100
gi = OBJECT_SIZE_BUILTIN(vp, 0);
// CHECK: store i32 100
gi = OBJECT_SIZE_BUILTIN(vp, 1);
// CHECK: store i32 100
gi = OBJECT_SIZE_BUILTIN(vp, 2);
// CHECK: store i32 100
gi = OBJECT_SIZE_BUILTIN(vp, 3);
void *const arr = my_calloc(100, 5);
// CHECK: store i32 500
gi = OBJECT_SIZE_BUILTIN(arr, 0);
// CHECK: store i32 500
gi = OBJECT_SIZE_BUILTIN(arr, 1);
// CHECK: store i32 500
gi = OBJECT_SIZE_BUILTIN(arr, 2);
// CHECK: store i32 500
gi = OBJECT_SIZE_BUILTIN(arr, 3);
// CHECK: store i32 100
gi = OBJECT_SIZE_BUILTIN(my_malloc(100), 0);
// CHECK: store i32 100
gi = OBJECT_SIZE_BUILTIN(my_malloc(100), 1);
// CHECK: store i32 100
gi = OBJECT_SIZE_BUILTIN(my_malloc(100), 2);
// CHECK: store i32 100
gi = OBJECT_SIZE_BUILTIN(my_malloc(100), 3);
// CHECK: store i32 500
gi = OBJECT_SIZE_BUILTIN(my_calloc(100, 5), 0);
// CHECK: store i32 500
gi = OBJECT_SIZE_BUILTIN(my_calloc(100, 5), 1);
// CHECK: store i32 500
gi = OBJECT_SIZE_BUILTIN(my_calloc(100, 5), 2);
// CHECK: store i32 500
gi = OBJECT_SIZE_BUILTIN(my_calloc(100, 5), 3);
void *const zeroPtr = my_malloc(0);
// CHECK: store i32 0
gi = OBJECT_SIZE_BUILTIN(zeroPtr, 0);
// CHECK: store i32 0
gi = OBJECT_SIZE_BUILTIN(my_malloc(0), 0);
void *const zeroArr1 = my_calloc(0, 1);
void *const zeroArr2 = my_calloc(1, 0);
// CHECK: store i32 0
gi = OBJECT_SIZE_BUILTIN(zeroArr1, 0);
// CHECK: store i32 0
gi = OBJECT_SIZE_BUILTIN(zeroArr2, 0);
// CHECK: store i32 0
gi = OBJECT_SIZE_BUILTIN(my_calloc(1, 0), 0);
// CHECK: store i32 0
gi = OBJECT_SIZE_BUILTIN(my_calloc(0, 1), 0);
}
// CHECK-LABEL: @test2
void test2() {
void *const vp = my_malloc(gi);
// CHECK: @llvm.objectsize
gi = OBJECT_SIZE_BUILTIN(vp, 0);
void *const arr1 = my_calloc(gi, 1);
// CHECK: @llvm.objectsize
gi = OBJECT_SIZE_BUILTIN(arr1, 0);
void *const arr2 = my_calloc(1, gi);
// CHECK: @llvm.objectsize
gi = OBJECT_SIZE_BUILTIN(arr2, 0);
}
// CHECK-LABEL: @test3
void test3() {
char *const buf = (char *)my_calloc(100, 5);
// CHECK: store i32 500
gi = OBJECT_SIZE_BUILTIN(buf, 0);
// CHECK: store i32 500
gi = OBJECT_SIZE_BUILTIN(buf, 1);
// CHECK: store i32 500
gi = OBJECT_SIZE_BUILTIN(buf, 2);
// CHECK: store i32 500
gi = OBJECT_SIZE_BUILTIN(buf, 3);
}
struct Data {
int a;
int t[10];
char pad[3];
char end[1];
};
// CHECK-LABEL: @test5
void test5() {
struct Data *const data = my_malloc(sizeof(*data));
// CHECK: store i32 48
gi = OBJECT_SIZE_BUILTIN(data, 0);
// CHECK: store i32 48
gi = OBJECT_SIZE_BUILTIN(data, 1);
// CHECK: store i32 48
gi = OBJECT_SIZE_BUILTIN(data, 2);
// CHECK: store i32 48
gi = OBJECT_SIZE_BUILTIN(data, 3);
// CHECK: store i32 40
gi = OBJECT_SIZE_BUILTIN(&data->t[1], 0);
// CHECK: store i32 36
gi = OBJECT_SIZE_BUILTIN(&data->t[1], 1);
// CHECK: store i32 40
gi = OBJECT_SIZE_BUILTIN(&data->t[1], 2);
// CHECK: store i32 36
gi = OBJECT_SIZE_BUILTIN(&data->t[1], 3);
struct Data *const arr = my_calloc(sizeof(*data), 2);
// CHECK: store i32 96
gi = OBJECT_SIZE_BUILTIN(arr, 0);
// CHECK: store i32 96
gi = OBJECT_SIZE_BUILTIN(arr, 1);
// CHECK: store i32 96
gi = OBJECT_SIZE_BUILTIN(arr, 2);
// CHECK: store i32 96
gi = OBJECT_SIZE_BUILTIN(arr, 3);
// CHECK: store i32 88
gi = OBJECT_SIZE_BUILTIN(&arr->t[1], 0);
// CHECK: store i32 36
gi = OBJECT_SIZE_BUILTIN(&arr->t[1], 1);
// CHECK: store i32 88
gi = OBJECT_SIZE_BUILTIN(&arr->t[1], 2);
// CHECK: store i32 36
gi = OBJECT_SIZE_BUILTIN(&arr->t[1], 3);
}
// CHECK-LABEL: @test6
void test6() {
// Things that would normally trigger conservative estimates don't need to do
// so when we know the source of the allocation.
struct Data *const data = my_malloc(sizeof(*data) + 10);
// CHECK: store i32 11
gi = OBJECT_SIZE_BUILTIN(data->end, 0);
// CHECK: store i32 11
gi = OBJECT_SIZE_BUILTIN(data->end, 1);
// CHECK: store i32 11
gi = OBJECT_SIZE_BUILTIN(data->end, 2);
// CHECK: store i32 11
gi = OBJECT_SIZE_BUILTIN(data->end, 3);
struct Data *const arr = my_calloc(sizeof(*arr) + 5, 3);
// AFAICT, GCC treats malloc and calloc identically. So, we should do the
// same.
//
// Additionally, GCC ignores the initial array index when determining whether
// we're writing off the end of an alloc_size base. e.g.
// arr[0].end
// arr[1].end
// arr[2].end
// ...Are all considered "writing off the end", because there's no way to tell
// with high accuracy if the user meant "allocate a single N-byte `Data`",
// or "allocate M smaller `Data`s with extra padding".
// CHECK: store i32 112
gi = OBJECT_SIZE_BUILTIN(arr->end, 0);
// CHECK: store i32 112
gi = OBJECT_SIZE_BUILTIN(arr->end, 1);
// CHECK: store i32 112
gi = OBJECT_SIZE_BUILTIN(arr->end, 2);
// CHECK: store i32 112
gi = OBJECT_SIZE_BUILTIN(arr->end, 3);
// CHECK: store i32 112
gi = OBJECT_SIZE_BUILTIN(arr[0].end, 0);
// CHECK: store i32 112
gi = OBJECT_SIZE_BUILTIN(arr[0].end, 1);
// CHECK: store i32 112
gi = OBJECT_SIZE_BUILTIN(arr[0].end, 2);
// CHECK: store i32 112
gi = OBJECT_SIZE_BUILTIN(arr[0].end, 3);
// CHECK: store i32 64
gi = OBJECT_SIZE_BUILTIN(arr[1].end, 0);
// CHECK: store i32 64
gi = OBJECT_SIZE_BUILTIN(arr[1].end, 1);
// CHECK: store i32 64
gi = OBJECT_SIZE_BUILTIN(arr[1].end, 2);
// CHECK: store i32 64
gi = OBJECT_SIZE_BUILTIN(arr[1].end, 3);
// CHECK: store i32 16
gi = OBJECT_SIZE_BUILTIN(arr[2].end, 0);
// CHECK: store i32 16
gi = OBJECT_SIZE_BUILTIN(arr[2].end, 1);
// CHECK: store i32 16
gi = OBJECT_SIZE_BUILTIN(arr[2].end, 2);
// CHECK: store i32 16
gi = OBJECT_SIZE_BUILTIN(arr[2].end, 3);
}
// CHECK-LABEL: @test7
void test7() {
struct Data *const data = my_malloc(sizeof(*data) + 5);
// CHECK: store i32 9
gi = OBJECT_SIZE_BUILTIN(data->pad, 0);
// CHECK: store i32 3
gi = OBJECT_SIZE_BUILTIN(data->pad, 1);
// CHECK: store i32 9
gi = OBJECT_SIZE_BUILTIN(data->pad, 2);
// CHECK: store i32 3
gi = OBJECT_SIZE_BUILTIN(data->pad, 3);
}
// CHECK-LABEL: @test8
void test8() {
// Non-const pointers aren't currently supported.
void *buf = my_calloc(100, 5);
// CHECK: @llvm.objectsize.i64.p0i8(i8* %{{.*}}, i1 false, i1 true, i1
gi = OBJECT_SIZE_BUILTIN(buf, 0);
// CHECK: @llvm.objectsize
gi = OBJECT_SIZE_BUILTIN(buf, 1);
// CHECK: @llvm.objectsize
gi = OBJECT_SIZE_BUILTIN(buf, 2);
// CHECK: store i32 0
gi = OBJECT_SIZE_BUILTIN(buf, 3);
}
// CHECK-LABEL: @test9
void test9() {
// Check to be sure that we unwrap things correctly.
short *const buf0 = (my_malloc(100));
short *const buf1 = (short*)(my_malloc(100));
short *const buf2 = ((short*)(my_malloc(100)));
// CHECK: store i32 100
gi = OBJECT_SIZE_BUILTIN(buf0, 0);
// CHECK: store i32 100
gi = OBJECT_SIZE_BUILTIN(buf1, 0);
// CHECK: store i32 100
gi = OBJECT_SIZE_BUILTIN(buf2, 0);
}
// CHECK-LABEL: @test10
void test10() {
// Yay overflow
short *const arr = my_calloc((size_t)-1 / 2 + 1, 2);
// CHECK: @llvm.objectsize
gi = OBJECT_SIZE_BUILTIN(arr, 0);
// CHECK: @llvm.objectsize
gi = OBJECT_SIZE_BUILTIN(arr, 1);
// CHECK: @llvm.objectsize
gi = OBJECT_SIZE_BUILTIN(arr, 2);
// CHECK: store i32 0
gi = OBJECT_SIZE_BUILTIN(arr, 3);
// As an implementation detail, CharUnits can't handle numbers greater than or
// equal to 2**63. Realistically, this shouldn't be a problem, but we should
// be sure we don't emit crazy results for this case.
short *const buf = my_malloc((size_t)-1);
// CHECK: @llvm.objectsize
gi = OBJECT_SIZE_BUILTIN(buf, 0);
// CHECK: @llvm.objectsize
gi = OBJECT_SIZE_BUILTIN(buf, 1);
// CHECK: @llvm.objectsize
gi = OBJECT_SIZE_BUILTIN(buf, 2);
// CHECK: store i32 0
gi = OBJECT_SIZE_BUILTIN(buf, 3);
short *const arr_big = my_calloc((size_t)-1 / 2 - 1, 2);
// CHECK: @llvm.objectsize
gi = OBJECT_SIZE_BUILTIN(arr_big, 0);
// CHECK: @llvm.objectsize
gi = OBJECT_SIZE_BUILTIN(arr_big, 1);
// CHECK: @llvm.objectsize
gi = OBJECT_SIZE_BUILTIN(arr_big, 2);
// CHECK: store i32 0
gi = OBJECT_SIZE_BUILTIN(arr_big, 3);
}
void *my_tiny_malloc(char) __attribute__((alloc_size(1)));
void *my_tiny_calloc(char, char) __attribute__((alloc_size(1, 2)));
// CHECK-LABEL: @test11
void test11() {
void *const vp = my_tiny_malloc(100);
// CHECK: store i32 100
gi = OBJECT_SIZE_BUILTIN(vp, 0);
// CHECK: store i32 100
gi = OBJECT_SIZE_BUILTIN(vp, 1);
// CHECK: store i32 100
gi = OBJECT_SIZE_BUILTIN(vp, 2);
// CHECK: store i32 100
gi = OBJECT_SIZE_BUILTIN(vp, 3);
// N.B. This causes char overflow, but not size_t overflow, so it should be
// supported.
void *const arr = my_tiny_calloc(100, 5);
// CHECK: store i32 500
gi = OBJECT_SIZE_BUILTIN(arr, 0);
// CHECK: store i32 500
gi = OBJECT_SIZE_BUILTIN(arr, 1);
// CHECK: store i32 500
gi = OBJECT_SIZE_BUILTIN(arr, 2);
// CHECK: store i32 500
gi = OBJECT_SIZE_BUILTIN(arr, 3);
}
void *my_signed_malloc(long) __attribute__((alloc_size(1)));
void *my_signed_calloc(long, long) __attribute__((alloc_size(1, 2)));
// CHECK-LABEL: @test12
void test12() {
// CHECK: store i32 100
gi = OBJECT_SIZE_BUILTIN(my_signed_malloc(100), 0);
// CHECK: store i32 500
gi = OBJECT_SIZE_BUILTIN(my_signed_calloc(100, 5), 0);
void *const vp = my_signed_malloc(-2);
// CHECK: @llvm.objectsize
gi = OBJECT_SIZE_BUILTIN(vp, 0);
// N.B. These get lowered to -1 because the function calls may have
// side-effects, and we can't determine the objectsize.
// CHECK: store i32 -1
gi = OBJECT_SIZE_BUILTIN(my_signed_malloc(-2), 0);
void *const arr1 = my_signed_calloc(-2, 1);
void *const arr2 = my_signed_calloc(1, -2);
// CHECK: @llvm.objectsize
gi = OBJECT_SIZE_BUILTIN(arr1, 0);
// CHECK: @llvm.objectsize
gi = OBJECT_SIZE_BUILTIN(arr2, 0);
// CHECK: store i32 -1
gi = OBJECT_SIZE_BUILTIN(my_signed_calloc(1, -2), 0);
// CHECK: store i32 -1
gi = OBJECT_SIZE_BUILTIN(my_signed_calloc(-2, 1), 0);
}
void *alloc_uchar(unsigned char) __attribute__((alloc_size(1)));
// CHECK-LABEL: @test13
void test13() {
// If 128 were incorrectly seen as negative, the result would become -1.
// CHECK: store i32 128,
gi = OBJECT_SIZE_BUILTIN(alloc_uchar(128), 0);
}
Reference in New Issue View Git Blame Copy Permalink