[TSanRuntime] Upstream thread swift race detector.

[davide]

Summary

This is self-contained, and doesn't need anything in the
compiler to work. Mainly to reduce the diff between upstream
and downstream.

Patch by Kuba Mracek!

[labath]

Patch by Kuba Mracek!

Somehow, I don't think this patch would be so "self-contained" if we were following llvm developer policy. I also doubt you would be so enthusiastic if other people started "upstreaming" random chunks of their downstream repositories without any tests...

lldb/source/Plugins/InstrumentationRuntime/TSan/TSanRuntime.h

private:
 
   static bool NotifyBreakpointHit(void *baton,
                                   StoppointCallbackContext *context,
                                   lldb::user_id_t break_id,
                                   lldb::user_id_t break_loc_id);
 
   StructuredData::ObjectSP RetrieveReportData(ExecutionContextRef exe_ctx_ref);
 
-  std::string FormatDescription(StructuredData::ObjectSP report);
+  std::string FormatDescription(StructuredData::ObjectSP report,
+                                bool &is_swift_access_race);
 
   std::string GenerateSummary(StructuredData::ObjectSP report);
 
   lldb::addr_t GetMainRacyAddress(StructuredData::ObjectSP report);
 
   std::string GetLocationDescription(StructuredData::ObjectSP report,
                                      lldb::addr_t &global_addr,
                                      std::string &global_name,

lldb/source/Plugins/InstrumentationRuntime/TSan/TSanRuntime.cpp

extern "C"
     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);
   
     // TODO: dlsym won't work on Windows.
     void *dlsym(void* handle, const char* symbol);
     int (*ptr__tsan_get_report_loc_object_type)(void *report, unsigned long idx, const char **object_type);
+    int (*ptr__tsan_get_report_tag)(void *report, unsigned long *tag);
 }
 
 const int REPORT_TRACE_SIZE = 128;
 const int REPORT_ARRAY_SIZE = 4;
 
 struct data {
     void *report;
     const char *description;
     int report_count;
+    unsigned long tag;
     
     void *sleep_trace[REPORT_TRACE_SIZE];
     
     int stack_count;
     struct {
         int idx;
         void *trace[REPORT_TRACE_SIZE];
     } stacks[REPORT_ARRAY_SIZE];
struct data {
     } 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");
+ptr__tsan_get_report_tag = (typeof(ptr__tsan_get_report_tag))(void *)dlsym((void*)-2 /*RTLD_DEFAULT*/, "__tsan_get_report_tag");
 
 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 (ptr__tsan_get_report_tag)
+    ptr__tsan_get_report_tag(t.report, &t.tag);
+
 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++) {
ThreadSanitizerRuntime::RetrieveReportData(ExecutionContextRef exe_ctx_ref) {
   dict->AddStringItem("instrumentation_class", "ThreadSanitizer");
   dict->AddStringItem("issue_type",
                       RetrieveString(main_value, process_sp, ".description"));
   dict->AddIntegerItem("report_count",
                        main_value->GetValueForExpressionPath(".report_count")
                            ->GetValueAsUnsigned(0));
   dict->AddItem("sleep_trace", StructuredData::ObjectSP(CreateStackTrace(
                                    main_value, ".sleep_trace")));
+  dict->AddIntegerItem(
+      "tag",
+      main_value->GetValueForExpressionPath(".tag")->GetValueAsUnsigned(0));
 
   StructuredData::Array *stacks = ConvertToStructuredArray(
       main_value, ".stacks", ".stack_count",
       [thread_sp](ValueObjectSP o, StructuredData::Dictionary *dict) {
         dict->AddIntegerItem(
             "index",
             o->GetValueForExpressionPath(".idx")->GetValueAsUnsigned(0));
         dict->AddItem("trace", StructuredData::ObjectSP(CreateStackTrace(o)));
StructuredData::Array *unique_tids = ConvertToStructuredArray(
                 o->GetValueForExpressionPath(".tid")->GetValueAsUnsigned(0),
                 thread_id_map));
       });
   dict->AddItem("unique_tids", StructuredData::ObjectSP(unique_tids));
 
   return StructuredData::ObjectSP(dict);
 }
 
-std::string
-ThreadSanitizerRuntime::FormatDescription(StructuredData::ObjectSP report) {
+std::string ThreadSanitizerRuntime::FormatDescription(
+    StructuredData::ObjectSP report, bool &is_swift_access_race) {
   std::string description = report->GetAsDictionary()
                                 ->GetValueForKey("issue_type")
                                 ->GetAsString()
                                 ->GetValue();
 
   if (description == "data-race") {
     return "Data race";
   } else if (description == "data-race-vptr") {
if (description == "data-race") {
     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") {
+    auto tag = report->GetAsDictionary()
+                   ->GetValueForKey("tag")
+                   ->GetAsInteger()
+                   ->GetValue();
+    static const unsigned long kSwiftAccessRaceTag = 0x1;
+    if (tag == kSwiftAccessRaceTag) {
+      is_swift_access_race = true;
+      return "Swift access race";
+    }
     return "Race on a library object";
   } else if (description == "swift-access-race") {
+    is_swift_access_race = true;
     return "Swift access race";
   }
 
   // for unknown report codes just show the code
   return description;
 }
 
 static std::string Sprintf(const char *format, ...) {

 std::string
 ThreadSanitizerRuntime::GenerateSummary(StructuredData::ObjectSP report) {
   ProcessSP process_sp = GetProcessSP();
 
   std::string summary = report->GetAsDictionary()
                             ->GetValueForKey("description")
                             ->GetAsString()
                             ->GetValue();
+  bool is_swift_access_race = report->GetAsDictionary()
+                                  ->GetValueForKey("is_swift_access_race")
+                                  ->GetAsBoolean()
+                                  ->GetValue();
+
   bool skip_one_frame =
-      report->GetObjectForDotSeparatedPath("issue_type")->GetStringValue() ==
-      "external-race";
+      (report->GetObjectForDotSeparatedPath("issue_type")->GetStringValue() ==
+      "external-race") && (!is_swift_access_race);
 
   addr_t pc = 0;
   if (report->GetAsDictionary()
           ->GetValueForKey("mops")
           ->GetAsArray()
           ->GetSize() > 0)
     pc = GetFirstNonInternalFramePc(report->GetAsDictionary()
                                         ->GetValueForKey("mops")
bool ThreadSanitizerRuntime::NotifyBreakpointHit(
 
   if (process_sp->GetModIDRef().IsLastResumeForUserExpression())
     return false;
 
   StructuredData::ObjectSP report =
       instance->RetrieveReportData(context->exe_ctx_ref);
   std::string stop_reason_description;
   if (report) {
-    std::string issue_description = instance->FormatDescription(report);
+    bool is_swift_access_race = false;
+    std::string issue_description =
+        instance->FormatDescription(report, is_swift_access_race);
     report->GetAsDictionary()->AddStringItem("description", issue_description);
+    report->GetAsDictionary()->AddBooleanItem("is_swift_access_race",
+                                              is_swift_access_race);
     stop_reason_description = issue_description + " detected";
     report->GetAsDictionary()->AddStringItem("stop_description",
                                              stop_reason_description);
     std::string summary = instance->GenerateSummary(report);
     report->GetAsDictionary()->AddStringItem("summary", summary);
     addr_t main_address = instance->GetMainRacyAddress(report);
     report->GetAsDictionary()->AddIntegerItem("memory_address", main_address);