Shorten sanitizer plugin names

[labath]

Summary

The new UndefinedBehaviorSanitizer plugin was breaking file path length
limits, because it's (fairly long name) appears multiple times in the
path. Cmake ends up putting the object file at path
tools/lldb/source/Plugins/InstrumentationRuntime/UndefinedBehaviorSanitizer/CMakeFiles/lldbPluginInstrumentationRuntimeUndefinedBehaviorSanitizer.dir/UndefinedBehaviorSanitizerRuntime.cpp.obj
which is 191 characters long and very dangerously close to the 260
character path limit on windows systems (also, just the include line for
that file was breaking the 80 character line limit).

This renames the sanitizer plugins to use shorter names (asan, ubsan,
tsan). I think this will still be quite understandable to everyone as
those are the names everyone uses to refer to them anyway.

[kubamracek]

Oh wow, we really need to limit path lengths? What about files like ./packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/breakpoints_delayed_breakpoint_one_watchpoint/TestConcurrentBreakpointsDelayedBreakpointOneWatchpoint.py?

[labath]

In D34553#789023, @kubamracek wrote:

Oh wow, we really need to limit path lengths?

It's a bit annoying, but windows has issues with paths like that. It's actually possible to avoid it nowadays, if you use the right APIs, but not all programs have been updated to do that. Ironically enough, the error here comes from the MSVC linker, which means clang either succeeded in creating the object file, or failed silently doing that (I can't say which one as this was happening on the buildbot).

What about files like ./packages/Python/lldbsuite/test/functionalities/thread/concurrent_events/breakpoints_delayed_breakpoint_one_watchpoint/TestConcurrentBreakpointsDelayedBreakpointOneWatchpoint.py?

That's another fine example of an incredibly long path, and it was causing some problems already (it broke dotest log file name length), but I've managed to work around those.

However, even without these limits, I feel that our file names/paths tend to be unnecessarily long.

[amccarth]

Thanks for doing this. This seems a reasonable alternative to fixing all the build tools upstream. And overly long paths are difficult to read.

[vsk]

Thanks, this lgtm. Our tools don't depend on these plugins having a particular file name.

[jingham]

I try to avoid making cryptic file names just to get them under some character count, since that also makes code hard to comprehend particularly for new users. But in this case everybody calls these features ASAN, UBSAN, etc. So this change shouldn't cause any confusion.

[krytarowski]

Looks good. It's easier to parse [at least for my eyes]: ubsan, asan, tsan etc than full-names.

lldb/trunk/source/API/SystemInitializerFull.cpp

 #include "Plugins/ABI/SysV-x86_64/ABISysV_x86_64.h"
 #include "Plugins/Disassembler/llvm/DisassemblerLLVMC.h"
 #include "Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOS.h"
 #include "Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h"
 #include "Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h"
 #include "Plugins/DynamicLoader/Static/DynamicLoaderStatic.h"
 #include "Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.h"
 #include "Plugins/Instruction/ARM64/EmulateInstructionARM64.h"
-#include "Plugins/InstrumentationRuntime/AddressSanitizer/AddressSanitizerRuntime.h"
-#include "Plugins/InstrumentationRuntime/ThreadSanitizer/ThreadSanitizerRuntime.h"
-#include "Plugins/InstrumentationRuntime/UndefinedBehaviorSanitizer/UndefinedBehaviorSanitizerRuntime.h"
+#include "Plugins/InstrumentationRuntime/ASan/ASanRuntime.h"
+#include "Plugins/InstrumentationRuntime/TSan/TSanRuntime.h"
+#include "Plugins/InstrumentationRuntime/UBSan/UBSanRuntime.h"
 #include "Plugins/InstrumentationRuntime/MainThreadChecker/MainThreadCheckerRuntime.h"
 #include "Plugins/JITLoader/GDB/JITLoaderGDB.h"
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
 #include "Plugins/Language/Go/GoLanguage.h"
 #include "Plugins/Language/Java/JavaLanguage.h"
 #include "Plugins/Language/OCaml/OCamlLanguage.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 #include "Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.h"

lldb/trunk/source/Plugins/InstrumentationRuntime/ASan/ASanRuntime.h

+//===-- AddressSanitizerRuntime.h -------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_AddressSanitizerRuntime_h_
+#define liblldb_AddressSanitizerRuntime_h_
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "lldb/Core/StructuredData.h"
+#include "lldb/Target/InstrumentationRuntime.h"
+#include "lldb/Target/Process.h"
+#include "lldb/lldb-private.h"
+
+namespace lldb_private {
+
+class AddressSanitizerRuntime : public lldb_private::InstrumentationRuntime {
+public:
+  ~AddressSanitizerRuntime() override;
+
+  static lldb::InstrumentationRuntimeSP
+  CreateInstance(const lldb::ProcessSP &process_sp);
+
+  static void Initialize();
+
+  static void Terminate();
+
+  static lldb_private::ConstString GetPluginNameStatic();
+
+  static lldb::InstrumentationRuntimeType GetTypeStatic();
+
+  lldb_private::ConstString GetPluginName() override {
+    return GetPluginNameStatic();
+  }
+
+  virtual lldb::InstrumentationRuntimeType GetType() { return GetTypeStatic(); }
+
+  uint32_t GetPluginVersion() override { return 1; }
+
+private:
+  AddressSanitizerRuntime(const lldb::ProcessSP &process_sp)
+      : lldb_private::InstrumentationRuntime(process_sp) {}
+
+  const RegularExpression &GetPatternForRuntimeLibrary() override;
+
+  bool CheckIfRuntimeIsValid(const lldb::ModuleSP module_sp) override;
+
+  void Activate() override;
+
+  void Deactivate();
+
+  static bool NotifyBreakpointHit(void *baton,
+                                  StoppointCallbackContext *context,
+                                  lldb::user_id_t break_id,
+                                  lldb::user_id_t break_loc_id);
+
+  StructuredData::ObjectSP RetrieveReportData();
+
+  std::string FormatDescription(StructuredData::ObjectSP report);
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_AddressSanitizerRuntime_h_

lldb/trunk/source/Plugins/InstrumentationRuntime/ASan/ASanRuntime.cpp

+//===-- ASanRuntime.cpp -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ASanRuntime.h"
+
+#include "lldb/Breakpoint/StoppointCallbackContext.h"
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/PluginInterface.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/StreamFile.h"
+#include "lldb/Core/ValueObject.h"
+#include "lldb/Expression/UserExpression.h"
+#include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Symbol/Symbol.h"
+#include "lldb/Target/InstrumentationRuntimeStopInfo.h"
+#include "lldb/Target/StopInfo.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/Thread.h"
+#include "lldb/Utility/RegularExpression.h"
+#include "lldb/Utility/Stream.h"
+
+#include "llvm/ADT/StringSwitch.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+lldb::InstrumentationRuntimeSP
+AddressSanitizerRuntime::CreateInstance(const lldb::ProcessSP &process_sp) {
+  return InstrumentationRuntimeSP(new AddressSanitizerRuntime(process_sp));
+}
+
+void AddressSanitizerRuntime::Initialize() {
+  PluginManager::RegisterPlugin(
+      GetPluginNameStatic(), "AddressSanitizer instrumentation runtime plugin.",
+      CreateInstance, GetTypeStatic);
+}
+
+void AddressSanitizerRuntime::Terminate() {
+  PluginManager::UnregisterPlugin(CreateInstance);
+}
+
+lldb_private::ConstString AddressSanitizerRuntime::GetPluginNameStatic() {
+  return ConstString("AddressSanitizer");
+}
+
+lldb::InstrumentationRuntimeType AddressSanitizerRuntime::GetTypeStatic() {
+  return eInstrumentationRuntimeTypeAddressSanitizer;
+}
+
+AddressSanitizerRuntime::~AddressSanitizerRuntime() { Deactivate(); }
+
+const RegularExpression &
+AddressSanitizerRuntime::GetPatternForRuntimeLibrary() {
+  // FIXME: This shouldn't include the "dylib" suffix.
+  static RegularExpression regex(
+      llvm::StringRef("libclang_rt.asan_(.*)_dynamic\\.dylib"));
+  return regex;
+}
+
+bool AddressSanitizerRuntime::CheckIfRuntimeIsValid(
+    const lldb::ModuleSP module_sp) {
+  const Symbol *symbol = module_sp->FindFirstSymbolWithNameAndType(
+      ConstString("__asan_get_alloc_stack"), lldb::eSymbolTypeAny);
+
+  return symbol != nullptr;
+}
+
+static constexpr std::chrono::seconds g_retrieve_report_data_function_timeout(2);
+const char *address_sanitizer_retrieve_report_data_prefix = R"(
+extern "C"
+{
+int __asan_report_present();
+void *__asan_get_report_pc();
+void *__asan_get_report_bp();
+void *__asan_get_report_sp();
+void *__asan_get_report_address();
+const char *__asan_get_report_description();
+int __asan_get_report_access_type();
+size_t __asan_get_report_access_size();
+}
+)";
+
+const char *address_sanitizer_retrieve_report_data_command = R"(
+struct {
+    int present;
+    int access_type;
+    void *pc;
+    void *bp;
+    void *sp;
+    void *address;
+    size_t access_size;
+    const char *description;
+} t;
+
+t.present = __asan_report_present();
+t.access_type = __asan_get_report_access_type();
+t.pc = __asan_get_report_pc();
+t.bp = __asan_get_report_bp();
+t.sp = __asan_get_report_sp();
+t.address = __asan_get_report_address();
+t.access_size = __asan_get_report_access_size();
+t.description = __asan_get_report_description();
+t
+)";
+
+StructuredData::ObjectSP AddressSanitizerRuntime::RetrieveReportData() {
+  ProcessSP process_sp = GetProcessSP();
+  if (!process_sp)
+    return StructuredData::ObjectSP();
+
+  ThreadSP thread_sp =
+      process_sp->GetThreadList().GetExpressionExecutionThread();
+  StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
+
+  if (!frame_sp)
+    return StructuredData::ObjectSP();
+
+  EvaluateExpressionOptions options;
+  options.SetUnwindOnError(true);
+  options.SetTryAllThreads(true);
+  options.SetStopOthers(true);
+  options.SetIgnoreBreakpoints(true);
+  options.SetTimeout(g_retrieve_report_data_function_timeout);
+  options.SetPrefix(address_sanitizer_retrieve_report_data_prefix);
+  options.SetAutoApplyFixIts(false);
+  options.SetLanguage(eLanguageTypeObjC_plus_plus);
+
+  ValueObjectSP return_value_sp;
+  ExecutionContext exe_ctx;
+  Status eval_error;
+  frame_sp->CalculateExecutionContext(exe_ctx);
+  ExpressionResults result = UserExpression::Evaluate(
+      exe_ctx, options, address_sanitizer_retrieve_report_data_command, "",
+      return_value_sp, eval_error);
+  if (result != eExpressionCompleted) {
+    process_sp->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf(
+        "Warning: Cannot evaluate AddressSanitizer expression:\n%s\n",
+        eval_error.AsCString());
+    return StructuredData::ObjectSP();
+  }
+
+  int present = return_value_sp->GetValueForExpressionPath(".present")
+                    ->GetValueAsUnsigned(0);
+  if (present != 1)
+    return StructuredData::ObjectSP();
+
+  addr_t pc =
+      return_value_sp->GetValueForExpressionPath(".pc")->GetValueAsUnsigned(0);
+  /* commented out because rdar://problem/18533301
+  addr_t bp =
+  return_value_sp->GetValueForExpressionPath(".bp")->GetValueAsUnsigned(0);
+  addr_t sp =
+  return_value_sp->GetValueForExpressionPath(".sp")->GetValueAsUnsigned(0);
+  */
+  addr_t address = return_value_sp->GetValueForExpressionPath(".address")
+                       ->GetValueAsUnsigned(0);
+  addr_t access_type =
+      return_value_sp->GetValueForExpressionPath(".access_type")
+          ->GetValueAsUnsigned(0);
+  addr_t access_size =
+      return_value_sp->GetValueForExpressionPath(".access_size")
+          ->GetValueAsUnsigned(0);
+  addr_t description_ptr =
+      return_value_sp->GetValueForExpressionPath(".description")
+          ->GetValueAsUnsigned(0);
+  std::string description;
+  Status error;
+  process_sp->ReadCStringFromMemory(description_ptr, description, error);
+
+  StructuredData::Dictionary *dict = new StructuredData::Dictionary();
+  dict->AddStringItem("instrumentation_class", "AddressSanitizer");
+  dict->AddStringItem("stop_type", "fatal_error");
+  dict->AddIntegerItem("pc", pc);
+  /* commented out because rdar://problem/18533301
+  dict->AddIntegerItem("bp", bp);
+  dict->AddIntegerItem("sp", sp);
+  */
+  dict->AddIntegerItem("address", address);
+  dict->AddIntegerItem("access_type", access_type);
+  dict->AddIntegerItem("access_size", access_size);
+  dict->AddStringItem("description", description);
+
+  return StructuredData::ObjectSP(dict);
+}
+
+std::string
+AddressSanitizerRuntime::FormatDescription(StructuredData::ObjectSP report) {
+  std::string description = report->GetAsDictionary()
+                                ->GetValueForKey("description")
+                                ->GetAsString()
+                                ->GetValue();
+  return llvm::StringSwitch<std::string>(description)
+      .Case("heap-use-after-free", "Use of deallocated memory")
+      .Case("heap-buffer-overflow", "Heap buffer overflow")
+      .Case("stack-buffer-underflow", "Stack buffer underflow")
+      .Case("initialization-order-fiasco", "Initialization order problem")
+      .Case("stack-buffer-overflow", "Stack buffer overflow")
+      .Case("stack-use-after-return", "Use of stack memory after return")
+      .Case("use-after-poison", "Use of poisoned memory")
+      .Case("container-overflow", "Container overflow")
+      .Case("stack-use-after-scope", "Use of out-of-scope stack memory")
+      .Case("global-buffer-overflow", "Global buffer overflow")
+      .Case("unknown-crash", "Invalid memory access")
+      .Case("stack-overflow", "Stack space exhausted")
+      .Case("null-deref", "Dereference of null pointer")
+      .Case("wild-jump", "Jump to non-executable address")
+      .Case("wild-addr-write", "Write through wild pointer")
+      .Case("wild-addr-read", "Read from wild pointer")
+      .Case("wild-addr", "Access through wild pointer")
+      .Case("signal", "Deadly signal")
+      .Case("double-free", "Deallocation of freed memory")
+      .Case("new-delete-type-mismatch",
+            "Deallocation size different from allocation size")
+      .Case("bad-free", "Deallocation of non-allocated memory")
+      .Case("alloc-dealloc-mismatch",
+            "Mismatch between allocation and deallocation APIs")
+      .Case("bad-malloc_usable_size", "Invalid argument to malloc_usable_size")
+      .Case("bad-__sanitizer_get_allocated_size",
+            "Invalid argument to __sanitizer_get_allocated_size")
+      .Case("param-overlap",
+            "Call to function disallowing overlapping memory ranges")
+      .Case("negative-size-param", "Negative size used when accessing memory")
+      .Case("bad-__sanitizer_annotate_contiguous_container",
+            "Invalid argument to __sanitizer_annotate_contiguous_container")
+      .Case("odr-violation", "Symbol defined in multiple translation units")
+      .Case(
+          "invalid-pointer-pair",
+          "Comparison or arithmetic on pointers from different memory regions")
+      // for unknown report codes just show the code
+      .Default("AddressSanitizer detected: " + description);
+}
+
+bool AddressSanitizerRuntime::NotifyBreakpointHit(
+    void *baton, StoppointCallbackContext *context, user_id_t break_id,
+    user_id_t break_loc_id) {
+  assert(baton && "null baton");
+  if (!baton)
+    return false;
+
+  AddressSanitizerRuntime *const instance =
+      static_cast<AddressSanitizerRuntime *>(baton);
+
+  StructuredData::ObjectSP report = instance->RetrieveReportData();
+  std::string description;
+  if (report) {
+    description = instance->FormatDescription(report);
+  }
+  ProcessSP process_sp = instance->GetProcessSP();
+  // Make sure this is the right process
+  if (process_sp && process_sp == context->exe_ctx_ref.GetProcessSP()) {
+    ThreadSP thread_sp = context->exe_ctx_ref.GetThreadSP();
+    if (thread_sp)
+      thread_sp->SetStopInfo(InstrumentationRuntimeStopInfo::
+                                 CreateStopReasonWithInstrumentationData(
+                                     *thread_sp, description, report));
+
+    StreamFileSP stream_sp(
+        process_sp->GetTarget().GetDebugger().GetOutputFile());
+    if (stream_sp) {
+      stream_sp->Printf("AddressSanitizer report breakpoint hit. Use 'thread "
+                        "info -s' to get extended information about the "
+                        "report.\n");
+    }
+    return true; // Return true to stop the target
+  } else
+    return false; // Let target run
+}
+
+void AddressSanitizerRuntime::Activate() {
+  if (IsActive())
+    return;
+
+  ProcessSP process_sp = GetProcessSP();
+  if (!process_sp)
+    return;
+
+  ConstString symbol_name("__asan::AsanDie()");
+  const Symbol *symbol = GetRuntimeModuleSP()->FindFirstSymbolWithNameAndType(
+      symbol_name, eSymbolTypeCode);
+
+  if (symbol == NULL)
+    return;
+
+  if (!symbol->ValueIsAddress() || !symbol->GetAddressRef().IsValid())
+    return;
+
+  Target &target = process_sp->GetTarget();
+  addr_t symbol_address = symbol->GetAddressRef().GetOpcodeLoadAddress(&target);
+
+  if (symbol_address == LLDB_INVALID_ADDRESS)
+    return;
+
+  bool internal = true;
+  bool hardware = false;
+  Breakpoint *breakpoint =
+      process_sp->GetTarget()
+          .CreateBreakpoint(symbol_address, internal, hardware)
+          .get();
+  breakpoint->SetCallback(AddressSanitizerRuntime::NotifyBreakpointHit, this,
+                          true);
+  breakpoint->SetBreakpointKind("address-sanitizer-report");
+  SetBreakpointID(breakpoint->GetID());
+
+  SetActive(true);
+}
+
+void AddressSanitizerRuntime::Deactivate() {
+  if (GetBreakpointID() != LLDB_INVALID_BREAK_ID) {
+    ProcessSP process_sp = GetProcessSP();
+    if (process_sp) {
+      process_sp->GetTarget().RemoveBreakpointByID(GetBreakpointID());
+      SetBreakpointID(LLDB_INVALID_BREAK_ID);
+    }
+  }
+  SetActive(false);
+}

lldb/trunk/source/Plugins/InstrumentationRuntime/ASan/CMakeLists.txt

+add_lldb_library(lldbPluginInstrumentationRuntimeASan PLUGIN
+  ASanRuntime.cpp
+
+  LINK_LIBS
+    lldbBreakpoint
+    lldbCore
+    lldbExpression
+    lldbInterpreter
+    lldbSymbol
+    lldbTarget
+  LINK_COMPONENTS
+    Support
+  )

lldb/trunk/source/Plugins/InstrumentationRuntime/AddressSanitizer/AddressSanitizerRuntime.h

-//===-- AddressSanitizerRuntime.h -------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_AddressSanitizerRuntime_h_
-#define liblldb_AddressSanitizerRuntime_h_
-
-// C Includes
-// C++ Includes
-// Other libraries and framework includes
-// Project includes
-#include "lldb/Core/StructuredData.h"
-#include "lldb/Target/InstrumentationRuntime.h"
-#include "lldb/Target/Process.h"
-#include "lldb/lldb-private.h"
-
-namespace lldb_private {
-
-class AddressSanitizerRuntime : public lldb_private::InstrumentationRuntime {
-public:
-  ~AddressSanitizerRuntime() override;
-
-  static lldb::InstrumentationRuntimeSP
-  CreateInstance(const lldb::ProcessSP &process_sp);
-
-  static void Initialize();
-
-  static void Terminate();
-
-  static lldb_private::ConstString GetPluginNameStatic();
-
-  static lldb::InstrumentationRuntimeType GetTypeStatic();
-
-  lldb_private::ConstString GetPluginName() override {
-    return GetPluginNameStatic();
-  }
-
-  virtual lldb::InstrumentationRuntimeType GetType() { return GetTypeStatic(); }
-
-  uint32_t GetPluginVersion() override { return 1; }
-
-private:
-  AddressSanitizerRuntime(const lldb::ProcessSP &process_sp)
-      : lldb_private::InstrumentationRuntime(process_sp) {}
-
-  const RegularExpression &GetPatternForRuntimeLibrary() override;
-
-  bool CheckIfRuntimeIsValid(const lldb::ModuleSP module_sp) override;
-
-  void Activate() override;
-
-  void Deactivate();
-
-  static bool NotifyBreakpointHit(void *baton,
-                                  StoppointCallbackContext *context,
-                                  lldb::user_id_t break_id,
-                                  lldb::user_id_t break_loc_id);
-
-  StructuredData::ObjectSP RetrieveReportData();
-
-  std::string FormatDescription(StructuredData::ObjectSP report);
-};
-
-} // namespace lldb_private
-
-#endif // liblldb_AddressSanitizerRuntime_h_

lldb/trunk/source/Plugins/InstrumentationRuntime/AddressSanitizer/AddressSanitizerRuntime.cpp

-//===-- AddressSanitizerRuntime.cpp -----------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "AddressSanitizerRuntime.h"
-
-#include "lldb/Breakpoint/StoppointCallbackContext.h"
-#include "lldb/Core/Debugger.h"
-#include "lldb/Core/Module.h"
-#include "lldb/Core/PluginInterface.h"
-#include "lldb/Core/PluginManager.h"
-#include "lldb/Core/StreamFile.h"
-#include "lldb/Core/ValueObject.h"
-#include "lldb/Expression/UserExpression.h"
-#include "lldb/Interpreter/CommandReturnObject.h"
-#include "lldb/Symbol/Symbol.h"
-#include "lldb/Target/InstrumentationRuntimeStopInfo.h"
-#include "lldb/Target/StopInfo.h"
-#include "lldb/Target/Target.h"
-#include "lldb/Target/Thread.h"
-#include "lldb/Utility/RegularExpression.h"
-#include "lldb/Utility/Stream.h"
-
-#include "llvm/ADT/StringSwitch.h"
-
-using namespace lldb;
-using namespace lldb_private;
-
-lldb::InstrumentationRuntimeSP
-AddressSanitizerRuntime::CreateInstance(const lldb::ProcessSP &process_sp) {
-  return InstrumentationRuntimeSP(new AddressSanitizerRuntime(process_sp));
-}
-
-void AddressSanitizerRuntime::Initialize() {
-  PluginManager::RegisterPlugin(
-      GetPluginNameStatic(), "AddressSanitizer instrumentation runtime plugin.",
-      CreateInstance, GetTypeStatic);
-}
-
-void AddressSanitizerRuntime::Terminate() {
-  PluginManager::UnregisterPlugin(CreateInstance);
-}
-
-lldb_private::ConstString AddressSanitizerRuntime::GetPluginNameStatic() {
-  return ConstString("AddressSanitizer");
-}
-
-lldb::InstrumentationRuntimeType AddressSanitizerRuntime::GetTypeStatic() {
-  return eInstrumentationRuntimeTypeAddressSanitizer;
-}
-
-AddressSanitizerRuntime::~AddressSanitizerRuntime() { Deactivate(); }
-
-const RegularExpression &
-AddressSanitizerRuntime::GetPatternForRuntimeLibrary() {
-  // FIXME: This shouldn't include the "dylib" suffix.
-  static RegularExpression regex(
-      llvm::StringRef("libclang_rt.asan_(.*)_dynamic\\.dylib"));
-  return regex;
-}
-
-bool AddressSanitizerRuntime::CheckIfRuntimeIsValid(
-    const lldb::ModuleSP module_sp) {
-  const Symbol *symbol = module_sp->FindFirstSymbolWithNameAndType(
-      ConstString("__asan_get_alloc_stack"), lldb::eSymbolTypeAny);
-
-  return symbol != nullptr;
-}
-
-static constexpr std::chrono::seconds g_retrieve_report_data_function_timeout(2);
-const char *address_sanitizer_retrieve_report_data_prefix = R"(
-extern "C"
-{
-int __asan_report_present();
-void *__asan_get_report_pc();
-void *__asan_get_report_bp();
-void *__asan_get_report_sp();
-void *__asan_get_report_address();
-const char *__asan_get_report_description();
-int __asan_get_report_access_type();
-size_t __asan_get_report_access_size();
-}
-)";
-
-const char *address_sanitizer_retrieve_report_data_command = R"(
-struct {
-    int present;
-    int access_type;
-    void *pc;
-    void *bp;
-    void *sp;
-    void *address;
-    size_t access_size;
-    const char *description;
-} t;
-
-t.present = __asan_report_present();
-t.access_type = __asan_get_report_access_type();
-t.pc = __asan_get_report_pc();
-t.bp = __asan_get_report_bp();
-t.sp = __asan_get_report_sp();
-t.address = __asan_get_report_address();
-t.access_size = __asan_get_report_access_size();
-t.description = __asan_get_report_description();
-t
-)";
-
-StructuredData::ObjectSP AddressSanitizerRuntime::RetrieveReportData() {
-  ProcessSP process_sp = GetProcessSP();
-  if (!process_sp)
-    return StructuredData::ObjectSP();
-
-  ThreadSP thread_sp =
-      process_sp->GetThreadList().GetExpressionExecutionThread();
-  StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
-
-  if (!frame_sp)
-    return StructuredData::ObjectSP();
-
-  EvaluateExpressionOptions options;
-  options.SetUnwindOnError(true);
-  options.SetTryAllThreads(true);
-  options.SetStopOthers(true);
-  options.SetIgnoreBreakpoints(true);
-  options.SetTimeout(g_retrieve_report_data_function_timeout);
-  options.SetPrefix(address_sanitizer_retrieve_report_data_prefix);
-  options.SetAutoApplyFixIts(false);
-  options.SetLanguage(eLanguageTypeObjC_plus_plus);
-
-  ValueObjectSP return_value_sp;
-  ExecutionContext exe_ctx;
-  Status eval_error;
-  frame_sp->CalculateExecutionContext(exe_ctx);
-  ExpressionResults result = UserExpression::Evaluate(
-      exe_ctx, options, address_sanitizer_retrieve_report_data_command, "",
-      return_value_sp, eval_error);
-  if (result != eExpressionCompleted) {
-    process_sp->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf(
-        "Warning: Cannot evaluate AddressSanitizer expression:\n%s\n",
-        eval_error.AsCString());
-    return StructuredData::ObjectSP();
-  }
-
-  int present = return_value_sp->GetValueForExpressionPath(".present")
-                    ->GetValueAsUnsigned(0);
-  if (present != 1)
-    return StructuredData::ObjectSP();
-
-  addr_t pc =
-      return_value_sp->GetValueForExpressionPath(".pc")->GetValueAsUnsigned(0);
-  /* commented out because rdar://problem/18533301
-  addr_t bp =
-  return_value_sp->GetValueForExpressionPath(".bp")->GetValueAsUnsigned(0);
-  addr_t sp =
-  return_value_sp->GetValueForExpressionPath(".sp")->GetValueAsUnsigned(0);
-  */
-  addr_t address = return_value_sp->GetValueForExpressionPath(".address")
-                       ->GetValueAsUnsigned(0);
-  addr_t access_type =
-      return_value_sp->GetValueForExpressionPath(".access_type")
-          ->GetValueAsUnsigned(0);
-  addr_t access_size =
-      return_value_sp->GetValueForExpressionPath(".access_size")
-          ->GetValueAsUnsigned(0);
-  addr_t description_ptr =
-      return_value_sp->GetValueForExpressionPath(".description")
-          ->GetValueAsUnsigned(0);
-  std::string description;
-  Status error;
-  process_sp->ReadCStringFromMemory(description_ptr, description, error);
-
-  StructuredData::Dictionary *dict = new StructuredData::Dictionary();
-  dict->AddStringItem("instrumentation_class", "AddressSanitizer");
-  dict->AddStringItem("stop_type", "fatal_error");
-  dict->AddIntegerItem("pc", pc);
-  /* commented out because rdar://problem/18533301
-  dict->AddIntegerItem("bp", bp);
-  dict->AddIntegerItem("sp", sp);
-  */
-  dict->AddIntegerItem("address", address);
-  dict->AddIntegerItem("access_type", access_type);
-  dict->AddIntegerItem("access_size", access_size);
-  dict->AddStringItem("description", description);
-
-  return StructuredData::ObjectSP(dict);
-}
-
-std::string
-AddressSanitizerRuntime::FormatDescription(StructuredData::ObjectSP report) {
-  std::string description = report->GetAsDictionary()
-                                ->GetValueForKey("description")
-                                ->GetAsString()
-                                ->GetValue();
-  return llvm::StringSwitch<std::string>(description)
-      .Case("heap-use-after-free", "Use of deallocated memory")
-      .Case("heap-buffer-overflow", "Heap buffer overflow")
-      .Case("stack-buffer-underflow", "Stack buffer underflow")
-      .Case("initialization-order-fiasco", "Initialization order problem")
-      .Case("stack-buffer-overflow", "Stack buffer overflow")
-      .Case("stack-use-after-return", "Use of stack memory after return")
-      .Case("use-after-poison", "Use of poisoned memory")
-      .Case("container-overflow", "Container overflow")
-      .Case("stack-use-after-scope", "Use of out-of-scope stack memory")
-      .Case("global-buffer-overflow", "Global buffer overflow")
-      .Case("unknown-crash", "Invalid memory access")
-      .Case("stack-overflow", "Stack space exhausted")
-      .Case("null-deref", "Dereference of null pointer")
-      .Case("wild-jump", "Jump to non-executable address")
-      .Case("wild-addr-write", "Write through wild pointer")
-      .Case("wild-addr-read", "Read from wild pointer")
-      .Case("wild-addr", "Access through wild pointer")
-      .Case("signal", "Deadly signal")
-      .Case("double-free", "Deallocation of freed memory")
-      .Case("new-delete-type-mismatch",
-            "Deallocation size different from allocation size")
-      .Case("bad-free", "Deallocation of non-allocated memory")
-      .Case("alloc-dealloc-mismatch",
-            "Mismatch between allocation and deallocation APIs")
-      .Case("bad-malloc_usable_size", "Invalid argument to malloc_usable_size")
-      .Case("bad-__sanitizer_get_allocated_size",
-            "Invalid argument to __sanitizer_get_allocated_size")
-      .Case("param-overlap",
-            "Call to function disallowing overlapping memory ranges")
-      .Case("negative-size-param", "Negative size used when accessing memory")
-      .Case("bad-__sanitizer_annotate_contiguous_container",
-            "Invalid argument to __sanitizer_annotate_contiguous_container")
-      .Case("odr-violation", "Symbol defined in multiple translation units")
-      .Case(
-          "invalid-pointer-pair",
-          "Comparison or arithmetic on pointers from different memory regions")
-      // for unknown report codes just show the code
-      .Default("AddressSanitizer detected: " + description);
-}
-
-bool AddressSanitizerRuntime::NotifyBreakpointHit(
-    void *baton, StoppointCallbackContext *context, user_id_t break_id,
-    user_id_t break_loc_id) {
-  assert(baton && "null baton");
-  if (!baton)
-    return false;
-
-  AddressSanitizerRuntime *const instance =
-      static_cast<AddressSanitizerRuntime *>(baton);
-
-  StructuredData::ObjectSP report = instance->RetrieveReportData();
-  std::string description;
-  if (report) {
-    description = instance->FormatDescription(report);
-  }
-  ProcessSP process_sp = instance->GetProcessSP();
-  // Make sure this is the right process
-  if (process_sp && process_sp == context->exe_ctx_ref.GetProcessSP()) {
-    ThreadSP thread_sp = context->exe_ctx_ref.GetThreadSP();
-    if (thread_sp)
-      thread_sp->SetStopInfo(InstrumentationRuntimeStopInfo::
-                                 CreateStopReasonWithInstrumentationData(
-                                     *thread_sp, description, report));
-
-    StreamFileSP stream_sp(
-        process_sp->GetTarget().GetDebugger().GetOutputFile());
-    if (stream_sp) {
-      stream_sp->Printf("AddressSanitizer report breakpoint hit. Use 'thread "
-                        "info -s' to get extended information about the "
-                        "report.\n");
-    }
-    return true; // Return true to stop the target
-  } else
-    return false; // Let target run
-}
-
-void AddressSanitizerRuntime::Activate() {
-  if (IsActive())
-    return;
-
-  ProcessSP process_sp = GetProcessSP();
-  if (!process_sp)
-    return;
-
-  ConstString symbol_name("__asan::AsanDie()");
-  const Symbol *symbol = GetRuntimeModuleSP()->FindFirstSymbolWithNameAndType(
-      symbol_name, eSymbolTypeCode);
-
-  if (symbol == NULL)
-    return;
-
-  if (!symbol->ValueIsAddress() || !symbol->GetAddressRef().IsValid())
-    return;
-
-  Target &target = process_sp->GetTarget();
-  addr_t symbol_address = symbol->GetAddressRef().GetOpcodeLoadAddress(&target);
-
-  if (symbol_address == LLDB_INVALID_ADDRESS)
-    return;
-
-  bool internal = true;
-  bool hardware = false;
-  Breakpoint *breakpoint =
-      process_sp->GetTarget()
-          .CreateBreakpoint(symbol_address, internal, hardware)
-          .get();
-  breakpoint->SetCallback(AddressSanitizerRuntime::NotifyBreakpointHit, this,
-                          true);
-  breakpoint->SetBreakpointKind("address-sanitizer-report");
-  SetBreakpointID(breakpoint->GetID());
-
-  SetActive(true);
-}
-
-void AddressSanitizerRuntime::Deactivate() {
-  if (GetBreakpointID() != LLDB_INVALID_BREAK_ID) {
-    ProcessSP process_sp = GetProcessSP();
-    if (process_sp) {
-      process_sp->GetTarget().RemoveBreakpointByID(GetBreakpointID());
-      SetBreakpointID(LLDB_INVALID_BREAK_ID);
-    }
-  }
-  SetActive(false);
-}

