774ffe5cce
Wire up the `-fsanitize=alloc-token` command-line option, hooking up
the `AllocToken` pass -- it provides allocation tokens to compatible
runtime allocators, enabling different heap organization strategies,
e.g. hardening schemes based on heap partitioning.
The instrumentation rewrites standard allocation calls into variants
that accept an additional `size_t token_id` argument. For example,
calls to `malloc(size)` become `__alloc_token_malloc(size, token_id)`,
and a C++ `new MyType` expression will call
`__alloc_token__Znwm(size, token_id)`.
Currently untyped allocation calls do not yet have `!alloc_token`
metadata, and therefore receive the fallback token only. This will be
fixed in subsequent changes through best-effort type-inference.
One benefit of the instrumentation approach is that it can be applied
transparently to large codebases, and scales in deployment as other
sanitizers.
Similarly to other sanitizers, instrumentation can selectively be
controlled using `__attribute__((no_sanitize("alloc-token")))`. Support
for sanitizer ignorelists to disable instrumentation for specific
functions or source files is implemented.
See clang/docs/AllocToken.rst for more usage instructions.
Link:
https://discourse.llvm.org/t/rfc-a-framework-for-allocator-partitioning-hints/87434
---
This change is part of the following series:
1. https://github.com/llvm/llvm-project/pull/160131
2. https://github.com/llvm/llvm-project/pull/156838
3. https://github.com/llvm/llvm-project/pull/162098
4. https://github.com/llvm/llvm-project/pull/162099
5. https://github.com/llvm/llvm-project/pull/156839
6. https://github.com/llvm/llvm-project/pull/156840
7. https://github.com/llvm/llvm-project/pull/156841
8. https://github.com/llvm/llvm-project/pull/156842
38 lines
1.5 KiB
C
38 lines
1.5 KiB
C
// RUN: %clang_cc1 -fsanitize=alloc-token -triple x86_64-linux-gnu -emit-llvm -disable-llvm-passes %s -o - | FileCheck %s
|
|
|
|
typedef __typeof(sizeof(int)) size_t;
|
|
|
|
void *aligned_alloc(size_t alignment, size_t size);
|
|
void *malloc(size_t size);
|
|
void *calloc(size_t num, size_t size);
|
|
void *realloc(void *ptr, size_t size);
|
|
void *reallocarray(void *ptr, size_t nmemb, size_t size);
|
|
void *memalign(size_t alignment, size_t size);
|
|
void *valloc(size_t size);
|
|
void *pvalloc(size_t size);
|
|
int posix_memalign(void **memptr, size_t alignment, size_t size);
|
|
|
|
void *sink;
|
|
|
|
// CHECK-LABEL: define dso_local void @test_malloc_like(
|
|
// CHECK: call ptr @malloc(i64 noundef 4)
|
|
// CHECK: call ptr @calloc(i64 noundef 3, i64 noundef 4)
|
|
// CHECK: call ptr @realloc(ptr noundef {{.*}}, i64 noundef 8)
|
|
// CHECK: call ptr @reallocarray(ptr noundef {{.*}}, i64 noundef 5, i64 noundef 8)
|
|
// CHECK: call align 128 ptr @aligned_alloc(i64 noundef 128, i64 noundef 1024)
|
|
// CHECK: call align 16 ptr @memalign(i64 noundef 16, i64 noundef 256)
|
|
// CHECK: call ptr @valloc(i64 noundef 4096)
|
|
// CHECK: call ptr @pvalloc(i64 noundef 8192)
|
|
// CHECK: call i32 @posix_memalign(ptr noundef @sink, i64 noundef 64, i64 noundef 4)
|
|
void test_malloc_like() {
|
|
sink = malloc(sizeof(int));
|
|
sink = calloc(3, sizeof(int));
|
|
sink = realloc(sink, sizeof(long));
|
|
sink = reallocarray(sink, 5, sizeof(long));
|
|
sink = aligned_alloc(128, 1024);
|
|
sink = memalign(16, 256);
|
|
sink = valloc(4096);
|
|
sink = pvalloc(8192);
|
|
posix_memalign(&sink, 64, sizeof(int));
|
|
}
|