145 lines
4.9 KiB
C++
145 lines
4.9 KiB
C++
// Test basic new functionality.
|
|
// RUN: %clangxx_hwasan -std=c++17 %s -o %t -fsized-deallocation
|
|
// RUN: %run %t
|
|
|
|
#include <cassert>
|
|
#include <cstdint>
|
|
#include <cstdlib>
|
|
#include <new>
|
|
#include <sanitizer/allocator_interface.h>
|
|
#include <sanitizer/hwasan_interface.h>
|
|
|
|
void operator_new_delete(size_t size) {
|
|
void *alloc = operator new(size);
|
|
assert(alloc != nullptr);
|
|
assert(__sanitizer_get_allocated_size(alloc) == size);
|
|
operator delete(alloc);
|
|
|
|
alloc = operator new(size);
|
|
assert(alloc != nullptr);
|
|
assert(__sanitizer_get_allocated_size(alloc) == size);
|
|
operator delete(alloc, size);
|
|
}
|
|
|
|
void operator_new_delete_array(size_t size) {
|
|
void *alloc = operator new[](size);
|
|
assert(alloc != nullptr);
|
|
assert(__sanitizer_get_allocated_size(alloc) == size);
|
|
operator delete[](alloc);
|
|
|
|
alloc = operator new[](size);
|
|
assert(alloc != nullptr);
|
|
assert(__sanitizer_get_allocated_size(alloc) == size);
|
|
operator delete[](alloc, size);
|
|
}
|
|
|
|
void operator_new_delete(size_t size, std::align_val_t align) {
|
|
void *alloc = operator new(size, align);
|
|
assert(alloc != nullptr);
|
|
assert(reinterpret_cast<uintptr_t>(alloc) % static_cast<uintptr_t>(align) == 0);
|
|
assert(__sanitizer_get_allocated_size(alloc) >= size);
|
|
operator delete(alloc, align);
|
|
|
|
alloc = operator new(size, align);
|
|
assert(alloc != nullptr);
|
|
assert(reinterpret_cast<uintptr_t>(alloc) % static_cast<uintptr_t>(align) == 0);
|
|
assert(__sanitizer_get_allocated_size(alloc) >= size);
|
|
operator delete(alloc, size, align);
|
|
}
|
|
|
|
void operator_new_delete_array(size_t size, std::align_val_t align) {
|
|
void *alloc = operator new[](size, align);
|
|
assert(alloc != nullptr);
|
|
assert(reinterpret_cast<uintptr_t>(alloc) % static_cast<uintptr_t>(align) == 0);
|
|
assert(__sanitizer_get_allocated_size(alloc) >= size);
|
|
operator delete[](alloc, align);
|
|
|
|
alloc = operator new[](size, align);
|
|
assert(alloc != nullptr);
|
|
assert(reinterpret_cast<uintptr_t>(alloc) % static_cast<uintptr_t>(align) == 0);
|
|
assert(__sanitizer_get_allocated_size(alloc) >= size);
|
|
operator delete[](alloc, size, align);
|
|
}
|
|
|
|
void operator_new_delete(size_t size, const std::nothrow_t &tag) {
|
|
void *alloc = operator new(size, tag);
|
|
assert(alloc != nullptr);
|
|
assert(__sanitizer_get_allocated_size(alloc) == size);
|
|
operator delete(alloc, tag);
|
|
}
|
|
|
|
void operator_new_delete_array(size_t size, const std::nothrow_t &tag) {
|
|
void *alloc = operator new[](size, tag);
|
|
assert(alloc != nullptr);
|
|
assert(__sanitizer_get_allocated_size(alloc) == size);
|
|
operator delete[](alloc, tag);
|
|
}
|
|
|
|
void operator_new_delete(size_t size, std::align_val_t align, const std::nothrow_t &tag) {
|
|
void *alloc = operator new(size, align, tag);
|
|
assert(alloc != nullptr);
|
|
assert(reinterpret_cast<uintptr_t>(alloc) % static_cast<uintptr_t>(align) == 0);
|
|
assert(__sanitizer_get_allocated_size(alloc) >= size);
|
|
operator delete(alloc, align, tag);
|
|
}
|
|
|
|
void operator_new_delete_array(size_t size, std::align_val_t align, const std::nothrow_t &tag) {
|
|
void *alloc = operator new[](size, align, tag);
|
|
assert(alloc != nullptr);
|
|
assert(reinterpret_cast<uintptr_t>(alloc) % static_cast<uintptr_t>(align) == 0);
|
|
assert(__sanitizer_get_allocated_size(alloc) >= size);
|
|
operator delete[](alloc, align, tag);
|
|
}
|
|
|
|
void operator_new_delete(size_t size, void *ptr) {
|
|
void *alloc = operator new(size, ptr);
|
|
assert(alloc == ptr);
|
|
operator delete(alloc, ptr);
|
|
}
|
|
|
|
void operator_new_delete_array(size_t size, void *ptr) {
|
|
void *alloc = operator new[](size, ptr);
|
|
assert(alloc == ptr);
|
|
operator delete[](alloc, ptr);
|
|
}
|
|
|
|
int main() {
|
|
__hwasan_enable_allocator_tagging();
|
|
|
|
size_t volatile n = 0;
|
|
char *a1 = new char[n];
|
|
assert(a1 != nullptr);
|
|
assert(__sanitizer_get_allocated_size(a1) == 1);
|
|
delete[] a1;
|
|
|
|
constexpr size_t kSize = 8;
|
|
operator_new_delete(kSize);
|
|
operator_new_delete_array(kSize);
|
|
operator_new_delete(kSize, std::nothrow);
|
|
operator_new_delete_array(kSize, std::nothrow);
|
|
|
|
char buffer[kSize];
|
|
operator_new_delete(kSize, buffer);
|
|
operator_new_delete_array(kSize, buffer);
|
|
|
|
#if defined(__cpp_aligned_new) && \
|
|
(!defined(__GLIBCXX__) || \
|
|
(defined(_GLIBCXX_RELEASE) && _GLIBCXX_RELEASE >= 7))
|
|
// Aligned new/delete
|
|
constexpr auto kAlign = std::align_val_t{8};
|
|
void *a2 = ::operator new(4, kAlign);
|
|
assert(a2 != nullptr);
|
|
assert(reinterpret_cast<uintptr_t>(a2) % static_cast<uintptr_t>(kAlign) == 0);
|
|
assert(__sanitizer_get_allocated_size(a2) >= 4);
|
|
::operator delete(a2, kAlign);
|
|
|
|
operator_new_delete(kSize, std::align_val_t{kSize});
|
|
operator_new_delete_array(kSize, std::align_val_t{kSize});
|
|
operator_new_delete(kSize, std::align_val_t{kSize * 2});
|
|
operator_new_delete_array(kSize, std::align_val_t{kSize * 2});
|
|
operator_new_delete(kSize, std::align_val_t{kSize}, std::nothrow);
|
|
operator_new_delete_array(kSize, std::align_val_t{kSize}, std::nothrow);
|
|
operator_new_delete(kSize, std::align_val_t{kSize * 2}, std::nothrow);
|
|
operator_new_delete_array(kSize, std::align_val_t{kSize * 2}, std::nothrow);
|
|
#endif
|
|
}
|