lldb/trunk/source/Plugins/InstrumentationRuntime/AddressSanitizer/CMakeLists.txt

-add_lldb_library(lldbPluginInstrumentationRuntimeAddressSanitizer PLUGIN
-  AddressSanitizerRuntime.cpp
-
-  LINK_LIBS
-    lldbBreakpoint
-    lldbCore
-    lldbExpression
-    lldbInterpreter
-    lldbSymbol
-    lldbTarget
-  LINK_COMPONENTS
-    Support
-  )

lldb/trunk/source/Plugins/InstrumentationRuntime/CMakeLists.txt

-add_subdirectory(AddressSanitizer)
-add_subdirectory(ThreadSanitizer)
-add_subdirectory(UndefinedBehaviorSanitizer)
+add_subdirectory(ASan)
 add_subdirectory(MainThreadChecker)
+add_subdirectory(TSan)
+add_subdirectory(UBSan)

lldb/trunk/source/Plugins/InstrumentationRuntime/TSan/CMakeLists.txt

+add_lldb_library(lldbPluginInstrumentationRuntimeTSan PLUGIN
+  TSanRuntime.cpp
+
+  LINK_LIBS
+    lldbBreakpoint
+    lldbCore
+    lldbExpression
+    lldbInterpreter
+    lldbSymbol
+    lldbTarget
+    lldbPluginProcessUtility
+  )

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

