[Sanitizers] Make common allocator agnostic to failure handling modes.

Summary:
Make common allocator agnostic to failure handling modes and move the
decision up to the particular sanitizer's allocator, where the context
is available (call stack, parameters, return nullptr/crash mode etc.)

It simplifies the common allocator and allows the particular sanitizer's
allocator to generate more specific and detailed error reports (which
will be implemented later).

The behavior is largely the same, except one case, the violation of the
common allocator's check for "size + alignment" overflow is now reportied
as OOM instead of "bad request". It feels like a worthy tradeoff and
"size + alignment" is huge in this case anyway (thus, can be interpreted
as not enough memory to satisfy the request). There's also a Report()
statement added there.

Reviewers: eugenis

Subscribers: kubamracek, llvm-commits, #sanitizers

Differential Revision: https://reviews.llvm.org/D42198

git-svn-id: https://llvm.org/svn/llvm-project/compiler-rt/trunk@322784 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 7 insertions, 7 deletions

diff --git a/lib/tsan/rtl/tsan_mman.cc b/lib/tsan/rtl/tsan_mman.cc
index 19680238b..39c0d8607 100644
--- a/lib/tsan/rtl/tsan_mman.cc
+++ b/lib/tsan/rtl/tsan_mman.cc
@@ -153,10 +153,10 @@ static void SignalUnsafeCall(ThreadState *thr, uptr pc) {
 void *user_alloc_internal(ThreadState *thr, uptr pc, uptr sz, uptr align,
                           bool signal) {
   if ((sz >= (1ull << 40)) || (align >= (1ull << 40)))
-    return Allocator::FailureHandler::OnBadRequest();
+    return ReturnNullOrDieOnFailure::OnBadRequest();
   void *p = allocator()->Allocate(&thr->proc()->alloc_cache, sz, align);
   if (UNLIKELY(p == 0))
-    return 0;
+    return ReturnNullOrDieOnFailure::OnOOM();
   if (ctx && ctx->initialized)
     OnUserAlloc(thr, pc, (uptr)p, sz, true);
   if (signal)
@@ -179,7 +179,7 @@ void *user_alloc(ThreadState *thr, uptr pc, uptr sz) {
 
 void *user_calloc(ThreadState *thr, uptr pc, uptr size, uptr n) {
   if (UNLIKELY(CheckForCallocOverflow(size, n)))
-    return SetErrnoOnNull(Allocator::FailureHandler::OnBadRequest());
+    return SetErrnoOnNull(ReturnNullOrDieOnFailure::OnBadRequest());
   void *p = user_alloc_internal(thr, pc, n * size);
   if (p)
     internal_memset(p, 0, n * size);
@@ -224,7 +224,7 @@ void *user_realloc(ThreadState *thr, uptr pc, void *p, uptr sz) {
 void *user_memalign(ThreadState *thr, uptr pc, uptr align, uptr sz) {
   if (UNLIKELY(!IsPowerOfTwo(align))) {
     errno = errno_EINVAL;
-    return Allocator::FailureHandler::OnBadRequest();
+    return ReturnNullOrDieOnFailure::OnBadRequest();
   }
   return SetErrnoOnNull(user_alloc_internal(thr, pc, sz, align));
 }
@@ -232,7 +232,7 @@ void *user_memalign(ThreadState *thr, uptr pc, uptr align, uptr sz) {
 int user_posix_memalign(ThreadState *thr, uptr pc, void **memptr, uptr align,
                         uptr sz) {
   if (UNLIKELY(!CheckPosixMemalignAlignment(align))) {
-    Allocator::FailureHandler::OnBadRequest();
+    ReturnNullOrDieOnFailure::OnBadRequest();
     return errno_EINVAL;
   }
   void *ptr = user_alloc_internal(thr, pc, sz, align);
@@ -246,7 +246,7 @@ int user_posix_memalign(ThreadState *thr, uptr pc, void **memptr, uptr align,
 void *user_aligned_alloc(ThreadState *thr, uptr pc, uptr align, uptr sz) {
   if (UNLIKELY(!CheckAlignedAllocAlignmentAndSize(align, sz))) {
     errno = errno_EINVAL;
-    return Allocator::FailureHandler::OnBadRequest();
+    return ReturnNullOrDieOnFailure::OnBadRequest();
   }
   return SetErrnoOnNull(user_alloc_internal(thr, pc, sz, align));
 }
@@ -259,7 +259,7 @@ void *user_pvalloc(ThreadState *thr, uptr pc, uptr sz) {
   uptr PageSize = GetPageSizeCached();
   if (UNLIKELY(CheckForPvallocOverflow(sz, PageSize))) {
     errno = errno_ENOMEM;
-    return Allocator::FailureHandler::OnBadRequest();
+    return ReturnNullOrDieOnFailure::OnBadRequest();
   }
   // pvalloc(0) should allocate one page.
   sz = sz ? RoundUpTo(sz, PageSize) : PageSize;