[compiler-rt][sanitizer] Have all OOM-related error messages start with the same format

[leonardchan]

Summary

This way downstream tools that read sanitizer output can differentiate between OOM errors reported by sanitizers from other sanitizer errors.

Changes:

• Introduce ErrorIsOOM for checking if a platform-specific error code from an "mmap" is an OOM err.
• Add ReportOOMError which just prepends this error message to the start of a Report call.
• Replace some Reports for OOMs with calls to ReportOOMError.
• Update necessary tests.

[phosek]

compiler-rt/lib/asan/asan_errors.cpp

282

The "out of memory" part is redundant now.

compiler-rt/lib/sanitizer_common/sanitizer_allocator_report.cpp

132

The "out of memory" part is redundant now.

compiler-rt/lib/sanitizer_common/sanitizer_common.h

323

I'd consider using ALL_CAPS to make it clear to the use that this is a macro.

324

I'd avoid capitalization for consistency with other errors.

[vitalybuka]

Up to you if you, if you want to wait for Peter. Feel free to remove and land it if you think it's done.
I added blocker only to make sure that review is shown to @phosek on Phabricator main page.

[phosek]

LGTM

compiler-rt/lib/asan/asan_errors.cpp

void ErrorRssLimitExceeded::Print() {
   stack->Print();
   PrintHintAllocatorCannotReturnNull();
   ReportErrorSummary(scariness.GetDescription(), stack);
 }
 
 void ErrorOutOfMemory::Print() {
   Decorator d;
   Printf("%s", d.Error());
-  Report(
-      "ERROR: AddressSanitizer: allocator is out of memory trying to allocate "
-      "0x%zx bytes\n", requested_size);
+  ERROR_OOM("allocator is trying to allocate 0x%zx bytes\n", requested_size);
   Printf("%s", d.Default());
   stack->Print();
   PrintHintAllocatorCannotReturnNull();
   ReportErrorSummary(scariness.GetDescription(), stack);
 }
 
 void ErrorStringFunctionMemoryRangesOverlap::Print() {
   Decorator d;

compiler-rt/lib/sanitizer_common/sanitizer_allocator_report.cpp

Report("ERROR: %s: requested allocation size 0x%zx exceeds maximum "
            "supported size of 0x%zx\n", SanitizerToolName, user_size, max_size);
   }
   Die();
 }
 
 void NORETURN ReportOutOfMemory(uptr requested_size, const StackTrace *stack) {
   {
     ScopedAllocatorErrorReport report("out-of-memory", stack);
-    Report("ERROR: %s: allocator is out of memory trying to allocate 0x%zx "
-           "bytes\n", SanitizerToolName, requested_size);
+    ERROR_OOM("allocator is trying to allocate 0x%zx bytes\n", requested_size);
   }
   Die();
 }
 
 void NORETURN ReportRssLimitExceeded(const StackTrace *stack) {
   {
     ScopedAllocatorErrorReport report("rss-limit-exceeded", stack);
     Report("ERROR: %s: allocator exceeded the RSS limit\n", SanitizerToolName);
   }
   Die();
 }
 
 }  // namespace __sanitizer

compiler-rt/lib/sanitizer_common/sanitizer_common.h

 void NORETURN Abort();
 void NORETURN Die();
 void NORETURN
 CheckFailed(const char *file, int line, const char *cond, u64 v1, u64 v2);
 void NORETURN ReportMmapFailureAndDie(uptr size, const char *mem_type,
                                       const char *mmap_type, error_t err,
                                       bool raw_report = false);
 
+// Returns true if the platform-specific error reported is an OOM error.
+bool ErrorIsOOM(error_t err);
+
+// This reports an error in the form:
+//
+//   `ERROR: {{SanitizerToolName}}: out of memory: {{err_msg}}`
+//
+// Downstream tools that read sanitizer output will know that errors starting
+// in this format are specifically OOM errors.
+#define ERROR_OOM(err_msg, ...) \
+  Report("ERROR: %s: out of memory: " err_msg, SanitizerToolName, __VA_ARGS__)
+
 // Specific tools may override behavior of "Die" function to do tool-specific
 // job.
 typedef void (*DieCallbackType)(void);
 
 // It's possible to add several callbacks that would be run when "Die" is
 // called. The callbacks will be run in the opposite order. The tools are
 // strongly recommended to setup all callbacks during initialization, when there
 // is only a single thread.

compiler-rt/lib/sanitizer_common/sanitizer_common.cpp