+//===-- ThreadSanitizerRuntime.h --------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_ThreadSanitizerRuntime_h_
+#define liblldb_ThreadSanitizerRuntime_h_
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "lldb/Core/StructuredData.h"
+#include "lldb/Target/ABI.h"
+#include "lldb/Target/InstrumentationRuntime.h"
+#include "lldb/lldb-private.h"
+
+namespace lldb_private {
+
+class ThreadSanitizerRuntime : public lldb_private::InstrumentationRuntime {
+public:
+  ~ThreadSanitizerRuntime() override;
+
+  static lldb::InstrumentationRuntimeSP
+  CreateInstance(const lldb::ProcessSP &process_sp);
+
+  static void Initialize();
+
+  static void Terminate();
+
+  static lldb_private::ConstString GetPluginNameStatic();
+
+  static lldb::InstrumentationRuntimeType GetTypeStatic();
+
+  lldb_private::ConstString GetPluginName() override {
+    return GetPluginNameStatic();
+  }
+
+  virtual lldb::InstrumentationRuntimeType GetType() { return GetTypeStatic(); }
+
+  uint32_t GetPluginVersion() override { return 1; }
+
+  lldb::ThreadCollectionSP
+  GetBacktracesFromExtendedStopInfo(StructuredData::ObjectSP info) override;
+
+private:
+  ThreadSanitizerRuntime(const lldb::ProcessSP &process_sp)
+      : lldb_private::InstrumentationRuntime(process_sp) {}
+
+  const RegularExpression &GetPatternForRuntimeLibrary() override;
+
+  bool CheckIfRuntimeIsValid(const lldb::ModuleSP module_sp) override;
+
+  void Activate() override;
+
+  void Deactivate();
+
+  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 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,
+                                     std::string &filename, uint32_t &line);
+
+  lldb::addr_t GetFirstNonInternalFramePc(StructuredData::ObjectSP trace,
+                                          bool skip_one_frame = false);
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_ThreadSanitizerRuntime_h_

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

+//===-- TSanRuntime.cpp -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "TSanRuntime.h"
+
+#include "Plugins/Process/Utility/HistoryThread.h"
+#include "lldb/Breakpoint/StoppointCallbackContext.h"
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/PluginInterface.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/StreamFile.h"
+#include "lldb/Core/ValueObject.h"
+#include "lldb/Expression/UserExpression.h"
+#include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Symbol/Symbol.h"
+#include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Symbol/Variable.h"
+#include "lldb/Symbol/VariableList.h"
+#include "lldb/Target/InstrumentationRuntimeStopInfo.h"
+#include "lldb/Target/SectionLoadList.h"
+#include "lldb/Target/StopInfo.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/Thread.h"
+#include "lldb/Utility/RegularExpression.h"
+#include "lldb/Utility/Stream.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+lldb::InstrumentationRuntimeSP
+ThreadSanitizerRuntime::CreateInstance(const lldb::ProcessSP &process_sp) {
+  return InstrumentationRuntimeSP(new ThreadSanitizerRuntime(process_sp));
+}
+
+void ThreadSanitizerRuntime::Initialize() {
+  PluginManager::RegisterPlugin(
+      GetPluginNameStatic(), "ThreadSanitizer instrumentation runtime plugin.",
+      CreateInstance, GetTypeStatic);
+}
+
+void ThreadSanitizerRuntime::Terminate() {
+  PluginManager::UnregisterPlugin(CreateInstance);
+}
+
+lldb_private::ConstString ThreadSanitizerRuntime::GetPluginNameStatic() {
+  return ConstString("ThreadSanitizer");
+}
+
+lldb::InstrumentationRuntimeType ThreadSanitizerRuntime::GetTypeStatic() {
+  return eInstrumentationRuntimeTypeThreadSanitizer;
+}
+
+ThreadSanitizerRuntime::~ThreadSanitizerRuntime() { Deactivate(); }
+
+static constexpr std::chrono::seconds g_retrieve_data_function_timeout(2);
+
+const char *thread_sanitizer_retrieve_report_data_prefix = R"(
+extern "C"
+{
+    void *__tsan_get_current_report();
+    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_stack(void *report, unsigned long idx, void **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_loc(void *report, unsigned long idx, const char **type,
+                              void **addr, unsigned long *start, unsigned long *size, int *tid,
+                              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);
+  
+    // 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);
+}
+
+const int REPORT_TRACE_SIZE = 128;
+const int REPORT_ARRAY_SIZE = 4;
+
+struct data {
+    void *report;
+    const char *description;
+    int report_count;
+    
+    void *sleep_trace[REPORT_TRACE_SIZE];
+    
+    int stack_count;
+    struct {
+        int idx;
+        void *trace[REPORT_TRACE_SIZE];
+    } stacks[REPORT_ARRAY_SIZE];
+    
+    int mop_count;
+    struct {
+        int idx;
+        int tid;
+        int size;
+        int write;
+        int atomic;
+        void *addr;
+        void *trace[REPORT_TRACE_SIZE];
+    } mops[REPORT_ARRAY_SIZE];
+    
+    int loc_count;
+    struct {
+        int idx;
+        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;
+        void *trace[REPORT_TRACE_SIZE];
+    } mutexes[REPORT_ARRAY_SIZE];
+    
+    int thread_count;
+    struct {
+        int idx;
+        int tid;
+        unsigned long os_id;
+        int running;
+        const char *name;
+        int parent_tid;
+        void *trace[REPORT_TRACE_SIZE];
+    } threads[REPORT_ARRAY_SIZE];
+    
+    int unique_tid_count;
+    struct {
+        int idx;
+        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);
+}
+
+if (t.thread_count > REPORT_ARRAY_SIZE) t.thread_count = REPORT_ARRAY_SIZE;
+for (int i = 0; i < t.thread_count; i++) {
+    t.threads[i].idx = i;
+    __tsan_get_report_thread(t.report, i, &t.threads[i].tid, &t.threads[i].os_id, &t.threads[i].running, &t.threads[i].name, &t.threads[i].parent_tid, t.threads[i].trace, REPORT_TRACE_SIZE);
+}
+
+if (t.unique_tid_count > REPORT_ARRAY_SIZE) t.unique_tid_count = REPORT_ARRAY_SIZE;
+for (int i = 0; i < t.unique_tid_count; i++) {
+    t.unique_tids[i].idx = i;
+    __tsan_get_report_unique_tid(t.report, i, &t.unique_tids[i].tid);
+}
+
+t;
+)";
+
+static StructuredData::Array *
+CreateStackTrace(ValueObjectSP o,
+                 const std::string &trace_item_name = ".trace") {
+  StructuredData::Array *trace = new StructuredData::Array();
+  ValueObjectSP trace_value_object =
+      o->GetValueForExpressionPath(trace_item_name.c_str());
+  size_t count = trace_value_object->GetNumChildren();
+  for (size_t j = 0; j < count; j++) {
+    addr_t trace_addr =
+        trace_value_object->GetChildAtIndex(j, true)->GetValueAsUnsigned(0);
+    if (trace_addr == 0)
+      break;
+    trace->AddItem(
+        StructuredData::ObjectSP(new StructuredData::Integer(trace_addr)));
+  }
+  return trace;
+}
+
+static StructuredData::Array *ConvertToStructuredArray(
+    ValueObjectSP return_value_sp, const std::string &items_name,
+    const std::string &count_name,
+    std::function<void(ValueObjectSP o, StructuredData::Dictionary *dict)> const
+        &callback) {
+  StructuredData::Array *array = new StructuredData::Array();
+  unsigned int count =
+      return_value_sp->GetValueForExpressionPath(count_name.c_str())
+          ->GetValueAsUnsigned(0);
+  ValueObjectSP objects =
+      return_value_sp->GetValueForExpressionPath(items_name.c_str());
+  for (unsigned int i = 0; i < count; i++) {
+    ValueObjectSP o = objects->GetChildAtIndex(i, true);
+    StructuredData::Dictionary *dict = new StructuredData::Dictionary();
+
+    callback(o, dict);
+
+    array->AddItem(StructuredData::ObjectSP(dict));
+  }
+  return array;
+}
+
+static std::string RetrieveString(ValueObjectSP return_value_sp,
+                                  ProcessSP process_sp,
+                                  const std::string &expression_path) {
+  addr_t ptr =
+      return_value_sp->GetValueForExpressionPath(expression_path.c_str())
+          ->GetValueAsUnsigned(0);
+  std::string str;
+  Status error;
+  process_sp->ReadCStringFromMemory(ptr, str, error);
+  return str;
+}
+
+static void
+GetRenumberedThreadIds(ProcessSP process_sp, ValueObjectSP data,
+                       std::map<uint64_t, user_id_t> &thread_id_map) {
+  ConvertToStructuredArray(
+      data, ".threads", ".thread_count",
+      [process_sp, &thread_id_map](ValueObjectSP o,
+                                   StructuredData::Dictionary *dict) {
+        uint64_t thread_id =
+            o->GetValueForExpressionPath(".tid")->GetValueAsUnsigned(0);
+        uint64_t thread_os_id =
+            o->GetValueForExpressionPath(".os_id")->GetValueAsUnsigned(0);
+        user_id_t lldb_user_id = 0;
+
+        bool can_update = true;
+        ThreadSP lldb_thread = process_sp->GetThreadList().FindThreadByID(
+            thread_os_id, can_update);
+        if (lldb_thread) {
+          lldb_user_id = lldb_thread->GetIndexID();
+        } else {
+          // This isn't a live thread anymore.  Ask process to assign a new
+          // Index ID (or return an old one if we've already seen this
+          // thread_os_id).
+          // It will also make sure that no new threads are assigned this Index
+          // ID.
+          lldb_user_id = process_sp->AssignIndexIDToThread(thread_os_id);
+        }
+
+        thread_id_map[thread_id] = lldb_user_id;
+      });
+}
+
+static user_id_t Renumber(uint64_t id,
+                          std::map<uint64_t, user_id_t> &thread_id_map) {
+  auto IT = thread_id_map.find(id);
+  if (IT == thread_id_map.end())
+    return 0;
+
+  return IT->second;
+}
+
+StructuredData::ObjectSP
+ThreadSanitizerRuntime::RetrieveReportData(ExecutionContextRef exe_ctx_ref) {
+  ProcessSP process_sp = GetProcessSP();
+  if (!process_sp)
+    return StructuredData::ObjectSP();
+
+  ThreadSP thread_sp = exe_ctx_ref.GetThreadSP();
+  StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
+
+  if (!frame_sp)
+    return StructuredData::ObjectSP();
+
+  EvaluateExpressionOptions options;
+  options.SetUnwindOnError(true);
+  options.SetTryAllThreads(true);
+  options.SetStopOthers(true);
+  options.SetIgnoreBreakpoints(true);
+  options.SetTimeout(g_retrieve_data_function_timeout);
+  options.SetPrefix(thread_sanitizer_retrieve_report_data_prefix);
+  options.SetAutoApplyFixIts(false);
+  options.SetLanguage(eLanguageTypeObjC_plus_plus);
+
+  ValueObjectSP main_value;
+  ExecutionContext exe_ctx;
+  Status eval_error;
+  frame_sp->CalculateExecutionContext(exe_ctx);
+  ExpressionResults result = UserExpression::Evaluate(
+      exe_ctx, options, thread_sanitizer_retrieve_report_data_command, "",
+      main_value, eval_error);
+  if (result != eExpressionCompleted) {
+    process_sp->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf(
+        "Warning: Cannot evaluate ThreadSanitizer expression:\n%s\n",
+        eval_error.AsCString());
+    return StructuredData::ObjectSP();
+  }
+
+  std::map<uint64_t, user_id_t> thread_id_map;
+  GetRenumberedThreadIds(process_sp, main_value, thread_id_map);
+
+  StructuredData::Dictionary *dict = new StructuredData::Dictionary();
+  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")));
+
+  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)));
+        // "stacks" happen on the current thread
+        dict->AddIntegerItem("thread_id", thread_sp->GetIndexID());
+      });
+  dict->AddItem("stacks", StructuredData::ObjectSP(stacks));
+
+  StructuredData::Array *mops = ConvertToStructuredArray(
+      main_value, ".mops", ".mop_count",
+      [&thread_id_map](ValueObjectSP o, StructuredData::Dictionary *dict) {
+        dict->AddIntegerItem(
+            "index",
+            o->GetValueForExpressionPath(".idx")->GetValueAsUnsigned(0));
+        dict->AddIntegerItem(
+            "thread_id",
+            Renumber(
+                o->GetValueForExpressionPath(".tid")->GetValueAsUnsigned(0),
+                thread_id_map));
+        dict->AddIntegerItem(
+            "size",
+            o->GetValueForExpressionPath(".size")->GetValueAsUnsigned(0));
+        dict->AddBooleanItem(
+            "is_write",
+            o->GetValueForExpressionPath(".write")->GetValueAsUnsigned(0));
+        dict->AddBooleanItem(
+            "is_atomic",
+            o->GetValueForExpressionPath(".atomic")->GetValueAsUnsigned(0));
+        dict->AddIntegerItem(
+            "address",
+            o->GetValueForExpressionPath(".addr")->GetValueAsUnsigned(0));
+        dict->AddItem("trace", StructuredData::ObjectSP(CreateStackTrace(o)));
+      });
+  dict->AddItem("mops", StructuredData::ObjectSP(mops));
+
+  StructuredData::Array *locs = ConvertToStructuredArray(
+      main_value, ".locs", ".loc_count",
+      [process_sp, &thread_id_map](ValueObjectSP o,
+                                   StructuredData::Dictionary *dict) {
+        dict->AddIntegerItem(
+            "index",
+            o->GetValueForExpressionPath(".idx")->GetValueAsUnsigned(0));
+        dict->AddStringItem("type", RetrieveString(o, process_sp, ".type"));
+        dict->AddIntegerItem(
+            "address",
+            o->GetValueForExpressionPath(".addr")->GetValueAsUnsigned(0));
+        dict->AddIntegerItem(
+            "start",
+            o->GetValueForExpressionPath(".start")->GetValueAsUnsigned(0));
+        dict->AddIntegerItem(
+            "size",
+            o->GetValueForExpressionPath(".size")->GetValueAsUnsigned(0));
+        dict->AddIntegerItem(
+            "thread_id",
+            Renumber(
+                o->GetValueForExpressionPath(".tid")->GetValueAsUnsigned(0),
+                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",
+            o->GetValueForExpressionPath(".idx")->GetValueAsUnsigned(0));
+        dict->AddIntegerItem(
+            "mutex_id",
+            o->GetValueForExpressionPath(".mutex_id")->GetValueAsUnsigned(0));
+        dict->AddIntegerItem(
+            "address",
+            o->GetValueForExpressionPath(".addr")->GetValueAsUnsigned(0));
+        dict->AddIntegerItem(
+            "destroyed",
+            o->GetValueForExpressionPath(".destroyed")->GetValueAsUnsigned(0));
+        dict->AddItem("trace", StructuredData::ObjectSP(CreateStackTrace(o)));
+      });
+  dict->AddItem("mutexes", StructuredData::ObjectSP(mutexes));
+
+  StructuredData::Array *threads = ConvertToStructuredArray(
+      main_value, ".threads", ".thread_count",
+      [process_sp, &thread_id_map](ValueObjectSP o,
+                                   StructuredData::Dictionary *dict) {
+        dict->AddIntegerItem(
+            "index",
+            o->GetValueForExpressionPath(".idx")->GetValueAsUnsigned(0));
+        dict->AddIntegerItem(
+            "thread_id",
+            Renumber(
+                o->GetValueForExpressionPath(".tid")->GetValueAsUnsigned(0),
+                thread_id_map));
+        dict->AddIntegerItem(
+            "thread_os_id",
+            o->GetValueForExpressionPath(".os_id")->GetValueAsUnsigned(0));
+        dict->AddIntegerItem(
+            "running",
+            o->GetValueForExpressionPath(".running")->GetValueAsUnsigned(0));
+        dict->AddStringItem("name", RetrieveString(o, process_sp, ".name"));
+        dict->AddIntegerItem(
+            "parent_thread_id",
+            Renumber(o->GetValueForExpressionPath(".parent_tid")
+                         ->GetValueAsUnsigned(0),
+                     thread_id_map));
+        dict->AddItem("trace", StructuredData::ObjectSP(CreateStackTrace(o)));
+      });
+  dict->AddItem("threads", StructuredData::ObjectSP(threads));
+
+  StructuredData::Array *unique_tids = ConvertToStructuredArray(
+      main_value, ".unique_tids", ".unique_tid_count",
+      [&thread_id_map](ValueObjectSP o, StructuredData::Dictionary *dict) {
+        dict->AddIntegerItem(
+            "index",
+            o->GetValueForExpressionPath(".idx")->GetValueAsUnsigned(0));
+        dict->AddIntegerItem(
+            "tid",
+            Renumber(
+                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 description = report->GetAsDictionary()
+                                ->GetValueForKey("issue_type")
+                                ->GetAsString()
+                                ->GetValue();
+
+  if (description == "data-race") {
+    return "Data race";
+  } else if (description == "data-race-vptr") {
+    return "Data race on C++ virtual pointer";
+  } else if (description == "heap-use-after-free") {
+    return "Use of deallocated memory";
+  } else if (description == "heap-use-after-free-vptr") {
+    return "Use of deallocated C++ virtual pointer";
+  } else if (description == "thread-leak") {
+    return "Thread leak";
+  } else if (description == "locked-mutex-destroy") {
+    return "Destruction of a locked mutex";
+  } else if (description == "mutex-double-lock") {
+    return "Double lock of a mutex";
+  } else if (description == "mutex-invalid-access") {
+    return "Use of an uninitialized or destroyed mutex";
+  } else if (description == "mutex-bad-unlock") {
+    return "Unlock of an unlocked mutex (or by a wrong thread)";
+  } else if (description == "mutex-bad-read-lock") {
+    return "Read lock of a write locked mutex";
+  } 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";
+  } else if (description == "swift-access-race") {
+    return "Swift access race";
+  }
+
+  // for unknown report codes just show the code
+  return description;
+}
+
+static std::string Sprintf(const char *format, ...) {
+  StreamString s;
+  va_list args;
+  va_start(args, format);
+  s.PrintfVarArg(format, args);
+  va_end(args);
+  return s.GetString();
+}
+
+static std::string GetSymbolNameFromAddress(ProcessSP process_sp, addr_t addr) {
+  lldb_private::Address so_addr;
+  if (!process_sp->GetTarget().GetSectionLoadList().ResolveLoadAddress(addr,
+                                                                       so_addr))
+    return "";
+
+  lldb_private::Symbol *symbol = so_addr.CalculateSymbolContextSymbol();
+  if (!symbol)
+    return "";
+
+  std::string sym_name = symbol->GetName().GetCString();
+  return sym_name;
+}
+
+static void GetSymbolDeclarationFromAddress(ProcessSP process_sp, addr_t addr,
+                                            Declaration &decl) {
+  lldb_private::Address so_addr;
+  if (!process_sp->GetTarget().GetSectionLoadList().ResolveLoadAddress(addr,
+                                                                       so_addr))
+    return;
+
+  lldb_private::Symbol *symbol = so_addr.CalculateSymbolContextSymbol();
+  if (!symbol)
+    return;
+
+  ConstString sym_name = symbol->GetMangled().GetName(
+      lldb::eLanguageTypeUnknown, Mangled::ePreferMangled);
+
+  ModuleSP module = symbol->CalculateSymbolContextModule();
+  if (!module)
+    return;
+
+  VariableList var_list;
+  module->FindGlobalVariables(sym_name, nullptr, true, 1U, var_list);
+  if (var_list.GetSize() < 1)
+    return;
+
+  VariableSP var = var_list.GetVariableAtIndex(0);
+  decl = var->GetDeclaration();
+}
+
+addr_t ThreadSanitizerRuntime::GetFirstNonInternalFramePc(
+    StructuredData::ObjectSP trace, bool skip_one_frame) {
+  ProcessSP process_sp = GetProcessSP();
+  ModuleSP runtime_module_sp = GetRuntimeModuleSP();
+
+  StructuredData::Array *trace_array = trace->GetAsArray();
+  for (size_t i = 0; i < trace_array->GetSize(); i++) {
+    if (skip_one_frame && i == 0)
+      continue;
+
+    addr_t addr;
+    if (!trace_array->GetItemAtIndexAsInteger(i, addr))
+      continue;
+
+    lldb_private::Address so_addr;
+    if (!process_sp->GetTarget().GetSectionLoadList().ResolveLoadAddress(
+            addr, so_addr))
+      continue;
+
+    if (so_addr.GetModule() == runtime_module_sp)
+      continue;
+
+    return addr;
+  }
+
+  return 0;
+}
+
+std::string
+ThreadSanitizerRuntime::GenerateSummary(StructuredData::ObjectSP report) {
+  ProcessSP process_sp = GetProcessSP();
+
+  std::string summary = report->GetAsDictionary()
+                            ->GetValueForKey("description")
+                            ->GetAsString()
+                            ->GetValue();
+  bool skip_one_frame =
+      report->GetObjectForDotSeparatedPath("issue_type")->GetStringValue() ==
+      "external-race";
+
+  addr_t pc = 0;
+  if (report->GetAsDictionary()
+          ->GetValueForKey("mops")
+          ->GetAsArray()
+          ->GetSize() > 0)
+    pc = GetFirstNonInternalFramePc(report->GetAsDictionary()
+                                        ->GetValueForKey("mops")
+                                        ->GetAsArray()
+                                        ->GetItemAtIndex(0)
+                                        ->GetAsDictionary()
+                                        ->GetValueForKey("trace"),
+                                    skip_one_frame);
+
+  if (report->GetAsDictionary()
+          ->GetValueForKey("stacks")
+          ->GetAsArray()
+          ->GetSize() > 0)
+    pc = GetFirstNonInternalFramePc(report->GetAsDictionary()
+                                        ->GetValueForKey("stacks")
+                                        ->GetAsArray()
+                                        ->GetItemAtIndex(0)
+                                        ->GetAsDictionary()
+                                        ->GetValueForKey("trace"),
+                                    skip_one_frame);
+
+  if (pc != 0) {
+    summary = summary + " in " + GetSymbolNameFromAddress(process_sp, pc);
+  }
+
+  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()
+                 ->GetValue();
+
+    if (addr != 0) {
+      std::string global_name = GetSymbolNameFromAddress(process_sp, addr);
+      if (!global_name.empty()) {
+        summary = summary + " at " + global_name;
+      } else {
+        summary = summary + " at " + Sprintf("0x%llx", addr);
+      }
+    } else {
+      int fd = loc->GetAsDictionary()
+                   ->GetValueForKey("file_descriptor")
+                   ->GetAsInteger()
+                   ->GetValue();
+      if (fd != 0) {
+        summary = summary + " on file descriptor " + Sprintf("%d", fd);
+      }
+    }
+  }
+
+  return summary;
+}
+
+addr_t
+ThreadSanitizerRuntime::GetMainRacyAddress(StructuredData::ObjectSP report) {
+  addr_t result = (addr_t)-1;
+
+  report->GetObjectForDotSeparatedPath("mops")->GetAsArray()->ForEach(
+      [&result](StructuredData::Object *o) -> bool {
+        addr_t addr =
+            o->GetObjectForDotSeparatedPath("address")->GetIntegerValue();
+        if (addr < result)
+          result = addr;
+        return true;
+      });
+
+  return (result == (addr_t)-1) ? 0 : result;
+}
+
+std::string ThreadSanitizerRuntime::GetLocationDescription(
+    StructuredData::ObjectSP report, addr_t &global_addr,
+    std::string &global_name, std::string &filename, uint32_t &line) {
+  std::string result = "";
+
+  ProcessSP process_sp = GetProcessSP();
+
+  if (report->GetAsDictionary()
+          ->GetValueForKey("locs")
+          ->GetAsArray()
+          ->GetSize() > 0) {
+    StructuredData::ObjectSP loc = report->GetAsDictionary()
+                                       ->GetValueForKey("locs")
+                                       ->GetAsArray()
+                                       ->GetItemAtIndex(0);
+    std::string type =
+        loc->GetAsDictionary()->GetValueForKey("type")->GetStringValue();
+    if (type == "global") {
+      global_addr = loc->GetAsDictionary()
+                        ->GetValueForKey("address")
+                        ->GetAsInteger()
+                        ->GetValue();
+      global_name = GetSymbolNameFromAddress(process_sp, global_addr);
+      if (!global_name.empty()) {
+        result = Sprintf("'%s' is a global variable (0x%llx)",
+                         global_name.c_str(), global_addr);
+      } else {
+        result = Sprintf("0x%llx is a global variable", global_addr);
+      }
+
+      Declaration decl;
+      GetSymbolDeclarationFromAddress(process_sp, global_addr, decl);
+      if (decl.GetFile()) {
+        filename = decl.GetFile().GetPath();
+        line = decl.GetLine();
+      }
+    } else if (type == "heap") {
+      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()
+                    ->GetValueForKey("thread_id")
+                    ->GetAsInteger()
+                    ->GetValue();
+      result = Sprintf("Location is TLS of thread %d", tid);
+    } else if (type == "fd") {
+      int fd = loc->GetAsDictionary()
+                   ->GetValueForKey("file_descriptor")
+                   ->GetAsInteger()
+                   ->GetValue();
+      result = Sprintf("Location is file descriptor %d", fd);
+    }
+  }
+
+  return result;
+}
+
+bool ThreadSanitizerRuntime::NotifyBreakpointHit(
+    void *baton, StoppointCallbackContext *context, user_id_t break_id,
+    user_id_t break_loc_id) {
+  assert(baton && "null baton");
+  if (!baton)
+    return false;
+
+  ThreadSanitizerRuntime *const instance =
+      static_cast<ThreadSanitizerRuntime *>(baton);
+
+  StructuredData::ObjectSP report =
+      instance->RetrieveReportData(context->exe_ctx_ref);
+  std::string stop_reason_description;
+  if (report) {
+    std::string issue_description = instance->FormatDescription(report);
+    report->GetAsDictionary()->AddStringItem("description", issue_description);
+    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);
+
+    addr_t global_addr = 0;
+    std::string global_name = "";
+    std::string location_filename = "";
+    uint32_t location_line = 0;
+    std::string location_description = instance->GetLocationDescription(
+        report, global_addr, global_name, location_filename, location_line);
+    report->GetAsDictionary()->AddStringItem("location_description",
+                                             location_description);
+    if (global_addr != 0) {
+      report->GetAsDictionary()->AddIntegerItem("global_address", global_addr);
+    }
+    if (!global_name.empty()) {
+      report->GetAsDictionary()->AddStringItem("global_name", global_name);
+    }
+    if (location_filename != "") {
+      report->GetAsDictionary()->AddStringItem("location_filename",
+                                               location_filename);
+      report->GetAsDictionary()->AddIntegerItem("location_line", location_line);
+    }
+
+    bool all_addresses_are_same = true;
+    report->GetObjectForDotSeparatedPath("mops")->GetAsArray()->ForEach(
+        [&all_addresses_are_same,
+         main_address](StructuredData::Object *o) -> bool {
+          addr_t addr =
+              o->GetObjectForDotSeparatedPath("address")->GetIntegerValue();
+          if (main_address != addr)
+            all_addresses_are_same = false;
+          return true;
+        });
+    report->GetAsDictionary()->AddBooleanItem("all_addresses_are_same",
+                                              all_addresses_are_same);
+  }
+
+  ProcessSP process_sp = instance->GetProcessSP();
+  // Make sure this is the right process
+  if (process_sp && process_sp == context->exe_ctx_ref.GetProcessSP()) {
+    ThreadSP thread_sp = context->exe_ctx_ref.GetThreadSP();
+    if (thread_sp)
+      thread_sp->SetStopInfo(
+          InstrumentationRuntimeStopInfo::
+              CreateStopReasonWithInstrumentationData(
+                  *thread_sp, stop_reason_description, report));
+
+    StreamFileSP stream_sp(
+        process_sp->GetTarget().GetDebugger().GetOutputFile());
+    if (stream_sp) {
+      stream_sp->Printf("ThreadSanitizer report breakpoint hit. Use 'thread "
+                        "info -s' to get extended information about the "
+                        "report.\n");
+    }
+    return true; // Return true to stop the target
+  } else
+    return false; // Let target run
+}
+
+const RegularExpression &ThreadSanitizerRuntime::GetPatternForRuntimeLibrary() {
+  static RegularExpression regex(llvm::StringRef("libclang_rt.tsan_"));
+  return regex;
+}
+
+bool ThreadSanitizerRuntime::CheckIfRuntimeIsValid(
+    const lldb::ModuleSP module_sp) {
+  static ConstString g_tsan_get_current_report("__tsan_get_current_report");
+  const Symbol *symbol = module_sp->FindFirstSymbolWithNameAndType(
+      g_tsan_get_current_report, lldb::eSymbolTypeAny);
+  return symbol != nullptr;
+}
+
+void ThreadSanitizerRuntime::Activate() {
+  if (IsActive())
+    return;
+
+  ProcessSP process_sp = GetProcessSP();
+  if (!process_sp)
+    return;
+
+  ConstString symbol_name("__tsan_on_report");
+  const Symbol *symbol = GetRuntimeModuleSP()->FindFirstSymbolWithNameAndType(
+      symbol_name, eSymbolTypeCode);
+
+  if (symbol == NULL)
+    return;
+
+  if (!symbol->ValueIsAddress() || !symbol->GetAddressRef().IsValid())
+    return;
+
+  Target &target = process_sp->GetTarget();
+  addr_t symbol_address = symbol->GetAddressRef().GetOpcodeLoadAddress(&target);
+
+  if (symbol_address == LLDB_INVALID_ADDRESS)
+    return;
+
+  bool internal = true;
+  bool hardware = false;
+  Breakpoint *breakpoint =
+      process_sp->GetTarget()
+          .CreateBreakpoint(symbol_address, internal, hardware)
+          .get();
+  breakpoint->SetCallback(ThreadSanitizerRuntime::NotifyBreakpointHit, this,
+                          true);
+  breakpoint->SetBreakpointKind("thread-sanitizer-report");
+  SetBreakpointID(breakpoint->GetID());
+
+  SetActive(true);
+}
+
+void ThreadSanitizerRuntime::Deactivate() {
+  if (GetBreakpointID() != LLDB_INVALID_BREAK_ID) {
+    ProcessSP process_sp = GetProcessSP();
+    if (process_sp) {
+      process_sp->GetTarget().RemoveBreakpointByID(GetBreakpointID());
+      SetBreakpointID(LLDB_INVALID_BREAK_ID);
+    }
+  }
+  SetActive(false);
+}
+static std::string GenerateThreadName(const std::string &path,
+                                      StructuredData::Object *o,
+                                      StructuredData::ObjectSP main_info) {
+  std::string result = "additional information";
+
+  if (path == "mops") {
+    int size = o->GetObjectForDotSeparatedPath("size")->GetIntegerValue();
+    int thread_id =
+        o->GetObjectForDotSeparatedPath("thread_id")->GetIntegerValue();
+    bool is_write =
+        o->GetObjectForDotSeparatedPath("is_write")->GetBooleanValue();
+    bool is_atomic =
+        o->GetObjectForDotSeparatedPath("is_atomic")->GetBooleanValue();
+    addr_t addr = o->GetObjectForDotSeparatedPath("address")->GetIntegerValue();
+
+    std::string addr_string = Sprintf(" at 0x%llx", addr);
+
+    if (main_info->GetObjectForDotSeparatedPath("all_addresses_are_same")
+            ->GetBooleanValue()) {
+      addr_string = "";
+    }
+
+    if (main_info->GetObjectForDotSeparatedPath("issue_type")
+            ->GetStringValue() == "external-race") {
+      result = Sprintf("%s access by thread %d",
+                       is_write ? "mutating" : "read-only", thread_id);
+    } else if (main_info->GetObjectForDotSeparatedPath("issue_type")
+                   ->GetStringValue() == "swift-access-race") {
+      result = Sprintf("modifying access by thread %d", thread_id);
+    } else {
+      result = Sprintf("%s%s of size %d%s by thread %d",
+                       is_atomic ? "atomic " : "", is_write ? "write" : "read",
+                       size, addr_string.c_str(), thread_id);
+    }
+  }
+
+  if (path == "threads") {
+    int thread_id =
+        o->GetObjectForDotSeparatedPath("thread_id")->GetIntegerValue();
+    result = Sprintf("Thread %d created", thread_id);
+  }
+
+  if (path == "locs") {
+    std::string type =
+        o->GetAsDictionary()->GetValueForKey("type")->GetStringValue();
+    int thread_id =
+        o->GetObjectForDotSeparatedPath("thread_id")->GetIntegerValue();
+    int fd =
+        o->GetObjectForDotSeparatedPath("file_descriptor")->GetIntegerValue();
+    if (type == "heap") {
+      result = Sprintf("Heap block allocated by thread %d", thread_id);
+    } else if (type == "fd") {
+      result =
+          Sprintf("File descriptor %d created by thread %t", fd, thread_id);
+    }
+  }
+
+  if (path == "mutexes") {
+    int mutex_id =
+        o->GetObjectForDotSeparatedPath("mutex_id")->GetIntegerValue();
+
+    result = Sprintf("Mutex M%d created", mutex_id);
+  }
+
+  if (path == "stacks") {
+    int thread_id =
+        o->GetObjectForDotSeparatedPath("thread_id")->GetIntegerValue();
+    result = Sprintf("Thread %d", thread_id);
+  }
+
+  result[0] = toupper(result[0]);
+
+  return result;
+}
+
+static void AddThreadsForPath(const std::string &path,
+                              ThreadCollectionSP threads, ProcessSP process_sp,
+                              StructuredData::ObjectSP info) {
+  info->GetObjectForDotSeparatedPath(path)->GetAsArray()->ForEach(
+      [process_sp, threads, path, info](StructuredData::Object *o) -> bool {
+        std::vector<lldb::addr_t> pcs;
+        o->GetObjectForDotSeparatedPath("trace")->GetAsArray()->ForEach(
+            [&pcs](StructuredData::Object *pc) -> bool {
+              pcs.push_back(pc->GetAsInteger()->GetValue());
+              return true;
+            });
+
+        if (pcs.size() == 0)
+          return true;
+
+        StructuredData::ObjectSP thread_id_obj =
+            o->GetObjectForDotSeparatedPath("thread_os_id");
+        tid_t tid = thread_id_obj ? thread_id_obj->GetIntegerValue() : 0;
+
+        uint32_t stop_id = 0;
+        bool stop_id_is_valid = false;
+        HistoryThread *history_thread =
+            new HistoryThread(*process_sp, tid, pcs, stop_id, stop_id_is_valid);
+        ThreadSP new_thread_sp(history_thread);
+        new_thread_sp->SetName(GenerateThreadName(path, o, info).c_str());
+
+        // Save this in the Process' ExtendedThreadList so a strong pointer
+        // retains the object
+        process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
+        threads->AddThread(new_thread_sp);
+
+        return true;
+      });
+}
+
+lldb::ThreadCollectionSP
+ThreadSanitizerRuntime::GetBacktracesFromExtendedStopInfo(
+    StructuredData::ObjectSP info) {
+  ThreadCollectionSP threads;
+  threads.reset(new ThreadCollection());
+
+  if (info->GetObjectForDotSeparatedPath("instrumentation_class")
+          ->GetStringValue() != "ThreadSanitizer")
+    return threads;
+
+  ProcessSP process_sp = GetProcessSP();
+
+  AddThreadsForPath("stacks", threads, process_sp, info);
+  AddThreadsForPath("mops", threads, process_sp, info);
+  AddThreadsForPath("locs", threads, process_sp, info);
+  AddThreadsForPath("mutexes", threads, process_sp, info);
+  AddThreadsForPath("threads", threads, process_sp, info);
+
+  return threads;
+}

lldb/trunk/source/Plugins/InstrumentationRuntime/ThreadSanitizer/CMakeLists.txt

-add_lldb_library(lldbPluginInstrumentationRuntimeThreadSanitizer PLUGIN
-  ThreadSanitizerRuntime.cpp
-
-  LINK_LIBS
-    lldbBreakpoint
-    lldbCore
-    lldbExpression
-    lldbInterpreter
-    lldbSymbol
-    lldbTarget
-    lldbPluginProcessUtility
-  )

lldb/trunk/source/Plugins/InstrumentationRuntime/ThreadSanitizer/ThreadSanitizerRuntime.h

-//===-- ThreadSanitizerRuntime.h --------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_ThreadSanitizerRuntime_h_
-#define liblldb_ThreadSanitizerRuntime_h_
-
-// C Includes
-// C++ Includes
-// Other libraries and framework includes
-// Project includes
-#include "lldb/Core/StructuredData.h"
-#include "lldb/Target/ABI.h"
-#include "lldb/Target/InstrumentationRuntime.h"
-#include "lldb/lldb-private.h"
-
-namespace lldb_private {
-
-class ThreadSanitizerRuntime : public lldb_private::InstrumentationRuntime {
-public:
-  ~ThreadSanitizerRuntime() override;
-
-  static lldb::InstrumentationRuntimeSP
-  CreateInstance(const lldb::ProcessSP &process_sp);
-
-  static void Initialize();
-
-  static void Terminate();
-
-  static lldb_private::ConstString GetPluginNameStatic();
-
-  static lldb::InstrumentationRuntimeType GetTypeStatic();
-
-  lldb_private::ConstString GetPluginName() override {
-    return GetPluginNameStatic();
-  }
-
-  virtual lldb::InstrumentationRuntimeType GetType() { return GetTypeStatic(); }
-
-  uint32_t GetPluginVersion() override { return 1; }
-
-  lldb::ThreadCollectionSP
-  GetBacktracesFromExtendedStopInfo(StructuredData::ObjectSP info) override;
-
-private:
-  ThreadSanitizerRuntime(const lldb::ProcessSP &process_sp)
-      : lldb_private::InstrumentationRuntime(process_sp) {}
-
-  const RegularExpression &GetPatternForRuntimeLibrary() override;
-
-  bool CheckIfRuntimeIsValid(const lldb::ModuleSP module_sp) override;
-
-  void Activate() override;
-
-  void Deactivate();
-
-  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 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,
-                                     std::string &filename, uint32_t &line);
-
-  lldb::addr_t GetFirstNonInternalFramePc(StructuredData::ObjectSP trace,
-                                          bool skip_one_frame = false);
-};
-
-} // namespace lldb_private
-
-#endif // liblldb_ThreadSanitizerRuntime_h_

