[lldb] Add support for "external" reports in ThreadSanitizer LLDB plugin

[kubamracek]

Summary

TSan now has the ability to report races on "external" object, i.e. any library class/object that has read-shared write-exclusive threading semantics. The detection and reporting work almost out of the box, but TSan can now provide the type of the object (as a string). This patch implements this into LLDB.

This is a new API in the TSan dylib, and we should still support cases the old dylib (that don't have the API), so the expression contains a call to dlsym to see if the new API is available or not. Let me know if there's a better solution.

[clayborg]

Looks good.

source/Plugins/InstrumentationRuntime/ThreadSanitizer/ThreadSanitizerRuntime.cpp

89

Doesn't "dlsym" work on all platforms? Windows?

[kubamracek]

source/Plugins/InstrumentationRuntime/ThreadSanitizer/ThreadSanitizerRuntime.cpp

89

Right, it probably doesn't work on Windows. I'll put in a FIXME/TODO (TSan currenly only works on POSIX anyway), okay?

[clayborg]

source/Plugins/InstrumentationRuntime/ThreadSanitizer/ThreadSanitizerRuntime.cpp

89

Now worries, you can also #ifdef around it if needed and put the code needed for windows right in the expression text here. Does TSAN current work on Windows? If so it seems like bug to not support this feature on windows?

[kubamracek]

source/Plugins/InstrumentationRuntime/ThreadSanitizer/ThreadSanitizerRuntime.cpp

89

TSan doesn't work on Windows.

source/Plugins/InstrumentationRuntime/ThreadSanitizer/ThreadSanitizerRuntime.cpp

int __tsan_get_report_loc(void *report, unsigned long idx, const char **type,
                               int *fd, int *suppressable, void **trace,
                               unsigned long trace_size);
     int __tsan_get_report_mutex(void *report, unsigned long idx, unsigned long *mutex_id, void **addr,
                                 int *destroyed, void **trace, unsigned long trace_size);
     int __tsan_get_report_thread(void *report, unsigned long idx, int *tid, unsigned long *os_id,
                                  int *running, const char **name, int *parent_tid,
                                  void **trace, unsigned long trace_size);
     int __tsan_get_report_unique_tid(void *report, unsigned long idx, int *tid);
+  
+    void *dlsym(void* handle, const char* symbol);
+    int (*ptr__tsan_get_report_loc_object_type)(void *report, unsigned long idx, const char **object_type);
 }
 
 const int REPORT_TRACE_SIZE = 128;
 const int REPORT_ARRAY_SIZE = 4;
 
 struct data {
     void *report;
     const char *description;
struct {
         const char *type;
         void *addr;
         unsigned long start;
         unsigned long size;
         int tid;
         int fd;
         int suppressable;
         void *trace[REPORT_TRACE_SIZE];
+        const char *object_type;
     } locs[REPORT_ARRAY_SIZE];
     
     int mutex_count;
     struct {
         int idx;
         unsigned long mutex_id;
         void *addr;
         int destroyed;
struct {
         int tid;
     } unique_tids[REPORT_ARRAY_SIZE];
 };
 )";
 
 const char *thread_sanitizer_retrieve_report_data_command = R"(
 data t = {0};
 
+ptr__tsan_get_report_loc_object_type = (typeof(ptr__tsan_get_report_loc_object_type))(void *)dlsym((void*)-2 /*RTLD_DEFAULT*/, "__tsan_get_report_loc_object_type");
+
 t.report = __tsan_get_current_report();
 __tsan_get_report_data(t.report, &t.description, &t.report_count, &t.stack_count, &t.mop_count, &t.loc_count, &t.mutex_count, &t.thread_count, &t.unique_tid_count, t.sleep_trace, REPORT_TRACE_SIZE);
 
 if (t.stack_count > REPORT_ARRAY_SIZE) t.stack_count = REPORT_ARRAY_SIZE;
 for (int i = 0; i < t.stack_count; i++) {
     t.stacks[i].idx = i;
     __tsan_get_report_stack(t.report, i, t.stacks[i].trace, REPORT_TRACE_SIZE);
 }
 
 if (t.mop_count > REPORT_ARRAY_SIZE) t.mop_count = REPORT_ARRAY_SIZE;
 for (int i = 0; i < t.mop_count; i++) {
     t.mops[i].idx = i;
     __tsan_get_report_mop(t.report, i, &t.mops[i].tid, &t.mops[i].addr, &t.mops[i].size, &t.mops[i].write, &t.mops[i].atomic, t.mops[i].trace, REPORT_TRACE_SIZE);
 }
 
 if (t.loc_count > REPORT_ARRAY_SIZE) t.loc_count = REPORT_ARRAY_SIZE;
 for (int i = 0; i < t.loc_count; i++) {
     t.locs[i].idx = i;
     __tsan_get_report_loc(t.report, i, &t.locs[i].type, &t.locs[i].addr, &t.locs[i].start, &t.locs[i].size, &t.locs[i].tid, &t.locs[i].fd, &t.locs[i].suppressable, t.locs[i].trace, REPORT_TRACE_SIZE);
+    if (ptr__tsan_get_report_loc_object_type)
+        ptr__tsan_get_report_loc_object_type(t.report, i, &t.locs[i].object_type);
 }
 
 if (t.mutex_count > REPORT_ARRAY_SIZE) t.mutex_count = REPORT_ARRAY_SIZE;
 for (int i = 0; i < t.mutex_count; i++) {
     t.mutexes[i].idx = i;
     __tsan_get_report_mutex(t.report, i, &t.mutexes[i].mutex_id, &t.mutexes[i].addr, &t.mutexes[i].destroyed, t.mutexes[i].trace, REPORT_TRACE_SIZE);
 }
 
