Make FuzzerLoop error printing more uniform.

[aarongreen]

Summary

This change ensures libfuzzer always prints errors the same way, i.e. "==<pid>== ERROR: libfuzzer: ...". For simple errors, it provides PrintError(const char *). For formatted errors, the approach is to use PrintErrorPrefix, followed by Printf. Having a formatted version of PrintError, i.e. PrintErrorf, was considered but avoided since there isn't a varargs version of Printf available in FuzzerIO.h (VPrintf is not equivalent to vprintf).

This change also makes sure libfuzzer reports when the sanitizer invokes its death callback, which allows easier log collection on platforms that process exceptions out of process (e.g. Fuchsia)

Finally, it corrects the error message for overwriting const input data.

compiler-rt/lib/fuzzer/FuzzerLoop.cpp

if (int TraceLevel = AllocTracer.TraceLevel) {
     if (Lock.IsDisabled())
       return;
     Printf("FREE[%zd]   %p\n", N, ptr);
     if (TraceLevel >= 2 && EF)
       PrintStackTrace();
   }
 }
 
+static void PrintErrorPrefix() {
+  Printf("==%lu== ERROR: libFuzzer: ", GetPid());
+}
+
+static void PrintError(const char *Message) {
+  PrintErrorPrefix();
+  Printf("%s\n", Message);
+}
+
 // Crash on a single malloc that exceeds the rss limit.
 void Fuzzer::HandleMalloc(size_t Size) {
   if (!Options.MallocLimitMb || (Size >> 20) < (size_t)Options.MallocLimitMb)
     return;
-  Printf("==%d== ERROR: libFuzzer: out-of-memory (malloc(%zd))\n", GetPid(),
-         Size);
+  PrintErrorPrefix();
+  Printf("out-of-memory (malloc(%zd))\n", Size);
   Printf("   To change the out-of-memory limit use -rss_limit_mb=<N>\n\n");
   PrintStackTrace();
   DumpCurrentUnit("oom-");
   Printf("SUMMARY: libFuzzer: out-of-memory\n");
   PrintFinalStats();
   _Exit(Options.OOMExitCode); // Stop right now.
 }
 
if (UnitSize <= kMaxUnitSizeToPrint) {
     PrintASCII(CurrentUnitData, UnitSize, "\n");
   }
   WriteUnitToFileWithPrefix({CurrentUnitData, CurrentUnitData + UnitSize},
                             Prefix);
 }
 
 NO_SANITIZE_MEMORY
 void Fuzzer::DeathCallback() {
+  PrintError("sanitizer terminated fuzz target");
   DumpCurrentUnit("crash-");
   PrintFinalStats();
 }
 
 void Fuzzer::StaticAlarmCallback() {
   assert(F);
   F->AlarmCallback();
 }

 
 void Fuzzer::StaticGracefulExitCallback() {
   assert(F);
   F->GracefulExitRequested = true;
   Printf("INFO: signal received, trying to exit gracefully\n");
 }
 
 void Fuzzer::StaticFileSizeExceedCallback() {
-  Printf("==%lu== ERROR: libFuzzer: file size exceeded\n", GetPid());
+  PrintError("file size exceeded");
   exit(1);
 }
 
 void Fuzzer::CrashCallback() {
   if (EF->__sanitizer_acquire_crash_state &&
       !EF->__sanitizer_acquire_crash_state())
     return;
-  Printf("==%lu== ERROR: libFuzzer: deadly signal\n", GetPid());
+  PrintError("deadly signal");
   PrintStackTrace();
   Printf("NOTE: libFuzzer has rudimentary signal handlers.\n"
          "      Combine libFuzzer with AddressSanitizer or similar for better "
          "crash reports.\n");
   Printf("SUMMARY: libFuzzer: deadly signal\n");
   DumpCurrentUnit("crash-");
   PrintFinalStats();
   _Exit(Options.ErrorExitCode); // Stop right now.
 }
 
 void Fuzzer::ExitCallback() {
   if (!RunningUserCallback)
     return; // This exit did not come from the user callback
   if (EF->__sanitizer_acquire_crash_state &&
       !EF->__sanitizer_acquire_crash_state())
     return;
-  Printf("==%lu== ERROR: libFuzzer: fuzz target exited\n", GetPid());
+  PrintError("fuzz target exited");
   PrintStackTrace();
   Printf("SUMMARY: libFuzzer: fuzz target exited\n");
   DumpCurrentUnit("crash-");
   PrintFinalStats();
   _Exit(Options.ErrorExitCode);
 }
 
 void Fuzzer::MaybeExitGracefully() {
#endif
   if (Seconds >= (size_t)Options.UnitTimeoutSec) {
     if (EF->__sanitizer_acquire_crash_state &&
         !EF->__sanitizer_acquire_crash_state())
       return;
     Printf("ALARM: working on the last Unit for %zd seconds\n", Seconds);
     Printf("       and the timeout value is %d (use -timeout=N to change)\n",
            Options.UnitTimeoutSec);
     DumpCurrentUnit("timeout-");
-    Printf("==%lu== ERROR: libFuzzer: timeout after %d seconds\n", GetPid(),
-           Seconds);
+    PrintErrorPrefix();
+    Printf("timeout after %d seconds\n", Seconds);
     PrintStackTrace();
     Printf("SUMMARY: libFuzzer: timeout\n");
     PrintFinalStats();
     _Exit(Options.TimeoutExitCode); // Stop right now.
   }
 }
 
 void Fuzzer::RssLimitCallback() {
   if (EF->__sanitizer_acquire_crash_state &&
       !EF->__sanitizer_acquire_crash_state())
     return;
-  Printf(
-      "==%lu== ERROR: libFuzzer: out-of-memory (used: %zdMb; limit: %zdMb)\n",
-      GetPid(), GetPeakRSSMb(), Options.RssLimitMb);
+  PrintErrorPrefix();
+  Printf("out-of-memory (used: %zdMb; limit: %zdMb)\n", GetPeakRSSMb(), Options.RssLimitMb);
   Printf("   To change the out-of-memory limit use -rss_limit_mb=<N>\n\n");
   PrintMemoryProfile();
   DumpCurrentUnit("oom-");
   Printf("SUMMARY: libFuzzer: out-of-memory\n");
   PrintFinalStats();
   _Exit(Options.OOMExitCode); // Stop right now.
 }
 

 
 size_t Fuzzer::GetCurrentUnitInFuzzingThead(const uint8_t **Data) const {
   assert(InFuzzingThread());
   *Data = CurrentUnitData;
   return CurrentUnitSize;
 }
 
 void Fuzzer::CrashOnOverwrittenData() {
-  Printf("==%d== ERROR: libFuzzer: fuzz target overwrites it's const input\n",
-         GetPid());
+  PrintError("fuzz target overwrites its const input");
   DumpCurrentUnit("crash-");
-  Printf("SUMMARY: libFuzzer: out-of-memory\n");
+  Printf("SUMMARY: libFuzzer: input overwritten\n");
   _Exit(Options.ErrorExitCode); // Stop right now.
 }
 
 // Compare two arrays, but not all bytes if the arrays are large.
 static bool LooseMemeq(const uint8_t *A, const uint8_t *B, size_t Size) {
   const size_t Limit = 64;
   if (Size <= 64)
     return !memcmp(A, B, Size);