lldb/trunk/source/Plugins/InstrumentationRuntime/ThreadSanitizer/ThreadSanitizerRuntime.cpp

-//===-- ThreadSanitizerRuntime.cpp ------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "ThreadSanitizerRuntime.h"
-
-#include "Plugins/Process/Utility/HistoryThread.h"
-#include "lldb/Breakpoint/StoppointCallbackContext.h"
-#include "lldb/Core/Debugger.h"
-#include "lldb/Core/Module.h"
-#include "lldb/Core/PluginInterface.h"
-#include "lldb/Core/PluginManager.h"
-#include "lldb/Core/StreamFile.h"
-#include "lldb/Core/ValueObject.h"
-#include "lldb/Expression/UserExpression.h"
-#include "lldb/Interpreter/CommandReturnObject.h"
-#include "lldb/Symbol/Symbol.h"
-#include "lldb/Symbol/SymbolContext.h"
-#include "lldb/Symbol/Variable.h"
-#include "lldb/Symbol/VariableList.h"
-#include "lldb/Target/InstrumentationRuntimeStopInfo.h"
-#include "lldb/Target/SectionLoadList.h"
-#include "lldb/Target/StopInfo.h"
-#include "lldb/Target/Target.h"
-#include "lldb/Target/Thread.h"
-#include "lldb/Utility/RegularExpression.h"
-#include "lldb/Utility/Stream.h"
-
-using namespace lldb;
-using namespace lldb_private;
-
-lldb::InstrumentationRuntimeSP
-ThreadSanitizerRuntime::CreateInstance(const lldb::ProcessSP &process_sp) {
-  return InstrumentationRuntimeSP(new ThreadSanitizerRuntime(process_sp));
-}
-
-void ThreadSanitizerRuntime::Initialize() {
-  PluginManager::RegisterPlugin(
-      GetPluginNameStatic(), "ThreadSanitizer instrumentation runtime plugin.",
-      CreateInstance, GetTypeStatic);
-}
-
-void ThreadSanitizerRuntime::Terminate() {
-  PluginManager::UnregisterPlugin(CreateInstance);
-}
-
-lldb_private::ConstString ThreadSanitizerRuntime::GetPluginNameStatic() {
-  return ConstString("ThreadSanitizer");
-}
-
-lldb::InstrumentationRuntimeType ThreadSanitizerRuntime::GetTypeStatic() {
-  return eInstrumentationRuntimeTypeThreadSanitizer;
-}
-
-ThreadSanitizerRuntime::~ThreadSanitizerRuntime() { Deactivate(); }
-
-static constexpr std::chrono::seconds g_retrieve_data_function_timeout(2);
-
-const char *thread_sanitizer_retrieve_report_data_prefix = R"(
-extern "C"
-{
-    void *__tsan_get_current_report();
-    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_stack(void *report, unsigned long idx, void **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_loc(void *report, unsigned long idx, const char **type,
-                              void **addr, unsigned long *start, unsigned long *size, int *tid,
-                              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);
-  
-    // 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);
-}
-
-const int REPORT_TRACE_SIZE = 128;
-const int REPORT_ARRAY_SIZE = 4;
-
-struct data {
-    void *report;
-    const char *description;
-    int report_count;
-    
-    void *sleep_trace[REPORT_TRACE_SIZE];
-    
-    int stack_count;
-    struct {
-        int idx;
-        void *trace[REPORT_TRACE_SIZE];
-    } stacks[REPORT_ARRAY_SIZE];
-    
-    int mop_count;
-    struct {
-        int idx;
-        int tid;
-        int size;
-        int write;
-        int atomic;
-        void *addr;
-        void *trace[REPORT_TRACE_SIZE];
-    } mops[REPORT_ARRAY_SIZE];
-    
-    int loc_count;
-    struct {
-        int idx;
-        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;
-        void *trace[REPORT_TRACE_SIZE];
-    } mutexes[REPORT_ARRAY_SIZE];
-    
-    int thread_count;
-    struct {
-        int idx;
-        int tid;
-        unsigned long os_id;
-        int running;
-        const char *name;
-        int parent_tid;
-        void *trace[REPORT_TRACE_SIZE];
-    } threads[REPORT_ARRAY_SIZE];
-    
-    int unique_tid_count;
-    struct {
-        int idx;
-        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);
-}
-
-if (t.thread_count > REPORT_ARRAY_SIZE) t.thread_count = REPORT_ARRAY_SIZE;
-for (int i = 0; i < t.thread_count; i++) {
-    t.threads[i].idx = i;
-    __tsan_get_report_thread(t.report, i, &t.threads[i].tid, &t.threads[i].os_id, &t.threads[i].running, &t.threads[i].name, &t.threads[i].parent_tid, t.threads[i].trace, REPORT_TRACE_SIZE);
-}
-
-if (t.unique_tid_count > REPORT_ARRAY_SIZE) t.unique_tid_count = REPORT_ARRAY_SIZE;
-for (int i = 0; i < t.unique_tid_count; i++) {
-    t.unique_tids[i].idx = i;
-    __tsan_get_report_unique_tid(t.report, i, &t.unique_tids[i].tid);
-}
-
-t;
-)";
-
-static StructuredData::Array *
-CreateStackTrace(ValueObjectSP o,
-                 const std::string &trace_item_name = ".trace") {
-  StructuredData::Array *trace = new StructuredData::Array();
-  ValueObjectSP trace_value_object =
-      o->GetValueForExpressionPath(trace_item_name.c_str());
-  size_t count = trace_value_object->GetNumChildren();
-  for (size_t j = 0; j < count; j++) {
-    addr_t trace_addr =
-        trace_value_object->GetChildAtIndex(j, true)->GetValueAsUnsigned(0);
-    if (trace_addr == 0)
-      break;
-    trace->AddItem(
-        StructuredData::ObjectSP(new StructuredData::Integer(trace_addr)));
-  }
-  return trace;
-}
-
-static StructuredData::Array *ConvertToStructuredArray(
-    ValueObjectSP return_value_sp, const std::string &items_name,
-    const std::string &count_name,
-    std::function<void(ValueObjectSP o, StructuredData::Dictionary *dict)> const
-        &callback) {
-  StructuredData::Array *array = new StructuredData::Array();
-  unsigned int count =
-      return_value_sp->GetValueForExpressionPath(count_name.c_str())
-          ->GetValueAsUnsigned(0);
-  ValueObjectSP objects =
-      return_value_sp->GetValueForExpressionPath(items_name.c_str());
-  for (unsigned int i = 0; i < count; i++) {
-    ValueObjectSP o = objects->GetChildAtIndex(i, true);
-    StructuredData::Dictionary *dict = new StructuredData::Dictionary();
-
-    callback(o, dict);
-
-    array->AddItem(StructuredData::ObjectSP(dict));
-  }
-  return array;
-}
-
-static std::string RetrieveString(ValueObjectSP return_value_sp,
-                                  ProcessSP process_sp,
-                                  const std::string &expression_path) {
-  addr_t ptr =
-      return_value_sp->GetValueForExpressionPath(expression_path.c_str())
-          ->GetValueAsUnsigned(0);
-  std::string str;
-  Status error;
-  process_sp->ReadCStringFromMemory(ptr, str, error);
-  return str;
-}
-
-static void
-GetRenumberedThreadIds(ProcessSP process_sp, ValueObjectSP data,
-                       std::map<uint64_t, user_id_t> &thread_id_map) {
-  ConvertToStructuredArray(
-      data, ".threads", ".thread_count",
-      [process_sp, &thread_id_map](ValueObjectSP o,
-                                   StructuredData::Dictionary *dict) {
-        uint64_t thread_id =
-            o->GetValueForExpressionPath(".tid")->GetValueAsUnsigned(0);
-        uint64_t thread_os_id =
-            o->GetValueForExpressionPath(".os_id")->GetValueAsUnsigned(0);
-        user_id_t lldb_user_id = 0;
-
-        bool can_update = true;
-        ThreadSP lldb_thread = process_sp->GetThreadList().FindThreadByID(
-            thread_os_id, can_update);
-        if (lldb_thread) {
-          lldb_user_id = lldb_thread->GetIndexID();
-        } else {
-          // This isn't a live thread anymore.  Ask process to assign a new
-          // Index ID (or return an old one if we've already seen this
-          // thread_os_id).
-          // It will also make sure that no new threads are assigned this Index
-          // ID.
-          lldb_user_id = process_sp->AssignIndexIDToThread(thread_os_id);
-        }
-
-        thread_id_map[thread_id] = lldb_user_id;
-      });
-}
-
-static user_id_t Renumber(uint64_t id,
-                          std::map<uint64_t, user_id_t> &thread_id_map) {
-  auto IT = thread_id_map.find(id);
-  if (IT == thread_id_map.end())
-    return 0;
-
-  return IT->second;
-}
-
-StructuredData::ObjectSP
-ThreadSanitizerRuntime::RetrieveReportData(ExecutionContextRef exe_ctx_ref) {
-  ProcessSP process_sp = GetProcessSP();
-  if (!process_sp)
-    return StructuredData::ObjectSP();
-
-  ThreadSP thread_sp = exe_ctx_ref.GetThreadSP();
-  StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
-
-  if (!frame_sp)
-    return StructuredData::ObjectSP();
-
-  EvaluateExpressionOptions options;
-  options.SetUnwindOnError(true);
-  options.SetTryAllThreads(true);
-  options.SetStopOthers(true);
-  options.SetIgnoreBreakpoints(true);
-  options.SetTimeout(g_retrieve_data_function_timeout);
-  options.SetPrefix(thread_sanitizer_retrieve_report_data_prefix);
-  options.SetAutoApplyFixIts(false);
-  options.SetLanguage(eLanguageTypeObjC_plus_plus);
-
-  ValueObjectSP main_value;
-  ExecutionContext exe_ctx;
-  Status eval_error;
-  frame_sp->CalculateExecutionContext(exe_ctx);
-  ExpressionResults result = UserExpression::Evaluate(
-      exe_ctx, options, thread_sanitizer_retrieve_report_data_command, "",
-      main_value, eval_error);
-  if (result != eExpressionCompleted) {
-    process_sp->GetTarget().GetDebugger().GetAsyncOutputStream()->Printf(
-        "Warning: Cannot evaluate ThreadSanitizer expression:\n%s\n",
-        eval_error.AsCString());
-    return StructuredData::ObjectSP();
-  }
-
-  std::map<uint64_t, user_id_t> thread_id_map;
-  GetRenumberedThreadIds(process_sp, main_value, thread_id_map);
-
-  StructuredData::Dictionary *dict = new StructuredData::Dictionary();
-  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")));
-
-  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)));
-        // "stacks" happen on the current thread
-        dict->AddIntegerItem("thread_id", thread_sp->GetIndexID());
-      });
-  dict->AddItem("stacks", StructuredData::ObjectSP(stacks));
-
-  StructuredData::Array *mops = ConvertToStructuredArray(
-      main_value, ".mops", ".mop_count",
-      [&thread_id_map](ValueObjectSP o, StructuredData::Dictionary *dict) {
-        dict->AddIntegerItem(
-            "index",
-            o->GetValueForExpressionPath(".idx")->GetValueAsUnsigned(0));
-        dict->AddIntegerItem(
-            "thread_id",
-            Renumber(
-                o->GetValueForExpressionPath(".tid")->GetValueAsUnsigned(0),
-                thread_id_map));
-        dict->AddIntegerItem(
-            "size",
-            o->GetValueForExpressionPath(".size")->GetValueAsUnsigned(0));
-        dict->AddBooleanItem(
-            "is_write",
-            o->GetValueForExpressionPath(".write")->GetValueAsUnsigned(0));
-        dict->AddBooleanItem(
-            "is_atomic",
-            o->GetValueForExpressionPath(".atomic")->GetValueAsUnsigned(0));
-        dict->AddIntegerItem(
-            "address",
-            o->GetValueForExpressionPath(".addr")->GetValueAsUnsigned(0));
-        dict->AddItem("trace", StructuredData::ObjectSP(CreateStackTrace(o)));
-      });
-  dict->AddItem("mops", StructuredData::ObjectSP(mops));
-
-  StructuredData::Array *locs = ConvertToStructuredArray(
-      main_value, ".locs", ".loc_count",
-      [process_sp, &thread_id_map](ValueObjectSP o,
-                                   StructuredData::Dictionary *dict) {
-        dict->AddIntegerItem(
-            "index",
-            o->GetValueForExpressionPath(".idx")->GetValueAsUnsigned(0));
-        dict->AddStringItem("type", RetrieveString(o, process_sp, ".type"));
-        dict->AddIntegerItem(
-            "address",
-            o->GetValueForExpressionPath(".addr")->GetValueAsUnsigned(0));
-        dict->AddIntegerItem(
-            "start",
-            o->GetValueForExpressionPath(".start")->GetValueAsUnsigned(0));
-        dict->AddIntegerItem(
-            "size",
-            o->GetValueForExpressionPath(".size")->GetValueAsUnsigned(0));
-        dict->AddIntegerItem(
-            "thread_id",
-            Renumber(
-                o->GetValueForExpressionPath(".tid")->GetValueAsUnsigned(0),
-                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",
-            o->GetValueForExpressionPath(".idx")->GetValueAsUnsigned(0));
-        dict->AddIntegerItem(
-            "mutex_id",
-            o->GetValueForExpressionPath(".mutex_id")->GetValueAsUnsigned(0));
-        dict->AddIntegerItem(
-            "address",
-            o->GetValueForExpressionPath(".addr")->GetValueAsUnsigned(0));
-        dict->AddIntegerItem(
-            "destroyed",
-            o->GetValueForExpressionPath(".destroyed")->GetValueAsUnsigned(0));
-        dict->AddItem("trace", StructuredData::ObjectSP(CreateStackTrace(o)));
-      });
-  dict->AddItem("mutexes", StructuredData::ObjectSP(mutexes));
-
-  StructuredData::Array *threads = ConvertToStructuredArray(
-      main_value, ".threads", ".thread_count",
-      [process_sp, &thread_id_map](ValueObjectSP o,
-                                   StructuredData::Dictionary *dict) {
-        dict->AddIntegerItem(
-            "index",
-            o->GetValueForExpressionPath(".idx")->GetValueAsUnsigned(0));
-        dict->AddIntegerItem(
-            "thread_id",
-            Renumber(
-                o->GetValueForExpressionPath(".tid")->GetValueAsUnsigned(0),
-                thread_id_map));
-        dict->AddIntegerItem(
-            "thread_os_id",
-            o->GetValueForExpressionPath(".os_id")->GetValueAsUnsigned(0));
-        dict->AddIntegerItem(
-            "running",
-            o->GetValueForExpressionPath(".running")->GetValueAsUnsigned(0));
-        dict->AddStringItem("name", RetrieveString(o, process_sp, ".name"));
-        dict->AddIntegerItem(
-            "parent_thread_id",
-            Renumber(o->GetValueForExpressionPath(".parent_tid")
-                         ->GetValueAsUnsigned(0),
-                     thread_id_map));
-        dict->AddItem("trace", StructuredData::ObjectSP(CreateStackTrace(o)));
-      });
-  dict->AddItem("threads", StructuredData::ObjectSP(threads));
-
-  StructuredData::Array *unique_tids = ConvertToStructuredArray(
-      main_value, ".unique_tids", ".unique_tid_count",
-      [&thread_id_map](ValueObjectSP o, StructuredData::Dictionary *dict) {
-        dict->AddIntegerItem(
-            "index",
-            o->GetValueForExpressionPath(".idx")->GetValueAsUnsigned(0));
-        dict->AddIntegerItem(
-            "tid",
-            Renumber(
-                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 description = report->GetAsDictionary()
-                                ->GetValueForKey("issue_type")
-                                ->GetAsString()
-                                ->GetValue();
-
-  if (description == "data-race") {
-    return "Data race";
-  } else if (description == "data-race-vptr") {
-    return "Data race on C++ virtual pointer";
-  } else if (description == "heap-use-after-free") {
-    return "Use of deallocated memory";
-  } else if (description == "heap-use-after-free-vptr") {
-    return "Use of deallocated C++ virtual pointer";
-  } else if (description == "thread-leak") {
-    return "Thread leak";
-  } else if (description == "locked-mutex-destroy") {
-    return "Destruction of a locked mutex";
-  } else if (description == "mutex-double-lock") {
-    return "Double lock of a mutex";
-  } else if (description == "mutex-invalid-access") {
-    return "Use of an uninitialized or destroyed mutex";
-  } else if (description == "mutex-bad-unlock") {
-    return "Unlock of an unlocked mutex (or by a wrong thread)";
-  } else if (description == "mutex-bad-read-lock") {
-    return "Read lock of a write locked mutex";
-  } 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";
-  } else if (description == "swift-access-race") {
-    return "Swift access race";
-  }
-
-  // for unknown report codes just show the code
-  return description;
-}
-
-static std::string Sprintf(const char *format, ...) {
-  StreamString s;
-  va_list args;
-  va_start(args, format);
-  s.PrintfVarArg(format, args);
-  va_end(args);
-  return s.GetString();
-}
-
-static std::string GetSymbolNameFromAddress(ProcessSP process_sp, addr_t addr) {
-  lldb_private::Address so_addr;
-  if (!process_sp->GetTarget().GetSectionLoadList().ResolveLoadAddress(addr,
-                                                                       so_addr))
-    return "";
-
-  lldb_private::Symbol *symbol = so_addr.CalculateSymbolContextSymbol();
-  if (!symbol)
-    return "";
-
-  std::string sym_name = symbol->GetName().GetCString();
-  return sym_name;
-}
-
-static void GetSymbolDeclarationFromAddress(ProcessSP process_sp, addr_t addr,
-                                            Declaration &decl) {
-  lldb_private::Address so_addr;
-  if (!process_sp->GetTarget().GetSectionLoadList().ResolveLoadAddress(addr,
-                                                                       so_addr))
-    return;
-
-  lldb_private::Symbol *symbol = so_addr.CalculateSymbolContextSymbol();
-  if (!symbol)
-    return;
-
-  ConstString sym_name = symbol->GetMangled().GetName(
-      lldb::eLanguageTypeUnknown, Mangled::ePreferMangled);
-
-  ModuleSP module = symbol->CalculateSymbolContextModule();
-  if (!module)
-    return;
-
-  VariableList var_list;
-  module->FindGlobalVariables(sym_name, nullptr, true, 1U, var_list);
-  if (var_list.GetSize() < 1)
-    return;
-
-  VariableSP var = var_list.GetVariableAtIndex(0);
-  decl = var->GetDeclaration();
-}
-
-addr_t ThreadSanitizerRuntime::GetFirstNonInternalFramePc(
-    StructuredData::ObjectSP trace, bool skip_one_frame) {
-  ProcessSP process_sp = GetProcessSP();
-  ModuleSP runtime_module_sp = GetRuntimeModuleSP();
-
-  StructuredData::Array *trace_array = trace->GetAsArray();
-  for (size_t i = 0; i < trace_array->GetSize(); i++) {
-    if (skip_one_frame && i == 0)
-      continue;
-
-    addr_t addr;
-    if (!trace_array->GetItemAtIndexAsInteger(i, addr))
-      continue;
-
-    lldb_private::Address so_addr;
-    if (!process_sp->GetTarget().GetSectionLoadList().ResolveLoadAddress(
-            addr, so_addr))
-      continue;
-
-    if (so_addr.GetModule() == runtime_module_sp)
-      continue;
-
-    return addr;
-  }
-
-  return 0;
-}
-
-std::string
-ThreadSanitizerRuntime::GenerateSummary(StructuredData::ObjectSP report) {
-  ProcessSP process_sp = GetProcessSP();
-
-  std::string summary = report->GetAsDictionary()
-                            ->GetValueForKey("description")
-                            ->GetAsString()
-                            ->GetValue();
-  bool skip_one_frame =
-      report->GetObjectForDotSeparatedPath("issue_type")->GetStringValue() ==
-      "external-race";
-
-  addr_t pc = 0;
-  if (report->GetAsDictionary()
-          ->GetValueForKey("mops")
-          ->GetAsArray()
-          ->GetSize() > 0)
-    pc = GetFirstNonInternalFramePc(report->GetAsDictionary()
-                                        ->GetValueForKey("mops")
-                                        ->GetAsArray()
-                                        ->GetItemAtIndex(0)
-                                        ->GetAsDictionary()
-                                        ->GetValueForKey("trace"),
-                                    skip_one_frame);
-
-  if (report->GetAsDictionary()
-          ->GetValueForKey("stacks")
-          ->GetAsArray()
-          ->GetSize() > 0)
-    pc = GetFirstNonInternalFramePc(report->GetAsDictionary()
-                                        ->GetValueForKey("stacks")
-                                        ->GetAsArray()
-                                        ->GetItemAtIndex(0)
-                                        ->GetAsDictionary()
-                                        ->GetValueForKey("trace"),
-                                    skip_one_frame);
-
-  if (pc != 0) {
-    summary = summary + " in " + GetSymbolNameFromAddress(process_sp, pc);
-  }
-
-  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()
-                 ->GetValue();
-
-    if (addr != 0) {
-      std::string global_name = GetSymbolNameFromAddress(process_sp, addr);
-      if (!global_name.empty()) {
-        summary = summary + " at " + global_name;
-      } else {
-        summary = summary + " at " + Sprintf("0x%llx", addr);
-      }
-    } else {
-      int fd = loc->GetAsDictionary()
-                   ->GetValueForKey("file_descriptor")
-                   ->GetAsInteger()
-                   ->GetValue();
-      if (fd != 0) {
-        summary = summary + " on file descriptor " + Sprintf("%d", fd);
-      }
-    }
-  }
-
-  return summary;
-}
-
-addr_t
-ThreadSanitizerRuntime::GetMainRacyAddress(StructuredData::ObjectSP report) {
-  addr_t result = (addr_t)-1;
-
-  report->GetObjectForDotSeparatedPath("mops")->GetAsArray()->ForEach(
-      [&result](StructuredData::Object *o) -> bool {
-        addr_t addr =
-            o->GetObjectForDotSeparatedPath("address")->GetIntegerValue();
-        if (addr < result)
-          result = addr;
-        return true;
-      });
-
-  return (result == (addr_t)-1) ? 0 : result;
-}
-
-std::string ThreadSanitizerRuntime::GetLocationDescription(
-    StructuredData::ObjectSP report, addr_t &global_addr,
-    std::string &global_name, std::string &filename, uint32_t &line) {
-  std::string result = "";
-
-  ProcessSP process_sp = GetProcessSP();
-
-  if (report->GetAsDictionary()
-          ->GetValueForKey("locs")
-          ->GetAsArray()
-          ->GetSize() > 0) {
-    StructuredData::ObjectSP loc = report->GetAsDictionary()
-                                       ->GetValueForKey("locs")
-                                       ->GetAsArray()
-                                       ->GetItemAtIndex(0);
-    std::string type =
-        loc->GetAsDictionary()->GetValueForKey("type")->GetStringValue();
-    if (type == "global") {
-      global_addr = loc->GetAsDictionary()
-                        ->GetValueForKey("address")
-                        ->GetAsInteger()
-                        ->GetValue();
-      global_name = GetSymbolNameFromAddress(process_sp, global_addr);
-      if (!global_name.empty()) {
-        result = Sprintf("'%s' is a global variable (0x%llx)",
-                         global_name.c_str(), global_addr);
-      } else {
-        result = Sprintf("0x%llx is a global variable", global_addr);
-      }
-
-      Declaration decl;
-      GetSymbolDeclarationFromAddress(process_sp, global_addr, decl);
-      if (decl.GetFile()) {
-        filename = decl.GetFile().GetPath();
-        line = decl.GetLine();
-      }
-    } else if (type == "heap") {
-      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()
-                    ->GetValueForKey("thread_id")
-                    ->GetAsInteger()
-                    ->GetValue();
-      result = Sprintf("Location is TLS of thread %d", tid);
-    } else if (type == "fd") {
-      int fd = loc->GetAsDictionary()
-                   ->GetValueForKey("file_descriptor")
-                   ->GetAsInteger()
-                   ->GetValue();
-      result = Sprintf("Location is file descriptor %d", fd);
-    }
-  }
-
-  return result;
-}
-
-bool ThreadSanitizerRuntime::NotifyBreakpointHit(
-    void *baton, StoppointCallbackContext *context, user_id_t break_id,
-    user_id_t break_loc_id) {
-  assert(baton && "null baton");
-  if (!baton)
-    return false;
-
-  ThreadSanitizerRuntime *const instance =
-      static_cast<ThreadSanitizerRuntime *>(baton);
-
-  StructuredData::ObjectSP report =
-      instance->RetrieveReportData(context->exe_ctx_ref);
-  std::string stop_reason_description;
-  if (report) {
-    std::string issue_description = instance->FormatDescription(report);
-    report->GetAsDictionary()->AddStringItem("description", issue_description);
-    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);
-
-    addr_t global_addr = 0;
-    std::string global_name = "";
-    std::string location_filename = "";
-    uint32_t location_line = 0;
-    std::string location_description = instance->GetLocationDescription(
-        report, global_addr, global_name, location_filename, location_line);
-    report->GetAsDictionary()->AddStringItem("location_description",
-                                             location_description);
-    if (global_addr != 0) {
-      report->GetAsDictionary()->AddIntegerItem("global_address", global_addr);
-    }
-    if (!global_name.empty()) {
-      report->GetAsDictionary()->AddStringItem("global_name", global_name);
-    }
-    if (location_filename != "") {
-      report->GetAsDictionary()->AddStringItem("location_filename",
-                                               location_filename);
-      report->GetAsDictionary()->AddIntegerItem("location_line", location_line);
-    }
-
-    bool all_addresses_are_same = true;
-    report->GetObjectForDotSeparatedPath("mops")->GetAsArray()->ForEach(
-        [&all_addresses_are_same,
-         main_address](StructuredData::Object *o) -> bool {
-          addr_t addr =
-              o->GetObjectForDotSeparatedPath("address")->GetIntegerValue();
-          if (main_address != addr)
-            all_addresses_are_same = false;
-          return true;
-        });
-    report->GetAsDictionary()->AddBooleanItem("all_addresses_are_same",
-                                              all_addresses_are_same);
-  }
-
-  ProcessSP process_sp = instance->GetProcessSP();
-  // Make sure this is the right process
-  if (process_sp && process_sp == context->exe_ctx_ref.GetProcessSP()) {
-    ThreadSP thread_sp = context->exe_ctx_ref.GetThreadSP();
-    if (thread_sp)
-      thread_sp->SetStopInfo(
-          InstrumentationRuntimeStopInfo::
-              CreateStopReasonWithInstrumentationData(
-                  *thread_sp, stop_reason_description, report));
-
-    StreamFileSP stream_sp(
-        process_sp->GetTarget().GetDebugger().GetOutputFile());
-    if (stream_sp) {
-      stream_sp->Printf("ThreadSanitizer report breakpoint hit. Use 'thread "
-                        "info -s' to get extended information about the "
-                        "report.\n");
-    }
-    return true; // Return true to stop the target
-  } else
-    return false; // Let target run
-}
-
-const RegularExpression &ThreadSanitizerRuntime::GetPatternForRuntimeLibrary() {
-  static RegularExpression regex(llvm::StringRef("libclang_rt.tsan_"));
-  return regex;
-}
-
-bool ThreadSanitizerRuntime::CheckIfRuntimeIsValid(
-    const lldb::ModuleSP module_sp) {
-  static ConstString g_tsan_get_current_report("__tsan_get_current_report");
-  const Symbol *symbol = module_sp->FindFirstSymbolWithNameAndType(
-      g_tsan_get_current_report, lldb::eSymbolTypeAny);
-  return symbol != nullptr;
-}
-
-void ThreadSanitizerRuntime::Activate() {
-  if (IsActive())
-    return;
-
-  ProcessSP process_sp = GetProcessSP();
-  if (!process_sp)
-    return;
-
-  ConstString symbol_name("__tsan_on_report");
-  const Symbol *symbol = GetRuntimeModuleSP()->FindFirstSymbolWithNameAndType(
-      symbol_name, eSymbolTypeCode);
-
-  if (symbol == NULL)
-    return;
-
-  if (!symbol->ValueIsAddress() || !symbol->GetAddressRef().IsValid())
-    return;
-
-  Target &target = process_sp->GetTarget();
-  addr_t symbol_address = symbol->GetAddressRef().GetOpcodeLoadAddress(&target);
-
-  if (symbol_address == LLDB_INVALID_ADDRESS)
-    return;
-
-  bool internal = true;
-  bool hardware = false;
-  Breakpoint *breakpoint =
-      process_sp->GetTarget()
-          .CreateBreakpoint(symbol_address, internal, hardware)
-          .get();
-  breakpoint->SetCallback(ThreadSanitizerRuntime::NotifyBreakpointHit, this,
-                          true);
-  breakpoint->SetBreakpointKind("thread-sanitizer-report");
-  SetBreakpointID(breakpoint->GetID());
-
-  SetActive(true);
-}
-
-void ThreadSanitizerRuntime::Deactivate() {
-  if (GetBreakpointID() != LLDB_INVALID_BREAK_ID) {
-    ProcessSP process_sp = GetProcessSP();
-    if (process_sp) {
-      process_sp->GetTarget().RemoveBreakpointByID(GetBreakpointID());
-      SetBreakpointID(LLDB_INVALID_BREAK_ID);
-    }
-  }
-  SetActive(false);
-}
-static std::string GenerateThreadName(const std::string &path,
-                                      StructuredData::Object *o,
-                                      StructuredData::ObjectSP main_info) {
-  std::string result = "additional information";
-
-  if (path == "mops") {
-    int size = o->GetObjectForDotSeparatedPath("size")->GetIntegerValue();
-    int thread_id =
-        o->GetObjectForDotSeparatedPath("thread_id")->GetIntegerValue();
-    bool is_write =
-        o->GetObjectForDotSeparatedPath("is_write")->GetBooleanValue();
-    bool is_atomic =
-        o->GetObjectForDotSeparatedPath("is_atomic")->GetBooleanValue();
-    addr_t addr = o->GetObjectForDotSeparatedPath("address")->GetIntegerValue();
-
-    std::string addr_string = Sprintf(" at 0x%llx", addr);
-
-    if (main_info->GetObjectForDotSeparatedPath("all_addresses_are_same")
-            ->GetBooleanValue()) {
-      addr_string = "";
-    }
-
-    if (main_info->GetObjectForDotSeparatedPath("issue_type")
-            ->GetStringValue() == "external-race") {
-      result = Sprintf("%s access by thread %d",
-                       is_write ? "mutating" : "read-only", thread_id);
-    } else if (main_info->GetObjectForDotSeparatedPath("issue_type")
-                   ->GetStringValue() == "swift-access-race") {
-      result = Sprintf("modifying access by thread %d", thread_id);
-    } else {
-      result = Sprintf("%s%s of size %d%s by thread %d",
-                       is_atomic ? "atomic " : "", is_write ? "write" : "read",
-                       size, addr_string.c_str(), thread_id);
-    }
-  }
-
-  if (path == "threads") {
-    int thread_id =
-        o->GetObjectForDotSeparatedPath("thread_id")->GetIntegerValue();
-    result = Sprintf("Thread %d created", thread_id);
-  }
-
-  if (path == "locs") {
-    std::string type =
-        o->GetAsDictionary()->GetValueForKey("type")->GetStringValue();
-    int thread_id =
-        o->GetObjectForDotSeparatedPath("thread_id")->GetIntegerValue();
-    int fd =
-        o->GetObjectForDotSeparatedPath("file_descriptor")->GetIntegerValue();
-    if (type == "heap") {
-      result = Sprintf("Heap block allocated by thread %d", thread_id);
-    } else if (type == "fd") {
-      result =
-          Sprintf("File descriptor %d created by thread %t", fd, thread_id);
-    }
-  }
-
-  if (path == "mutexes") {
-    int mutex_id =
-        o->GetObjectForDotSeparatedPath("mutex_id")->GetIntegerValue();
-
-    result = Sprintf("Mutex M%d created", mutex_id);
-  }
-
-  if (path == "stacks") {
-    int thread_id =
-        o->GetObjectForDotSeparatedPath("thread_id")->GetIntegerValue();
-    result = Sprintf("Thread %d", thread_id);
-  }
-
-  result[0] = toupper(result[0]);
-
-  return result;
-}
-
-static void AddThreadsForPath(const std::string &path,
-                              ThreadCollectionSP threads, ProcessSP process_sp,
-                              StructuredData::ObjectSP info) {
-  info->GetObjectForDotSeparatedPath(path)->GetAsArray()->ForEach(
-      [process_sp, threads, path, info](StructuredData::Object *o) -> bool {
-        std::vector<lldb::addr_t> pcs;
-        o->GetObjectForDotSeparatedPath("trace")->GetAsArray()->ForEach(
-            [&pcs](StructuredData::Object *pc) -> bool {
-              pcs.push_back(pc->GetAsInteger()->GetValue());
-              return true;
-            });
-
-        if (pcs.size() == 0)
-          return true;
-
-        StructuredData::ObjectSP thread_id_obj =
-            o->GetObjectForDotSeparatedPath("thread_os_id");
-        tid_t tid = thread_id_obj ? thread_id_obj->GetIntegerValue() : 0;
-
-        uint32_t stop_id = 0;
-        bool stop_id_is_valid = false;
-        HistoryThread *history_thread =
-            new HistoryThread(*process_sp, tid, pcs, stop_id, stop_id_is_valid);
-        ThreadSP new_thread_sp(history_thread);
-        new_thread_sp->SetName(GenerateThreadName(path, o, info).c_str());
-
-        // Save this in the Process' ExtendedThreadList so a strong pointer
-        // retains the object
-        process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
-        threads->AddThread(new_thread_sp);
-
-        return true;
-      });
-}
-
-lldb::ThreadCollectionSP
-ThreadSanitizerRuntime::GetBacktracesFromExtendedStopInfo(
-    StructuredData::ObjectSP info) {
-  ThreadCollectionSP threads;
-  threads.reset(new ThreadCollection());
-
-  if (info->GetObjectForDotSeparatedPath("instrumentation_class")
-          ->GetStringValue() != "ThreadSanitizer")
-    return threads;
-
-  ProcessSP process_sp = GetProcessSP();
-
-  AddThreadsForPath("stacks", threads, process_sp, info);
-  AddThreadsForPath("mops", threads, process_sp, info);
-  AddThreadsForPath("locs", threads, process_sp, info);
-  AddThreadsForPath("mutexes", threads, process_sp, info);
-  AddThreadsForPath("threads", threads, process_sp, info);
-
-  return threads;
-}

lldb/trunk/source/Plugins/InstrumentationRuntime/UBSan/CMakeLists.txt

+add_lldb_library(lldbPluginInstrumentationRuntimeUBSan PLUGIN
+  UBSanRuntime.cpp
+
+  LINK_LIBS
+    lldbBreakpoint
+    lldbCore
+    lldbExpression
+    lldbInterpreter
+    lldbSymbol
+    lldbTarget
+  LINK_COMPONENTS
+    Support
+  )

lldb/trunk/source/Plugins/InstrumentationRuntime/UBSan/UBSanRuntime.h

+//===-- UndefinedBehaviorSanitizerRuntime.h ---------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_UndefinedBehaviorSanitizerRuntime_h_
+#define liblldb_UndefinedBehaviorSanitizerRuntime_h_
+
+#include "lldb/Core/StructuredData.h"
+#include "lldb/Target/ABI.h"
+#include "lldb/Target/InstrumentationRuntime.h"
+#include "lldb/lldb-private.h"
+
+namespace lldb_private {
+
+class UndefinedBehaviorSanitizerRuntime
+    : public lldb_private::InstrumentationRuntime {
+public:
+  ~UndefinedBehaviorSanitizerRuntime() override;
+
+  static lldb::InstrumentationRuntimeSP
+  CreateInstance(const lldb::ProcessSP &process_sp);
+
+  static void Initialize();
+
+  static void Terminate();
+
+  static lldb_private::ConstString GetPluginNameStatic();
+
+  static lldb::InstrumentationRuntimeType GetTypeStatic();
+
+  lldb_private::ConstString GetPluginName() override {
+    return GetPluginNameStatic();
+  }
+
+  virtual lldb::InstrumentationRuntimeType GetType() { return GetTypeStatic(); }
+
+  uint32_t GetPluginVersion() override { return 1; }
+
+  lldb::ThreadCollectionSP
+  GetBacktracesFromExtendedStopInfo(StructuredData::ObjectSP info) override;
+
+private:
+  UndefinedBehaviorSanitizerRuntime(const lldb::ProcessSP &process_sp)
+      : lldb_private::InstrumentationRuntime(process_sp) {}
+
+  const RegularExpression &GetPatternForRuntimeLibrary() override;
+
+  bool CheckIfRuntimeIsValid(const lldb::ModuleSP module_sp) override;
+
+  void Activate() override;
+
+  void Deactivate();
+
+  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);
+};
+
+} // namespace lldb_private
+
+#endif // liblldb_UndefinedBehaviorSanitizerRuntime_h_

