[tsan] print error summary line

[kcc]

Summary

done

[dvyukov]

other than that LGTM

tsan/rtl/tsan_report.cc

171

It's not necessary "tsan/rtl", some interceptors are in sanitizer_common.
Please unify it with logic in tsan_rtl_report.cc.

[dvyukov]

LGTM

tsan/rtl/tsan_rtl_report.cc

502

Please add
tsan_interface_ann.cc
tsan_interface_atomic.cc
tsan_interface_java.cc
in a subsequent CL.

[Eugene.Zelenko]

Committed in rL174505.

sanitizer_common/sanitizer_common.cc

if (end != map_end)
     UnmapOrDie((void*)end, map_end - end);
   return (void*)res;
 }
 
 void ReportErrorSummary(const char *error_type, const char *file,
                         int line, const char *function) {
   const int kMaxSize = 1024;  // We don't want a summary too long.
   InternalScopedBuffer<char> buff(kMaxSize);
-  internal_snprintf(buff.data(), kMaxSize, "%s %s %s:%d %s",
+  internal_snprintf(buff.data(), kMaxSize, "%s: %s %s:%d %s",
                     SanitizerToolName, error_type,
                     file, line, function);
   __sanitizer_report_error_summary(buff.data());
 }
 
 }  // namespace __sanitizer
 
 using namespace __sanitizer;  // NOLINT

tsan/lit_tests/free_race.c

 
 // CHECK: WARNING: ThreadSanitizer: heap-use-after-free
 // CHECK:   Write of size 4 at {{.*}} by main thread{{.*}}:
 // CHECK:     #0 Thread2
 // CHECK:     #1 main
 // CHECK:   Previous write of size 8 at {{.*}} by thread T1{{.*}}:
 // CHECK:     #0 free
 // CHECK:     #{{(1|2)}} Thread1
+// CHECK: SUMMARY: ThreadSanitizer: heap-use-after-free{{.*}}Thread2

tsan/lit_tests/mutex_destroy_locked.cc

 // CHECK:     #0 pthread_mutex_destroy
 // CHECK:     #1 main
 // CHECK:   and:
 // CHECK:     #0 pthread_mutex_lock
 // CHECK:     #1 main
 // CHECK:   Mutex {{.*}} created at:
 // CHECK:     #0 pthread_mutex_init
 // CHECK:     #1 main
+// CHECK: SUMMARY: ThreadSanitizer: destroy of a locked mutex{{.*}}main

tsan/lit_tests/signal_errno.cc

 // RUN: %clang_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s
 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <signal.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <errno.h>
 
 pthread_t mainth;
 volatile int done;
 
-static void handler(int, siginfo_t *s, void *c) {
+static void MyHandler(int, siginfo_t *s, void *c) {
   errno = 1;
   done = 1;
 }
 
 static void* sendsignal(void *p) {
   pthread_kill(mainth, SIGPROF);
   return 0;
 }
 
 int main() {
   mainth = pthread_self();
   struct sigaction act = {};
-  act.sa_sigaction = &handler;
+  act.sa_sigaction = &MyHandler;
   sigaction(SIGPROF, &act, 0);
   pthread_t th;
   pthread_create(&th, 0, sendsignal, 0);
   while (done == 0) {
     volatile char *p = (char*)malloc(1);
     p[0] = 0;
     free((void*)p);
     pthread_yield();
   }
   pthread_join(th, 0);
   return 0;
 }
 
 // CHECK: WARNING: ThreadSanitizer: signal handler spoils errno
-// CHECK:     #0 handler(int, siginfo{{(_t)?}}*, void*) {{.*}}signal_errno.cc
+// CHECK:     #0 MyHandler(int, siginfo{{(_t)?}}*, void*) {{.*}}signal_errno.cc
+// CHECK: SUMMARY: ThreadSanitizer: signal handler spoils errno{{.*}}MyHandler
 

tsan/lit_tests/signal_malloc.cc

 // RUN: %clang_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s
 #include <stdio.h>
 #include <stdlib.h>
 #include <signal.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 static void handler(int, siginfo_t*, void*) {
   // CHECK: WARNING: ThreadSanitizer: signal-unsafe call inside of a signal
   // CHECK:     #0 malloc
-  // CHECK:     #{{(1|2)}} handler(int, siginfo{{(_t)?}}*, void*) {{.*}}signal_malloc.cc:[[@LINE+1]]
+  // CHECK:     #{{(1|2)}} handler(int, siginfo{{(_t)?}}*, void*) {{.*}}signal_malloc.cc:[[@LINE+2]]
+  // CHECK: SUMMARY: ThreadSanitizer: signal-unsafe call inside of a signal{{.*}}handler
   volatile char *p = (char*)malloc(1);
   p[0] = 0;
   free((void*)p);
 }
 
 int main() {
   struct sigaction act = {};
   act.sa_sigaction = &handler;
   sigaction(SIGPROF, &act, 0);
   kill(getpid(), SIGPROF);
   sleep(1);
   return 0;
 }
 

