contrib/compiler-rt/lib/sanitizer_common/sanitizer_allocator_report.cc

   1 //===-- sanitizer_allocator_report.cc ---------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 ///
  10 /// \file
  11 /// Shared allocator error reporting for ThreadSanitizer, MemorySanitizer, etc.
  12 ///
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "sanitizer_allocator.h"
  16 #include "sanitizer_allocator_report.h"
  17 #include "sanitizer_common.h"
  18 #include "sanitizer_report_decorator.h"
  19
  20 namespace __sanitizer {
  21
  22 class ScopedAllocatorErrorReport {
  23  public:
  24   ScopedAllocatorErrorReport(const char *error_summary_,
  25                              const StackTrace *stack_)
  26       : error_summary(error_summary_),
  27         stack(stack_) {
  28     Printf("%s", d.Error());
  29   }
  30   ~ScopedAllocatorErrorReport() {
  31     Printf("%s", d.Default());
  32     stack->Print();
  33     PrintHintAllocatorCannotReturnNull();
  34     ReportErrorSummary(error_summary, stack);
  35   }
  36
  37  private:
  38   ScopedErrorReportLock lock;
  39   const char *error_summary;
  40   const StackTrace* const stack;
  41   const SanitizerCommonDecorator d;
  42 };
  43
  44 void NORETURN ReportCallocOverflow(uptr count, uptr size,
  45                                    const StackTrace *stack) {
  46   {
  47     ScopedAllocatorErrorReport report("calloc-overflow", stack);
  48     Report("ERROR: %s: calloc parameters overflow: count * size (%zd * %zd) "
  49            "cannot be represented in type size_t\n", SanitizerToolName, count,
  50            size);
  51   }
  52   Die();
  53 }
  54
  55 void NORETURN ReportPvallocOverflow(uptr size, const StackTrace *stack) {
  56   {
  57     ScopedAllocatorErrorReport report("pvalloc-overflow", stack);
  58     Report("ERROR: %s: pvalloc parameters overflow: size 0x%zx rounded up to "
  59            "system page size 0x%zx cannot be represented in type size_t\n",
  60            SanitizerToolName, size, GetPageSizeCached());
  61   }
  62   Die();
  63 }
  64
  65 void NORETURN ReportInvalidAllocationAlignment(uptr alignment,
  66                                                const StackTrace *stack) {
  67   {
  68     ScopedAllocatorErrorReport report("invalid-allocation-alignment", stack);
  69     Report("ERROR: %s: invalid allocation alignment: %zd, alignment must be a "
  70            "power of two\n", SanitizerToolName, alignment);
  71   }
  72   Die();
  73 }
  74
  75 void NORETURN ReportInvalidAlignedAllocAlignment(uptr size, uptr alignment,
  76                                                  const StackTrace *stack) {
  77   {
  78     ScopedAllocatorErrorReport report("invalid-aligned-alloc-alignment", stack);
  79 #if SANITIZER_POSIX
  80     Report("ERROR: %s: invalid alignment requested in "
  81            "aligned_alloc: %zd, alignment must be a power of two and the "
  82            "requested size 0x%zx must be a multiple of alignment\n",
  83            SanitizerToolName, alignment, size);
  84 #else
  85     Report("ERROR: %s: invalid alignment requested in aligned_alloc: %zd, "
  86            "the requested size 0x%zx must be a multiple of alignment\n",
  87            SanitizerToolName, alignment, size);
  88 #endif
  89   }
  90   Die();
  91 }
  92
  93 void NORETURN ReportInvalidPosixMemalignAlignment(uptr alignment,
  94                                                   const StackTrace *stack) {
  95   {
  96     ScopedAllocatorErrorReport report("invalid-posix-memalign-alignment",
  97                                       stack);
  98     Report("ERROR: %s: invalid alignment requested in "
  99            "posix_memalign: %zd, alignment must be a power of two and a "
 100            "multiple of sizeof(void*) == %zd\n", SanitizerToolName, alignment,
 101            sizeof(void*));  // NOLINT
 102   }
 103   Die();
 104 }
 105
 106 void NORETURN ReportAllocationSizeTooBig(uptr user_size, uptr max_size,
 107                                          const StackTrace *stack) {
 108   {
 109     ScopedAllocatorErrorReport report("allocation-size-too-big", stack);
 110     Report("ERROR: %s: requested allocation size 0x%zx exceeds maximum "
 111            "supported size of 0x%zx\n", SanitizerToolName, user_size, max_size);
 112   }
 113   Die();
 114 }
 115
 116 void NORETURN ReportOutOfMemory(uptr requested_size, const StackTrace *stack) {
 117   {
 118     ScopedAllocatorErrorReport report("out-of-memory", stack);
 119     Report("ERROR: %s: allocator is out of memory trying to allocate 0x%zx "
 120            "bytes\n", SanitizerToolName, requested_size);
 121   }
 122   Die();
 123 }
 124
 125 }  // namespace __sanitizer