lldb/trunk/source/Plugins/InstrumentationRuntime/UBSan/UBSanRuntime.cpp

+//===-- UBSanRuntime.cpp ----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "UBSanRuntime.h"
+
+#include "Plugins/Process/Utility/HistoryThread.h"
+#include "lldb/Breakpoint/StoppointCallbackContext.h"
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/PluginInterface.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/StreamFile.h"
+#include "lldb/Core/ValueObject.h"
+#include "lldb/Expression/UserExpression.h"
+#include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Symbol/Symbol.h"
+#include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Symbol/Variable.h"
+#include "lldb/Symbol/VariableList.h"
+#include "lldb/Target/InstrumentationRuntimeStopInfo.h"
+#include "lldb/Target/SectionLoadList.h"
+#include "lldb/Target/StopInfo.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/Thread.h"
+#include "lldb/Utility/RegularExpression.h"
+#include "lldb/Utility/Stream.h"
+#include <ctype.h>
+
+using namespace lldb;
+using namespace lldb_private;
+
+UndefinedBehaviorSanitizerRuntime::~UndefinedBehaviorSanitizerRuntime() {
+  Deactivate();
+}
+
+lldb::InstrumentationRuntimeSP
+UndefinedBehaviorSanitizerRuntime::CreateInstance(
+    const lldb::ProcessSP &process_sp) {
+  return InstrumentationRuntimeSP(
+      new UndefinedBehaviorSanitizerRuntime(process_sp));
+}
+
+void UndefinedBehaviorSanitizerRuntime::Initialize() {
+  PluginManager::RegisterPlugin(
+      GetPluginNameStatic(),
+      "UndefinedBehaviorSanitizer instrumentation runtime plugin.",
+      CreateInstance, GetTypeStatic);
+}
+
+void UndefinedBehaviorSanitizerRuntime::Terminate() {
+  PluginManager::UnregisterPlugin(CreateInstance);
+}
+
+lldb_private::ConstString
+UndefinedBehaviorSanitizerRuntime::GetPluginNameStatic() {
+  return ConstString("UndefinedBehaviorSanitizer");
+}
+
+lldb::InstrumentationRuntimeType
+UndefinedBehaviorSanitizerRuntime::GetTypeStatic() {
+  return eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer;
+}
+
+static const char *ub_sanitizer_retrieve_report_data_prefix = R"(
+extern "C" {
+void
+__ubsan_get_current_report_data(const char **OutIssueKind,
+    const char **OutMessage, const char **OutFilename, unsigned *OutLine,
+    unsigned *OutCol, char **OutMemoryAddr);
+}
+
+struct data {
+  const char *issue_kind;
+  const char *message;
+  const char *filename;
+  unsigned line;
+  unsigned col;
+  char *memory_addr;
+};
+)";
+
+static const char *ub_sanitizer_retrieve_report_data_command = R"(
+data t;
+__ubsan_get_current_report_data(&t.issue_kind, &t.message, &t.filename, &t.line,
+                                &t.col, &t.memory_addr);
+t;
+)";
+
+static addr_t RetrieveUnsigned(ValueObjectSP return_value_sp,
+                               ProcessSP process_sp,
+                               const std::string &expression_path) {
+  return return_value_sp->GetValueForExpressionPath(expression_path.c_str())
+      ->GetValueAsUnsigned(0);
+}
+
+static std::string RetrieveString(ValueObjectSP return_value_sp,
+                                  ProcessSP process_sp,
+                                  const std::string &expression_path) {
+  addr_t ptr = RetrieveUnsigned(return_value_sp, process_sp, expression_path);
+  std::string str;
+  Status error;
+  process_sp->ReadCStringFromMemory(ptr, str, error);
+  return str;
+}
+
+StructuredData::ObjectSP UndefinedBehaviorSanitizerRuntime::RetrieveReportData(
+    ExecutionContextRef exe_ctx_ref) {
+  ProcessSP process_sp = GetProcessSP();
+  if (!process_sp)
+    return StructuredData::ObjectSP();
+
+  ThreadSP thread_sp = exe_ctx_ref.GetThreadSP();
+  StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
+  ModuleSP runtime_module_sp = GetRuntimeModuleSP();
+  Target &target = process_sp->GetTarget();
+
+  if (!frame_sp)
+    return StructuredData::ObjectSP();
+
+  StreamFileSP Stream(target.GetDebugger().GetOutputFile());
+
+  EvaluateExpressionOptions options;
+  options.SetUnwindOnError(true);
+  options.SetTryAllThreads(true);
+  options.SetStopOthers(true);
+  options.SetIgnoreBreakpoints(true);
+  options.SetTimeout(std::chrono::seconds(2));
+  options.SetPrefix(ub_sanitizer_retrieve_report_data_prefix);
+  options.SetAutoApplyFixIts(false);
+  options.SetLanguage(eLanguageTypeObjC_plus_plus);
+
+  ValueObjectSP main_value;
+  ExecutionContext exe_ctx;
+  Status eval_error;
+  frame_sp->CalculateExecutionContext(exe_ctx);
+  ExpressionResults result = UserExpression::Evaluate(
+      exe_ctx, options, ub_sanitizer_retrieve_report_data_command, "",
+      main_value, eval_error);
+  if (result != eExpressionCompleted) {
+    target.GetDebugger().GetAsyncOutputStream()->Printf(
+        "Warning: Cannot evaluate UndefinedBehaviorSanitizer expression:\n%s\n",
+        eval_error.AsCString());
+    return StructuredData::ObjectSP();
+  }
+
+  // Gather the PCs of the user frames in the backtrace.
+  StructuredData::Array *trace = new StructuredData::Array();
+  auto trace_sp = StructuredData::ObjectSP(trace);
+  for (unsigned I = 0; I < thread_sp->GetStackFrameCount(); ++I) {
+    const Address FCA =
+        thread_sp->GetStackFrameAtIndex(I)->GetFrameCodeAddress();
+    if (FCA.GetModule() == runtime_module_sp) // Skip PCs from the runtime.
+      continue;
+
+    lldb::addr_t PC = FCA.GetLoadAddress(&target);
+    trace->AddItem(StructuredData::ObjectSP(new StructuredData::Integer(PC)));
+  }
+
+  std::string IssueKind = RetrieveString(main_value, process_sp, ".issue_kind");
+  std::string ErrMessage = RetrieveString(main_value, process_sp, ".message");
+  std::string Filename = RetrieveString(main_value, process_sp, ".filename");
+  unsigned Line = RetrieveUnsigned(main_value, process_sp, ".line");
+  unsigned Col = RetrieveUnsigned(main_value, process_sp, ".col");
+  uintptr_t MemoryAddr =
+      RetrieveUnsigned(main_value, process_sp, ".memory_addr");
+
+  auto *d = new StructuredData::Dictionary();
+  auto dict_sp = StructuredData::ObjectSP(d);
+  d->AddStringItem("instrumentation_class", "UndefinedBehaviorSanitizer");
+  d->AddStringItem("description", IssueKind);
+  d->AddStringItem("summary", ErrMessage);
+  d->AddStringItem("filename", Filename);
+  d->AddIntegerItem("line", Line);
+  d->AddIntegerItem("col", Col);
+  d->AddIntegerItem("memory_address", MemoryAddr);
+  d->AddIntegerItem("tid", thread_sp->GetID());
+  d->AddItem("trace", trace_sp);
+  return dict_sp;
+}
+
+static std::string GetStopReasonDescription(StructuredData::ObjectSP report) {
+  llvm::StringRef stop_reason_description_ref;
+  report->GetAsDictionary()->GetValueForKeyAsString("description",
+                                                    stop_reason_description_ref);
+  std::string stop_reason_description = stop_reason_description_ref;
+
+  if (!stop_reason_description.size()) {
+    stop_reason_description = "Undefined behavior detected";
+  } else {
+    stop_reason_description[0] = toupper(stop_reason_description[0]);
+    for (unsigned I = 1; I < stop_reason_description.size(); ++I)
+      if (stop_reason_description[I] == '-')
+        stop_reason_description[I] = ' ';
+  }
+  return stop_reason_description;
+}
+
+bool UndefinedBehaviorSanitizerRuntime::NotifyBreakpointHit(
+    void *baton, StoppointCallbackContext *context, user_id_t break_id,
+    user_id_t break_loc_id) {
+  assert(baton && "null baton");
+  if (!baton)
+    return false; //< false => resume execution.
+
+  UndefinedBehaviorSanitizerRuntime *const instance =
+      static_cast<UndefinedBehaviorSanitizerRuntime *>(baton);
+
+  ProcessSP process_sp = instance->GetProcessSP();
+  ThreadSP thread_sp = context->exe_ctx_ref.GetThreadSP();
+  if (!process_sp || !thread_sp ||
+      process_sp != context->exe_ctx_ref.GetProcessSP())
+    return false;
+
+  StructuredData::ObjectSP report =
+      instance->RetrieveReportData(context->exe_ctx_ref);
+
+  if (report) {
+    thread_sp->SetStopInfo(
+        InstrumentationRuntimeStopInfo::CreateStopReasonWithInstrumentationData(
+            *thread_sp, GetStopReasonDescription(report), report));
+    return true;
+  }
+
+  return false;
+}
+
+const RegularExpression &
+UndefinedBehaviorSanitizerRuntime::GetPatternForRuntimeLibrary() {
+  static RegularExpression regex(llvm::StringRef("libclang_rt\\.(a|t|ub)san_"));
+  return regex;
+}
+
+bool UndefinedBehaviorSanitizerRuntime::CheckIfRuntimeIsValid(
+    const lldb::ModuleSP module_sp) {
+  static ConstString ubsan_test_sym("__ubsan_on_report");
+  const Symbol *symbol = module_sp->FindFirstSymbolWithNameAndType(
+      ubsan_test_sym, lldb::eSymbolTypeAny);
+  return symbol != nullptr;
+}
+
+// FIXME: Factor out all the logic we have in common with the {a,t}san plugins.
+void UndefinedBehaviorSanitizerRuntime::Activate() {
+  if (IsActive())
+    return;
+
+  ProcessSP process_sp = GetProcessSP();
+  if (!process_sp)
+    return;
+
+  ModuleSP runtime_module_sp = GetRuntimeModuleSP();
+
+  ConstString symbol_name("__ubsan_on_report");
+  const Symbol *symbol = runtime_module_sp->FindFirstSymbolWithNameAndType(
+      symbol_name, eSymbolTypeCode);
+
+  if (symbol == nullptr)
+    return;
+
+  if (!symbol->ValueIsAddress() || !symbol->GetAddressRef().IsValid())
+    return;
+
+  Target &target = process_sp->GetTarget();
+  addr_t symbol_address = symbol->GetAddressRef().GetOpcodeLoadAddress(&target);
+
+  if (symbol_address == LLDB_INVALID_ADDRESS)
+    return;
+
+  Breakpoint *breakpoint =
+      process_sp->GetTarget()
+          .CreateBreakpoint(symbol_address, /*internal=*/true,
+                            /*hardware=*/false)
+          .get();
+  breakpoint->SetCallback(
+      UndefinedBehaviorSanitizerRuntime::NotifyBreakpointHit, this, true);
+  breakpoint->SetBreakpointKind("undefined-behavior-sanitizer-report");
+  SetBreakpointID(breakpoint->GetID());
+
+  SetActive(true);
+}
+
+void UndefinedBehaviorSanitizerRuntime::Deactivate() {
+  SetActive(false);
+
+  auto BID = GetBreakpointID();
+  if (BID == LLDB_INVALID_BREAK_ID)
+    return;
+
+  if (ProcessSP process_sp = GetProcessSP()) {
+    process_sp->GetTarget().RemoveBreakpointByID(BID);
+    SetBreakpointID(LLDB_INVALID_BREAK_ID);
+  }
+}
+
+lldb::ThreadCollectionSP
+UndefinedBehaviorSanitizerRuntime::GetBacktracesFromExtendedStopInfo(
+    StructuredData::ObjectSP info) {
+  ThreadCollectionSP threads;
+  threads.reset(new ThreadCollection());
+
+  ProcessSP process_sp = GetProcessSP();
+
+  if (info->GetObjectForDotSeparatedPath("instrumentation_class")
+          ->GetStringValue() != "UndefinedBehaviorSanitizer")
+    return threads;
+
+  std::vector<lldb::addr_t> PCs;
+  auto trace = info->GetObjectForDotSeparatedPath("trace")->GetAsArray();
+  trace->ForEach([&PCs](StructuredData::Object *PC) -> bool {
+    PCs.push_back(PC->GetAsInteger()->GetValue());
+    return true;
+  });
+
+  if (PCs.empty())
+    return threads;
+
+  StructuredData::ObjectSP thread_id_obj =
+      info->GetObjectForDotSeparatedPath("tid");
+  tid_t tid = thread_id_obj ? thread_id_obj->GetIntegerValue() : 0;
+
+  uint32_t stop_id = 0;
+  bool stop_id_is_valid = false;
+  HistoryThread *history_thread =
+      new HistoryThread(*process_sp, tid, PCs, stop_id, stop_id_is_valid);
+  ThreadSP new_thread_sp(history_thread);
+  std::string stop_reason_description = GetStopReasonDescription(info);
+  new_thread_sp->SetName(stop_reason_description.c_str());
+
+  // Save this in the Process' ExtendedThreadList so a strong pointer
+  // retains the object
+  process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
+  threads->AddThread(new_thread_sp);
+
+  return threads;
+}

