//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// REQUIRES: asan
// UNSUPPORTED: c++03
// Test based on: https://bugs.chromium.org/p/chromium/issues/detail?id=1419798#c5
// Some allocators during deallocation may not call destructors and just reuse memory.
// In those situations, one may want to deactivate annotations for a specific allocator.
// It's possible with __asan_annotate_container_with_allocator template class.
// This test confirms that those allocators work after turning off annotations.
//
// A context to this test is a situations when memory is repurposed and destructors are not called.
// Related issue: https://github.com/llvm/llvm-project/issues/60384
//
// That issue appeared in the past and was addressed here: https://reviews.llvm.org/D145628
//
// There was also a discussion, if it's UB.
// Related discussion: https://reviews.llvm.org/D136765#4155262
// Related notes: https://eel.is/c++draft/basic.life#6
// Probably it's no longer UB due a change in CWG2523.
// https://cplusplus.github.io/CWG/issues/2523.html
//
// Therefore we make sure that it works that way, also because people rely on this behavior.
// Annotations are turned off only, if a user explicitly turns off annotations for a specific allocator.
#include <assert.h>
#include <stdlib.h>
#include <string>
#include <new>
// Allocator with pre-allocated (with malloc in constructor) buffers.
// Memory may be freed without calling destructors.
struct reuse_allocator {
static size_t const N = 100;
reuse_allocator() {
for (size_t i = 0; i < N; ++i)
__buffers[i] = malloc(8 * 1024);
}
~reuse_allocator() {
for (size_t i = 0; i < N; ++i)
free(__buffers[i]);
}
void* alloc() {
assert(__next_id < N);
return __buffers[__next_id++];
}
void reset() { __next_id = 0; }
void* __buffers[N];
size_t __next_id = 0;
} reuse_buffers;
template <typename T>
struct user_allocator {
using value_type = T;
user_allocator() = default;
template <class U>
user_allocator(user_allocator<U>) {}
friend bool operator==(user_allocator, user_allocator) { return true; }
friend bool operator!=(user_allocator x, user_allocator y) { return !(x == y); }
T* allocate(size_t n) {
if (n * sizeof(T) > 8 * 1024)
throw std::bad_array_new_length();
return (T*)reuse_buffers.alloc();
}
void deallocate(T*, size_t) noexcept {}
};
// Turn off annotations for user_allocator:
template <class T>
struct std::__asan_annotate_container_with_allocator<user_allocator<T>> {
static bool const value = false;
};
int main(int, char**) {
using S = std::basic_string<char, std::char_traits<char>, user_allocator<char>>;
{
// Create a string with a buffer from reuse allocator object:
S* s = new (reuse_buffers.alloc()) S();
// Use string, so it's poisoned, if container annotations for that allocator are not turned off:
for (int i = 0; i < 40; i++)
s->push_back('a');
}
// Reset the state of the allocator, don't call destructors, allow memory to be reused:
reuse_buffers.reset();
{
// Create a next string with the same allocator, so the same buffer due to the reset:
S s;
// Use memory inside the string again, if it's poisoned, an error will be raised:
for (int i = 0; i < 60; i++)
s.push_back('a');
}
return 0;
}