StructuredData::Array *locs = ConvertToStructuredArray(
                 thread_id_map));
         dict->AddIntegerItem(
             "file_descriptor",
             o->GetValueForExpressionPath(".fd")->GetValueAsUnsigned(0));
         dict->AddIntegerItem("suppressable",
                              o->GetValueForExpressionPath(".suppressable")
                                  ->GetValueAsUnsigned(0));
         dict->AddItem("trace", StructuredData::ObjectSP(CreateStackTrace(o)));
+        dict->AddStringItem("object_type",
+                            RetrieveString(o, process_sp, ".object_type"));
       });
   dict->AddItem("locs", StructuredData::ObjectSP(locs));
 
   StructuredData::Array *mutexes = ConvertToStructuredArray(
       main_value, ".mutexes", ".mutex_count",
       [](ValueObjectSP o, StructuredData::Dictionary *dict) {
         dict->AddIntegerItem(
             "index",
ThreadSanitizerRuntime::FormatDescription(StructuredData::ObjectSP report) {
   } else if (description == "mutex-bad-read-unlock") {
     return "Read unlock of a write locked mutex";
   } else if (description == "signal-unsafe-call") {
     return "Signal-unsafe call inside a signal handler";
   } else if (description == "errno-in-signal-handler") {
     return "Overwrite of errno in a signal handler";
   } else if (description == "lock-order-inversion") {
     return "Lock order inversion (potential deadlock)";
+  } else if (description == "external-race") {
+    return "Race on a library object";
   }
 
   // for unknown report codes just show the code
   return description;
 }
 
 static std::string Sprintf(const char *format, ...) {
   StreamString s;
ThreadSanitizerRuntime::GenerateSummary(StructuredData::ObjectSP report) {
   if (report->GetAsDictionary()
           ->GetValueForKey("locs")
           ->GetAsArray()
           ->GetSize() > 0) {
     StructuredData::ObjectSP loc = report->GetAsDictionary()
                                        ->GetValueForKey("locs")
                                        ->GetAsArray()
                                        ->GetItemAtIndex(0);
+    std::string object_type = loc->GetAsDictionary()
+                                  ->GetValueForKey("object_type")
+                                  ->GetAsString()
+                                  ->GetValue();
+    if (!object_type.empty()) {
+      summary = "Race on " + object_type + " object";
+    }
     addr_t addr = loc->GetAsDictionary()
                       ->GetValueForKey("address")
                       ->GetAsInteger()
                       ->GetValue();
     if (addr == 0)
       addr = loc->GetAsDictionary()
                  ->GetValueForKey("start")
                  ->GetAsInteger()
if (type == "global") {
       addr_t addr = loc->GetAsDictionary()
                         ->GetValueForKey("start")
                         ->GetAsInteger()
                         ->GetValue();
       long size = loc->GetAsDictionary()
                       ->GetValueForKey("size")
                       ->GetAsInteger()
                       ->GetValue();
+      std::string object_type = loc->GetAsDictionary()
+                                    ->GetValueForKey("object_type")
+                                    ->GetAsString()
+                                    ->GetValue();
+      if (!object_type.empty()) {
+        result = Sprintf("Location is a %ld-byte %s object at 0x%llx", size,
+                         object_type.c_str(), addr);
+      } else {
         result =
             Sprintf("Location is a %ld-byte heap object at 0x%llx", size, addr);
+      }
     } else if (type == "stack") {
       int tid = loc->GetAsDictionary()
                     ->GetValueForKey("thread_id")
                     ->GetAsInteger()
                     ->GetValue();
       result = Sprintf("Location is stack of thread %d", tid);
     } else if (type == "tls") {
       int tid = loc->GetAsDictionary()