lldb/trunk/source/Plugins/InstrumentationRuntime/UndefinedBehaviorSanitizer/CMakeLists.txt

-add_lldb_library(lldbPluginInstrumentationRuntimeUndefinedBehaviorSanitizer PLUGIN
-  UndefinedBehaviorSanitizerRuntime.cpp
-
-  LINK_LIBS
-    lldbBreakpoint
-    lldbCore
-    lldbExpression
-    lldbInterpreter
-    lldbSymbol
-    lldbTarget
-  LINK_COMPONENTS
-    Support
-  )

lldb/trunk/source/Plugins/InstrumentationRuntime/UndefinedBehaviorSanitizer/UndefinedBehaviorSanitizerRuntime.h

-//===-- UndefinedBehaviorSanitizerRuntime.h ---------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef liblldb_UndefinedBehaviorSanitizerRuntime_h_
-#define liblldb_UndefinedBehaviorSanitizerRuntime_h_
-
-#include "lldb/Core/StructuredData.h"
-#include "lldb/Target/ABI.h"
-#include "lldb/Target/InstrumentationRuntime.h"
-#include "lldb/lldb-private.h"
-
-namespace lldb_private {
-
-class UndefinedBehaviorSanitizerRuntime
-    : public lldb_private::InstrumentationRuntime {
-public:
-  ~UndefinedBehaviorSanitizerRuntime() override;
-
-  static lldb::InstrumentationRuntimeSP
-  CreateInstance(const lldb::ProcessSP &process_sp);
-
-  static void Initialize();
-
-  static void Terminate();
-
-  static lldb_private::ConstString GetPluginNameStatic();
-
-  static lldb::InstrumentationRuntimeType GetTypeStatic();
-
-  lldb_private::ConstString GetPluginName() override {
-    return GetPluginNameStatic();
-  }
-
-  virtual lldb::InstrumentationRuntimeType GetType() { return GetTypeStatic(); }
-
-  uint32_t GetPluginVersion() override { return 1; }
-
-  lldb::ThreadCollectionSP
-  GetBacktracesFromExtendedStopInfo(StructuredData::ObjectSP info) override;
-
-private:
-  UndefinedBehaviorSanitizerRuntime(const lldb::ProcessSP &process_sp)
-      : lldb_private::InstrumentationRuntime(process_sp) {}
-
-  const RegularExpression &GetPatternForRuntimeLibrary() override;
-
-  bool CheckIfRuntimeIsValid(const lldb::ModuleSP module_sp) override;
-
-  void Activate() override;
-
-  void Deactivate();
-
-  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);
-};
-
-} // namespace lldb_private
-
-#endif // liblldb_UndefinedBehaviorSanitizerRuntime_h_