tsan/lit_tests/simple_race.cc

int main() {
   pthread_t t[2];
   pthread_create(&t[0], NULL, Thread1, NULL);
   pthread_create(&t[1], NULL, Thread2, NULL);
   pthread_join(t[0], NULL);
   pthread_join(t[1], NULL);
 }
 
 // CHECK: WARNING: ThreadSanitizer: data race
+// CHECK: SUMMARY: ThreadSanitizer: data race{{.*}}Thread

tsan/lit_tests/thread_leak3.c

 // RUN: %clang_tsan -O1 %s -o %t && %t 2>&1 | FileCheck %s
 #include <pthread.h>
 
 void *Thread(void *x) {
   return 0;
 }
 
 int main() {
   pthread_t t;
   pthread_create(&t, 0, Thread, 0);
   return 0;
 }
 
 // CHECK: WARNING: ThreadSanitizer: thread leak
+// CHECK: SUMMARY: ThreadSanitizer: thread leak{{.*}}main

tsan/rtl/tsan_report.cc

 const int kThreadBufSize = 32;
 const char *thread_name(char *buf, int tid) {
   if (tid == 0)
     return "main thread";
   internal_snprintf(buf, kThreadBufSize, "thread T%d", tid);
   return buf;
 }
 
-static void PrintHeader(ReportType typ) {
-  Printf("WARNING: ThreadSanitizer: ");
-
+static const char *ReportTypeString(ReportType typ) {
   if (typ == ReportTypeRace)
-    Printf("data race");
-  else if (typ == ReportTypeUseAfterFree)
-    Printf("heap-use-after-free");
-  else if (typ == ReportTypeThreadLeak)
-    Printf("thread leak");
-  else if (typ == ReportTypeMutexDestroyLocked)
-    Printf("destroy of a locked mutex");
-  else if (typ == ReportTypeSignalUnsafe)
-    Printf("signal-unsafe call inside of a signal");
-  else if (typ == ReportTypeErrnoInSignal)
-    Printf("signal handler spoils errno");
-
-  Printf(" (pid=%d)\n", GetPid());
+    return "data race";
+  if (typ == ReportTypeUseAfterFree)
+    return "heap-use-after-free";
+  if (typ == ReportTypeThreadLeak)
+    return "thread leak";
+  if (typ == ReportTypeMutexDestroyLocked)
+    return "destroy of a locked mutex";
+  if (typ == ReportTypeSignalUnsafe)
+    return "signal-unsafe call inside of a signal";
+  if (typ == ReportTypeErrnoInSignal)
+    return "signal handler spoils errno";
+  return "";
 }
 
 void PrintStack(const ReportStack *ent) {
   if (ent == 0) {
     Printf("    [failed to restore the stack]\n\n");
     return;
   }
   for (int i = 0; ent; ent = ent->next, i++) {
static void PrintThread(const ReportThread *rt) {
   PrintStack(rt->stack);
 }
 
 static void PrintSleep(const ReportStack *s) {
   Printf("  As if synchronized via sleep:\n");
   PrintStack(s);
 }
 
+static ReportStack *ChooseSummaryStack(const ReportDesc *rep) {
+  if (rep->mops.Size())
+    return rep->mops[0]->stack;
+  if (rep->stacks.Size())
+    return rep->stacks[0];
+  if (rep->mutexes.Size())
+    return rep->mutexes[0]->stack;
+  if (rep->threads.Size())
+    return rep->threads[0]->stack;
+  return 0;
+}
+
+static ReportStack *SkipTsanInternalFrame(ReportStack *ent) {
+  if (FrameIsInternal(ent) && ent->next)
+    return ent->next;
+  return ent;
+}
+
 void PrintReport(const ReportDesc *rep) {
   Printf("==================\n");
-  PrintHeader(rep->typ);
+  const char *rep_typ_str = ReportTypeString(rep->typ);
+  Printf("WARNING: ThreadSanitizer: %s (pid=%d)\n", rep_typ_str, GetPid());
 
   for (uptr i = 0; i < rep->stacks.Size(); i++) {
     if (i)
       Printf("  and:\n");
     PrintStack(rep->stacks[i]);
   }
 
   for (uptr i = 0; i < rep->mops.Size(); i++)
     PrintMop(rep->mops[i], i == 0);
 
   if (rep->sleep)
     PrintSleep(rep->sleep);
 
   for (uptr i = 0; i < rep->locs.Size(); i++)
     PrintLocation(rep->locs[i]);
 
   for (uptr i = 0; i < rep->mutexes.Size(); i++)
     PrintMutex(rep->mutexes[i]);
 
   for (uptr i = 0; i < rep->threads.Size(); i++)
     PrintThread(rep->threads[i]);
 
+  if (ReportStack *ent = SkipTsanInternalFrame(ChooseSummaryStack(rep)))
+    ReportErrorSummary(rep_typ_str, ent->file, ent->line, ent->func);
+
   Printf("==================\n");
 }
 
 #else
 
 void PrintStack(const ReportStack *ent) {
   if (ent == 0) {
     Printf("  [failed to restore the stack]\n\n");

tsan/rtl/tsan_rtl.h

 bool OutputReport(Context *ctx,
                   const ScopedReport &srep,
                   const ReportStack *suppress_stack1 = 0,
                   const ReportStack *suppress_stack2 = 0);
 bool IsFiredSuppression(Context *ctx,
                         const ScopedReport &srep,
                         const StackTrace &trace);
 bool IsExpectedReport(uptr addr, uptr size);
+bool FrameIsInternal(const ReportStack *frame);
 
 #if defined(TSAN_DEBUG_OUTPUT) && TSAN_DEBUG_OUTPUT >= 1
 # define DPrintf Printf
 #else
 # define DPrintf(...)
 #endif
 
 #if defined(TSAN_DEBUG_OUTPUT) && TSAN_DEBUG_OUTPUT >= 2

tsan/rtl/tsan_rtl_report.cc

for (uptr k = 0; k < ctx->fired_suppressions.Size(); k++) {
     for (uptr j = 0; j < trace.Size(); j++) {
       if (trace.Get(j) == ctx->fired_suppressions[k].pc)
         return true;
     }
   }
   return false;
 }
 
+bool FrameIsInternal(const ReportStack *frame) {
+  return frame != 0 && frame->file != 0
+      && (internal_strstr(frame->file, "tsan_interceptors.cc") ||
+          internal_strstr(frame->file, "sanitizer_common_interceptors.inc"));
+}
+
 // On programs that use Java we see weird reports like:
 // WARNING: ThreadSanitizer: data race (pid=22512)
 //   Read of size 8 at 0x7d2b00084318 by thread 100:
 //     #0 memcpy tsan_interceptors.cc:406 (foo+0x00000d8dfae3)
 //     #1 <null> <null>:0 (0x7f7ad9b40193)
 //   Previous write of size 8 at 0x7d2b00084318 by thread 105:
 //     #0 strncpy tsan_interceptors.cc:501 (foo+0x00000d8e0919)
 //     #1 <null> <null>:0 (0x7f7ad9b42707)
 static bool IsJavaNonsense(const ReportDesc *rep) {
   for (uptr i = 0; i < rep->mops.Size(); i++) {
     ReportMop *mop = rep->mops[i];
     ReportStack *frame = mop->stack;
     if (frame == 0
         || (frame->func == 0 && frame->file == 0 && frame->line == 0
           && frame->module == 0)) {
       return true;
     }
-    if (frame != 0 && frame->file != 0
-        && (internal_strstr(frame->file, "tsan_interceptors.cc") ||
-           internal_strstr(frame->file, "sanitizer_common_interceptors.inc"))) {
+    if (FrameIsInternal(frame)) {
       frame = frame->next;
       if (frame == 0
           || (frame->func == 0 && frame->file == 0 && frame->line == 0
             && frame->module == 0)) {
         if (frame) {
           FiredSuppression supp = {rep->typ, frame->pc};
           CTX()->fired_suppressions.PushBack(supp);
         }