[tsan] Rename ReportThread->pid to ReportThread->os_id

[kubamracek]

Summary

The field "pid" in ReportThread is used to store the OS-provided thread ID (pthread_self or gettid). The name "pid" suggests it's a process ID, which it isn't. Let's rename it.

compiler-rt/trunk/lib/tsan/rtl/tsan_debugging.cc

int __tsan_get_report_mutex(void *report, uptr idx, uptr *mutex_id, void **addr,
   *mutex_id = mutex->id;
   *addr = (void *)mutex->addr;
   *destroyed = mutex->destroyed;
   if (mutex->stack) CopyTrace(mutex->stack->frames, trace, trace_size);
   return 1;
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
-int __tsan_get_report_thread(void *report, uptr idx, int *tid, uptr *pid,
+int __tsan_get_report_thread(void *report, uptr idx, int *tid, uptr *os_id,
                              int *running, const char **name, int *parent_tid,
                              void **trace, uptr trace_size) {
   const ReportDesc *rep = (ReportDesc *)report;
   CHECK_LT(idx, rep->threads.Size());
   ReportThread *thread = rep->threads[idx];
   *tid = thread->id;
-  *pid = thread->pid;
+  *os_id = thread->os_id;
   *running = thread->running;
   *name = thread->name;
   *parent_tid = thread->parent_tid;
   if (thread->stack) CopyTrace(thread->stack->frames, trace, trace_size);
   return 1;
 }
 
 SANITIZER_INTERFACE_ATTRIBUTE
 int __tsan_get_report_unique_tid(void *report, uptr idx, int *tid) {
   const ReportDesc *rep = (ReportDesc *)report;
   CHECK_LT(idx, rep->unique_tids.Size());
   *tid = rep->unique_tids[idx];
   return 1;
 }

compiler-rt/trunk/lib/tsan/rtl/tsan_interface.h

 
 // Returns information about mutexes included in the report.
 SANITIZER_INTERFACE_ATTRIBUTE
 int __tsan_get_report_mutex(void *report, uptr idx, uptr *mutex_id, void **addr,
                             int *destroyed, void **trace, uptr trace_size);
 
 // Returns information about threads included in the report.
 SANITIZER_INTERFACE_ATTRIBUTE
-int __tsan_get_report_thread(void *report, uptr idx, int *tid, uptr *pid,
+int __tsan_get_report_thread(void *report, uptr idx, int *tid, uptr *os_id,
                              int *running, const char **name, int *parent_tid,
                              void **trace, uptr trace_size);
 
 // Returns information about unique thread IDs included in the report.
 SANITIZER_INTERFACE_ATTRIBUTE
 int __tsan_get_report_unique_tid(void *report, uptr idx, int *tid);
 
 #endif  // SANITIZER_GO

compiler-rt/trunk/lib/tsan/rtl/tsan_report.h

struct ReportLocation {
 
   static ReportLocation *New(ReportLocationType type);
  private:
   explicit ReportLocation(ReportLocationType type);
 };
 
 struct ReportThread {
   int id;
-  uptr pid;
+  uptr os_id;
   bool running;
   char *name;
   int parent_tid;
   ReportStack *stack;
 };
 
 struct ReportMutex {
   u64 id;

compiler-rt/trunk/lib/tsan/rtl/tsan_report.cc

static void PrintThread(const ReportThread *rt) {
   if (rt->id == 0)  // Little sense in describing the main thread.
     return;
   Printf("%s", d.ThreadDescription());
   Printf("  Thread T%d", rt->id);
   if (rt->name && rt->name[0] != '\0')
     Printf(" '%s'", rt->name);
   char thrbuf[kThreadBufSize];
   Printf(" (tid=%zu, %s) created by %s",
-    rt->pid, rt->running ? "running" : "finished",
+    rt->os_id, rt->running ? "running" : "finished",
     thread_name(thrbuf, rt->parent_tid));
   if (rt->stack)
     Printf(" at:");
   Printf("\n");
   Printf("%s", d.EndThreadDescription());
   PrintStack(rt->stack);
 }
 

compiler-rt/trunk/lib/tsan/rtl/tsan_rtl_report.cc

void ScopedReport::AddThread(const ThreadContext *tctx, bool suppressable) {
   for (uptr i = 0; i < rep_->threads.Size(); i++) {
     if ((u32)rep_->threads[i]->id == tctx->tid)
       return;
   }
   void *mem = internal_alloc(MBlockReportThread, sizeof(ReportThread));
   ReportThread *rt = new(mem) ReportThread;
   rep_->threads.PushBack(rt);
   rt->id = tctx->tid;
-  rt->pid = tctx->os_id;
+  rt->os_id = tctx->os_id;
   rt->running = (tctx->status == ThreadStatusRunning);
   rt->name = internal_strdup(tctx->name);
   rt->parent_tid = tctx->parent_tid;
   rt->stack = 0;
   rt->stack = SymbolizeStackId(tctx->creation_stack_id);
   if (rt->stack)
     rt->stack->suppressable = suppressable;
 }

compiler-rt/trunk/test/tsan/debugging.cc

int __tsan_get_report_data(void *report, const char **description, int *count,
                            int *stack_count, int *mop_count, int *loc_count,
                            int *mutex_count, int *thread_count,
                            int *unique_tid_count, void **sleep_trace,
                            unsigned long trace_size);
 int __tsan_get_report_mop(void *report, unsigned long idx, int *tid,
                           void **addr, int *size, int *write, int *atomic,
                           void **trace, unsigned long trace_size);
 int __tsan_get_report_thread(void *report, unsigned long idx, int *tid,
-                             unsigned long *pid, int *running,
+                             unsigned long *os_id, int *running,
                              const char **name, int *parent_tid, void **trace,
                              unsigned long trace_size);
 }
 
 long my_global;
 
 void *Thread(void *a) {
   barrier_wait(&barrier);
fprintf(stderr, "tid = %d, addr = %p, size = %d, write = %d, atomic = %d\n",
           tid, addr, size, write, atomic);
   // CHECK: tid = 0, addr = [[GLOBAL]], size = 8, write = 1, atomic = 0
   fprintf(stderr, "trace[0] = %p, trace[1] = %p\n", trace[0], trace[1]);
   // CHECK: trace[0] = 0x{{[0-9a-f]+}}, trace[1] = {{0x0|\(nil\)|\(null\)}}
 
   fprintf(stderr, "thread_count = %d\n", thread_count);
   // CHECK: thread_count = 2
 
-  unsigned long pid;
+  unsigned long os_id;
   int running;
   const char *name;
   int parent_tid;
 
-  __tsan_get_report_thread(report, 0, &tid, &pid, &running, &name, &parent_tid, trace, 16);
+  __tsan_get_report_thread(report, 0, &tid, &os_id, &running, &name, &parent_tid, trace, 16);
   fprintf(stderr, "tid = %d\n", tid);
   // CHECK: tid = 1
 
-  __tsan_get_report_thread(report, 1, &tid, &pid, &running, &name, &parent_tid, trace, 16);
+  __tsan_get_report_thread(report, 1, &tid, &os_id, &running, &name, &parent_tid, trace, 16);
   fprintf(stderr, "tid = %d\n", tid);
   // CHECK: tid = 0
 }
 
 // CHECK: Done.
 // CHECK: ThreadSanitizer: reported 1 warnings