lldb/trunk/source/Plugins/InstrumentationRuntime/UndefinedBehaviorSanitizer/UndefinedBehaviorSanitizerRuntime.cpp

-//===-- UndefinedBehaviorSanitizerRuntime.cpp -------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "UndefinedBehaviorSanitizerRuntime.h"
-
-#include "Plugins/Process/Utility/HistoryThread.h"
-#include "lldb/Breakpoint/StoppointCallbackContext.h"
-#include "lldb/Core/Debugger.h"
-#include "lldb/Core/Module.h"
-#include "lldb/Core/PluginInterface.h"
-#include "lldb/Core/PluginManager.h"
-#include "lldb/Core/StreamFile.h"
-#include "lldb/Core/ValueObject.h"
-#include "lldb/Expression/UserExpression.h"
-#include "lldb/Interpreter/CommandReturnObject.h"
-#include "lldb/Symbol/Symbol.h"
-#include "lldb/Symbol/SymbolContext.h"
-#include "lldb/Symbol/Variable.h"
-#include "lldb/Symbol/VariableList.h"
-#include "lldb/Target/InstrumentationRuntimeStopInfo.h"
-#include "lldb/Target/SectionLoadList.h"
-#include "lldb/Target/StopInfo.h"
-#include "lldb/Target/Target.h"
-#include "lldb/Target/Thread.h"
-#include "lldb/Utility/RegularExpression.h"
-#include "lldb/Utility/Stream.h"
-#include <ctype.h>
-
-using namespace lldb;
-using namespace lldb_private;
-
-UndefinedBehaviorSanitizerRuntime::~UndefinedBehaviorSanitizerRuntime() {
-  Deactivate();
-}
-
-lldb::InstrumentationRuntimeSP
-UndefinedBehaviorSanitizerRuntime::CreateInstance(
-    const lldb::ProcessSP &process_sp) {
-  return InstrumentationRuntimeSP(
-      new UndefinedBehaviorSanitizerRuntime(process_sp));
-}
-
-void UndefinedBehaviorSanitizerRuntime::Initialize() {
-  PluginManager::RegisterPlugin(
-      GetPluginNameStatic(),
-      "UndefinedBehaviorSanitizer instrumentation runtime plugin.",
-      CreateInstance, GetTypeStatic);
-}
-
-void UndefinedBehaviorSanitizerRuntime::Terminate() {
-  PluginManager::UnregisterPlugin(CreateInstance);
-}
-
-lldb_private::ConstString
-UndefinedBehaviorSanitizerRuntime::GetPluginNameStatic() {
-  return ConstString("UndefinedBehaviorSanitizer");
-}
-
-lldb::InstrumentationRuntimeType
-UndefinedBehaviorSanitizerRuntime::GetTypeStatic() {
-  return eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer;
-}
-
-static const char *ub_sanitizer_retrieve_report_data_prefix = R"(
-extern "C" {
-void
-__ubsan_get_current_report_data(const char **OutIssueKind,
-    const char **OutMessage, const char **OutFilename, unsigned *OutLine,
-    unsigned *OutCol, char **OutMemoryAddr);
-}
-
-struct data {
-  const char *issue_kind;
-  const char *message;
-  const char *filename;
-  unsigned line;
-  unsigned col;
-  char *memory_addr;
-};
-)";
-
-static const char *ub_sanitizer_retrieve_report_data_command = R"(
-data t;
-__ubsan_get_current_report_data(&t.issue_kind, &t.message, &t.filename, &t.line,
-                                &t.col, &t.memory_addr);
-t;
-)";
-
-static addr_t RetrieveUnsigned(ValueObjectSP return_value_sp,
-                               ProcessSP process_sp,
-                               const std::string &expression_path) {
-  return return_value_sp->GetValueForExpressionPath(expression_path.c_str())
-      ->GetValueAsUnsigned(0);
-}
-
-static std::string RetrieveString(ValueObjectSP return_value_sp,
-                                  ProcessSP process_sp,
-                                  const std::string &expression_path) {
-  addr_t ptr = RetrieveUnsigned(return_value_sp, process_sp, expression_path);
-  std::string str;
-  Status error;
-  process_sp->ReadCStringFromMemory(ptr, str, error);
-  return str;
-}
-
-StructuredData::ObjectSP UndefinedBehaviorSanitizerRuntime::RetrieveReportData(
-    ExecutionContextRef exe_ctx_ref) {
-  ProcessSP process_sp = GetProcessSP();
-  if (!process_sp)
-    return StructuredData::ObjectSP();
-
-  ThreadSP thread_sp = exe_ctx_ref.GetThreadSP();
-  StackFrameSP frame_sp = thread_sp->GetSelectedFrame();
-  ModuleSP runtime_module_sp = GetRuntimeModuleSP();
-  Target &target = process_sp->GetTarget();
-
-  if (!frame_sp)
-    return StructuredData::ObjectSP();
-
-  StreamFileSP Stream(target.GetDebugger().GetOutputFile());
-
-  EvaluateExpressionOptions options;
-  options.SetUnwindOnError(true);
-  options.SetTryAllThreads(true);
-  options.SetStopOthers(true);
-  options.SetIgnoreBreakpoints(true);
-  options.SetTimeout(std::chrono::seconds(2));
-  options.SetPrefix(ub_sanitizer_retrieve_report_data_prefix);
-  options.SetAutoApplyFixIts(false);
-  options.SetLanguage(eLanguageTypeObjC_plus_plus);
-
-  ValueObjectSP main_value;
-  ExecutionContext exe_ctx;
-  Status eval_error;
-  frame_sp->CalculateExecutionContext(exe_ctx);
-  ExpressionResults result = UserExpression::Evaluate(
-      exe_ctx, options, ub_sanitizer_retrieve_report_data_command, "",
-      main_value, eval_error);
-  if (result != eExpressionCompleted) {
-    target.GetDebugger().GetAsyncOutputStream()->Printf(
-        "Warning: Cannot evaluate UndefinedBehaviorSanitizer expression:\n%s\n",
-        eval_error.AsCString());
-    return StructuredData::ObjectSP();
-  }
-
-  // Gather the PCs of the user frames in the backtrace.
-  StructuredData::Array *trace = new StructuredData::Array();
-  auto trace_sp = StructuredData::ObjectSP(trace);
-  for (unsigned I = 0; I < thread_sp->GetStackFrameCount(); ++I) {
-    const Address FCA =
-        thread_sp->GetStackFrameAtIndex(I)->GetFrameCodeAddress();
-    if (FCA.GetModule() == runtime_module_sp) // Skip PCs from the runtime.
-      continue;
-
-    lldb::addr_t PC = FCA.GetLoadAddress(&target);
-    trace->AddItem(StructuredData::ObjectSP(new StructuredData::Integer(PC)));
-  }
-
-  std::string IssueKind = RetrieveString(main_value, process_sp, ".issue_kind");
-  std::string ErrMessage = RetrieveString(main_value, process_sp, ".message");
-  std::string Filename = RetrieveString(main_value, process_sp, ".filename");
-  unsigned Line = RetrieveUnsigned(main_value, process_sp, ".line");
-  unsigned Col = RetrieveUnsigned(main_value, process_sp, ".col");
-  uintptr_t MemoryAddr =
-      RetrieveUnsigned(main_value, process_sp, ".memory_addr");
-
-  auto *d = new StructuredData::Dictionary();
-  auto dict_sp = StructuredData::ObjectSP(d);
-  d->AddStringItem("instrumentation_class", "UndefinedBehaviorSanitizer");
-  d->AddStringItem("description", IssueKind);
-  d->AddStringItem("summary", ErrMessage);
-  d->AddStringItem("filename", Filename);
-  d->AddIntegerItem("line", Line);
-  d->AddIntegerItem("col", Col);
-  d->AddIntegerItem("memory_address", MemoryAddr);
-  d->AddIntegerItem("tid", thread_sp->GetID());
-  d->AddItem("trace", trace_sp);
-  return dict_sp;
-}
-
-static std::string GetStopReasonDescription(StructuredData::ObjectSP report) {
-  llvm::StringRef stop_reason_description_ref;
-  report->GetAsDictionary()->GetValueForKeyAsString("description",
-                                                    stop_reason_description_ref);
-  std::string stop_reason_description = stop_reason_description_ref;
-
-  if (!stop_reason_description.size()) {
-    stop_reason_description = "Undefined behavior detected";
-  } else {
-    stop_reason_description[0] = toupper(stop_reason_description[0]);
-    for (unsigned I = 1; I < stop_reason_description.size(); ++I)
-      if (stop_reason_description[I] == '-')
-        stop_reason_description[I] = ' ';
-  }
-  return stop_reason_description;
-}
-
-bool UndefinedBehaviorSanitizerRuntime::NotifyBreakpointHit(
-    void *baton, StoppointCallbackContext *context, user_id_t break_id,
-    user_id_t break_loc_id) {
-  assert(baton && "null baton");
-  if (!baton)
-    return false; //< false => resume execution.
-
-  UndefinedBehaviorSanitizerRuntime *const instance =
-      static_cast<UndefinedBehaviorSanitizerRuntime *>(baton);
-
-  ProcessSP process_sp = instance->GetProcessSP();
-  ThreadSP thread_sp = context->exe_ctx_ref.GetThreadSP();
-  if (!process_sp || !thread_sp ||
-      process_sp != context->exe_ctx_ref.GetProcessSP())
-    return false;
-
-  StructuredData::ObjectSP report =
-      instance->RetrieveReportData(context->exe_ctx_ref);
-
-  if (report) {
-    thread_sp->SetStopInfo(
-        InstrumentationRuntimeStopInfo::CreateStopReasonWithInstrumentationData(
-            *thread_sp, GetStopReasonDescription(report), report));
-    return true;
-  }
-
-  return false;
-}
-
-const RegularExpression &
-UndefinedBehaviorSanitizerRuntime::GetPatternForRuntimeLibrary() {
-  static RegularExpression regex(llvm::StringRef("libclang_rt\\.(a|t|ub)san_"));
-  return regex;
-}
-
-bool UndefinedBehaviorSanitizerRuntime::CheckIfRuntimeIsValid(
-    const lldb::ModuleSP module_sp) {
-  static ConstString ubsan_test_sym("__ubsan_on_report");
-  const Symbol *symbol = module_sp->FindFirstSymbolWithNameAndType(
-      ubsan_test_sym, lldb::eSymbolTypeAny);
-  return symbol != nullptr;
-}
-
-// FIXME: Factor out all the logic we have in common with the {a,t}san plugins.
-void UndefinedBehaviorSanitizerRuntime::Activate() {
-  if (IsActive())
-    return;
-
-  ProcessSP process_sp = GetProcessSP();
-  if (!process_sp)
-    return;
-
-  ModuleSP runtime_module_sp = GetRuntimeModuleSP();
-
-  ConstString symbol_name("__ubsan_on_report");
-  const Symbol *symbol = runtime_module_sp->FindFirstSymbolWithNameAndType(
-      symbol_name, eSymbolTypeCode);
-
-  if (symbol == nullptr)
-    return;
-
-  if (!symbol->ValueIsAddress() || !symbol->GetAddressRef().IsValid())
-    return;
-
-  Target &target = process_sp->GetTarget();
-  addr_t symbol_address = symbol->GetAddressRef().GetOpcodeLoadAddress(&target);
-
-  if (symbol_address == LLDB_INVALID_ADDRESS)
-    return;
-
-  Breakpoint *breakpoint =
-      process_sp->GetTarget()
-          .CreateBreakpoint(symbol_address, /*internal=*/true,
-                            /*hardware=*/false)
-          .get();
-  breakpoint->SetCallback(
-      UndefinedBehaviorSanitizerRuntime::NotifyBreakpointHit, this, true);
-  breakpoint->SetBreakpointKind("undefined-behavior-sanitizer-report");
-  SetBreakpointID(breakpoint->GetID());
-
-  SetActive(true);
-}
-
-void UndefinedBehaviorSanitizerRuntime::Deactivate() {
-  SetActive(false);
-
-  auto BID = GetBreakpointID();
-  if (BID == LLDB_INVALID_BREAK_ID)
-    return;
-
-  if (ProcessSP process_sp = GetProcessSP()) {
-    process_sp->GetTarget().RemoveBreakpointByID(BID);
-    SetBreakpointID(LLDB_INVALID_BREAK_ID);
-  }
-}
-
-lldb::ThreadCollectionSP
-UndefinedBehaviorSanitizerRuntime::GetBacktracesFromExtendedStopInfo(
-    StructuredData::ObjectSP info) {
-  ThreadCollectionSP threads;
-  threads.reset(new ThreadCollection());
-
-  ProcessSP process_sp = GetProcessSP();
-
-  if (info->GetObjectForDotSeparatedPath("instrumentation_class")
-          ->GetStringValue() != "UndefinedBehaviorSanitizer")
-    return threads;
-
-  std::vector<lldb::addr_t> PCs;
-  auto trace = info->GetObjectForDotSeparatedPath("trace")->GetAsArray();
-  trace->ForEach([&PCs](StructuredData::Object *PC) -> bool {
-    PCs.push_back(PC->GetAsInteger()->GetValue());
-    return true;
-  });
-
-  if (PCs.empty())
-    return threads;
-
-  StructuredData::ObjectSP thread_id_obj =
-      info->GetObjectForDotSeparatedPath("tid");
-  tid_t tid = thread_id_obj ? thread_id_obj->GetIntegerValue() : 0;
-
-  uint32_t stop_id = 0;
-  bool stop_id_is_valid = false;
-  HistoryThread *history_thread =
-      new HistoryThread(*process_sp, tid, PCs, stop_id, stop_id_is_valid);
-  ThreadSP new_thread_sp(history_thread);
-  std::string stop_reason_description = GetStopReasonDescription(info);
-  new_thread_sp->SetName(stop_reason_description.c_str());
-
-  // Save this in the Process' ExtendedThreadList so a strong pointer
-  // retains the object
-  process_sp->GetExtendedThreadList().AddThread(new_thread_sp);
-  threads->AddThread(new_thread_sp);
-
-  return threads;
-}