void NORETURN ReportMmapFailureAndDie(uptr size, const char *mem_type,
   static int recursion_count;
   if (raw_report || recursion_count) {
     // If raw report is requested or we went into recursion just die.  The
     // Report() and CHECK calls below may call mmap recursively and fail.
     RawWrite("ERROR: Failed to mmap\n");
     Die();
   }
   recursion_count++;
-  Report("ERROR: %s failed to "
-         "%s 0x%zx (%zd) bytes of %s (error code: %d)\n",
-         SanitizerToolName, mmap_type, size, size, mem_type, err);
+  if (ErrorIsOOM(err)) {
+    ERROR_OOM("failed to %s 0x%zx (%zd) bytes of %s (error code: %d)\n",
+              mmap_type, size, size, mem_type, err);
+  } else {
+    Report(
+        "ERROR: %s failed to "
+  }
 #if !SANITIZER_GO
   DumpProcessMap();
 #endif
   UNREACHABLE("unable to mmap");
 }
 
 typedef bool UptrComparisonFunction(const uptr &a, const uptr &b);
 typedef bool U32ComparisonFunction(const u32 &a, const u32 &b);

compiler-rt/lib/sanitizer_common/sanitizer_fuchsia.cpp

 
 uptr GetMaxUserVirtualAddress() {
   InitShadowBounds();
   return ShadowBounds.memory_limit - 1;
 }
 
 uptr GetMaxVirtualAddress() { return GetMaxUserVirtualAddress(); }
 
+bool ErrorIsOOM(error_t err) { return err == ZX_ERR_NO_MEMORY; }
+
 static void *DoAnonymousMmapOrDie(uptr size, const char *mem_type,
                                   bool raw_report, bool die_for_nomem) {
   size = RoundUpTo(size, GetPageSize());
 
   zx_handle_t vmo;
   zx_status_t status = _zx_vmo_create(size, 0, &vmo);
   if (status != ZX_OK) {
     if (status != ZX_ERR_NO_MEMORY || die_for_nomem)

compiler-rt/lib/sanitizer_common/sanitizer_posix.cpp

 
 namespace __sanitizer {
 
 // ------------- sanitizer_common.h
 uptr GetMmapGranularity() {
   return GetPageSize();
 }
 
+bool ErrorIsOOM(error_t err) { return err == ENOMEM; }
+
 void *MmapOrDie(uptr size, const char *mem_type, bool raw_report) {
   size = RoundUpTo(size, GetPageSizeCached());
   uptr res = MmapNamed(nullptr, size, PROT_READ | PROT_WRITE,
                        MAP_PRIVATE | MAP_ANON, mem_type);
   int reserrno;
   if (UNLIKELY(internal_iserror(res, &reserrno)))
     ReportMmapFailureAndDie(size, mem_type, "allocate", reserrno, raw_report);
   IncreaseTotalMmap(size);

compiler-rt/lib/sanitizer_common/sanitizer_win.cpp

void GetThreadStackTopAndBottom(bool at_initialization, uptr *stack_top,
   // FIXME: is it possible for the stack to not be a single allocation?
   // Are these values what ASan expects to get (reserved, not committed;
   // including stack guard page) ?
   *stack_top = (uptr)mbi.BaseAddress + mbi.RegionSize;
   *stack_bottom = (uptr)mbi.AllocationBase;
 }
 #endif  // #if !SANITIZER_GO
 
+bool ErrorIsOOM(error_t err) {
+  // TODO: This should check which `err`s correspond to OOM.
+  return false;
+}
+
 void *MmapOrDie(uptr size, const char *mem_type, bool raw_report) {
   void *rv = VirtualAlloc(0, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
   if (rv == 0)
     ReportMmapFailureAndDie(size, mem_type, "allocate",
                             GetLastError(), raw_report);
   return rv;
 }
 

compiler-rt/test/hwasan/TestCases/sizes.cpp

int main(int argc, char **argv) {
   } else {
     assert(0);
   }
 
   return 0;
 }
 
 // CHECK-max: {{ERROR: HWAddressSanitizer: requested allocation size .* exceeds maximum supported size}}
-// CHECK-oom: ERROR: HWAddressSanitizer: allocator is out of memory
+// CHECK-oom: ERROR: HWAddressSanitizer: out of memory: allocator is trying to allocate
 // CHECK-calloc: ERROR: HWAddressSanitizer: calloc parameters overflow
 // CHECK-reallocarray: ERROR: HWAddressSanitizer: reallocarray parameters overflow

compiler-rt/test/lsan/TestCases/realloc_too_big.c

 // RUN: %clang_lsan %s -o %t
 // RUN: %env_lsan_opts=allocator_may_return_null=1:max_allocation_size_mb=1:use_stacks=0 not %run %t 2>&1 | FileCheck %s
 
 /// Fails when only leak sanitizer is enabled
 // UNSUPPORTED: arm-linux, armhf-linux
 
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 
-// CHECK: {{Leak|Address}}Sanitizer failed to allocate 0x100001 bytes
+// CHECK: {{Leak|Address}}Sanitizer: out of memory: failed to allocate 0x100001 bytes
 
 // CHECK: {{Leak|Address}}Sanitizer: detected memory leaks
 // CHECK: {{Leak|Address}}Sanitizer: 9 byte(s) leaked in 1 allocation(s).
 
 int main() {
   char *p = malloc(9);
   fprintf(stderr, "nine: %p\n", p);
   assert(realloc(p, 0x100001) == NULL); // 1MiB+1
   p = 0;
 }